@ericsanchezok/synergy-util 3.0.23 → 3.1.0

package/dist/file-patch.d.ts

@@ -0,0 +1,31 @@
+export declare namespace FilePatch {
+    interface Hunk {
+        anchor?: string;
+        rows: {
+            kind: " " | "+" | "-";
+            text: string;
+        }[];
+        eof: boolean;
+    }
+    type Section = {
+        type: "add";
+        path: string;
+        content: string;
+    } | {
+        type: "delete";
+        path: string;
+    } | {
+        type: "update";
+        path: string;
+        move?: string;
+        hunks: Hunk[];
+    };
+    class Invalid extends Error {
+        name: string;
+    }
+    function parse(text: string): Section[];
+    function paths(text: string): string[];
+    function update(content: string, section: Extract<Section, {
+        type: "update";
+    }>): string;
+}

package/dist/file-patch.js

@@ -0,0 +1,218 @@
+// Provenance: https://github.com/openai/codex/tree/160b2b1ef62114eeb41e41e5e3be0000d944b713/codex-rs/apply-patch/src
+// Local adaptation: Codex parsing and ordered match tiers; preserve BOM and terminal-newline state. Execution stays with the selected Workspace.
+// Copyright 2025 OpenAI. Derived portions are Apache-2.0; see ../LICENSE.codex and ../NOTICE.
+export var FilePatch;
+(function (FilePatch) {
+    class Invalid extends Error {
+        name = "InvalidFilePatch";
+    }
+    FilePatch.Invalid = Invalid;
+    const whitespace = (text) => text.replace(/^\p{White_Space}+|\p{White_Space}+$/gu, "");
+    const trailingWhitespace = (text) => text.replace(/\p{White_Space}+$/gu, "");
+    function parse(text) {
+        if (text.includes("\0") || !text.isWellFormed())
+            throw new Invalid("Patch content must be valid Unicode text without NUL bytes.");
+        let lines = whitespace(text).split(/\r?\n/);
+        if (["<<EOF", "<<'EOF'", '<<"EOF"'].includes(lines[0]) && lines.at(-1)?.endsWith("EOF") && lines.length >= 4)
+            lines = lines.slice(1, -1);
+        if (whitespace(lines.shift() ?? "") !== "*** Begin Patch" || whitespace(lines.pop() ?? "") !== "*** End Patch")
+            throw new Invalid("Expected one complete *** Begin Patch / *** End Patch document, without surrounding text.");
+        const sections = [];
+        const filename = (line, prefix) => {
+            const value = line.slice(prefix.length);
+            if (!value || /[\0\r\n]/.test(value))
+                throw new Invalid("Patch paths must be nonempty and contain no NUL, CR or LF characters.");
+            return value;
+        };
+        let index = 0;
+        while (index < lines.length) {
+            const line = whitespace(lines[index++]);
+            if (line.startsWith("*** Add File: ")) {
+                const path = filename(line, "*** Add File: ");
+                const rows = [];
+                while (lines[index]?.startsWith("+"))
+                    rows.push(lines[index++].slice(1));
+                sections.push({ type: "add", path, content: rows.length ? `${rows.join("\n")}\n` : "" });
+                continue;
+            }
+            if (line.startsWith("*** Delete File: ")) {
+                sections.push({ type: "delete", path: filename(line, "*** Delete File: ") });
+                continue;
+            }
+            if (!line.startsWith("*** Update File: "))
+                throw new Invalid(`Unexpected patch line: ${line}. Expected an Add, Update or Delete File section.`);
+            const section = {
+                type: "update",
+                path: filename(line, "*** Update File: "),
+                hunks: [],
+            };
+            while (index < lines.length) {
+                const row = lines[index];
+                const structural = trailingWhitespace(row);
+                if (/^\*\*\* (?:Add File: |Update File: |Delete File: )/.test(structural))
+                    break;
+                if (!section.hunks.length && !section.move && structural.startsWith("*** Move to: ")) {
+                    section.move = filename(structural, "*** Move to: ");
+                    index++;
+                    continue;
+                }
+                let hunk = section.hunks.at(-1);
+                if (structural === "@@" || structural.startsWith("@@ ")) {
+                    if (hunk && !hunk.rows.length)
+                        throw new Invalid(`Empty hunk in ${section.path} at patch line ${index + 2}.`);
+                    section.hunks.push({ anchor: structural === "@@" ? undefined : structural.slice(3), rows: [], eof: false });
+                    index++;
+                    continue;
+                }
+                if (hunk?.eof && structural === "") {
+                    index++;
+                    continue;
+                }
+                if (structural === "*** End of File" && hunk?.rows.length) {
+                    hunk.eof = true;
+                    index++;
+                    continue;
+                }
+                const kind = row === "" ? " " : row[0];
+                if (hunk?.eof || (kind !== " " && kind !== "+" && kind !== "-"))
+                    throw new Invalid(`Invalid update row in ${section.path} at patch line ${index + 2}: ${row}. Use @@, context, +added or -removed lines.`);
+                if (!hunk) {
+                    hunk = { rows: [], eof: false };
+                    section.hunks.push(hunk);
+                }
+                hunk.rows.push({ kind, text: row.slice(1) });
+                index++;
+            }
+            if (section.hunks.some((hunk) => !hunk.rows.length))
+                throw new Invalid(`Empty update hunk in ${section.path}.`);
+            if (!section.hunks.length && !section.move)
+                throw new Invalid("An Update requires a hunk or Move to destination.");
+            sections.push(section);
+        }
+        if (!sections.length)
+            throw new Invalid("The patch contains no file sections.");
+        return sections;
+    }
+    FilePatch.parse = parse;
+    function paths(text) {
+        return parse(text).flatMap((section) => section.type === "update" && section.move ? [section.path, section.move] : [section.path]);
+    }
+    FilePatch.paths = paths;
+    function punctuation(text) {
+        return whitespace(text)
+            .replace(/[\u2010-\u2015\u2212]/g, "-")
+            .replace(/[\u2018-\u201b]/g, "'")
+            .replace(/[\u201c-\u201f]/g, '"')
+            .replace(/[\u00a0\u2002-\u200a\u202f\u205f\u3000]/g, " ");
+    }
+    function seek(lines, pattern, start, eof) {
+        if (!pattern.length)
+            return start;
+        if (pattern.length > lines.length)
+            return;
+        const first = eof ? Math.max(start, lines.length - pattern.length) : start;
+        for (const normalize of [(line) => line, trailingWhitespace, whitespace, punctuation]) {
+            const expected = pattern.map(normalize);
+            for (let index = first; index <= lines.length - pattern.length; index++)
+                if (expected.every((line, offset) => normalize(lines[index + offset]) === line))
+                    return index;
+        }
+    }
+    function update(content, section) {
+        const bom = content.startsWith("\uFEFF") ? "\uFEFF" : "";
+        const body = content.slice(bom.length);
+        const original = [];
+        for (const match of body.matchAll(/([^\r\n]*)(\r\n|\n|\r|$)/g)) {
+            if (!match[0])
+                break;
+            original.push({ text: match[1], ending: match[2] });
+        }
+        const ending = original.find((line) => line.ending)?.ending ?? "\n";
+        const terminal = original.at(-1)?.ending !== "" && original.length > 0;
+        const lines = original.map((line) => line.text);
+        const replacements = [];
+        let cursor = 0;
+        for (const [index, hunk] of section.hunks.entries()) {
+            let start = cursor;
+            const missing = (pattern, anchor = false) => {
+                const earlier = seek(lines, pattern, 0, hunk.eof);
+                const reason = earlier !== undefined && earlier < start
+                    ? `out-of-order or overlapping context at original line ${earlier + 1}; hunks must follow source order`
+                    : `no matching ${anchor ? "@@ anchor" : hunk.eof ? "end-of-file context" : "context"} at or after original line ${start + 1}`;
+                throw new Invalid(`Cannot apply hunk ${index + 1} in ${section.path}: ${reason}.\nExpected lines:\n${pattern.join("\n")}\nRead the affected range and correct this hunk.`);
+            };
+            if (hunk.anchor !== undefined) {
+                const anchor = seek(lines, [hunk.anchor], start, false);
+                if (anchor === undefined)
+                    missing([hunk.anchor], true);
+                start = anchor + 1;
+            }
+            const old = hunk.rows.filter((row) => row.kind !== "+").map((row) => row.text);
+            const next = hunk.rows.filter((row) => row.kind !== "-").map((row) => row.text);
+            if (!old.length) {
+                replacements.push({ start: original.length, length: 0, lines: next });
+                cursor = start;
+                continue;
+            }
+            let pattern = old;
+            let added = next;
+            let position = seek(lines, pattern, start, hunk.eof);
+            if (position === undefined && pattern.at(-1) === "") {
+                pattern = pattern.slice(0, -1);
+                if (added.at(-1) === "")
+                    added = added.slice(0, -1);
+                position = seek(lines, pattern, start, hunk.eof);
+            }
+            if (position === undefined)
+                missing(old);
+            let source = 0;
+            let target = 0;
+            let oldStart = 0;
+            let newStart = 0;
+            for (const row of hunk.rows) {
+                if (row.kind === " ") {
+                    if (source >= pattern.length || target >= added.length)
+                        break;
+                    if (oldStart !== source || newStart !== target)
+                        replacements.push({
+                            start: position + oldStart,
+                            length: source - oldStart,
+                            lines: added.slice(newStart, target),
+                        });
+                    oldStart = source + 1;
+                    newStart = target + 1;
+                }
+                if (row.kind !== "+")
+                    source++;
+                if (row.kind !== "-")
+                    target++;
+            }
+            if (oldStart !== pattern.length || newStart !== added.length)
+                replacements.push({
+                    start: position + oldStart,
+                    length: pattern.length - oldStart,
+                    lines: added.slice(newStart),
+                });
+            cursor = position + pattern.length;
+        }
+        replacements.sort((a, b) => a.start - b.start);
+        const result = [];
+        cursor = 0;
+        for (const replacement of replacements) {
+            if (replacement.start < cursor)
+                throw new Invalid(`Overlapping replacements in ${section.path}.`);
+            for (const line of original.slice(cursor, replacement.start))
+                result.push(line);
+            for (const text of replacement.lines)
+                result.push({ text, ending });
+            cursor = replacement.start + replacement.length;
+        }
+        for (const line of original.slice(cursor))
+            result.push(line);
+        return (bom +
+            result
+                .map((line, index) => line.text + (index === result.length - 1 ? (terminal ? line.ending || ending : "") : line.ending || ending))
+                .join(""));
+    }
+    FilePatch.update = update;
+})(FilePatch || (FilePatch = {}));

package/dist/filesystem-identity.d.ts

@@ -0,0 +1,28 @@
+type ObjectStat = {
+    dev: bigint;
+    ino: bigint;
+    birthtimeNs: bigint;
+};
+type VolumeIdentity = (filename: string) => string | undefined | Promise<string | undefined>;
+export declare function filesystemObjectID(stat: ObjectStat, volume?: string): string;
+export declare function matchesLegacyFilesystemIdentity(expected: string, actual: string | undefined, allowRemount?: boolean): boolean;
+export declare function identifyFilesystemObject(filename: string, volumeIdentity?: VolumeIdentity): Promise<{
+    directory: boolean;
+    physicalID: string;
+    legacyPhysicalID: undefined;
+} | {
+    directory: boolean;
+    physicalID: string;
+    legacyPhysicalID: string;
+}>;
+export declare function identifyDirectory(directory: string, allowMissing?: boolean, volumeIdentity?: VolumeIdentity): Promise<{
+    path: string;
+    physicalID: string;
+    legacyPhysicalID: string | undefined;
+} | {
+    legacyPhysicalID?: undefined;
+    path: string;
+    physicalID: undefined;
+}>;
+export declare function readOrCreateIdentityFile(filename: string): Promise<string>;
+export {};

package/dist/filesystem-identity.js

@@ -0,0 +1,71 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { withFileLock } from "./fs-lock";
+export function filesystemObjectID(stat, volume) {
+    return volume ? `volume-v1:${volume}:${stat.ino}:${stat.birthtimeNs}` : `${stat.dev}:${stat.ino}:${stat.birthtimeNs}`;
+}
+export function matchesLegacyFilesystemIdentity(expected, actual, allowRemount = false) {
+    if (actual === expected)
+        return true;
+    if (!allowRemount || !actual)
+        return false;
+    const previous = /^\d+:([1-9]\d*):([1-9]\d*)$/.exec(expected);
+    const current = /^\d+:([1-9]\d*):([1-9]\d*)$/.exec(actual);
+    return !!previous && !!current && previous[1] === current[1] && previous[2] === current[2];
+}
+export async function identifyFilesystemObject(filename, volumeIdentity) {
+    const stat = await fs.stat(filename, { bigint: true });
+    const directory = stat.isDirectory();
+    const overlay = directory && process.platform === "linux" && (await fs.statfs(filename, { bigint: true })).type === 0x794c7630n;
+    // OverlayFS copy-up replaces lower metadata, including birthtime, while preserving the directory.
+    // Provenance: https://docs.kernel.org/filesystems/overlayfs.html#directories
+    // Local adaptation: bind overlay directories to their mount device/inode rather than the backing layer's birthtime.
+    const legacyPhysicalID = overlay ? `overlay:${stat.dev}:${stat.ino}` : filesystemObjectID(stat);
+    const volume = !overlay && (await volumeIdentity?.(filename));
+    if (!volume)
+        return { directory, physicalID: legacyPhysicalID, legacyPhysicalID: undefined };
+    const current = await fs.stat(filename, { bigint: true });
+    if (filesystemObjectID(current) !== filesystemObjectID(stat))
+        throw new Error("Filesystem object changed during identity inspection");
+    return { directory, physicalID: filesystemObjectID(stat, volume), legacyPhysicalID };
+}
+export async function identifyDirectory(directory, allowMissing = false, volumeIdentity) {
+    const absolute = path.resolve(directory);
+    try {
+        const canonical = await fs.realpath(absolute);
+        const identity = await identifyFilesystemObject(canonical, volumeIdentity);
+        if (!identity.directory)
+            throw Object.assign(new Error("Workspace location is not a directory"), { code: "ENOTDIR" });
+        return { path: canonical, physicalID: identity.physicalID, legacyPhysicalID: identity.legacyPhysicalID };
+    }
+    catch (error) {
+        if (allowMissing && error.code === "ENOENT")
+            return { path: absolute, physicalID: undefined };
+        throw error;
+    }
+}
+export async function readOrCreateIdentityFile(filename) {
+    return withFileLock({ directory: path.join(path.dirname(filename), ".locks"), key: path.basename(filename) }, async () => {
+        const existing = await fs.readFile(filename, "utf8").catch((error) => {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw error;
+        });
+        if (existing !== undefined) {
+            if (!/^[0-9a-f-]{36}$/.test(existing))
+                throw new Error("Invalid local filesystem namespace identity");
+            return existing;
+        }
+        const identity = randomUUID();
+        const handle = await fs.open(filename, "wx", 0o600);
+        try {
+            await handle.writeFile(identity);
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        return identity;
+    });
+}

package/dist/fn.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 export declare function fn<T extends z.ZodType, Result>(schema: T, cb: (input: z.infer<T>) => Result): {
     (input: z.infer<T>): Result;
-    force(input: z.infer<T>): Result;
+    force: (input: z.infer<T>) => Result;
     schema: T;
 };

package/dist/fs-lock.d.ts

@@ -5,8 +5,12 @@ export interface FileLockOptions {
     timeoutMs?: number;
     staleMetadataMs?: number;
     timeoutMessage?: string;
+    signal?: AbortSignal;
+}
+export declare class FileLockTimeoutError extends Error {
+    readonly key: string;
+    constructor(key: string, message?: string);
 }
-export declare const HOLOS_ACCOUNTS_WRITE_LOCK_KEY = "holos-accounts:write";
 export declare const LEGACY_API_KEY_WRITE_LOCK_KEY = "legacy-api-key:write";
 export declare function authLockDirectory(synergyRoot: string): string;
 export declare function fileLockPath(directory: string, key: string): string;

package/dist/fs-lock.js

@@ -2,11 +2,19 @@ import { createHash, randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { processStartIdentity } from "./process-identity";
+import { retrySleep } from "./retry";
+export class FileLockTimeoutError extends Error {
+    key;
+    constructor(key, message) {
+        super(message ?? `Timed out acquiring file lock for ${key}`);
+        this.key = key;
+        this.name = "FileLockTimeoutError";
+    }
+}
 const DEFAULT_RETRY_MS = 25;
 const DEFAULT_TIMEOUT_MS = 60_000;
 const DEFAULT_STALE_METADATA_MS = 5_000;
 const VERIFIED_LIVE_TTL_MS = 1_000;
-export const HOLOS_ACCOUNTS_WRITE_LOCK_KEY = "holos-accounts:write";
 export const LEGACY_API_KEY_WRITE_LOCK_KEY = "legacy-api-key:write";
 export function authLockDirectory(synergyRoot) {
     return path.join(synergyRoot, "data", "auth", ".locks");
@@ -18,6 +26,7 @@ export function fileLockPath(directory, key) {
 export async function withFileLock(options, fn) {
     const lock = await acquireFileLock(options);
     try {
+        options.signal?.throwIfAborted();
         return await fn();
     }
     finally {
@@ -25,6 +34,7 @@ export async function withFileLock(options, fn) {
     }
 }
 async function acquireFileLock(options) {
+    options.signal?.throwIfAborted();
     const retryMs = options.retryMs ?? DEFAULT_RETRY_MS;
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const staleMetadataMs = options.staleMetadataMs ?? DEFAULT_STALE_METADATA_MS;
@@ -36,8 +46,9 @@ async function acquireFileLock(options) {
     const ownerToken = randomUUID();
     const verifiedLiveUntil = new Map();
     while (true) {
+        options.signal?.throwIfAborted();
         if (Date.now() - startedAt >= timeoutMs) {
-            throw new Error(options.timeoutMessage ?? `Timed out acquiring file lock for ${options.key}`);
+            throw new FileLockTimeoutError(options.key, options.timeoutMessage);
         }
         let handle;
         try {
@@ -60,7 +71,7 @@ async function acquireFileLock(options) {
                 if (await removeStaleLock(filename, snapshot.contents))
                     continue;
             }
-            await sleep(retryMs);
+            await retrySleep(Math.min(retryMs, Math.max(0, timeoutMs - (Date.now() - startedAt))), options.signal);
             continue;
         }
         try {
@@ -188,6 +199,3 @@ function processExists(pid) {
         return error.code !== "ESRCH";
     }
 }
-async function sleep(milliseconds) {
-    await new Promise((resolve) => setTimeout(resolve, milliseconds));
-}

package/dist/input-assistance.d.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+export declare namespace InputAssistance {
+    const Proposal: z.ZodObject<{
+        producer: z.ZodString;
+        proposalID: z.ZodString;
+        generatedFingerprint: z.ZodString;
+        acceptedFingerprint: z.ZodString;
+    }, z.core.$strip>;
+    const Info: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        proposals: z.ZodArray<z.ZodObject<{
+            producer: z.ZodString;
+            proposalID: z.ZodString;
+            generatedFingerprint: z.ZodString;
+            acceptedFingerprint: z.ZodString;
+        }, z.core.$strip>>;
+        submittedFingerprint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type Info = z.infer<typeof Info>;
+    const Metadata: z.ZodObject<{
+        assistance: z.ZodOptional<z.ZodObject<{
+            version: z.ZodLiteral<1>;
+            proposals: z.ZodArray<z.ZodObject<{
+                producer: z.ZodString;
+                proposalID: z.ZodString;
+                generatedFingerprint: z.ZodString;
+                acceptedFingerprint: z.ZodString;
+            }, z.core.$strip>>;
+            submittedFingerprint: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$loose>;
+    function read(metadata: unknown): Info | undefined;
+    function fingerprint(text: string): string;
+    function merge(...values: Array<Info | undefined>): Info | undefined;
+    function accept(previous: Info | undefined, input: {
+        producer: string;
+        proposalID: string;
+        generated: string;
+        accepted: string;
+    }): {
+        version: 1;
+        proposals: {
+            producer: string;
+            proposalID: string;
+            generatedFingerprint: string;
+            acceptedFingerprint: string;
+        }[];
+        submittedFingerprint?: string | undefined;
+    };
+    function submit(value: Info | undefined, text: string): Info | undefined;
+}

package/dist/input-assistance.js

@@ -0,0 +1,61 @@
+import { z } from "zod";
+export var InputAssistance;
+(function (InputAssistance) {
+    InputAssistance.Proposal = z.object({
+        producer: z.string().min(1).max(128),
+        proposalID: z.string().min(1).max(256),
+        generatedFingerprint: z.string(),
+        acceptedFingerprint: z.string(),
+    });
+    InputAssistance.Info = z
+        .object({
+        version: z.literal(1),
+        proposals: z.array(InputAssistance.Proposal).min(1).max(128),
+        submittedFingerprint: z.string().optional(),
+    })
+        .meta({ ref: "InputAssistance" });
+    InputAssistance.Metadata = z.looseObject({ assistance: InputAssistance.Info.optional() });
+    function read(metadata) {
+        if (!metadata || typeof metadata !== "object" || !("assistance" in metadata))
+            return;
+        const result = InputAssistance.Info.safeParse(metadata.assistance);
+        return result.success ? result.data : undefined;
+    }
+    InputAssistance.read = read;
+    // A portable diagnostic fingerprint, never an authentication or integrity check.
+    function fingerprint(text) {
+        let hash = 0xcbf29ce484222325n;
+        for (const byte of new TextEncoder().encode(text))
+            hash = BigInt.asUintN(64, (hash ^ BigInt(byte)) * 0x100000001b3n);
+        return `fnv1a64:${hash.toString(16).padStart(16, "0")}`;
+    }
+    InputAssistance.fingerprint = fingerprint;
+    function merge(...values) {
+        const proposals = new Map();
+        for (const value of values)
+            for (const proposal of value?.proposals ?? [])
+                proposals.set(JSON.stringify([proposal.producer, proposal.proposalID]), proposal);
+        if (!proposals.size)
+            return;
+        return InputAssistance.Info.parse({ version: 1, proposals: [...proposals.values()] });
+    }
+    InputAssistance.merge = merge;
+    function accept(previous, input) {
+        return merge(previous, {
+            version: 1,
+            proposals: [
+                {
+                    producer: input.producer,
+                    proposalID: input.proposalID,
+                    generatedFingerprint: fingerprint(input.generated),
+                    acceptedFingerprint: fingerprint(input.accepted),
+                },
+            ],
+        });
+    }
+    InputAssistance.accept = accept;
+    function submit(value, text) {
+        return value && { ...InputAssistance.Info.parse(value), submittedFingerprint: fingerprint(text) };
+    }
+    InputAssistance.submit = submit;
+})(InputAssistance || (InputAssistance = {}));

package/dist/installed-launcher.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export declare const InstallationPin: z.ZodObject<{
+    id: z.ZodUUID;
+    sha256: z.ZodString;
+}, z.core.$strict>;
+export declare const INSTALLED_WORKER_CONTROL_VERSION = 1;
+export declare const InstalledWorkerReady: z.ZodObject<{
+    synergyLauncher: z.ZodLiteral<"worker-ready">;
+    version: z.ZodLiteral<1>;
+    runner: z.ZodLiteral<"__plugin-runtime-runner">;
+    pin: z.ZodObject<{
+        id: z.ZodUUID;
+        sha256: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const CORE_RUNNERS: readonly ["storage-worker-runner", "owned-process-runner", "observability-worker-runner", "agent-turn-runner", "policy-worker-runner", "plugin-runtime-runner", "storage-maintenance-runner"];
+export declare function installedWorkerEnvironment(env: Record<string, string | undefined>): Record<string, string>;
+export declare function installedWorkerCommand(env: Record<string, string | undefined>, runner: string, args?: string[]): string[] | undefined;

package/dist/installed-launcher.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export const InstallationPin = z.object({ id: z.uuid(), sha256: z.string().regex(/^[a-f0-9]{64}$/) }).strict();
+export const INSTALLED_WORKER_CONTROL_VERSION = 1;
+export const InstalledWorkerReady = z
+    .object({
+    synergyLauncher: z.literal("worker-ready"),
+    version: z.literal(INSTALLED_WORKER_CONTROL_VERSION),
+    runner: z.literal("__plugin-runtime-runner"),
+    pin: InstallationPin,
+})
+    .strict();
+export const CORE_RUNNERS = [
+    "storage-worker-runner",
+    "owned-process-runner",
+    "observability-worker-runner",
+    "agent-turn-runner",
+    "policy-worker-runner",
+    "plugin-runtime-runner",
+    "storage-maintenance-runner",
+];
+export function installedWorkerEnvironment(env) {
+    return Object.fromEntries([
+        "SYNERGY_HOME",
+        "SYNERGY_RUNTIME_ROOT",
+        "SYNERGY_INSTALLATION_ROOT",
+        "SYNERGY_INSTALLATION_PIN",
+        "SYNERGY_LAUNCHER_COMMAND",
+        "SYNERGY_LAUNCHER_CONTROL_VERSION",
+    ].flatMap((key) => (env[key] === undefined ? [] : [[key, env[key]]])));
+}
+export function installedWorkerCommand(env, runner, args = []) {
+    if (!env.SYNERGY_INSTALLATION_PIN)
+        return undefined;
+    InstallationPin.parse(JSON.parse(env.SYNERGY_INSTALLATION_PIN));
+    if (!env.SYNERGY_LAUNCHER_COMMAND)
+        throw new Error("An installed worker requires its verified launcher");
+    const command = z.array(z.string().min(1)).min(1).parse(JSON.parse(env.SYNERGY_LAUNCHER_COMMAND));
+    return [...command, runner, ...args];
+}

package/dist/io-retry.d.ts

@@ -0,0 +1,11 @@
+export declare function isRetryableIOError(error: unknown): boolean;
+/**
+ * Read a file as UTF-8, retrying transient lock errors (EPERM/EACCES/EBUSY).
+ * Non-retryable errors (ENOENT, malformed content) and retry exhaustion
+ * propagate so callers keep fail-closed semantics instead of silently
+ * treating an unreadable store as empty.
+ */
+export declare function readFileWithRetry(file: string, options?: {
+    attempts?: number;
+    delayMs?: number;
+}): Promise<string>;

package/dist/io-retry.js

@@ -0,0 +1,36 @@
+import fs from "fs/promises";
+/**
+ * Transient filesystem errors that occur when another process briefly holds a
+ * file handle (Windows sharing violations, antivirus scans, OneDrive sync).
+ * Retrying is safe; a permanent permission or data error must not be masked.
+ */
+const RETRYABLE_CODES = new Set(["EPERM", "EACCES", "EBUSY"]);
+export function isRetryableIOError(error) {
+    if (typeof error !== "object" || error === null)
+        return false;
+    const code = error.code;
+    return typeof code === "string" && RETRYABLE_CODES.has(code);
+}
+/**
+ * Read a file as UTF-8, retrying transient lock errors (EPERM/EACCES/EBUSY).
+ * Non-retryable errors (ENOENT, malformed content) and retry exhaustion
+ * propagate so callers keep fail-closed semantics instead of silently
+ * treating an unreadable store as empty.
+ */
+export async function readFileWithRetry(file, options) {
+    const attempts = Math.max(1, options?.attempts ?? 3);
+    const delayMs = Math.max(0, options?.delayMs ?? 100);
+    let lastError;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+        try {
+            return await fs.readFile(file, "utf8");
+        }
+        catch (error) {
+            lastError = error;
+            if (!isRetryableIOError(error) || attempt === attempts)
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+    }
+    throw lastError;
+}

package/dist/json-value.d.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+declare const json: z.ZodJSONSchema;
+export declare const JsonValue: z.ZodType<z.infer<typeof json>>;
+export {};