CI: push to ipcr-push-85-17-246-67.ip.nsl.sh (the box's cert no longer covers nip.io) [skip ci]

.gitattributes

@@ -0,0 +1,6 @@
+# FIX CRLF always when developer has not set
+# Linux/Mac: git config --global core.autocrlf input
+# Windows: git config --global core.autocrlf true
+# Auto detect text files and perform LF normalization
+* text=auto
+* eol=lf

.gitea/workflows/docker.yml

@@ -0,0 +1,85 @@
+# Gitea twin of .github/workflows/docker.yml. Gitea runs only .gitea/workflows/ once this
+# folder exists, and GitHub never reads it.
+#
+# Publishes to IPCR on watch.nsl.sh instead of ghcr.io:
+#   push  ipcr-push-85-17-246-67.ip.nsl.sh/metadec.eth/<repo>:<tag>   docker login as metadec.eth with the
+#         IPCR_PUSH_TOKEN secret (the metadec.eth namespace token from the IPCR dashboard)
+#   pull  ipcr-watch.nsl.sh/ipns/metadec.eth/metadec.eth/<repo>:<tag>   anonymous
+# The push goes to ipcr-push-85-17-246-67.ip.nsl.sh, the box's own address, not ipcr-push-watch.nsl.sh: Cloudflare fronts
+# *.watch.nsl.sh and refuses any request over 100 MB (413), which a large image layer is.
+# That host's certificate is signed by the box's private Mesh Router CA, given to buildkit from
+# the IPCR_CA_PEM repo variable. docker login would make the job's Docker daemon check the
+# certificate without that CA, so the login is written straight into ~/.docker/config.json.
+# The runner's job image (node:22-bookworm) has no docker CLI, so the static one is
+# installed first; buildx installs itself. No `type=gha` cache: the runner has none.
+
+name: Build and Push Docker Image
+
+on:
+  push:
+    branches: [main, master]
+    tags: ['v*']
+  pull_request:
+    branches: [main, master]
+
+env:
+  REGISTRY: ipcr-push-85-17-246-67.ip.nsl.sh
+  IMAGE_NAME: metadec.eth/${{ github.event.repository.name }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install Docker CLI
+        run: curl -fsSL https://download.docker.com/linux/static/stable/x86_64/docker-28.5.1.tgz | tar -xz -C /usr/local/bin --strip-components=1 docker/docker
+
+      - name: Trust the Mesh Router CA
+        run: printf '%s\n' "$IPCR_CA_PEM" > /tmp/ipcr-ca.pem
+        env:
+          IPCR_CA_PEM: ${{ vars.IPCR_CA_PEM }}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          version: latest
+          buildkitd-config-inline: |
+            [registry."${{ env.REGISTRY }}"]
+              ca = ["/tmp/ipcr-ca.pem"]
+
+      - name: Log in to IPCR
+        if: github.event_name != 'pull_request'
+        env:
+          IPCR_PUSH_TOKEN: ${{ secrets.IPCR_PUSH_TOKEN }}
+        run: |
+          mkdir -p ~/.docker
+          printf '{"auths":{"%s":{"auth":"%s"}}}\n' "$REGISTRY" "$(printf 'metadec.eth:%s' "$IPCR_PUSH_TOKEN" | base64 -w0)" > ~/.docker/config.json
+
+      - name: Extract metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          tags: |
+            type=ref,event=branch
+            type=ref,event=pr
+            type=semver,pattern={{version}}
+            # A fix to release 1.2.3 is tagged v1.2.3.1: four numbers are not semver, so
+            # the pattern above makes no tag for it; this one does (image tag 1.2.3.1).
+            type=match,pattern=v(\d+\.\d+\.\d+\.\d+),group=1
+            type=semver,pattern={{major}}.{{minor}}
+            type=sha
+
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}

.github/workflows/docker.yml

@@ -42,6 +42,9 @@ jobs:
             type=ref,event=branch
             type=ref,event=pr
             type=semver,pattern={{version}}
+            # A fix to release 1.2.3 is tagged v1.2.3.1: four numbers are not semver, so
+            # the pattern above makes no tag for it; this one does (image tag 1.2.3.1).
+            type=match,pattern=v(\d+\.\d+\.\d+\.\d+),group=1
             type=semver,pattern={{major}}.{{minor}}
             type=sha
 

README.md

@@ -8,7 +8,8 @@ This plugin enriches video metadata by querying the TMDB API:
 
 - **Search by IMDB ID**: Uses existing IMDB ID for precise matching
 - **Search by title**: Falls back to title/year search
-- **Image download**: Downloads poster and backdrop images to `/files/poster/`
+- **Image download**: Downloads poster and backdrop images to `/files/plugin/tmdb/`
+- **Alternative posters**: Lists up to 10 posters (the primary plus the best-voted alternatives, as `url` locator CIDs — nothing extra is downloaded)
 - **Rich metadata**: Fetches plot, rating, genres, studios
 
 **Note**: This runs on the background queue as it makes external API calls.
@@ -26,9 +27,8 @@ This plugin enriches video metadata by querying the TMDB API:
 | `rating` | Vote average |
 | `plot/eng` | English plot synopsis |
 | `poster` | Poster image CID |
-| `posterPath` | Poster file path |
+| `posters/{lang3}/{cid}` | Alternative posters key-set, `poster` among them (METADATA_KEYS.md §6) |
 | `backdrop` | Backdrop image CID |
-| `backdropPath` | Backdrop file path |
 | `genres` | Genre set |
 | `studio` | Production company set |
 

package.json

@@ -5,7 +5,7 @@
   "description": "MetaMesh plugin: Fetches metadata from TMDB API",
   "type": "module",
   "main": "dist/index.js",
-  "scripts": { "build": "tsc", "start": "node dist/index.js" },
+  "scripts": { "build": "tsc", "start": "node dist/index.js", "test": "vitest run", "test:watch": "vitest" },
   "dependencies": { "fastify": "^5.0.0", "axios": "^1.6.0" },
-  "devDependencies": { "@types/node": "^20.0.0", "typescript": "^5.3.0" }
+  "devDependencies": { "@types/node": "^20.0.0", "typescript": "^5.3.0", "vitest": "^1.6.1" }
 }

src/beacon-advertise.ts

@@ -0,0 +1,188 @@
+/**
+ * Beacon v2 advertiser — makes this plugin findable by meta-sort's Plugins
+ * page (Scan → Add) without anyone typing its URL.
+ *
+ * Advertises one resource, cap `metamesh.enrich/<manifest id>`, on the beacon
+ * group (239.255.99.1:9099): unsolicited every 10 s, and unicast in reply to
+ * any probe whose `want` matches. Says `bye` on shutdown. It keeps no view of
+ * other nodes — a plugin only needs to be found. Spec:
+ * meta-root docs/project-architecture/beacon-v2.md.
+ *
+ * Env:
+ *   ENABLE_UDP_DISCOVERY  false/0/no/off disables
+ *   BEACON_ADVERTISE_URL  endpoints.http (default http://$HOSTNAME:$PORT)
+ *   BEACON_BINDS          the one meta-sort instance allowed to list it
+ *                         (meta-sort sets this on containers it spawns)
+ *   BEACON_GROUP / BEACON_PORT / BEACON_INTERVAL_MS
+ *
+ * ⚠ MIRRORED FILE. Byte-identical copies live in every TypeScript
+ * metamesh-plugin-*; see meta-root `scripts/check-mirrors.sh`. Never fatal: a
+ * host that blocks multicast logs a warning and the plugin serves on.
+ */
+
+import dgram from 'dgram';
+import { hostname, networkInterfaces } from 'os';
+
+const PROTO = 'beacon';
+const VERSION = 2;
+
+interface Resource {
+    id: string;
+    caps: string[];
+    endpoints: Record<string, string>;
+    binds?: string;
+}
+
+interface NodeInfo {
+    name: string;
+    instance: string;
+    version?: string;
+}
+
+function envNum(key: string): number | undefined {
+    const n = Number(process.env[key]);
+    return Number.isFinite(n) && n > 0 ? n : undefined;
+}
+
+function enabled(): boolean {
+    const v = (process.env.ENABLE_UDP_DISCOVERY ?? '').trim().toLowerCase();
+    return !['false', '0', 'no', 'off'].includes(v);
+}
+
+/** IPv4 addresses of every up, non-internal interface. */
+function interfaceAddresses(): string[] {
+    const out: string[] = [];
+    for (const list of Object.values(networkInterfaces())) {
+        for (const ni of list ?? []) {
+            const v4 = (ni as { family: string | number }).family === 'IPv4' || (ni as { family: string | number }).family === 4;
+            if (v4 && !ni.internal && ni.address) out.push(ni.address);
+        }
+    }
+    return out;
+}
+
+/** Same matching rules as the spec: `*`, `x/*`, optional `@contract`. */
+function capMatches(pattern: string, cap: string): boolean {
+    if (pattern === '*') return true;
+    const split = (s: string): [string, string | null] => {
+        const i = s.lastIndexOf('@');
+        return i >= 0 ? [s.slice(0, i), s.slice(i + 1)] : [s, null];
+    };
+    const [pb, pc] = split(pattern);
+    const [cb, cc] = split(cap);
+    if (pc !== null && cc !== pc) return false;
+    if (pb.endsWith('/*')) {
+        const prefix = pb.slice(0, -2);
+        const rest = cb.startsWith(prefix) ? cb.slice(prefix.length) : '';
+        return rest.startsWith('/') && rest.length > 1;
+    }
+    return pb === cb;
+}
+
+let socket: dgram.Socket | null = null;
+let timer: NodeJS.Timeout | null = null;
+let node: NodeInfo | null = null;
+let resource: Resource | null = null;
+let ifaces: string[] = [];
+let group = '239.255.99.1';
+let udpPort = 9099;
+
+function send(msg: object, dest?: { address: string; port: number }): void {
+    const s = socket;
+    if (!s) return;
+    const body = Buffer.from(JSON.stringify(msg));
+    if (dest) {
+        s.send(body, dest.port, dest.address, () => {});
+        return;
+    }
+    // Once per interface: the default route alone reaches one network.
+    for (const addr of ifaces) {
+        try {
+            s.setMulticastInterface(addr);
+            s.send(body, udpPort, group, () => {});
+        } catch (e) {
+            console.warn(`[beacon] send on ${addr} failed:`, e);
+        }
+    }
+}
+
+function advertise(dest?: { address: string; port: number }): void {
+    if (!node || !resource) return;
+    send({ proto: PROTO, v: VERSION, type: 'advertise', node, resources: [resource] }, dest);
+}
+
+/**
+ * Start advertising this plugin. Call once the HTTP server is listening, so a
+ * consumer that hears it can reach it. Idempotent.
+ */
+export function startBeacon(pluginId: string, version: string, httpPort: number): void {
+    if (socket || !enabled()) return;
+    group = process.env.BEACON_GROUP || group;
+    udpPort = envNum('BEACON_PORT') ?? udpPort;
+    const intervalMs = envNum('BEACON_INTERVAL_MS') ?? 10_000;
+    const instance = process.env.HOSTNAME || hostname();
+    const url = (process.env.BEACON_ADVERTISE_URL || `http://${instance}:${httpPort}`).replace(/\/+$/, '');
+    const binds = (process.env.BEACON_BINDS || '').trim();
+
+    node = { name: `metamesh-plugin-${pluginId}`, instance, ...(version ? { version } : {}) };
+    resource = {
+        id: pluginId,
+        caps: [`metamesh.enrich/${pluginId}`],
+        endpoints: { http: url, manifest: '/manifest' },
+        ...(binds ? { binds } : {}),
+    };
+
+    const s = dgram.createSocket({ type: 'udp4', reuseAddr: true });
+    socket = s;
+    s.on('error', (err) => console.warn('[beacon] socket error:', err.message));
+    s.on('message', (buf, rinfo) => {
+        let m: { proto?: string; v?: number; type?: string; from?: string; want?: string[] };
+        try {
+            m = JSON.parse(buf.toString('utf8'));
+        } catch {
+            return; // foreign traffic on the shared group
+        }
+        if (m?.proto !== PROTO || m.v !== VERSION || m.type !== 'probe' || m.from === instance) return;
+        const want = Array.isArray(m.want) ? m.want : [];
+        if (want.length === 0 || resource!.caps.some((c) => want.some((p) => capMatches(p, c)))) {
+            advertise({ address: rinfo.address, port: rinfo.port });
+        }
+    });
+    s.bind(udpPort, '0.0.0.0', () => {
+        try {
+            s.setMulticastTTL(1);
+        } catch {
+            /* best effort */
+        }
+        ifaces = interfaceAddresses();
+        for (const addr of ifaces) {
+            try {
+                s.addMembership(group, addr);
+            } catch (e) {
+                console.warn(`[beacon] join ${group} on ${addr} failed:`, e);
+            }
+        }
+        console.log(`[beacon] advertising metamesh.enrich/${pluginId} at ${url} on ${group}:${udpPort}`);
+        advertise();
+        timer = setInterval(() => advertise(), intervalMs);
+        timer.unref?.();
+    });
+}
+
+/** Say `bye` so consumers drop this plugin at once. */
+export async function stopBeacon(): Promise<void> {
+    if (!socket || !node) return;
+    if (timer) clearInterval(timer);
+    send({ proto: PROTO, v: VERSION, type: 'bye', node });
+    // Let the bye datagrams leave before the socket closes under them.
+    await new Promise((r) => setTimeout(r, 50));
+    const s = socket;
+    socket = null;
+    await new Promise<void>((resolve) => {
+        try {
+            s.close(() => resolve());
+        } catch {
+            resolve();
+        }
+    });
+}

src/cid.ts

@@ -0,0 +1,58 @@
+/**
+ * CID encoding helpers (METADATA_KEYS.md §2).
+ */
+
+const BASE32_ALPHABET = 'abcdefghijklmnopqrstuvwxyz234567';
+
+/** RFC 4648 base32, lowercase, no padding, with the `b` multibase prefix. */
+export function base32LowerMultibase(bytes: Uint8Array): string {
+    let out = 'b';
+    let bits = 0;
+    let value = 0;
+    for (const byte of bytes) {
+        value = (value << 8) | byte;
+        bits += 8;
+        while (bits >= 5) {
+            bits -= 5;
+            out += BASE32_ALPHABET[(value >> bits) & 0x1f];
+        }
+    }
+    if (bits > 0) {
+        out += BASE32_ALPHABET[(value << (5 - bits)) & 0x1f];
+    }
+    return out;
+}
+
+/** Unsigned LEB128 varint, as multiformats encodes codecs and lengths. */
+function varint(value: number): number[] {
+    const out: number[] = [];
+    let n = value;
+    while (n >= 0x80) {
+        out.push((n & 0x7f) | 0x80);
+        n = Math.floor(n / 0x80);
+    }
+    out.push(n);
+    return out;
+}
+
+/** Custom multicodec of the `url` locator (METADATA_KEYS.md §2.1). */
+export const URL_LOCATOR_CODEC = 0x1006;
+
+/**
+ * Encode an absolute http(s) URL as a `0x1006` identity-multihash CIDv1:
+ * `[0x01][varint codec][0x00][varint len][utf-8 url]`, base32lower. The digest
+ * is the URL itself, so minting one costs no I/O. `null` for anything that is
+ * not an absolute http(s) URL.
+ *
+ * CROSS-BINARY CONTRACT: byte-identical to meta-feeder-sdk's `compute_url_cid`
+ * (`hash.rs`); both test suites pin the same vectors.
+ */
+export function encodeUrlCid(url: string): string | null {
+    const trimmed = url.trim();
+    if (!trimmed.startsWith('http://') && !trimmed.startsWith('https://')) {
+        return null;
+    }
+    const digest = Buffer.from(trimmed, 'utf8');
+    const header = Buffer.from([0x01, ...varint(URL_LOCATOR_CODEC), 0x00, ...varint(digest.length)]);
+    return base32LowerMultibase(Buffer.concat([header, digest]));
+}

src/index.ts

@@ -27,6 +27,7 @@
 import Fastify from 'fastify';
 import type { HealthResponse, ProcessRequest, ProcessResponse, CallbackPayload, ConfigureRequest, ConfigureResponse } from './types.js';
 import { manifest, process as processFile, configure } from './plugin.js';
+import { startBeacon, stopBeacon } from './beacon-advertise.js';
 
 const app = Fastify({ logger: true });
 let ready = false;
@@ -64,5 +65,5 @@ app.post<{ Body: ProcessRequest }>('/process', async (request, reply) => {
 });
 
 const port = parseInt(process.env.PORT || '8080', 10);
-app.listen({ port, host: '0.0.0.0' }).then(() => { ready = true; console.log(`[${manifest.id}] Listening on port ${port}`); });
+app.listen({ port, host: '0.0.0.0' }).then(() => { startBeacon(manifest.id, manifest.version, port); ready = true; console.log(`[${manifest.id}] Listening on port ${port}`); });
-process.on('SIGTERM', async () => { ready = false; await app.close(); process.exit(0); });
+process.on('SIGTERM', async () => { await stopBeacon(); ready = false; await app.close(); process.exit(0); });

src/meta-core-client.ts

@@ -1,89 +1,380 @@
 /**
- * meta-core API Client for writing metadata
+ * meta-core client: signed claim writes (MMUR2) + plain reads.
- * Fails gracefully if meta-core is unavailable (logs warning, returns without throwing)
+ *
+ * MIRRORED byte-for-byte across every `metamesh-plugin-*` TypeScript plugin and
+ * meta-sort-core (`src/kv/meta-core-client.ts`) — guarded by
+ * `scripts/check-mirrors.sh`. Edit one copy, then copy it everywhere.
+ *
+ * Every write is a vote signed by THIS container's key
+ * (docs/implementation/metacore-claims-model.md §3, §9):
+ *
+ *   bytes_to_sign = "MMUR2\n" || canonical CBOR [cid, uid, key, value, ts]
+ *   sig           = ECDSA-secp256k1(SHA-256(bytes)), compact r||s, low-S
+ *
+ * and is posted to `POST {baseUrl}/api/claims` — meta-core directly, or
+ * meta-sort's pass-through relay when the plugin runs under meta-sort. The
+ * encoding is pinned by meta-core's `internal/claim/testdata/claim-vectors.json`
+ * (vendored as `test/claim-vectors.json`).
+ *
+ * Key: `METAMESH_SIGNING_KEY` (64 hex chars) or `METAMESH_SIGNING_KEY_FILE`
+ * (read; generated and written 0600 if missing). With neither, writes are
+ * refused (logged, return false) — no silent throwaway identities.
+ *
+ * Fails gracefully if meta-core is unavailable: logs and returns, never throws.
  */
 
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// ---------------------------------------------------------------- encoding --
+
+const DOMAIN = Buffer.from('MMUR2\n', 'utf8');
+const B58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+const N = BigInt('0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141');
+const HALF_N = N >> 1n;
+
+/** A claim value: text (public), bytes (private envelope) or null (retraction). */
+export type ClaimValue = string | Uint8Array | null;
+
+export interface SignedClaim {
+    cid: string;
+    uid: string;
+    key: string;
+    value: ClaimValue;
+    ts: number;
+    sig: Uint8Array;
+}
+
+function head(major: number, n: number | bigint): Buffer {
+    const m = major << 5;
+    const v = BigInt(n);
+    if (v < 24n) return Buffer.from([m | Number(v)]);
+    if (v <= 0xffn) return Buffer.from([m | 24, Number(v)]);
+    if (v <= 0xffffn) {
+        const b = Buffer.alloc(3);
+        b[0] = m | 25;
+        b.writeUInt16BE(Number(v), 1);
+        return b;
+    }
+    if (v <= 0xffffffffn) {
+        const b = Buffer.alloc(5);
+        b[0] = m | 26;
+        b.writeUInt32BE(Number(v), 1);
+        return b;
+    }
+    const b = Buffer.alloc(9);
+    b[0] = m | 27;
+    b.writeBigUInt64BE(v, 1);
+    return b;
+}
+
+function text(s: string): Buffer {
+    const raw = Buffer.from(s, 'utf8');
+    return Buffer.concat([head(3, raw.length), raw]);
+}
+
+/** The exact bytes an MMUR2 signature covers. */
+export function signedBytes(cid: string, uid: string, key: string, value: ClaimValue, ts: number): Buffer {
+    let v: Buffer;
+    if (value === null) v = Buffer.from([0xf6]);
+    else if (typeof value === 'string') v = text(value);
+    else v = Buffer.concat([head(2, value.length), Buffer.from(value)]);
+    return Buffer.concat([DOMAIN, head(4, 5), text(cid), text(uid), text(key), v, head(0, ts)]);
+}
+
+function base58Encode(bytes: Uint8Array): string {
+    let n = BigInt('0x' + (Buffer.from(bytes).toString('hex') || '0'));
+    let out = '';
+    while (n > 0n) {
+        out = B58[Number(n % 58n)] + out;
+        n /= 58n;
+    }
+    for (const b of bytes) {
+        if (b !== 0) break;
+        out = '1' + out;
+    }
+    return out;
+}
+
+function base58Decode(s: string): Buffer {
+    let n = 0n;
+    for (const ch of s) {
+        const i = B58.indexOf(ch);
+        if (i < 0) throw new Error(`invalid base58 character ${ch}`);
+        n = n * 58n + BigInt(i);
+    }
+    let hex = n === 0n ? '' : n.toString(16);
+    if (hex.length % 2) hex = '0' + hex;
+    let zeros = 0;
+    while (zeros < s.length && s[zeros] === '1') zeros++;
+    return Buffer.concat([Buffer.alloc(zeros), Buffer.from(hex, 'hex')]);
+}
+
+function b64url(b: Buffer): string {
+    return b.toString('base64url');
+}
+
+function publicKeyFromCompressed(compressed: Buffer): crypto.KeyObject {
+    const full = crypto.ECDH.convertKey(compressed, 'secp256k1', undefined, undefined, 'uncompressed') as Buffer;
+    return crypto.createPublicKey({
+        key: { kty: 'EC', crv: 'secp256k1', x: b64url(full.subarray(1, 33)), y: b64url(full.subarray(33, 65)) },
+        format: 'jwk',
+    });
+}
+
+/** Rewrite a compact signature to its low-S form (MMUR2 refuses high-S). */
+function lowS(sig: Buffer): Buffer {
+    const s = BigInt('0x' + sig.subarray(32).toString('hex'));
+    if (s <= HALF_N) return sig;
+    const fixed = Buffer.from((N - s).toString(16).padStart(64, '0'), 'hex');
+    return Buffer.concat([sig.subarray(0, 32), fixed]);
+}
+
+/** True when the claim's signature is a valid low-S signature by its uid. */
+export function verifyClaim(c: SignedClaim): boolean {
+    try {
+        const sig = Buffer.from(c.sig);
+        if (sig.length !== 64) return false;
+        if (BigInt('0x' + sig.subarray(32).toString('hex')) > HALF_N) return false;
+        if (!c.uid.startsWith('z')) return false;
+        const pub = base58Decode(c.uid.slice(1));
+        if (pub.length !== 33) return false;
+        return crypto.verify(
+            'sha256',
+            signedBytes(c.cid, c.uid, c.key, c.value, c.ts),
+            { key: publicKeyFromCompressed(pub), dsaEncoding: 'ieee-p1363' },
+            sig,
+        );
+    } catch {
+        return false;
+    }
+}
+
+// ----------------------------------------------------------------- signer --
+
+export class ClaimSigner {
+    readonly uid: string;
+    private readonly key: crypto.KeyObject;
+    private lastTs = 0;
+
+    constructor(privateKeyHex: string) {
+        const hex = privateKeyHex.trim().replace(/^0x/i, '');
+        if (!/^[0-9a-fA-F]{64}$/.test(hex)) throw new Error('signing key must be 64 hex characters');
+        const d = Buffer.from(hex, 'hex');
+        const ecdh = crypto.createECDH('secp256k1');
+        ecdh.setPrivateKey(d);
+        const full = ecdh.getPublicKey(null, 'uncompressed');
+        this.uid = 'z' + base58Encode(ecdh.getPublicKey(null, 'compressed'));
+        this.key = crypto.createPrivateKey({
+            key: {
+                kty: 'EC', crv: 'secp256k1', d: b64url(d),
+                x: b64url(full.subarray(1, 33)), y: b64url(full.subarray(33, 65)),
+            },
+            format: 'jwk',
+        });
+    }
+
+    /** Milliseconds, strictly increasing within this process (ts is the version). */
+    nextTs(): number {
+        this.lastTs = Math.max(Date.now(), this.lastTs + 1);
+        return this.lastTs;
+    }
+
+    sign(cid: string, key: string, value: ClaimValue, ts: number = this.nextTs()): SignedClaim {
+        const raw = crypto.sign('sha256', signedBytes(cid, this.uid, key, value, ts), {
+            key: this.key,
+            dsaEncoding: 'ieee-p1363',
+        });
+        return { cid, uid: this.uid, key, value, ts, sig: lowS(raw) };
+    }
+}
+
+let cachedSigner: ClaimSigner | null | undefined;
+
+/**
+ * The process signer from the environment, or null when no key is configured.
+ * Read lazily on first write; `resetSignerForTests()` forgets it.
+ */
+export function loadSigner(): ClaimSigner | null {
+    if (cachedSigner !== undefined) return cachedSigner;
+    const inline = process.env.METAMESH_SIGNING_KEY;
+    const file = process.env.METAMESH_SIGNING_KEY_FILE;
+    try {
+        if (inline) {
+            cachedSigner = new ClaimSigner(inline);
+        } else if (file) {
+            if (!fs.existsSync(file)) {
+                fs.mkdirSync(path.dirname(file), { recursive: true });
+                fs.writeFileSync(file, crypto.randomBytes(32).toString('hex') + '\n', { mode: 0o600 });
+            }
+            cachedSigner = new ClaimSigner(fs.readFileSync(file, 'utf8'));
+        } else {
+            cachedSigner = null;
+        }
+    } catch (error) {
+        console.warn(`[MetaCoreClient] Signing key unusable: ${error instanceof Error ? error.message : String(error)}`);
+        cachedSigner = null;
+    }
+    if (cachedSigner) console.log(`[MetaCoreClient] Signing claims as ${cachedSigner.uid}`);
+    else console.warn('[MetaCoreClient] No METAMESH_SIGNING_KEY / METAMESH_SIGNING_KEY_FILE — metadata writes are refused');
+    return cachedSigner;
+}
+
+export function resetSignerForTests(): void {
+    cachedSigner = undefined;
+}
+
+/** The §3.4 JSON form. */
+export function claimToJSON(c: SignedClaim): Record<string, unknown> {
+    let value: unknown = null;
+    if (typeof c.value === 'string') value = c.value;
+    else if (c.value) value = { b64: Buffer.from(c.value).toString('base64') };
+    return { cid: c.cid, uid: c.uid, key: c.key, value, ts: c.ts, sig: Buffer.from(c.sig).toString('base64') };
+}
+
+// ----------------------------------------------------------------- client --
+
 export class MetaCoreClient {
     constructor(private baseUrl: string) {}
 
     private async safeFetch(url: string, options: RequestInit): Promise<Response | null> {
         try {
-            return await fetch(url, { ...options, signal: AbortSignal.timeout(5000) });
+            return await fetch(url, { ...options, signal: AbortSignal.timeout(10000) });
         } catch (error) {
-            console.warn(`[MetaCoreClient] Warning: meta-core unavailable at ${this.baseUrl}`);
+            console.warn(`[MetaCoreClient] Warning: meta-core unavailable at ${this.baseUrl}: ${error instanceof Error ? error.message : String(error)}`);
             return null;
         }
     }
 
-    async setProperty(hashId: string, key: string, value: string): Promise<void> {
+    /**
-        const response = await this.safeFetch(`${this.baseUrl}/meta/${hashId}/${key}`, {
+     * Sign and post claims about `cid`. True when every claim was accepted (or
-            method: 'PUT',
+     * was already stored: `unchanged` / `stale` are not failures).
+     */
+    async writeClaims(cid: string, values: Array<[string, ClaimValue]>): Promise<boolean> {
+        if (values.length === 0) return true;
+        const signer = loadSigner();
+        if (!signer) return false;
+        const claims = values.map(([key, value]) => claimToJSON(signer.sign(cid, key, value)));
+        const response = await this.safeFetch(`${this.baseUrl}/api/claims`, {
+            method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ value }),
+            body: JSON.stringify(claims),
         });
-        if (response && !response.ok) {
+        if (!response) return false;
-            console.warn(`[MetaCoreClient] Failed to set property: ${response.status}`);
+        if (!response.ok) {
+            console.warn(`[MetaCoreClient] Claims for ${cid} rejected: ${response.status}`);
+            return false;
         }
+        const statuses = await response.json().catch(() => null) as Array<{ status?: string; reason?: string }> | null;
+        const bad = (statuses ?? []).filter((s) => s.status === 'bad_signature' || s.status === 'bad_request');
+        if (bad.length > 0) {
+            console.warn(`[MetaCoreClient] ${bad.length} claim(s) for ${cid} refused: ${bad[0].status} ${bad[0].reason ?? ''}`);
+            return false;
+        }
+        return true;
+    }
+
+    /** One text claim. */
+    async setProperty(hashId: string, key: string, value: string): Promise<boolean> {
+        return this.writeClaims(hashId, [[key, String(value)]]);
+    }
+
+    /** One text claim per entry, in a single batch. */
+    async mergeMetadata(hashId: string, metadata: Record<string, string>): Promise<boolean> {
+        return this.writeClaims(hashId, Object.entries(metadata).map(([k, v]) => [k, String(v)]));
+    }
+
+    /**
+     * Retract this signer's own vote for `key`. Other signers' votes for the
+     * same key are untouched (there are no negative votes).
+     */
+    async deleteProperty(hashId: string, key: string): Promise<boolean> {
+        return this.writeClaims(hashId, [[key, null]]);
+    }
+
+    /**
+     * Append a member to a legacy csv-set field (`genres`, `studio`, `tags`,
+     * `announceList`, …) — the comma-joined shape readers still parse (the
+     * METADATA_KEYS §14.12 key-set migration is out of scope for phase 1).
+     *
+     * Under claims a signer owns only its OWN vote, so this reads this
+     * signer's current claim for (cid, key) from
+     * `GET /api/meta/{cid}/claims?key=<key>` (other signers' claims are
+     * ignored), adds the member if absent and signs the new full value as one
+     * text claim. Members are kept raw (no escaping), same as the old
+     * meta-sort `_add` proxy. A member already present writes nothing.
+     */
+    async addToSet(hashId: string, key: string, value: string): Promise<boolean> {
+        const member = String(value);
+        if (!member) return true;
+        const signer = loadSigner();
+        if (!signer) return false;
+        const current = await this.ownClaimValue(hashId, key, signer.uid);
+        if (current === undefined) return false; // could not read: never clobber our own set
+        const members = current ? current.split(',').map((v) => v.trim()).filter(Boolean) : [];
+        if (members.includes(member)) return true;
+        return this.writeClaims(hashId, [[key, [...members, member].join(',')]]);
+    }
+
+    /**
+     * This signer's newest text claim for (cid, key): the value, `null` when it
+     * has none, `undefined` when the claims could not be read.
+     */
+    private async ownClaimValue(cid: string, key: string, uid: string): Promise<string | null | undefined> {
+        const url = `${this.baseUrl}/api/meta/${encodeURIComponent(cid)}/claims?key=${encodeURIComponent(key)}`;
+        const response = await this.safeFetch(url, { method: 'GET' });
+        if (!response) return undefined;
+        if (response.status === 404) return null;
+        if (!response.ok) {
+            console.warn(`[MetaCoreClient] Failed to read claims for ${cid}/${key}: ${response.status}`);
+            return undefined;
+        }
+        const body = await response.json().catch(() => null) as unknown;
+        const list = (Array.isArray(body) ? body : (body as { claims?: unknown })?.claims) as
+            Array<{ uid?: string; key?: string; value?: unknown; ts?: number }> | undefined;
+        let best: { value: string; ts: number } | null = null;
+        for (const c of Array.isArray(list) ? list : []) {
+            if (c.uid !== uid || c.key !== key || typeof c.value !== 'string') continue;
+            const ts = Number(c.ts) || 0;
+            if (!best || ts > best.ts) best = { value: c.value, ts };
+        }
+        return best ? best.value : null;
     }
 
     async getProperty(hashId: string, key: string): Promise<string | null> {
         const response = await this.safeFetch(`${this.baseUrl}/meta/${hashId}/${key}`, { method: 'GET' });
-        if (!response || response.status === 404) return null;
+        if (!response || !response.ok) return null;
-        if (!response.ok) return null;
+        const data = await response.json() as { value?: unknown };
-        const data = await response.json() as { value?: string };
+        return data.value === undefined || data.value === null ? null : String(data.value);
-        return data.value ?? null;
     }
 
-    async mergeMetadata(hashId: string, metadata: Record<string, string>): Promise<void> {
+    /**
-        const response = await this.safeFetch(`${this.baseUrl}/meta/${hashId}`, {
+     * Whole merged record, in whatever form the endpoint serves (meta-sort's
-            method: 'PATCH',
+     * /meta is nested, meta-core's is flat) — callers flatten. `null` when the
-            headers: { 'Content-Type': 'application/json' },
+     * call itself failed, `{}` when the record does not exist.
-            body: JSON.stringify(metadata),
+     */
-        });
+    async getMetadata(hashId: string): Promise<Record<string, unknown> | null> {
-        if (response && !response.ok) {
-            console.warn(`[MetaCoreClient] Failed to merge metadata: ${response.status}`);
-        }
-    }
-
-    async deleteProperty(hashId: string, key: string): Promise<void> {
-        const response = await this.safeFetch(`${this.baseUrl}/meta/${hashId}/${key}`, { method: 'DELETE' });
-        if (response && !response.ok && response.status !== 404) {
-            console.warn(`[MetaCoreClient] Failed to delete property: ${response.status}`);
-        }
-    }
-
-    async addToSet(hashId: string, key: string, value: string): Promise<void> {
-        const response = await this.safeFetch(`${this.baseUrl}/meta/${hashId}/_add/${key}`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ value }),
-        });
-        if (response && !response.ok) {
-            console.warn(`[MetaCoreClient] Failed to add to set: ${response.status}`);
-        }
-    }
-
-    async getMetadata(hashId: string): Promise<Record<string, string>> {
         const response = await this.safeFetch(`${this.baseUrl}/meta/${hashId}`, { method: 'GET' });
-        if (!response || response.status === 404) return {};
+        if (!response) return null;
-        if (!response.ok) return {};
+        if (response.status === 404) return {};
-        const data = await response.json() as { metadata?: Record<string, string> };
+        if (!response.ok) return null;
+        const data = await response.json() as { metadata?: Record<string, unknown> };
         return data.metadata ?? {};
     }
 
     /**
-     * Compute CID for a file
+     * Compute the CID of a file under FILES_PATH via meta-core's `POST /file/cid`.
-     * @param path - Path relative to FILES_PATH (e.g., "poster/Movie (2024)[tmdb12345]_poster.jpg")
+     * @param filePath - path relative to FILES_PATH (e.g. "poster/Movie (2024)_poster.jpg")
-     * @returns CID string or null if failed
      */
-    async computeFileCID(path: string): Promise<string | null> {
+    async computeFileCID(filePath: string): Promise<string | null> {
         const response = await this.safeFetch(`${this.baseUrl}/file/cid`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ path }),
+            body: JSON.stringify({ path: filePath }),
         });
         if (!response || !response.ok) return null;
-        const data = await response.json() as { cid?: string };
+        const data = await response.json().catch(() => null) as { cid?: string } | null;
-        return data.cid ?? null;
+        return data?.cid ?? null;
     }
 }

src/plugin.ts

@@ -25,10 +25,12 @@
  *
  * Matches old TMDBProcessor output:
  * - tmdbid, imdbid
- * - originalTitle, movieYear, releasedate
+ * - title, originalTitle, movieYear, releasedate
+ * - titles/<lang3>/<name> key-set: localized + original title + every AKA
  * - plot/eng, rating
  * - genres (add), studio (add), tags (add)
  * - poster, backdrop (CID hashes of downloaded images)
+ * - posters/{lang3}/{cid} (alternative posters as url locators, `poster` among them)
  */
 
 import axios from 'axios';
@@ -38,6 +40,8 @@ import type { PluginManifest, ProcessRequest, CallbackPayload } from './types.js
 import { MetaCoreClient } from './meta-core-client.js';
 import { readJson, writeJson } from './cache.js';
 import { getWebDAVClient, WebDAVClient } from './webdav-client.js';
+import { base32LowerMultibase } from './cid.js';
+import { posterMembers } from './posters.js';
 
 const IMAGE_BASE_URL = 'https://image.tmdb.org/t/p/original';
 
@@ -104,23 +108,7 @@ function computeMidHash256FromData(fileSize: number, sampleData: Buffer): string
     ]);
 
     // Encode as base32lower with 'b' prefix (multibase)
-    const base32Chars = 'abcdefghijklmnopqrstuvwxyz234567';
+    return base32LowerMultibase(cidBytes);
-    let cid = 'b';
-    let bits = 0;
-    let value = 0;
-    for (const byte of cidBytes) {
-        value = (value << 8) | byte;
-        bits += 8;
-        while (bits >= 5) {
-            bits -= 5;
-            cid += base32Chars[(value >> bits) & 0x1f];
-        }
-    }
-    if (bits > 0) {
-        cid += base32Chars[(value << (5 - bits)) & 0x1f];
-    }
-
-    return cid;
 }
 
 export const manifest: PluginManifest = {
@@ -168,6 +156,51 @@ let forceRecompute = false;
 
 const BASE_URL = 'https://api.themoviedb.org/3';
 
+// ISO 639-1 → ISO 639-3 (`lang3`, the 639-2/T form where B/T differ) for the
+// languages TMDB commonly returns. Unknown codes map to nothing.
+const ISO639_1_TO_3: Record<string, string> = {
+    en: 'eng', ja: 'jpn', fr: 'fra', de: 'deu', es: 'spa', it: 'ita', ru: 'rus',
+    ko: 'kor', zh: 'zho', pt: 'por', nl: 'nld', sv: 'swe', no: 'nor', da: 'dan',
+    fi: 'fin', pl: 'pol', tr: 'tur', cs: 'ces', hu: 'hun', el: 'ell', he: 'heb',
+    th: 'tha', vi: 'vie', id: 'ind', uk: 'ukr', ro: 'ron', ar: 'ara', fa: 'fas',
+    hi: 'hin', ta: 'tam', te: 'tel', ms: 'msa', tl: 'tgl', ca: 'cat', bg: 'bul',
+    hr: 'hrv', sr: 'srp', sk: 'slk', sl: 'slv', et: 'est', lv: 'lav', lt: 'lit',
+    is: 'isl', ga: 'gle', cn: 'zho',
+};
+
+function iso639_1to3(code: string | undefined | null): string | undefined {
+    return code ? ISO639_1_TO_3[code.trim().toLowerCase()] : undefined;
+}
+
+// TMDB keys AKAs by MARKET (`iso_3166_1`), not language. Only markets that
+// clearly imply one language are mapped; a multilingual or unknown market
+// (CA, CH, BE, IN, HK, SG, …, or empty) files its AKA under `und` rather than
+// guessing (METADATA_KEYS.md §3).
+const MARKET_TO_LANG3: Record<string, string> = {
+    US: 'eng', GB: 'eng', AU: 'eng', NZ: 'eng', IE: 'eng',
+    FR: 'fra', DE: 'deu', AT: 'deu', ES: 'spa', MX: 'spa', AR: 'spa', CO: 'spa',
+    CL: 'spa', PE: 'spa', VE: 'spa', IT: 'ita', BR: 'por', PT: 'por', JP: 'jpn',
+    KR: 'kor', CN: 'zho', TW: 'zho', RU: 'rus', NL: 'nld', SE: 'swe', NO: 'nor',
+    DK: 'dan', FI: 'fin', PL: 'pol', TR: 'tur', CZ: 'ces', HU: 'hun', GR: 'ell',
+    IL: 'heb', TH: 'tha', VN: 'vie', ID: 'ind', UA: 'ukr', RO: 'ron', IR: 'fas',
+    SA: 'ara', EG: 'ara', AE: 'ara', BG: 'bul', HR: 'hrv', RS: 'srp', SK: 'slk',
+    SI: 'slv', EE: 'est', LV: 'lav', LT: 'lit', IS: 'isl',
+};
+
+function marketToLang3(market: string | undefined | null): string {
+    return (market && MARKET_TO_LANG3[market.trim().toUpperCase()]) || 'und';
+}
+
+/**
+ * `titles/<lang3>/<name>` key-set member key (METADATA_KEYS.md §3): trimmed,
+ * whitespace collapsed, `/` (the key-set separator) written as U+2215 `∕`.
+ * `undefined` when nothing is left to name.
+ */
+function titleMemberKey(lang3: string, name: string | undefined | null): string | undefined {
+    const clean = (name ?? '').trim().replace(/\s+/g, ' ').replace(/\//g, '\u2215');
+    return clean ? `titles/${lang3}/${clean}` : undefined;
+}
+
 let apiKey: string | null = null;
 let isV4Token = false;
 let metadataLanguage = 'en-US';
@@ -218,7 +251,17 @@ async function findByImdbId(imdbId: string): Promise<any> {
 
 async function getByTmdbId(tmdbId: string, mediaType: string): Promise<any> {
     try {
-        const config = getAxiosConfig({ language: metadataLanguage });
+        // `alternative_titles` rides along so the AKAs land in `titles/*` (§3).
+        // `images` rides the same call too: the poster candidates for the
+        // `posters/{lang3}/{cid}` key-set (§6). `language` would otherwise filter
+        // them to one language, so widen it to the configured one, English and
+        // textless (`null`).
+        const lang1 = metadataLanguage.split('-')[0];
+        const config = getAxiosConfig({
+            language: metadataLanguage,
+            append_to_response: 'alternative_titles,images',
+            include_image_language: [...new Set([lang1, 'en'])].join(',') + ',null',
+        });
         const response = await axios.get(`${BASE_URL}/${mediaType}/${tmdbId}`, config);
         return response.data;
     } catch {
@@ -406,7 +449,7 @@ export async function process(
         // entry now, but tolerates the legacy raw-payload format from older builds.
         const midhash = existingMeta?.['cid_midhash256'];
         if (midhash && !forceRecompute) {
-            const cached = await readJson<any>(`${midhash}_tmdb.json`);
+            const cached = await readJson<any>(`${midhash}_aka_tmdb.json`);
             if (cached) {
                 console.log(`[tmdb] Using byte-hash cached TMDB data for ${label}`);
                 const isEntry = cached.data !== undefined;
@@ -453,7 +496,10 @@ export async function process(
             }
 
             if (!tmdbData) {
-                let title = existingMeta?.originalTitle || existingMeta?.fileName;
+                // filename-parser's guess lives under `parsedTitle` since the
+                // claims model (D12); `originalTitle` is kept as a fallback for
+                // records an NFO or an older parser wrote.
+                let title = existingMeta?.parsedTitle || existingMeta?.originalTitle || existingMeta?.fileName;
                 const year = existingMeta?.movieYear;
                 const videoType = existingMeta?.videoType;
 
@@ -485,7 +531,7 @@ export async function process(
             // Keep the exact-file cache warm too, so a future re-enrichment of
             // this same file skips straight to the byte-hash hit.
             if (midhash) {
-                await writeJson(`${midhash}_tmdb.json`, entry);
+                await writeJson(`${midhash}_aka_tmdb.json`, entry);
             }
             console.log(`[tmdb] Enriched ${label} (tmdbid=${entry.data.id})`);
         } else {
@@ -525,7 +571,9 @@ const tmdbEntryInflight = new Map<string, Promise<TmdbCacheEntry | null>>();
 // Persistent cache filename for a resolved show/movie. Includes mediaType +
 // language so a tv/movie id clash or a language switch can't return stale text.
 function tmdbCacheKey(tmdbId: string, mediaType: string): string {
-    return `tmdbid_${mediaType}_${tmdbId}_${metadataLanguage}_tmdb.json`;
+    // `_aka`: entries written before `alternative_titles` was appended carry no
+    // AKAs, so the name moved to make them refetch once.
+    return `tmdbid_${mediaType}_${tmdbId}_${metadataLanguage}_aka_tmdb.json`;
 }
 
 // Media type from a raw TMDB payload's own shape (tv payloads carry
@@ -632,6 +680,10 @@ async function applyTmdbData(
         data.original_name !== undefined;
     metadata.videoType = isTv ? 'tvshow' : 'movie';
     metadata.contentKind = isTv ? 'episode' : 'movie';
+    // `domain` is written in the same breath as `contentKind`
+    // (METADATA_KEYS.md §1) — it is the key meta-watch filters its wall on,
+    // and TMDB is precisely the identity graph that decides film vs tv here.
+    metadata.domain = isTv ? 'tv' : 'film';
 
     // Title - store both original and localized
     const originalTitle = data.original_title || data.original_name;
@@ -648,6 +700,23 @@ async function applyTmdbData(
         metadata.originalTitle = originalTitle;
     }
 
+    // Every clean name as a `titles/<lang3>/<name>` key-set member
+    // (METADATA_KEYS.md §3): the localized title under the configured metadata
+    // language, the original title under TMDB's `original_language`, and each
+    // AKA under the language its market implies (`und` when it doesn't).
+    const addTitleMember = (lang3: string, name: string | undefined) => {
+        const key = titleMemberKey(lang3, name);
+        if (key) metadata[key] = 'true';
+    };
+    addTitleMember(iso639_1to3(metadataLanguage.split('-')[0]) ?? 'und', localizedTitle);
+    addTitleMember(iso639_1to3(data.original_language) ?? 'und', originalTitle);
+    const akas = data.alternative_titles?.titles ?? data.alternative_titles?.results;
+    if (Array.isArray(akas)) {
+        for (const aka of akas) {
+            addTitleMember(marketToLang3(aka?.iso_3166_1), aka?.title);
+        }
+    }
+
     // Dates
     const releaseDate = data.release_date || data.first_air_date;
     let year: string | undefined;
@@ -662,9 +731,8 @@ async function applyTmdbData(
     // Plot (in configured language)
     if (data.overview) {
         // Extract language code from metadataLanguage (e.g., 'en-US' -> 'eng')
-        const langCode = metadataLanguage.split('-')[0];
+        const langKey = iso639_1to3(metadataLanguage.split('-')[0]);
-        const langKey = langCode === 'en' ? 'eng' : langCode;
+        if (langKey) metadata[`plot/${langKey}`] = data.overview;
-        metadata[`plot/${langKey}`] = data.overview;
         // Also set as primary plot for compatibility
         metadata['plot/eng'] = data.overview;
     }
@@ -706,6 +774,14 @@ async function applyTmdbData(
     if (posterCid) {
         await metaCore.setProperty(cid, 'poster', posterCid);
         console.log(`[tmdb] Set poster CID: ${posterCid}`);
+        // The alternatives, as the `posters/{lang3}/{cid}` key-set with `poster`
+        // among them (METADATA_KEYS.md §6). Leaf keys through PATCH — never
+        // addToSet, which writes the legacy comma-joined csv-set. Empty for a
+        // cached payload from before the `images` append: no backfill by design.
+        const members = posterMembers(data, posterCid);
+        if (Object.keys(members).length > 0) {
+            await metaCore.mergeMetadata(cid, members);
+        }
     }
 
     let backdropCid = images ? images.backdropCid : null;

src/posters.ts

@@ -0,0 +1,102 @@
+/**
+ * The `posters/{lang3}/{cid}` key-set for a TMDB-enriched video record
+ * (METADATA_KEYS.md §6): the primary poster plus the best-voted alternatives.
+ *
+ * CROSS-BINARY CONTRACT: same ranking, cap, CDN size and language rule as the
+ * tmdb card feeder's `poster_member_keys`
+ * (`meta-feeder-tmdb/feeder-plugin/card-feeder/src/card.rs`).
+ */
+
+import { encodeUrlCid } from './cid.js';
+
+/** Most members a record's `posters/*` key-set may carry, the primary included. */
+export const MAX_POSTER_MEMBERS = 10;
+
+/**
+ * CDN root + size the alternatives are referenced at. `w500`, as the card
+ * feeder's `poster_url`, so both writers mint the same locator for one image.
+ */
+export const ALT_POSTER_BASE_URL = 'https://image.tmdb.org/t/p/w500';
+
+/** One entry of a TMDB details payload's `images.posters` (`append_to_response=images`). */
+export interface TmdbImage {
+    file_path?: string;
+    iso_639_1?: string | null;
+    vote_average?: number;
+    vote_count?: number;
+}
+
+/**
+ * ISO 639-1 → ISO 639-3 (`lang3`), the 639-2/T form where B and T differ
+ * (`fra`, `deu`, `zho` — never `fre`/`ger`/`chi`). Mirrors the card feeder's
+ * `iso639_1_to_3` table.
+ */
+const ISO639_1_TO_3: Record<string, string> = {
+    en: 'eng', ja: 'jpn', fr: 'fra', de: 'deu', es: 'spa', it: 'ita', ru: 'rus',
+    ko: 'kor', zh: 'zho', pt: 'por', nl: 'nld', sv: 'swe', no: 'nor', da: 'dan',
+    fi: 'fin', pl: 'pol', tr: 'tur', ar: 'ara', hi: 'hin', th: 'tha', vi: 'vie',
+    id: 'ind', cs: 'ces', el: 'ell', he: 'heb', hu: 'hun', ro: 'ron', uk: 'ukr',
+    fa: 'fas', ms: 'msa', tl: 'tgl', ca: 'cat', nb: 'nob',
+};
+
+/**
+ * The language segment for a poster: that of the text printed on it. `zxx`
+ * (no linguistic content) when TMDB gives none — a textless poster — and
+ * `und` for a code outside the table.
+ */
+export function posterLang3(code: string | null | undefined): string {
+    const trimmed = (code ?? '').trim().toLowerCase();
+    if (!trimmed) return 'zxx';
+    return ISO639_1_TO_3[trimmed] ?? 'und';
+}
+
+function compareCandidates(a: TmdbImage, b: TmdbImage): number {
+    const byAverage = (b.vote_average ?? 0) - (a.vote_average ?? 0);
+    if (byAverage !== 0) return byAverage;
+    const byCount = (b.vote_count ?? 0) - (a.vote_count ?? 0);
+    if (byCount !== 0) return byCount;
+    const pa = a.file_path ?? '';
+    const pb = b.file_path ?? '';
+    return pa < pb ? -1 : pa > pb ? 1 : 0;
+}
+
+/**
+ * The `posters/{lang3}/{cid}` members to merge onto a record whose `poster` is
+ * `primaryPosterCid`. The primary is always a member, filed under the language
+ * of its own `images.posters` entry (`und` if TMDB did not list it); the
+ * alternatives follow as `url` locators, ranked by `vote_average`, then
+ * `vote_count`, then `file_path` (so equal payloads give equal keys), capped at
+ * {@link MAX_POSTER_MEMBERS} in total.
+ *
+ * Returns `{}` when the payload has no image list — a cached entry from before
+ * the `images` append. Without one the primary's language is unknown, and a set
+ * is better absent than mislabelled.
+ */
+export function posterMembers(data: any, primaryPosterCid: string): Record<string, 'true'> {
+    const candidates: TmdbImage[] = Array.isArray(data?.images?.posters) ? data.images.posters : [];
+    if (candidates.length === 0 || !primaryPosterCid) {
+        return {};
+    }
+    const primaryPath: string | undefined = data?.poster_path;
+    const members: Record<string, 'true'> = {};
+
+    const primary = candidates.find((img) => !!img.file_path && img.file_path === primaryPath);
+    const primaryLang = primary ? posterLang3(primary.iso_639_1) : 'und';
+    members[`posters/${primaryLang}/${primaryPosterCid}`] = 'true';
+    let count = 1;
+
+    const ranked = candidates
+        .filter((img) => typeof img.file_path === 'string' && img.file_path.trim() !== '' && img.file_path !== primaryPath)
+        .sort(compareCandidates);
+    for (const img of ranked) {
+        if (count >= MAX_POSTER_MEMBERS) break;
+        const cid = encodeUrlCid(`${ALT_POSTER_BASE_URL}/${img.file_path!.replace(/^\/+/, '')}`);
+        if (!cid) continue;
+        const key = `posters/${posterLang3(img.iso_639_1)}/${cid}`;
+        if (!(key in members)) {
+            members[key] = 'true';
+            count++;
+        }
+    }
+    return members;
+}

test/posters.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'vitest';
+import { encodeUrlCid } from '../src/cid.js';
+import { ALT_POSTER_BASE_URL, MAX_POSTER_MEMBERS, posterLang3, posterMembers, type TmdbImage } from '../src/posters.js';
+
+const alt = (path: string) => encodeUrlCid(`${ALT_POSTER_BASE_URL}${path}`)!;
+const img = (file_path: string, iso_639_1: string | null, vote_average = 0, vote_count = 0): TmdbImage => ({
+    file_path,
+    iso_639_1,
+    vote_average,
+    vote_count,
+});
+
+describe('encodeUrlCid', () => {
+    // Same vectors as meta-feeder-tmdb's vendored `hash.rs::url_cid_matches_pinned_vectors`.
+    it('matches the pinned Rust vectors', () => {
+        expect(encodeUrlCid('https://image.tmdb.org/t/p/w500/dqZENchTd7lp5zit1Q7Bkjzcxpi.jpg')).toBe(
+            'bagdcaab7nb2hi4dthixs62lnmftwkltunvsgeltpojts65bpoaxxonjqgaxwi4k2ivhgg2cumq3wy4bvpjuximkrg5bgw2t2mn4ha2jonjygo',
+        );
+    });
+
+    it('uses a two-byte length varint past 127 bytes', () => {
+        const long = `https://image.tmdb.org/t/p/w500/${'a'.repeat(100)}.jpg`;
+        expect(long.length).toBe(136);
+        expect(encodeUrlCid(long)).toBe(
+            'bagdcaaeiafuhi5dqom5c6l3jnvqwozjoorwwiyron5zgol3uf5yc65zvgayc6ylbmfqwcylbmfqwcylbmfqwcylbmfqwcylbmfqwcylbmfqwcylbmfqwcylbmfqwcylbmfqwcylbmfqwcylbmfqwcylbmfqwcylbmfqwcylbmfqwcylbmfqwcylbmfqwcylbmfqwcylbmfqwcylbmfqwcylbmfqwcltkobtq',
+        );
+    });
+
+    it('rejects anything but an absolute http(s) URL', () => {
+        expect(encodeUrlCid('/relative.jpg')).toBeNull();
+        expect(encodeUrlCid('ftp://example.com/x.jpg')).toBeNull();
+        expect(encodeUrlCid('')).toBeNull();
+    });
+});
+
+describe('posterLang3', () => {
+    it('maps to ISO 639-3, never 639-2/B', () => {
+        expect(posterLang3('fr')).toBe('fra');
+        expect(posterLang3('de')).toBe('deu');
+        expect(posterLang3('EN')).toBe('eng');
+    });
+
+    it('files a textless poster under zxx and an unknown code under und', () => {
+        expect(posterLang3(null)).toBe('zxx');
+        expect(posterLang3(undefined)).toBe('zxx');
+        expect(posterLang3('xx')).toBe('und');
+    });
+});
+
+describe('posterMembers', () => {
+    const PRIMARY_CID = 'bagacbabaecontentcid';
+
+    it('lists the primary under its own language, once, beside the alternatives', () => {
+        const data = {
+            poster_path: '/primary.jpg',
+            images: {
+                posters: [img('/alt-fr.jpg', 'fr', 5.5, 10), img('/primary.jpg', 'ja', 5, 3), img('/textless.jpg', null, 6, 1)],
+            },
+        };
+        expect(posterMembers(data, PRIMARY_CID)).toEqual({
+            [`posters/jpn/${PRIMARY_CID}`]: 'true',
+            [`posters/zxx/${alt('/textless.jpg')}`]: 'true',
+            [`posters/fra/${alt('/alt-fr.jpg')}`]: 'true',
+        });
+    });
+
+    it('ranks by vote_average then vote_count, and caps at ten including the primary', () => {
+        const posters = Array.from({ length: 15 }, (_, i) => img(`/p${String(i).padStart(2, '0')}.jpg`, 'en', i, 1));
+        const keys = Object.keys(posterMembers({ poster_path: '/primary.jpg', images: { posters } }, PRIMARY_CID));
+        expect(keys).toHaveLength(MAX_POSTER_MEMBERS);
+        expect(keys[0]).toBe(`posters/und/${PRIMARY_CID}`);
+        expect(keys[1]).toBe(`posters/eng/${alt('/p14.jpg')}`);
+        expect(keys).not.toContain(`posters/eng/${alt('/p05.jpg')}`);
+
+        const tie = Object.keys(
+            posterMembers(
+                { poster_path: '/primary.jpg', images: { posters: [img('/few.jpg', null, 5, 1), img('/many.jpg', null, 5, 9)] } },
+                PRIMARY_CID,
+            ),
+        );
+        expect(tie[1]).toBe(`posters/zxx/${alt('/many.jpg')}`);
+    });
+
+    it('writes no set when the payload has no image list', () => {
+        expect(posterMembers({ poster_path: '/primary.jpg' }, PRIMARY_CID)).toEqual({});
+        expect(posterMembers({ poster_path: '/primary.jpg', images: { posters: [] } }, PRIMARY_CID)).toEqual({});
+    });
+});

vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+        include: ['test/**/*.test.ts'],
+    },
+});