@skastr0/prism-sdk 0.3.0

package/dist/mcp/uds-singleton.js

@@ -0,0 +1,360 @@
+import { mkdir, unlink, readFile, open } from "node:fs/promises";
+import { dirname } from "node:path";
+import { existsSync } from "node:fs";
+import { Socket } from "node:net";
+/**
+ * Error type for singleton/stale-socket violations.
+ */
+export class UDSSingletonError extends Error {
+    context;
+    kind = "uds-singleton-error";
+    constructor(message, context) {
+        super(message);
+        this.context = context;
+        this.name = "UDSSingletonError";
+    }
+}
+/**
+ * Attempt to connect to an existing Unix domain socket to detect a live daemon.
+ *
+ * Returns "live" if a connection succeeds (live daemon).
+ * Returns "stale" if connection is refused/times out (socket file exists but no daemon).
+ * Returns "available" if the socket file does not exist.
+ *
+ * @param socketPath Absolute path to the UDS socket
+ * @param timeoutMs How long to wait before considering a connection attempt stale
+ */
+export async function probeSocketLiveness(socketPath, timeoutMs = 500) {
+    // Socket file does not exist — path is available
+    if (!existsSync(socketPath)) {
+        return "available";
+    }
+    // Socket file exists; try connecting to detect a live daemon
+    return new Promise((resolve) => {
+        const socket = new Socket();
+        let resolved = false;
+        const timeout = setTimeout(() => {
+            if (!resolved) {
+                resolved = true;
+                socket.destroy();
+                resolve("stale");
+            }
+        }, timeoutMs);
+        socket.on("connect", () => {
+            if (!resolved) {
+                resolved = true;
+                clearTimeout(timeout);
+                socket.destroy();
+                resolve("live");
+            }
+        });
+        socket.on("error", () => {
+            if (!resolved) {
+                resolved = true;
+                clearTimeout(timeout);
+                resolve("stale");
+            }
+        });
+        socket.connect({ path: socketPath });
+    });
+}
+/**
+ * Returns true if a process with the given pid is currently alive.
+ *
+ * Uses the `kill(pid, 0)` idiom: no signal is actually delivered, but the
+ * OS still validates that a process with this pid exists and reports
+ * permission errors for processes that exist but are owned by another
+ * user (EPERM means "alive, just not signalable by us" — still alive).
+ */
+function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+/**
+ * Best-effort read of the holder recorded in a lock file. Returns undefined
+ * if the file is missing, unreadable, or does not contain a well-formed
+ * holder record — callers must treat that as "unknown holder" and never
+ * infer liveness from it.
+ */
+async function readLockHolder(lockPath) {
+    try {
+        const content = await readFile(lockPath, "utf8");
+        const parsed = JSON.parse(content);
+        if (parsed &&
+            typeof parsed === "object" &&
+            typeof parsed.pid === "number" &&
+            typeof parsed.startedAt === "number") {
+            return parsed;
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Attempt to exclusively create the lock file in one atomic step (open with
+ * the `wx` flag: O_CREAT | O_EXCL). Unlike rename-based "locking", this
+ * fails with EEXIST when the destination already exists instead of
+ * silently replacing it — exactly one concurrent caller can ever succeed
+ * for a given lockPath.
+ *
+ * Returns true if this call created the file (lock acquired), false if the
+ * file already existed (EEXIST). Any other error propagates.
+ */
+async function tryCreateLockFile(lockPath, pid) {
+    let handle;
+    try {
+        handle = await open(lockPath, "wx");
+    }
+    catch (error) {
+        if (error.code === "EEXIST") {
+            return false;
+        }
+        throw error;
+    }
+    try {
+        const payload = { pid, startedAt: Date.now() };
+        await handle.writeFile(JSON.stringify(payload), "utf8");
+        return true;
+    }
+    finally {
+        await handle.close();
+    }
+}
+/**
+ * Acquire a lock via exclusive file creation (fs `wx` open), with
+ * dead-holder reclamation and retry.
+ *
+ * Only one concurrent caller can ever hold the lock: the underlying
+ * `open(lockPath, "wx")` is an atomic O_CREAT|O_EXCL create that fails with
+ * EEXIST for every caller after the first, unlike a rename-based scheme
+ * (which silently replaces the destination and lets every racer "succeed").
+ *
+ * On EEXIST, the recorded holder's pid is liveness-checked via
+ * `process.kill(pid, 0)`: a dead holder's lock file is reclaimed (unlinked)
+ * and creation is retried once immediately; a live holder means the lock is
+ * genuinely held elsewhere, so this attempt waits out the retry interval
+ * and tries again until timeoutMs elapses.
+ *
+ * @param lockPath Path to the lock file
+ * @param timeoutMs How long to wait
+ * @param pid Process ID to write into the lock file
+ */
+export async function acquireLock(lockPath, timeoutMs, pid) {
+    const lockDir = dirname(lockPath);
+    const startTime = Date.now();
+    const retryIntervalMs = 10;
+    // Ensure lock directory exists
+    try {
+        await mkdir(lockDir, { recursive: true });
+    }
+    catch {
+        // Directory may already exist
+    }
+    while (Date.now() - startTime < timeoutMs) {
+        if (await tryCreateLockFile(lockPath, pid)) {
+            return true;
+        }
+        // Lock file exists (EEXIST). Inspect the holder before deciding to wait.
+        const holder = await readLockHolder(lockPath);
+        if (holder && !isProcessAlive(holder.pid)) {
+            // Stale lock left by a dead process: reclaim it and retry immediately,
+            // once, before falling back to the normal wait-and-retry loop.
+            try {
+                await unlink(lockPath);
+            }
+            catch {
+                // Another process may have already reclaimed/removed it; fall
+                // through to the retry loop below.
+            }
+            if (await tryCreateLockFile(lockPath, pid)) {
+                return true;
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, retryIntervalMs));
+    }
+    return false; // Timeout reached
+}
+/**
+ * Atomically probe and recover from a stale socket using a lock file for race safety.
+ *
+ * On the first call (or after lock acquisition), probes for a live daemon:
+ * - If live: returns "live" immediately (this process should exit)
+ * - If stale: unlinks the socket file and returns "stale-recovered"
+ * - If available: returns "available" immediately
+ *
+ * The lock file (at `<socketPath>.lock`) ensures only one process enters the
+ * probe-unlink-bind critical section at a time. Two simultaneous spawners will
+ * race to acquire the lock; the winner probes/unlinks/binds, the loser re-probes
+ * and discovers "live" (sees the winner's bound socket) and exits.
+ *
+ * @param socketPath Absolute path to the UDS socket
+ * @param lockTimeoutMs How long to wait acquiring the lock file
+ * @returns "live" (other daemon won the race), "stale-recovered" (unlinked stale socket), or "available" (free to bind)
+ * @throws UDSSingletonError if lock acquisition fails or other I/O errors
+ */
+export async function probeAndRecoverWithLock(socketPath, lockTimeoutMs = 1000) {
+    const lockPath = `${socketPath}.lock`;
+    // Try to acquire lock
+    const lockAcquired = await acquireLock(lockPath, lockTimeoutMs, process.pid);
+    if (!lockAcquired) {
+        // Lock acquisition timed out; re-probe to see if another process succeeded
+        const probeResult = await probeSocketLiveness(socketPath);
+        if (probeResult === "live") {
+            return "live";
+        }
+        // Stale or available; try again (may get lock next time)
+        throw new UDSSingletonError(`Failed to acquire lock on ${lockPath} within ${lockTimeoutMs}ms; socket state is ${probeResult}`);
+    }
+    try {
+        // Locked section: probe for a live daemon
+        const probeResult = await probeSocketLiveness(socketPath);
+        if (probeResult === "live") {
+            // Another daemon owns this socket
+            return "live";
+        }
+        if (probeResult === "stale") {
+            // Socket file is stale; unlink it so bind() can proceed
+            try {
+                await unlink(socketPath);
+            }
+            catch {
+                // May have already been unlinked by another process; safe to ignore
+            }
+            return "stale-recovered";
+        }
+        // Socket path is free
+        return "available";
+    }
+    finally {
+        // Release lock by deleting the lock file
+        try {
+            await unlink(lockPath);
+        }
+        catch {
+            // Lock file cleanup failures are non-fatal
+        }
+    }
+}
+/**
+ * Ensure the daemon can bind to the given socket path, handling stale sockets.
+ *
+ * This is the high-level entry point for singleton + stale-socket recovery.
+ * Call this before binding to a UDS socket in your server:
+ *
+ * ```
+ * const result = await ensureSocketBindability(socketPath);
+ * if (result === "live") {
+ *   // Another daemon already owns this socket; exit gracefully
+ *   process.exit(0);
+ * }
+ * // result is "stale-recovered" or "available"; proceed with binding
+ * ```
+ *
+ * @param socketPath Absolute path to the UDS socket
+ * @returns "live" if another daemon owns the socket (exit immediately),
+ *          or "stale-recovered"/"available" (safe to bind)
+ * @throws UDSSingletonError on unrecoverable errors (lock acquisition, etc.)
+ */
+export async function ensureSocketBindability(socketPath) {
+    return probeAndRecoverWithLock(socketPath);
+}
+function isAddrInUseError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "EADDRINUSE");
+}
+/**
+ * Probe, recover from a stale socket, and invoke `bind()` — all inside the
+ * single critical section held by the `<socketPath>.lock` file.
+ *
+ * This closes the race the two-step "check bindability, then bind()
+ * separately" pattern leaves open: between releasing the probe/unlink lock
+ * and actually calling `bind()`, another process could probe the same
+ * now-empty path, also decide it is free, and race this one to `bind()`.
+ * Here `bind()` itself runs while the lock is still held, so at most one
+ * process per lock ever reaches it while the path is in the
+ * stale/available state.
+ *
+ * `bind()` is also wrapped in try/catch: if it still throws EADDRINUSE
+ * (e.g. a process outside this locking scheme bound the path, or a timing
+ * gap before the lock was acquired), the live owner is re-probed — if it
+ * responds, this process reports "already-served" instead of crashing
+ * uncaught; if it does not respond, the socket is stale, and `bind()` is
+ * retried exactly once after unlinking it.
+ *
+ * @param socketPath Absolute path to the UDS socket
+ * @param bind Callback that performs the actual bind (e.g. `() => Bun.serve(...)`)
+ * @param lockTimeoutMs How long to wait acquiring the lock file
+ */
+export async function bindUnixSocketSingleton(socketPath, bind, lockTimeoutMs = 1000) {
+    const lockPath = `${socketPath}.lock`;
+    const lockAcquired = await acquireLock(lockPath, lockTimeoutMs, process.pid);
+    if (!lockAcquired) {
+        // Could not get the bind lock in time; check whether someone else is
+        // actually serving before giving up entirely.
+        const probeResult = await probeSocketLiveness(socketPath);
+        if (probeResult === "live") {
+            return { kind: "already-served" };
+        }
+        throw new UDSSingletonError(`Failed to acquire bind lock on ${lockPath} within ${lockTimeoutMs}ms; socket state is ${probeResult}`);
+    }
+    try {
+        return await bindWithRecovery(socketPath, bind);
+    }
+    finally {
+        try {
+            await unlink(lockPath);
+        }
+        catch {
+            // Lock file cleanup failures are non-fatal.
+        }
+    }
+}
+async function bindWithRecovery(socketPath, bind) {
+    const initialProbe = await probeSocketLiveness(socketPath);
+    if (initialProbe === "live") {
+        return { kind: "already-served" };
+    }
+    if (initialProbe === "stale") {
+        try {
+            await unlink(socketPath);
+        }
+        catch {
+            // May already be gone.
+        }
+    }
+    try {
+        const server = await bind();
+        return { kind: "bound", server };
+    }
+    catch (error) {
+        if (!isAddrInUseError(error)) {
+            throw error;
+        }
+        // Something bound the path between our probe and our bind() attempt.
+        const raceProbe = await probeSocketLiveness(socketPath);
+        if (raceProbe === "live") {
+            return { kind: "already-served" };
+        }
+        // Stale socket file left behind by a process that died mid-race;
+        // reclaim it and retry exactly once.
+        try {
+            await unlink(socketPath);
+        }
+        catch {
+            // May already be gone.
+        }
+        const server = await bind();
+        return { kind: "bound", server };
+    }
+}

package/dist/refs.d.ts

@@ -0,0 +1,15 @@
+export interface ParsedNamedRef {
+    readonly pluginPrefix: string | undefined;
+    readonly name: string;
+}
+export interface ParsedSpaceItemRef {
+    readonly pluginPrefix: string | undefined;
+    readonly space: string;
+    readonly name: string;
+}
+export interface RegistryWithDeps<TSelf> {
+    readonly deps: ReadonlyMap<string, TSelf>;
+}
+export declare const parseNamedRef: (ref: string) => ParsedNamedRef;
+export declare const parseSpaceItemRef: (ref: string, separator: "/" | "#") => ParsedSpaceItemRef | undefined;
+export declare const registryForRef: <TRegistry extends RegistryWithDeps<TRegistry>>(ref: string, registry: TRegistry) => TRegistry | undefined;

package/dist/refs.js

@@ -0,0 +1,26 @@
+export const parseNamedRef = (ref) => {
+    const colon = ref.indexOf(":");
+    if (colon === -1)
+        return { pluginPrefix: undefined, name: ref };
+    return {
+        pluginPrefix: ref.slice(0, colon),
+        name: ref.slice(colon + 1),
+    };
+};
+export const parseSpaceItemRef = (ref, separator) => {
+    const parsed = parseNamedRef(ref);
+    const split = parsed.name.indexOf(separator);
+    if (split === -1)
+        return undefined;
+    const space = parsed.name.slice(0, split);
+    const name = parsed.name.slice(split + 1);
+    if (space.length === 0 || name.length === 0)
+        return undefined;
+    return { pluginPrefix: parsed.pluginPrefix, space, name };
+};
+export const registryForRef = (ref, registry) => {
+    const parsed = parseNamedRef(ref);
+    if (!parsed.pluginPrefix)
+        return registry;
+    return registry.deps.get(parsed.pluginPrefix);
+};

package/dist/snapshot.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Snapshot manifest — the ONLY persistent state the sync engine keeps per
+ * harness root (docs/overhaul-one-writer-plan.md, WS4). It replaces all
+ * per-harness managed ledgers.
+ *
+ * The manifest is a disposable cache, never the source of truth: it exists
+ * solely to answer "may I skip this write?" and "what do I prune?". Deleting
+ * it must always converge on the next refresh (state-is-disposable gate).
+ *
+ * Identity discipline: entries are keyed by `targetPath` alone within a
+ * manifest (one manifest per harness root). Artifact kinds, source paths,
+ * and scopes are never identity — that scheme is what produced 646 zombie
+ * duplicate ledger entries. `plugin` is diagnostic attribution only.
+ *
+ * Determinism discipline: the manifest carries no timestamps and no run ids,
+ * and entries are sorted by `targetPath` on commit — a converged run leaves
+ * the manifest byte-identical.
+ */
+import { Schema } from "effect";
+export declare const SNAPSHOT_MANIFEST_VERSION: 1;
+/**
+ * How the sync engine owns the entry's target:
+ *  - `owned`: a whole file Prism owns outright (rebuild/prune authority).
+ *  - `region`: a prism-named fragment inside a shared user file; `regionKey`
+ *    names the fragment and `contentHash` hashes the rendered fragment, not
+ *    the whole file.
+ */
+export declare const SnapshotEntryMode: Schema.Literal<["owned", "region"]>;
+export type SnapshotEntryMode = typeof SnapshotEntryMode.Type;
+export declare const SnapshotEntrySchema: Schema.Struct<{
+    targetPath: typeof Schema.String;
+    contentHash: typeof Schema.String;
+    mode: Schema.Literal<["owned", "region"]>;
+    regionKey: Schema.optional<typeof Schema.String>;
+    plugin: typeof Schema.String;
+}>;
+export type SnapshotEntry = typeof SnapshotEntrySchema.Type;
+/**
+ * Versioned union. Future versions join this union; readers decode the union
+ * and migrate forward in code. There is exactly one version today.
+ */
+export declare const SnapshotManifestSchema: Schema.Struct<{
+    version: Schema.Literal<[1]>;
+    harness: typeof Schema.String;
+    root: typeof Schema.String;
+    entries: Schema.Array$<Schema.Struct<{
+        targetPath: typeof Schema.String;
+        contentHash: typeof Schema.String;
+        mode: Schema.Literal<["owned", "region"]>;
+        regionKey: Schema.optional<typeof Schema.String>;
+        plugin: typeof Schema.String;
+    }>>;
+}>;
+export type SnapshotManifest = typeof SnapshotManifestSchema.Type;
+export declare const decodeSnapshotManifest: (u: unknown, overrideOptions?: import("effect/SchemaAST").ParseOptions) => import("effect/Either").Either<{
+    readonly entries: readonly {
+        readonly plugin: string;
+        readonly targetPath: string;
+        readonly contentHash: string;
+        readonly mode: "owned" | "region";
+        readonly regionKey?: string | undefined;
+    }[];
+    readonly version: 1;
+    readonly harness: string;
+    readonly root: string;
+}, import("effect/ParseResult").ParseError>;
+declare const decodeSnapshotManifestUnknown: (u: unknown, overrideOptions?: import("effect/SchemaAST").ParseOptions) => import("effect/Either").Either<{
+    readonly entries: readonly {
+        readonly plugin: string;
+        readonly targetPath: string;
+        readonly contentHash: string;
+        readonly mode: "owned" | "region";
+        readonly regionKey?: string | undefined;
+    }[];
+    readonly version: 1;
+    readonly harness: string;
+    readonly root: string;
+}, import("effect/ParseResult").ParseError>;
+/**
+ * Migrate a parsed snapshot manifest to the latest version.
+ *
+ * Today only version 1 exists, so this is the identity for valid v1 payloads.
+ * When a v2 format is introduced, this function will branch on `input.version`
+ * and transform older shapes forward before the final schema decode.
+ */
+export declare const migrateSnapshotManifest: (input: unknown) => ReturnType<typeof decodeSnapshotManifestUnknown>;
+export declare const encodeSnapshotManifest: (manifest: SnapshotManifest) => string;
+export declare const emptySnapshotManifest: (options: {
+    readonly harness: string;
+    readonly root: string;
+}) => SnapshotManifest;
+export {};

package/dist/snapshot.js

@@ -0,0 +1,74 @@
+/**
+ * Snapshot manifest — the ONLY persistent state the sync engine keeps per
+ * harness root (docs/overhaul-one-writer-plan.md, WS4). It replaces all
+ * per-harness managed ledgers.
+ *
+ * The manifest is a disposable cache, never the source of truth: it exists
+ * solely to answer "may I skip this write?" and "what do I prune?". Deleting
+ * it must always converge on the next refresh (state-is-disposable gate).
+ *
+ * Identity discipline: entries are keyed by `targetPath` alone within a
+ * manifest (one manifest per harness root). Artifact kinds, source paths,
+ * and scopes are never identity — that scheme is what produced 646 zombie
+ * duplicate ledger entries. `plugin` is diagnostic attribution only.
+ *
+ * Determinism discipline: the manifest carries no timestamps and no run ids,
+ * and entries are sorted by `targetPath` on commit — a converged run leaves
+ * the manifest byte-identical.
+ */
+import { Schema } from "effect";
+export const SNAPSHOT_MANIFEST_VERSION = 1;
+/**
+ * How the sync engine owns the entry's target:
+ *  - `owned`: a whole file Prism owns outright (rebuild/prune authority).
+ *  - `region`: a prism-named fragment inside a shared user file; `regionKey`
+ *    names the fragment and `contentHash` hashes the rendered fragment, not
+ *    the whole file.
+ */
+export const SnapshotEntryMode = Schema.Literal("owned", "region");
+export const SnapshotEntrySchema = Schema.Struct({
+    targetPath: Schema.String,
+    contentHash: Schema.String,
+    mode: SnapshotEntryMode,
+    regionKey: Schema.optional(Schema.String),
+    plugin: Schema.String,
+});
+const SnapshotManifestV1 = Schema.Struct({
+    version: Schema.Literal(SNAPSHOT_MANIFEST_VERSION),
+    harness: Schema.String,
+    root: Schema.String,
+    entries: Schema.Array(SnapshotEntrySchema),
+});
+/**
+ * Versioned union. Future versions join this union; readers decode the union
+ * and migrate forward in code. There is exactly one version today.
+ */
+export const SnapshotManifestSchema = SnapshotManifestV1;
+export const decodeSnapshotManifest = Schema.decodeUnknownEither(Schema.parseJson(SnapshotManifestSchema));
+const decodeSnapshotManifestUnknown = Schema.decodeUnknownEither(SnapshotManifestSchema);
+/**
+ * Migrate a parsed snapshot manifest to the latest version.
+ *
+ * Today only version 1 exists, so this is the identity for valid v1 payloads.
+ * When a v2 format is introduced, this function will branch on `input.version`
+ * and transform older shapes forward before the final schema decode.
+ */
+export const migrateSnapshotManifest = (input) => {
+    // Future migration hook: inspect input.version and apply v2/v3/etc. forward transforms.
+    return decodeSnapshotManifestUnknown(input);
+};
+export const encodeSnapshotManifest = (manifest) => {
+    const sorted = {
+        ...manifest,
+        entries: [...manifest.entries].sort((left, right) => left.targetPath === right.targetPath
+            ? (left.regionKey ?? "").localeCompare(right.regionKey ?? "")
+            : left.targetPath.localeCompare(right.targetPath)),
+    };
+    return `${JSON.stringify(sorted, null, 2)}\n`;
+};
+export const emptySnapshotManifest = (options) => ({
+    version: SNAPSHOT_MANIFEST_VERSION,
+    harness: options.harness,
+    root: options.root,
+    entries: [],
+});

package/dist/stable-json.d.ts

@@ -0,0 +1,8 @@
+export type StableJsonValue = null | boolean | number | string | readonly StableJsonValue[] | {
+    readonly [key: string]: StableJsonValue | undefined;
+};
+export declare const compareCodePoint: (left: string, right: string) => number;
+export declare const sortStableStrings: <T extends string>(values: Iterable<T>) => T[];
+export declare const stableJsonValue: (value: StableJsonValue) => StableJsonValue;
+export declare const stableJsonStringify: (value: StableJsonValue) => string;
+export declare const stableJsonHash: (value: StableJsonValue) => string;

package/dist/stable-json.js

@@ -0,0 +1,27 @@
+import { createHash } from "node:crypto";
+export const compareCodePoint = (left, right) => {
+    const normalizedLeft = left.normalize("NFC");
+    const normalizedRight = right.normalize("NFC");
+    if (normalizedLeft === normalizedRight)
+        return 0;
+    return normalizedLeft < normalizedRight ? -1 : 1;
+};
+export const sortStableStrings = (values) => [...values].sort(compareCodePoint);
+export const stableJsonValue = (value) => {
+    if (Array.isArray(value)) {
+        return value.map((item) => stableJsonValue(item));
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        const sorted = {};
+        for (const key of sortStableStrings(Object.keys(record))) {
+            const entry = record[key];
+            if (entry !== undefined)
+                sorted[key] = stableJsonValue(entry);
+        }
+        return sorted;
+    }
+    return value;
+};
+export const stableJsonStringify = (value) => JSON.stringify(stableJsonValue(value));
+export const stableJsonHash = (value) => createHash("sha256").update(stableJsonStringify(value)).digest("hex");

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@skastr0/prism-sdk",
+  "version": "0.3.0",
+  "type": "module",
+  "description": "Core Prism contracts, refs, stable JSON, and manifest codecs for Prism runtimes and workflow tooling.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/skastr0/prism.git",
+    "directory": "packages/prism-sdk"
+  },
+  "homepage": "https://github.com/skastr0/prism#readme",
+  "bugs": {
+    "url": "https://github.com/skastr0/prism/issues"
+  },
+  "keywords": [
+    "prism",
+    "ai-coding",
+    "agents",
+    "workflows",
+    "manifest"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "exports": {
+    "./compile-manifest": {
+      "types": "./dist/compile-manifest.d.ts",
+      "import": "./dist/compile-manifest.js"
+    },
+    "./refs": {
+      "types": "./dist/refs.d.ts",
+      "import": "./dist/refs.js"
+    },
+    "./snapshot": {
+      "types": "./dist/snapshot.d.ts",
+      "import": "./dist/snapshot.js"
+    },
+    "./stable-json": {
+      "types": "./dist/stable-json.d.ts",
+      "import": "./dist/stable-json.js"
+    },
+    "./mcp/shim": {
+      "types": "./dist/mcp/shim.d.ts",
+      "import": "./dist/mcp/shim.js"
+    },
+    "./mcp/uds-registry": {
+      "types": "./dist/mcp/uds-registry.d.ts",
+      "import": "./dist/mcp/uds-registry.js"
+    },
+    "./mcp/uds-singleton": {
+      "types": "./dist/mcp/uds-singleton.d.ts",
+      "import": "./dist/mcp/uds-singleton.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepack": "bun run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "effect": "^3.21.1",
+    "@modelcontextprotocol/sdk": "1.29.0"
+  }
+}