instar 1.3.774 → 1.3.775

package/dist/core/WorkingSetArtifactManager.d.ts

@@ -0,0 +1,104 @@
+/**
+ * WorkingSetArtifactManager — the durable, own-origin store of interactive working-set
+ * artifact rows (spec: intelligent-working-set-lazy-sync.md, Layer 1). It is the literal
+ * analog of `KnowledgeManager` (the local catalog the KnowledgeReplicatedStore rides): it
+ * holds THIS machine's per-topic record of files the agent wrote INTERACTIVELY under the
+ * `.instar/` jail — the case `WorkingSetManifest.computeWorkingSet` misses — and feeds:
+ *   (a) the `ReplicatedStoreReader`'s loadOriginRecords/listRecordKeys (own-origin
+ *       materialization the union reader merges against peer replicas), and
+ *   (b) `computeWorkingSet`'s new `ready`-row source (component 3).
+ *
+ * It stores OWN-ORIGIN rows only (producerMachineId === this machine). Peer replicas are
+ * NOT stored here — they arrive via the replicated journal and surface through the union
+ * reader (read-only, advisory, never clobbering a local file). Row identity is
+ * (topicId, relPath, producerMachineId); a re-record of the same triple UPSERTS.
+ *
+ * Row lifecycle (spec §64): `pendingHash` (recorded, hash deferred) → `ready(contentHash)`
+ * (hashed, fetch-eligible) → terminal `tooLarge` / `secretFlagged`. ONLY `ready` rows are
+ * returned by getReadyRows() — the fetch-nomination source (the serve-boundary hash-verify
+ * remains the authority). Tombstone is OWNER-ONLY (a row is always this machine's, so a
+ * local tombstone is legitimate; the replicated tombstone builder re-checks origin ===
+ * producer). GC purges rows older than the record TTL (default 30d).
+ *
+ * Durable + atomic (tmp+rename), mirroring KnowledgeManager. The emit seam is best-effort:
+ * a record/tombstone fires the replication emitter when wired (dark by default), else no-op.
+ */
+/** A locally-held working-set artifact row (own-origin). */
+export interface WorkingSetArtifactLocalRow {
+    topicId: number;
+    relPath: string;
+    contentHash: string | null;
+    /** ISO-8601 of the last write that produced/updated this row. */
+    lastWrittenAt: string;
+    producerMachineId: string;
+    /** pendingHash | ready | tooLarge | secretFlagged */
+    state: string;
+    /** ISO-8601 when this row was first recorded — GC anchor (record TTL). */
+    recordedAt: string;
+}
+/** The replication emit seam — fired on a record (put) / tombstone (delete). Best-effort;
+ *  wired ONLY when `multiMachine.stateSync.workingSetArtifact.enabled` (dark by default). */
+export interface WorkingSetArtifactReplicationEmitter {
+    emitPut(row: WorkingSetArtifactLocalRow): void;
+    emitDelete(row: {
+        topicId: number;
+        relPath: string;
+        producerMachineId: string;
+        deletedAt: string;
+    }): void;
+}
+export interface RecordArtifactInput {
+    topicId: number;
+    relPath: string;
+    producerMachineId: string;
+    /** Defaults to 'pendingHash' — hashing is deferred to the serve boundary / async worker. */
+    state?: string;
+    contentHash?: string | null;
+    /** ISO-8601; defaults to nowIso (injectable for tests). */
+    lastWrittenAt?: string;
+}
+/** Default record TTL for GC — distinct from the engine's 7d pending-pull TTL (spec F3). */
+export declare const DEFAULT_RECORD_TTL_MS: number;
+export declare class WorkingSetArtifactManager {
+    private readonly dir;
+    private readonly catalogPath;
+    private replication;
+    /** Injectable clock (tests) — returns ISO-8601. */
+    private readonly nowIso;
+    constructor(stateDir: string, nowIso?: () => string);
+    /** Wire the replication emitter (dark by default — only attached when stateSync enabled). */
+    setReplicationEmitter(emitter: WorkingSetArtifactReplicationEmitter | null): void;
+    /**
+     * Upsert a row keyed (topicId, relPath, producerMachineId). A re-record of the same triple
+     * updates lastWrittenAt/state/contentHash + preserves the original recordedAt (the GC
+     * anchor). Returns the stored row. Fires the emit seam (put) best-effort.
+     */
+    record(input: RecordArtifactInput): WorkingSetArtifactLocalRow;
+    /**
+     * Transition a pendingHash row to ready(contentHash) (or to a terminal tooLarge/secretFlagged).
+     * A no-op if the row is absent. Fires the emit seam (put) on a real transition.
+     */
+    setState(topicId: number, relPath: string, producerMachineId: string, state: string, contentHash?: string | null): boolean;
+    /**
+     * Owner-only tombstone: remove the row (topicId, relPath, producerMachineId) and fire the
+     * replicated tombstone. A row held here is always THIS machine's (own-origin), so a local
+     * tombstone is legitimate; the replicated tombstone builder re-checks origin === producer.
+     * Returns true if a row was removed.
+     */
+    tombstone(topicId: number, relPath: string, producerMachineId: string): boolean;
+    /** All own rows for a topic (any state). */
+    getRowsForTopic(topicId: number): WorkingSetArtifactLocalRow[];
+    /** Own `ready` rows for a topic — the fetch-nomination source (spec §64: only ready nominates). */
+    getReadyRows(topicId: number): WorkingSetArtifactLocalRow[];
+    /** All own rows (every topic) — the union reader's listRecordKeys source. */
+    getAllRows(): WorkingSetArtifactLocalRow[];
+    /**
+     * GC: purge rows whose recordedAt is older than ttlMs. Returns the count purged. A purge is
+     * a LOCAL cleanup (not a tombstone — an expired own row is simply forgotten; a peer's copy
+     * ages out under its own TTL). Injectable `nowMs` for tests.
+     */
+    gc(ttlMs?: number, nowMs?: number): number;
+    private loadCatalog;
+    private saveCatalog;
+}
+//# sourceMappingURL=WorkingSetArtifactManager.d.ts.map

package/dist/core/WorkingSetArtifactManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkingSetArtifactManager.d.ts","sourceRoot":"","sources":["../../src/core/WorkingSetArtifactManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAKH,4DAA4D;AAC5D,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,iEAAiE;IACjE,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,0EAA0E;IAC1E,UAAU,EAAE,MAAM,CAAC;CACpB;AAMD;6FAC6F;AAC7F,MAAM,WAAW,oCAAoC;IACnD,OAAO,CAAC,GAAG,EAAE,0BAA0B,GAAG,IAAI,CAAC;IAC/C,UAAU,CAAC,GAAG,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CAC3G;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,4FAA4F;IAC5F,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,2DAA2D;IAC3D,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAKD,4FAA4F;AAC5F,eAAO,MAAM,qBAAqB,QAA2B,CAAC;AAE9D,qBAAa,yBAAyB;IACpC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,WAAW,CAAqD;IACxE,mDAAmD;IACnD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;gBAE1B,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,MAAuC;IAMnF,6FAA6F;IAC7F,qBAAqB,CAAC,OAAO,EAAE,oCAAoC,GAAG,IAAI,GAAG,IAAI;IAIjF;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,mBAAmB,GAAG,0BAA0B;IA8B9D;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO;IAc1H;;;;;OAKG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,GAAG,OAAO;IAc/E,4CAA4C;IAC5C,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,0BAA0B,EAAE;IAI9D,mGAAmG;IACnG,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,0BAA0B,EAAE;IAI3D,6EAA6E;IAC7E,UAAU,IAAI,0BAA0B,EAAE;IAI1C;;;;OAIG;IACH,EAAE,CAAC,KAAK,GAAE,MAA8B,EAAE,KAAK,GAAE,MAAmB,GAAG,MAAM;IAa7E,OAAO,CAAC,WAAW;IAYnB,OAAO,CAAC,WAAW;CAMpB"}

package/dist/core/WorkingSetArtifactManager.js

@@ -0,0 +1,174 @@
+/**
+ * WorkingSetArtifactManager — the durable, own-origin store of interactive working-set
+ * artifact rows (spec: intelligent-working-set-lazy-sync.md, Layer 1). It is the literal
+ * analog of `KnowledgeManager` (the local catalog the KnowledgeReplicatedStore rides): it
+ * holds THIS machine's per-topic record of files the agent wrote INTERACTIVELY under the
+ * `.instar/` jail — the case `WorkingSetManifest.computeWorkingSet` misses — and feeds:
+ *   (a) the `ReplicatedStoreReader`'s loadOriginRecords/listRecordKeys (own-origin
+ *       materialization the union reader merges against peer replicas), and
+ *   (b) `computeWorkingSet`'s new `ready`-row source (component 3).
+ *
+ * It stores OWN-ORIGIN rows only (producerMachineId === this machine). Peer replicas are
+ * NOT stored here — they arrive via the replicated journal and surface through the union
+ * reader (read-only, advisory, never clobbering a local file). Row identity is
+ * (topicId, relPath, producerMachineId); a re-record of the same triple UPSERTS.
+ *
+ * Row lifecycle (spec §64): `pendingHash` (recorded, hash deferred) → `ready(contentHash)`
+ * (hashed, fetch-eligible) → terminal `tooLarge` / `secretFlagged`. ONLY `ready` rows are
+ * returned by getReadyRows() — the fetch-nomination source (the serve-boundary hash-verify
+ * remains the authority). Tombstone is OWNER-ONLY (a row is always this machine's, so a
+ * local tombstone is legitimate; the replicated tombstone builder re-checks origin ===
+ * producer). GC purges rows older than the record TTL (default 30d).
+ *
+ * Durable + atomic (tmp+rename), mirroring KnowledgeManager. The emit seam is best-effort:
+ * a record/tombstone fires the replication emitter when wired (dark by default), else no-op.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+/** The valid row states (mirrors WORKING_SET_ARTIFACT_STATES in the replicated store). */
+const VALID_STATES = new Set(['pendingHash', 'ready', 'tooLarge', 'secretFlagged']);
+/** Default record TTL for GC — distinct from the engine's 7d pending-pull TTL (spec F3). */
+export const DEFAULT_RECORD_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+export class WorkingSetArtifactManager {
+    dir;
+    catalogPath;
+    replication = null;
+    /** Injectable clock (tests) — returns ISO-8601. */
+    nowIso;
+    constructor(stateDir, nowIso = () => new Date().toISOString()) {
+        this.dir = path.join(stateDir, 'working-set');
+        this.catalogPath = path.join(this.dir, 'artifacts.json');
+        this.nowIso = nowIso;
+    }
+    /** Wire the replication emitter (dark by default — only attached when stateSync enabled). */
+    setReplicationEmitter(emitter) {
+        this.replication = emitter;
+    }
+    /**
+     * Upsert a row keyed (topicId, relPath, producerMachineId). A re-record of the same triple
+     * updates lastWrittenAt/state/contentHash + preserves the original recordedAt (the GC
+     * anchor). Returns the stored row. Fires the emit seam (put) best-effort.
+     */
+    record(input) {
+        const state = input.state && VALID_STATES.has(input.state) ? input.state : 'pendingHash';
+        const lastWrittenAt = input.lastWrittenAt ?? this.nowIso();
+        const catalog = this.loadCatalog();
+        const existing = catalog.rows.find((r) => r.topicId === input.topicId && r.relPath === input.relPath && r.producerMachineId === input.producerMachineId);
+        let row;
+        if (existing) {
+            existing.state = state;
+            existing.lastWrittenAt = lastWrittenAt;
+            existing.contentHash = input.contentHash ?? existing.contentHash ?? null;
+            row = existing;
+        }
+        else {
+            row = {
+                topicId: input.topicId,
+                relPath: input.relPath,
+                contentHash: input.contentHash ?? null,
+                lastWrittenAt,
+                producerMachineId: input.producerMachineId,
+                state,
+                recordedAt: this.nowIso(),
+            };
+            catalog.rows.push(row);
+        }
+        this.saveCatalog(catalog);
+        try {
+            this.replication?.emitPut(row);
+        }
+        catch { /* @silent-fallback-ok: best-effort replication emit (dark by default); a failed emit is re-driven by the store's own reconcile, never a data-loss fallback */ }
+        return row;
+    }
+    /**
+     * Transition a pendingHash row to ready(contentHash) (or to a terminal tooLarge/secretFlagged).
+     * A no-op if the row is absent. Fires the emit seam (put) on a real transition.
+     */
+    setState(topicId, relPath, producerMachineId, state, contentHash) {
+        if (!VALID_STATES.has(state))
+            return false;
+        const catalog = this.loadCatalog();
+        const row = catalog.rows.find((r) => r.topicId === topicId && r.relPath === relPath && r.producerMachineId === producerMachineId);
+        if (!row)
+            return false;
+        row.state = state;
+        if (contentHash !== undefined)
+            row.contentHash = contentHash;
+        this.saveCatalog(catalog);
+        try {
+            this.replication?.emitPut(row);
+        }
+        catch { /* @silent-fallback-ok: best-effort replication emit (dark by default); a failed emit is re-driven by the store's own reconcile, never a data-loss fallback */ }
+        return true;
+    }
+    /**
+     * Owner-only tombstone: remove the row (topicId, relPath, producerMachineId) and fire the
+     * replicated tombstone. A row held here is always THIS machine's (own-origin), so a local
+     * tombstone is legitimate; the replicated tombstone builder re-checks origin === producer.
+     * Returns true if a row was removed.
+     */
+    tombstone(topicId, relPath, producerMachineId) {
+        const catalog = this.loadCatalog();
+        const before = catalog.rows.length;
+        catalog.rows = catalog.rows.filter((r) => !(r.topicId === topicId && r.relPath === relPath && r.producerMachineId === producerMachineId));
+        if (catalog.rows.length === before)
+            return false;
+        this.saveCatalog(catalog);
+        try {
+            this.replication?.emitDelete({ topicId, relPath, producerMachineId, deletedAt: this.nowIso() });
+        }
+        catch { /* @silent-fallback-ok: best-effort replication emit (dark by default); a failed emit is re-driven by the store's own reconcile, never a data-loss fallback */ }
+        return true;
+    }
+    /** All own rows for a topic (any state). */
+    getRowsForTopic(topicId) {
+        return this.loadCatalog().rows.filter((r) => r.topicId === topicId);
+    }
+    /** Own `ready` rows for a topic — the fetch-nomination source (spec §64: only ready nominates). */
+    getReadyRows(topicId) {
+        return this.loadCatalog().rows.filter((r) => r.topicId === topicId && r.state === 'ready');
+    }
+    /** All own rows (every topic) — the union reader's listRecordKeys source. */
+    getAllRows() {
+        return this.loadCatalog().rows;
+    }
+    /**
+     * GC: purge rows whose recordedAt is older than ttlMs. Returns the count purged. A purge is
+     * a LOCAL cleanup (not a tombstone — an expired own row is simply forgotten; a peer's copy
+     * ages out under its own TTL). Injectable `nowMs` for tests.
+     */
+    gc(ttlMs = DEFAULT_RECORD_TTL_MS, nowMs = Date.now()) {
+        const catalog = this.loadCatalog();
+        const before = catalog.rows.length;
+        catalog.rows = catalog.rows.filter((r) => {
+            const age = nowMs - Date.parse(r.recordedAt ?? '');
+            return !(Number.isFinite(age) && age > ttlMs);
+        });
+        const purged = before - catalog.rows.length;
+        if (purged > 0)
+            this.saveCatalog(catalog);
+        return purged;
+    }
+    // ── persistence (atomic tmp+rename, mirrors KnowledgeManager) ─────────────────
+    loadCatalog() {
+        if (!fs.existsSync(this.catalogPath))
+            return { rows: [] };
+        try {
+            const parsed = JSON.parse(fs.readFileSync(this.catalogPath, 'utf-8'));
+            return Array.isArray(parsed?.rows) ? { rows: parsed.rows } : { rows: [] };
+        }
+        catch {
+            // @silent-fallback-ok: a corrupt/unreadable catalog reads as empty (documented contract) — the
+            // agent re-records artifacts on the next write; never throws into a caller, never loses live data.
+            return { rows: [] };
+        }
+    }
+    saveCatalog(catalog) {
+        if (!fs.existsSync(this.dir))
+            fs.mkdirSync(this.dir, { recursive: true });
+        const tmpPath = `${this.catalogPath}.${process.pid}.tmp`;
+        fs.writeFileSync(tmpPath, JSON.stringify(catalog, null, 2), 'utf-8');
+        fs.renameSync(tmpPath, this.catalogPath);
+    }
+}
+//# sourceMappingURL=WorkingSetArtifactManager.js.map

package/dist/core/WorkingSetArtifactManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkingSetArtifactManager.js","sourceRoot":"","sources":["../../src/core/WorkingSetArtifactManager.ts"],"names":[],"mappings":"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"}

package/dist/core/WorkingSetArtifactReplicatedStore.d.ts

@@ -0,0 +1,203 @@
+/**
+ * WorkingSetArtifactReplicatedStore — the WS2 replicated kind that lets an agent-produced
+ * artifact a conversation wrote INTERACTIVELY under the `.instar/` jail follow that
+ * conversation when its topic moves machines (spec: intelligent-working-set-lazy-sync.md,
+ * Layer 1). It is the literal analog of `KnowledgeReplicatedStore.ts` (WS2.4) — it layers
+ * a `working-set-artifact` replicated kind onto the SAME generic substrate
+ * (ReplicatedRecordEnvelope / UnionReader / ConflictStore / ReplicationBudget) so the
+ * per-topic record of what an agent wrote is ONE index across machines, not one-per-machine.
+ *
+ * WHY A NEW KIND (not the computed engine): `WorkingSetManifest.computeWorkingSet` derives
+ * the manifest from the `autonomous/<topic>.*` convention dir + `artifactPaths` on
+ * `autonomous-run` journal entries. A file the agent wrote INTERACTIVELY (no autonomous
+ * run) is invisible to it. This kind is the ONE new manifest source for that case — a
+ * durable, replicated per-topic record of `{ relPath, contentHash?, lastWrittenAt, state }`
+ * under the EXISTING `.instar/` jail. It does NOT widen the jail, lower a cap, or
+ * re-implement the fetch engine (those bind verbatim — spec §50).
+ *
+ * THE PATH-PAYLOAD / ENVELOPE PATH-JAIL COLLISION (spec §59, M1): this is the FIRST
+ * replicated kind whose payload is LEGITIMATELY a path. The envelope structurally auto-jails
+ * path-shaped fields (KnowledgeReplicatedStore jails a path-shaped `url` to null). So here:
+ *   - recordKey = sha256(jailedRelPath) + ':' + origin — a NON-path-shaped derivation
+ *     (never the raw path), so it survives envelope validation and still gives the
+ *     (relPath, producerMachine) identity. `origin` IS the authenticated producer machine
+ *     (spec §62: producerMachineId ≡ the applier's authenticated entry.machine, never a
+ *     separate trusted content field) — so a peer can never forge which machine produced a
+ *     row (the envelope origin is authenticated at apply).
+ *   - `relPath` lives in a store field explicitly CARVED OUT of the path-jail (so it may
+ *     hold a path) but is STRICTLY validated on RECEIVE by the canonical `jailValidateRelPath`
+ *     (relative-only; reject abs / drive / UNC / `..`-after-decode / NUL / empty; length-cap)
+ *     — the filesystem serve-jail is downstream, so an invalid verdict must reject FIRST.
+ *     This deliberately breaks the "envelope carries identifiers, never paths" invariant;
+ *     the receive-side relPath validation is the compensating control (spec §61).
+ *
+ * ROW STATES (spec §64): `pendingHash` (recorded, hash deferred) → `ready(hash)` (hashed,
+ * in scope) → terminal `tooLarge` / `secretFlagged`. ONLY `ready` rows enter fetch nominees
+ * (the serve-boundary hash-verify remains the authority; a stored hash is advisory until the
+ * pull re-reads live) — the wiring into computeWorkingSet (component 3) enforces that.
+ *
+ * IMPACT: HIGH at the REPLICATION layer (a concurrent divergent edit to the same recordKey
+ * — same relPath+producer, different content — goes through APPEND-BOTH-AND-FLAG; both
+ * surface, the fetch engine's no-clobber lands the second as `.from-<machine>`). ADVISORY at
+ * the READ layer (both variants are hints; the read never blocks, never clobbers a local file).
+ *
+ * TOMBSTONE AUTHORITY — OWNER-ONLY (spec §91): only the PRODUCER of a row (origin ===
+ * this machine) may tombstone it; a receiver deleting its FETCHED local copy is a
+ * machine-local suppression, NOT a cross-peer delete. A peer can never tombstone another
+ * producer's artifact.
+ *
+ * SAFETY POSTURE: MECHANISM, dark by default (`multiMachine.stateSync.workingSetArtifact`).
+ * PURE LOGIC — no fs, no network, no Date directly.
+ */
+import type { StoreFieldSchema, ReplicatedEnvelope } from './ReplicatedRecordEnvelope.js';
+import type { ImpactTier, OriginRecord, UnionResult } from './UnionReader.js';
+import type { ReplicatedKindBounds } from './ReplicationBudget.js';
+import type { HlcTimestamp } from './HybridLogicalClock.js';
+/** The stateSync config sub-key + advert suffix (`multiMachine.stateSync.workingSetArtifact.enabled`). */
+export declare const WORKING_SET_ARTIFACT_STORE_KEY = "workingSetArtifact";
+/** The JournalKind string this store rides — the DUAL-REGISTRY dynamic half. MUST also be
+ *  in CoherenceJournal.JOURNAL_KINDS (the static half) or the store advertises receive=true
+ *  yet serves/applies/pulls nothing (the silent no-replication trap). */
+export declare const WORKING_SET_ARTIFACT_KIND = "working-set-artifact";
+/** HIGH-impact at replication (append-both-and-flag on a concurrent divergent edit to the
+ *  same relPath+producer); ADVISORY at read. Same posture as knowledge/relationships. */
+export declare const WORKING_SET_ARTIFACT_IMPACT_TIER: ImpactTier;
+/** Row lifecycle states (spec §64). Only `ready` rows are fetch-eligible (enforced by the
+ *  computeWorkingSet union wiring, component 3). A foreign row whose `state` is outside this
+ *  set is rejected (markup cannot survive an enum slot). */
+export declare const WORKING_SET_ARTIFACT_STATES: ReadonlyArray<string>;
+/** A relPath under `.instar/` is short; a generous cap that still bounds a smuggled flood. */
+export declare const MAX_RELPATH_LENGTH = 1024;
+/** A content hash is a fixed-width hex digest; bound it hard. */
+export declare const MAX_CONTENT_HASH_LENGTH = 128;
+/**
+ * Per-kind replication bounds. Working-set artifact rows are FEW + bounded (a per-topic
+ * catalog of interactive writes), coalesced so a churny re-edit loop does not flood the
+ * stream. NEVER `rotateKeep: 0`.
+ */
+export declare const WORKING_SET_ARTIFACT_BOUNDS: ReplicatedKindBounds;
+/** Per-entry cap. A row is a tiny projection ({relPath, contentHash, lastWrittenAt, state});
+ *  8KB is ample. A record over cap is REJECTED with a named error (never silent-truncate). */
+export declare const WORKING_SET_ARTIFACT_MAX_ENTRY_BYTES: number;
+/** The store-owned VALUE fields (the unknown-field allowlist). `producerMachineId` is
+ *  DELIBERATELY ABSENT — it is the authenticated envelope `origin`, never a trusted content
+ *  field (spec §62). `recordKey`/`hlc`/`op`/`origin`/`observed` are reserved envelope fields. */
+export declare const WORKING_SET_ARTIFACT_KNOWN_FIELDS: ReadonlyArray<string>;
+/** The tombstone's only store-owned field beyond the reserved envelope set. */
+export declare const WORKING_SET_ARTIFACT_TOMBSTONE_KNOWN_FIELDS: ReadonlyArray<string>;
+/**
+ * The single canonical relative-path validator, used at ALL sites (record, replication
+ * receive, serve-jail) so the rules can't drift between callers (spec §64). Returns the
+ * relPath UNCHANGED if safe, else null (REJECT). Rules (spec §61/§92): relative-only —
+ * reject absolute, Windows drive (`C:`), UNC (`\\`), any `..` segment after decode, a NUL
+ * byte (isSafeRelPath does NOT catch NUL, and it would otherwise throw uncaught downstream —
+ * fail CLEAN here), empty, or over-cap. This is a STRING check; the realpath / O_NOFOLLOW /
+ * containment filesystem jail is the DOWNSTREAM serve-boundary control (this runs first,
+ * before any fs touch, because an invalid replication verdict must reject before the fs).
+ */
+export declare function jailValidateRelPath(relPath: unknown): string | null;
+/** Is `v` a clean ISO-8601 date string (no smuggled markup)? Mirrors KnowledgeReplicatedStore. */
+export declare function isIso8601(v: unknown): v is string;
+/**
+ * The `working-set-artifact` store schema. Strict typed validation on top of the envelope:
+ * TYPE-CLAMP every known field, and — critically — validate `relPath` with the canonical
+ * `jailValidateRelPath` (NOT the envelope's auto path-jail, which relPath is carved out of).
+ * A record whose relPath fails the jail-validator is REJECTED WHOLE (never landed with a
+ * null path). Returns the validated store-specific object, or null to reject the record.
+ * PURE (no I/O). The envelope validator has ALREADY validated `op` ∈ {put,delete}.
+ */
+export declare const workingSetArtifactStoreSchema: StoreFieldSchema;
+/**
+ * Derive the cross-machine recordKey for a working-set artifact row: a NON-path-shaped
+ * `sha256(jailedRelPath) + ':' + producerMachineId` (spec §60). `producerMachineId` IS the
+ * authenticated envelope `origin` — so the SAME relPath from the SAME producer collapses to
+ * ONE record, while divergent producers of the same path coexist (distinct recordKeys → the
+ * fetch engine's no-clobber lands the second as `.from-<machine>`). Returns null when the
+ * relPath fails the jail-validator or the producer id is empty (a degenerate row — the caller
+ * skips emission; it can never collide a stranger by an empty key).
+ */
+export declare function deriveWorkingSetArtifactRecordKey(relPath: string, producerMachineId: string): string | null;
+/** A local working-set artifact row (the record shape the manager holds). */
+export interface WorkingSetArtifactRow {
+    relPath: string;
+    contentHash?: string | null;
+    lastWrittenAt: string;
+    producerMachineId: string;
+    state: string;
+}
+/** The `data` object a `working-set-artifact` journal entry carries. */
+export type WorkingSetArtifactData = Record<string, unknown>;
+/** The named error a record-over-cap surfaces (never silent-truncate, never suspect-wedge). */
+export declare class WorkingSetArtifactTooLargeError extends Error {
+    readonly recordKey: string;
+    readonly bytes: number;
+    constructor(recordKey: string, bytes: number);
+}
+export interface BuildWorkingSetArtifactInput {
+    row: WorkingSetArtifactRow;
+    hlc: HlcTimestamp;
+    /** This machine's origin id — the authenticated producer; recordKey binds to it. */
+    origin: string;
+    observed?: HlcTimestamp;
+}
+/**
+ * Build the disclosure-minimized `op:'put'` envelope `data`. recordKey binds relPath to the
+ * `origin` (the producer) — NOT to any content field (spec §62). Returns null when the row
+ * has no stable identity surface (relPath fails jail / empty origin). Throws
+ * WorkingSetArtifactTooLargeError if the projection exceeds the per-entry cap.
+ */
+export declare function buildWorkingSetArtifactData(input: BuildWorkingSetArtifactInput): WorkingSetArtifactData | null;
+/** Throw WorkingSetArtifactTooLargeError if the projected data serializes over the cap. */
+export declare function assertProjectionUnderCap(recordKey: string, data: WorkingSetArtifactData): void;
+export interface BuildWorkingSetArtifactTombstoneInput {
+    relPath: string;
+    /** The producer of the row being tombstoned — MUST equal `origin` (owner-only, spec §91). */
+    producerMachineId: string;
+    hlc: HlcTimestamp;
+    origin: string;
+    deletedAt: string;
+    observed?: HlcTimestamp;
+}
+/**
+ * Build an `op:'delete'` TOMBSTONE. OWNER-ONLY (spec §91): the recordKey binds relPath to the
+ * PRODUCER, and a tombstone is only legitimate from that producer (origin === producerMachineId).
+ * Returns null when origin !== producerMachineId (a peer can never tombstone another producer's
+ * artifact — a remote-delete authority hole) or the identity surface is degenerate.
+ */
+export declare function buildWorkingSetArtifactTombstoneData(input: BuildWorkingSetArtifactTombstoneInput): WorkingSetArtifactData | null;
+/** A merged working-set artifact view entry. READ-ONLY — never written back locally. */
+export interface MergedWorkingSetArtifactView {
+    recordKey: string;
+    origin: string;
+    data: Record<string, unknown>;
+    /** True when this is one of ≥2 concurrent variants of an OPEN conflict (append-both). */
+    conflicted: boolean;
+}
+/**
+ * Collapse a `Map<recordKey, UnionResult>` into the merged view. HIGH-at-replication /
+ * ADVISORY-at-read: an OPEN conflict surfaces BOTH `put` variants (append-both, both are
+ * hints, the read never blocks); a delete-resolved key contributes nothing (the
+ * delete-resurrection guard). READ-ONLY — never clobbers a local file.
+ */
+export declare function mergeUnionToWorkingSetArtifacts(union: Map<string, UnionResult>): MergedWorkingSetArtifactView[];
+/**
+ * Build an OriginRecord for the OWN working-set store (the single-origin materialization the
+ * union reader merges against peer replicas). recordKey binds relPath to `origin`; the
+ * envelope carries a SYNTHETIC own-origin HLC derived from lastWrittenAt (physical) so the
+ * own record has a stable position relative to peer records. Returns null for a degenerate
+ * row (relPath fails jail).
+ */
+export declare function workingSetArtifactToOriginRecord(row: WorkingSetArtifactRow, origin: string): OriginRecord | null;
+/** The ReplicatedKindRegistry registration. server.ts registers this; the dual-registry
+ *  coupling test asserts `kind` is also present in JOURNAL_KINDS. */
+export declare const WORKING_SET_ARTIFACT_KIND_REGISTRATION: {
+    readonly kind: "working-set-artifact";
+    readonly store: "workingSetArtifact";
+    readonly schema: StoreFieldSchema;
+};
+/** The store's contributing journal kinds (for rollback-unmerge's kindsForStore wiring). */
+export declare function workingSetArtifactContributingKinds(): string[];
+/** Impact-tier resolver for ReplicatedStoreReader.tierOf — HIGH (append-both-and-flag). */
+export declare function workingSetArtifactTierOf(_store: string): ImpactTier;
+export type { ReplicatedEnvelope };
+//# sourceMappingURL=WorkingSetArtifactReplicatedStore.d.ts.map

package/dist/core/WorkingSetArtifactReplicatedStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkingSetArtifactReplicatedStore.d.ts","sourceRoot":"","sources":["../../src/core/WorkingSetArtifactReplicatedStore.ts"],"names":[],"mappings":"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"}