@wirecat/cli-core 0.395.0 → 0.397.0

package/dist/meetings/mcp/index.d.ts

@@ -38,6 +38,7 @@ export declare const meetingTools: ({
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
+            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -53,11 +54,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
-            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
+            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -75,11 +76,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
-            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
+            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -101,7 +102,6 @@ export declare const meetingTools: ({
                 minimum: number;
             };
             query?: undefined;
-            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
@@ -188,6 +188,7 @@ export declare const meetingTools: ({
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
+            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -203,11 +204,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
-            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
+            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -225,11 +226,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
-            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
+            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -251,7 +252,6 @@ export declare const meetingTools: ({
                 minimum: number;
             };
             query?: undefined;
-            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
@@ -338,6 +338,7 @@ export declare const meetingTools: ({
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
+            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -353,11 +354,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
-            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
+            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -375,11 +376,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
-            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
+            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -401,7 +402,6 @@ export declare const meetingTools: ({
                 minimum: number;
             };
             query?: undefined;
-            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
@@ -488,6 +488,7 @@ export declare const meetingTools: ({
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
+            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -503,11 +504,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
-            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
+            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -525,11 +526,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
-            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
+            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -551,7 +552,6 @@ export declare const meetingTools: ({
                 minimum: number;
             };
             query?: undefined;
-            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
@@ -638,6 +638,7 @@ export declare const meetingTools: ({
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
+            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -653,11 +654,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
-            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
+            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -675,11 +676,11 @@ export declare const meetingTools: ({
             format?: undefined;
             transcript_id?: undefined;
             query?: undefined;
-            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;
         } | {
+            limit?: undefined;
             event_id?: undefined;
             series_id?: undefined;
             page?: undefined;
@@ -701,7 +702,6 @@ export declare const meetingTools: ({
                 minimum: number;
             };
             query?: undefined;
-            limit?: undefined;
             scan_limit?: undefined;
             max_read_bytes?: undefined;
             cursor?: undefined;

package/dist/parity/catalogue.js

@@ -16,7 +16,7 @@ export const renderCatalogue = (manifest) => {
         add(name, `every command${where(entry)}`);
     for (const [path, row] of Object.entries(manifest.commands))
         for (const [name, entry] of Object.entries(row.options ?? {}))
-            add(name, `\`${path}\`${where(entry)}`);
+            add(name, `\`${path}\`${where(entry)}${typeof entry !== "string" && entry.wording ? ` — ${cell(entry.wording)}` : ""}`);
     const rows = Object.entries(manifest.options).map(([name, option]) => {
         const meaning = option.note ? `${option.meaning}. **${option.note}**` : option.meaning;
         return `| \`${name}\` | ${option.value ? `\`${cell(option.value)}\`` : ""} | ${cell(meaning)} | ${option.default === undefined ? "" : `\`${cell(option.default)}\``} | ${(commands.get(name) ?? []).join(", ")} |`;

package/dist/parity/manifest.d.ts

@@ -11,7 +11,9 @@ export interface Presence {
     planned?: Record<Cli, string>;
 }
 /** An option: `"all"` alone, or where it is and why not elsewhere. */
-export type Entry = "all" | Presence;
+export type Entry = "all" | (Presence & {
+    wording?: string;
+});
 export interface CommandRow extends Presence {
     /** On a planned row: it stands for every path below it, which then have no rows of their own. */
     subtree?: boolean;

package/dist/parity/manifest.js

@@ -18,6 +18,8 @@ const entryProblems = (clis, where, entry) => {
     const names = entry.in === "all" ? [] : Array.isArray(entry.in) ? entry.in : undefined;
     if (names === undefined)
         return [`${where}: "in" is neither "all" nor a list of CLIs`];
+    if ("wording" in entry && (typeof entry.wording !== "string" || entry.wording.trim() === ""))
+        problems.push(`${where}: a wording exception needs its reason`);
     const planned = Object.entries(entry.planned ?? {});
     for (const name of [...names, ...planned.map(([name]) => name)])
         if (!clis.includes(name))

package/dist/parity/wording.js

@@ -49,6 +49,8 @@ export const wordingProblems = (manifest, programs) => {
         const sentences = clis.map((cli) => said.get(cli)?.get(where));
         if (sentences.every((sentence) => sentence === sentences[0]))
             return [];
+        if (typeof entry !== "string" && entry.wording && sentences.every((sentence) => sentence !== undefined))
+            return [];
         return [`${where}: ${clis.map((cli, index) => `${cli} says "${sentences[index]}"`).join(", ")}`];
     });
 };

package/dist/search/lucene/registry.js

@@ -294,11 +294,11 @@ export const QUERY_FIELDS = [
     {
         name: "transcript",
         example: "transcript:invoice",
-        index: "attachment_words (voice transcripts)",
+        index: "attachment_words ∪ transcript_stems; garbled spellings from transcript_words_vocab",
         aliases: [],
         type: "txt",
         operators: terms,
-        normalization: "NFKD/marks/NFC/lowercase v1; what a voice message said, as transcribed",
+        normalization: "any form of the word (Snowball), widened to spellings speech recognition garbles; what a voice message said",
         support: "A2",
         validate: filled,
     },

package/dist/sends/permissions.js

@@ -271,6 +271,7 @@ const NAMED_WRITE_KEYS = [
     "stats.contacts.top.sync-first",
     "account.sessions.list",
     "attachments.extract",
+    "attachments.move",
     "attachments.text.set",
     "bot.callbacks.answer",
     "bot.chats.action",
@@ -388,6 +389,8 @@ export const readKeysForCommand = (path) => {
     const key = keyForCommand(path);
     if (!key)
         return [];
+    if (path[0] === "attachments" && path[1] === "download")
+        return [key, "messages", "chats"];
     if (path[0] === "attachments" && (path[1] === "extract" || path[1] === "show"))
         return [key, "messages"];
     if (path[0] === "store" && path[1] === "gaps" && path[2] === "repair")
@@ -430,6 +433,10 @@ export const keyForCommand = (path) => {
     // Picture models moved from `models image` (0.270.0); a model is housekeeping wherever it is listed.
     if (top === "images" && next === "models")
         return null;
+    if (top === "attachments" && (next === "check" || next === "jobs"))
+        return null;
+    if (top === "attachments" && next === "download")
+        return "messages";
     if (top === "store" && next !== undefined && STORE_MAINTENANCE.has(next))
         return null;
     // The agent's answers write only to the local store: their own key, so read-only messages can still link (phase 4 A10).

package/dist/services/index.d.ts

@@ -2,6 +2,11 @@ import { type BotCheckService } from "../botcheck/service.js";
 export type { ContextEvidenceItem, ContextEvidencePage, ContextEvidenceReader, ContextEvidenceRequest, ContextIndex, ContextReadLimits, ContextReadUsage, ContextRecordReader, ContextSource, ScopedContextEvidenceReader, } from "./context-evidence.js";
 export { contextEvidenceFingerprint, createContextEvidenceReader } from "./context-evidence.js";
 export { excerpt } from "./excerpt.js";
+export type { MediaArchiveOptions, MediaArchivePorts } from "./media-archive.js";
+export { archiveMedia, checkMediaArchive } from "./media-archive.js";
+export type { MediaArchiveEntry, MediaIdentity } from "./media-archive-manifest.js";
+export type { MoveMediaArchiveOptions } from "./media-archive-move.js";
+export { moveMediaArchive } from "./media-archive-move.js";
 export { type DownloadedModel, downloadImageModel, downloadTextModel, type ModelDownloadOptions, } from "./model-downloads.js";
 export type { ProjectEvidenceContext, ProjectEvidenceItem, ProjectGathering, ProjectGatheringPorts, ProjectGatheringStop, ProjectIndexCatchUp, ProjectSourceFetcher, } from "./project-gathering.js";
 export { gatherProjectEvidence } from "./project-gathering.js";

package/dist/services/index.js

@@ -1,6 +1,8 @@
 import { botCheckService } from "../botcheck/service.js";
 export { contextEvidenceFingerprint, createContextEvidenceReader } from "./context-evidence.js";
 export { excerpt } from "./excerpt.js";
+export { archiveMedia, checkMediaArchive } from "./media-archive.js";
+export { moveMediaArchive } from "./media-archive-move.js";
 export { downloadImageModel, downloadTextModel, } from "./model-downloads.js";
 export { gatherProjectEvidence } from "./project-gathering.js";
 export { documentPassage, storedMessageNeighbours, storedNeighbours } from "./project-gathering-around.js";

package/dist/services/media-archive-files.d.ts

@@ -0,0 +1,10 @@
+import type { RemoteFile } from "../ports/messenger.js";
+import { type MediaArchiveEntry, type MediaIdentity } from "./media-archive-manifest.js";
+export declare const archiveMediaFile: (root: string, identity: MediaIdentity, kind: string, file: () => Promise<RemoteFile>, beforeWrite: () => Promise<void>, signal?: AbortSignal, metadata?: {
+    messageTime?: string;
+    mime?: string;
+    expected?: {
+        size: number;
+        sha256: string;
+    };
+}) => Promise<MediaArchiveEntry>;

package/dist/services/media-archive-files.js

@@ -0,0 +1,110 @@
+import { lstat } from "node:fs/promises";
+import { CliError } from "@wirecat/cli-base";
+import { NativeRecordingPartialStore, NativeRecordingPublication } from "../persistence/native/index.js";
+import { commitMediaEntry, mediaKey, missingMediaFile, parseMediaEntry, } from "./media-archive-manifest.js";
+const validator = '"media-completed-v1"';
+const maximumFileBytes = 64 * 1024 * 1024 * 1024;
+export const archiveMediaFile = async (root, identity, kind, file, beforeWrite, signal, metadata = {}) => {
+    const key = mediaKey(identity);
+    const locator = {
+        provider: identity.provider,
+        account: identity.account,
+        occurrenceId: mediaKey({ ...identity, position: 0 }),
+        assetId: key,
+    };
+    const storage = new NativeRecordingPartialStore(root, locator, {
+        prefix: ".media-partial-",
+        persistent: true,
+        maxBytes: maximumFileBytes,
+        signal,
+    });
+    const publication = new NativeRecordingPublication(root, locator, {
+        prefix: ".media-publication-",
+        filename: `${key}.bin`,
+        maxBytes: maximumFileBytes,
+        metadataLimit: 16384,
+        codec: {
+            encode: JSON.stringify,
+            decode: (value) => {
+                const one = parseMediaEntry(value);
+                if (mediaKey(one) !== key || one.kind !== kind)
+                    throw new CliError("validation_error", "media recovery identity mismatch");
+                if (metadata.expected && (one.size !== metadata.expected.size || one.sha256 !== metadata.expected.sha256))
+                    throw new CliError("validation_error", "media recovery checksum differs from the source");
+                if (metadata.expected && (one.messageTime !== metadata.messageTime || one.mime !== metadata.mime))
+                    throw new CliError("validation_error", "media recovery metadata differs from the source");
+                return one;
+            },
+        },
+        evidence: (one) => ({ size: one.size, sha256: one.sha256, validator }),
+        signal,
+    });
+    const commit = async (one) => {
+        await beforeWrite();
+        await commitMediaEntry(root, one, beforeWrite);
+    };
+    let exists = false;
+    try {
+        await lstat(publication.finalPath);
+        exists = true;
+    }
+    catch (error) {
+        if (!missingMediaFile(error))
+            throw error;
+    }
+    const intent = await publication.read();
+    if (exists) {
+        await beforeWrite();
+        return publication.recover(storage.path, () => storage.load(locator), commit);
+    }
+    if (intent) {
+        const partial = await storage.load(locator);
+        if (!partial ||
+            partial.offset !== intent.size ||
+            partial.sha256 !== intent.sha256 ||
+            partial.validator !== validator)
+            throw new CliError("validation_error", "completed media recovery evidence is missing; choose a new destination");
+        await beforeWrite();
+        await publication.publish(storage.path, intent, () => commit(intent));
+        return intent;
+    }
+    const remote = await file();
+    if (remote.size !== undefined &&
+        (!Number.isSafeInteger(remote.size) || remote.size < 0 || remote.size > maximumFileBytes))
+        throw new CliError("validation_error", "invalid media download size");
+    await beforeWrite();
+    // No range validators are exposed by messenger streams. A cut download restarts; only finish writes a checkpoint.
+    const writer = await storage.open(locator, { validator, total: remote.size ?? null });
+    let proof;
+    try {
+        let received = 0;
+        for await (const chunk of remote.bytes()) {
+            await beforeWrite();
+            await writer.write(chunk);
+            received += chunk.length;
+        }
+        if (remote.size !== undefined && received !== remote.size)
+            throw new CliError("invalid_response", "media download ended with a different size");
+        proof = await writer.finish();
+    }
+    finally {
+        await writer.close();
+    }
+    if (metadata.expected && (proof.size !== metadata.expected.size || proof.sha256 !== metadata.expected.sha256))
+        throw new CliError("validation_error", "media source changed while copying; nothing was published");
+    const mime = (metadata.mime ?? remote.mime)?.split(";", 1)[0]?.trim().toLowerCase();
+    const entry = parseMediaEntry({
+        ...identity,
+        version: 1,
+        kind,
+        path: `${key}.bin`,
+        ...proof,
+        ...(metadata.messageTime ? { messageTime: metadata.messageTime } : {}),
+        ...(mime && mime.length <= 127 && /^[a-z0-9.+-]+\/[a-z0-9.+-]+$/.test(mime) ? { mime } : {}),
+    });
+    await beforeWrite();
+    await publication.write(entry);
+    await beforeWrite();
+    await publication.publish(storage.path, entry, () => commit(entry));
+    return entry;
+};

package/dist/services/media-archive-locks.d.ts

@@ -0,0 +1,6 @@
+/** Acquire in canonical path order, then recheck the graph before trusting relocation records. */
+export declare const withMediaArchiveLocks: <T>(directory: string, signal: AbortSignal | undefined, run: (root: string, beforeWrite: () => Promise<void>) => Promise<T>, options?: {
+    create?: boolean;
+    additional?: readonly string[];
+    createAdditional?: boolean;
+}) => Promise<T>;

package/dist/services/media-archive-locks.js

@@ -0,0 +1,71 @@
+import { mkdir, realpath } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { CliError } from "@wirecat/cli-base";
+import { acquireLock } from "../files/index.js";
+import { missingMediaFile, readMediaManifests } from "./media-archive-manifest.js";
+const archiveLocations = async (initial, signal) => {
+    const roots = new Set();
+    const queued = new Set(initial.map((directory) => resolve(directory)));
+    const pending = [...queued];
+    for (let at = 0; at < pending.length; at++) {
+        signal?.throwIfAborted();
+        let root;
+        try {
+            root = await realpath(pending[at]);
+        }
+        catch (error) {
+            if (missingMediaFile(error))
+                continue;
+            throw error;
+        }
+        if (roots.has(root))
+            continue;
+        if (roots.size >= 64)
+            throw new CliError("validation_error", "too many linked media archive directories");
+        roots.add(root);
+        for (const entry of await readMediaManifests(root, signal))
+            if (entry.relocatedTo) {
+                const location = resolve(entry.relocatedTo);
+                if (!queued.has(location)) {
+                    queued.add(location);
+                    pending.push(location);
+                }
+            }
+    }
+    return [...roots].sort();
+};
+/** Acquire in canonical path order, then recheck the graph before trusting relocation records. */
+export const withMediaArchiveLocks = async (directory, signal, run, options = {}) => {
+    signal?.throwIfAborted();
+    if (options.create)
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+    const root = await realpath(directory);
+    if (options.createAdditional)
+        for (const other of options.additional ?? [])
+            await mkdir(other, { recursive: true, mode: 0o700 });
+    const initial = [root, ...(options.additional ?? [])];
+    for (let attempt = 0; attempt < 3; attempt++) {
+        const locations = await archiveLocations(initial, signal);
+        const leases = [];
+        try {
+            for (const location of locations)
+                leases.push(await acquireLock(join(location, ".media-writers"), { signal }));
+            const current = await archiveLocations(initial, signal);
+            if (current.some((location) => !locations.includes(location)))
+                continue;
+            const beforeWrite = async () => {
+                signal?.throwIfAborted();
+                for (const lease of leases)
+                    if (!(await lease.held()))
+                        throw new CliError("validation_error", "media archive writer lost its lock");
+            };
+            await beforeWrite();
+            return await run(root, beforeWrite);
+        }
+        finally {
+            for (const lease of leases.reverse())
+                await lease.release();
+        }
+    }
+    throw new CliError("validation_error", "archive locations changed during locking; run the command again");
+};

package/dist/services/media-archive-manifest.d.ts

@@ -0,0 +1,29 @@
+export interface MediaIdentity {
+    provider: string;
+    account: string;
+    chat: string;
+    message: string;
+    position: number;
+}
+export interface MediaArchiveEntry extends MediaIdentity {
+    version: 1;
+    kind: string;
+    path: string;
+    size: number;
+    sha256: string;
+    messageTime?: string;
+    mime?: string;
+    relocatedTo?: string;
+}
+export declare const mediaKey: (one: MediaIdentity) => string;
+export declare const mediaManifestName: (one: MediaIdentity) => string;
+export declare const missingMediaFile: (error: unknown) => boolean;
+export declare const parseMediaEntry: (value: unknown) => MediaArchiveEntry;
+export declare const mediaFingerprint: (path: string, signal?: AbortSignal) => Promise<{
+    size: number;
+    sha256: string;
+}>;
+export declare const readMediaManifests: (root: string, signal?: AbortSignal) => Promise<MediaArchiveEntry[]>;
+export declare const verifyMediaEntry: (root: string, one: MediaArchiveEntry, signal?: AbortSignal) => Promise<boolean>;
+export declare const sameMediaCopy: (a: MediaArchiveEntry, b: MediaArchiveEntry) => boolean;
+export declare const commitMediaEntry: (root: string, one: MediaArchiveEntry, beforePublish: () => Promise<void>) => Promise<void>;

package/dist/services/media-archive-manifest.js

@@ -0,0 +1,116 @@
+import { createHash } from "node:crypto";
+import { readdir } from "node:fs/promises";
+import { isAbsolute, join, resolve } from "node:path";
+import { CliError } from "@wirecat/cli-base";
+import { openOrdinaryFile, readBoundedUtf8File, writeFileAtomic } from "../files/index.js";
+export const mediaKey = (one) => createHash("sha256")
+    .update(JSON.stringify([one.provider, one.account, one.chat, one.message, one.position]))
+    .digest("hex");
+export const mediaManifestName = (one) => `.media-archive-${mediaKey(one)}.json`;
+export const missingMediaFile = (error) => typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+export const parseMediaEntry = (value) => {
+    const one = value;
+    if (!one ||
+        typeof one !== "object" ||
+        Array.isArray(one) ||
+        one.version !== 1 ||
+        Object.keys(one).some((key) => ![
+            "account",
+            "chat",
+            "kind",
+            "message",
+            "path",
+            "position",
+            "provider",
+            "sha256",
+            "size",
+            "version",
+            "messageTime",
+            "mime",
+            "relocatedTo",
+        ].includes(key)) ||
+        (one.messageTime !== undefined &&
+            (typeof one.messageTime !== "string" ||
+                !Number.isFinite(Date.parse(one.messageTime)) ||
+                new Date(one.messageTime).toISOString() !== one.messageTime)) ||
+        (one.mime !== undefined &&
+            (typeof one.mime !== "string" || one.mime.length > 127 || !/^[a-z0-9.+-]+\/[a-z0-9.+-]+$/.test(one.mime))) ||
+        (one.relocatedTo !== undefined &&
+            (typeof one.relocatedTo !== "string" || !isAbsolute(one.relocatedTo) || /[\p{Cc}]/u.test(one.relocatedTo))) ||
+        [one.provider, one.account, one.chat, one.message, one.kind].some((text) => typeof text !== "string" || !text.trim() || text.length > 512 || /[\0\r\n]/.test(text)) ||
+        !Number.isSafeInteger(one.position) ||
+        one.position < 0 ||
+        !Number.isSafeInteger(one.size) ||
+        one.size < 0 ||
+        typeof one.sha256 !== "string" ||
+        !/^[a-f0-9]{64}$/.test(one.sha256) ||
+        one.path !== `${mediaKey(one)}.bin`)
+        throw new CliError("validation_error", "invalid media archive manifest");
+    return { ...one };
+};
+export const mediaFingerprint = async (path, signal) => {
+    signal?.throwIfAborted();
+    const file = await openOrdinaryFile(path);
+    try {
+        const hash = createHash("sha256");
+        let size = 0;
+        for await (const chunk of file.createReadStream({ autoClose: false, ...(signal ? { signal } : {}) })) {
+            signal?.throwIfAborted();
+            hash.update(chunk);
+            size += chunk.length;
+        }
+        return { size, sha256: hash.digest("hex") };
+    }
+    finally {
+        await file.close();
+    }
+};
+export const readMediaManifests = async (root, signal) => {
+    const entries = [];
+    for (const name of await readdir(root)) {
+        signal?.throwIfAborted();
+        if (!name.startsWith(".media-archive-") || !name.endsWith(".json"))
+            continue;
+        let one;
+        try {
+            one = parseMediaEntry(JSON.parse(await readBoundedUtf8File(join(root, name), { maxBytes: 16384 })));
+        }
+        catch {
+            throw new CliError("validation_error", "invalid media archive manifest");
+        }
+        if (name !== mediaManifestName(one))
+            throw new CliError("validation_error", "media manifest identity mismatch");
+        entries.push(one);
+    }
+    return entries;
+};
+export const verifyMediaEntry = async (root, one, signal) => {
+    let location = resolve(root);
+    let entry = one;
+    const visited = new Set();
+    while (entry.relocatedTo !== undefined) {
+        signal?.throwIfAborted();
+        if (visited.has(location) || visited.size >= 64)
+            throw new CliError("validation_error", "media archive relocation cycle or excessive depth");
+        visited.add(location);
+        location = resolve(entry.relocatedTo);
+        const target = parseMediaEntry(JSON.parse(await readBoundedUtf8File(join(location, mediaManifestName(one)), { maxBytes: 16384 })));
+        if (!sameMediaCopy(one, target))
+            return false;
+        entry = target;
+    }
+    if (visited.has(location))
+        return false;
+    const actual = await mediaFingerprint(join(location, one.path), signal);
+    return actual.size === one.size && actual.sha256 === one.sha256;
+};
+export const sameMediaCopy = (a, b) => mediaKey(a) === mediaKey(b) &&
+    a.size === b.size &&
+    a.sha256 === b.sha256 &&
+    a.kind === b.kind &&
+    a.messageTime === b.messageTime &&
+    a.mime === b.mime;
+export const commitMediaEntry = (root, one, beforePublish) => writeFileAtomic(join(root, mediaManifestName(one)), JSON.stringify(parseMediaEntry(one)), {
+    overwrite: false,
+    beforePublish,
+});