@ricsam/r5d-worker 0.0.100 → 0.0.103

package/dist/types/workspace-projection-ledger.d.ts

@@ -0,0 +1,59 @@
+export type WorkspaceProjectionLedgerMount = {
+    id: string;
+    /** Durable logical incarnation; a re-created branch never matches its predecessor's record. */
+    hydrationIncarnationKey: string;
+    mutationToken?: () => string;
+};
+/**
+ * Remembers, per mount incarnation, the visible-mutation token observed when
+ * the mount was last projected into the outer clone by a completed cycle,
+ * together with that cycle's result.
+ *
+ * Two decisions read it. A cycle skips mirroring a mount whose token is
+ * unchanged, because its outer subtree already carries those bytes. A
+ * request that targets a project checkout is answered with the previous
+ * cycle's result, without running a cycle, when no mount's token moved since
+ * that cycle. Both are cross-cycle skips only; the within-cycle busy and
+ * token re-checks in the sync engine stay as they are.
+ *
+ * The ledger is reset whenever something other than a recorded visible
+ * mutation can change checkout bytes: workspace configuration, canonical
+ * reset, outer remediation, branch creation or deletion, and any cycle that
+ * failed or ended in a conflict.
+ */
+export declare class WorkspaceProjectionLedger<Result extends {
+    outcome: string;
+}> {
+    private readonly projectedTokens;
+    private lastCycle;
+    private static recordKey;
+    get lastCycleResult(): Result | null;
+    lastProjectedToken(mount: {
+        id: string;
+        hydrationIncarnationKey: string;
+    }): string | undefined;
+    /**
+     * Record a completed cycle. `projectedMutationTokens` names the token each
+     * active mount carried when the cycle projected it; a mount absent from it
+     * keeps its earlier record. Any outcome that leaves the outer clone without
+     * a trustworthy projection clears the ledger.
+     */
+    recordCycle(input: {
+        result: Result;
+        mounts: readonly WorkspaceProjectionLedgerMount[];
+        projectedMutationTokens: Readonly<Record<string, string>> | undefined;
+    }): void;
+    reset(): void;
+    /**
+     * The previous cycle's result when every request targets a configured
+     * mount and no mount's token moved since its recorded projection. A request
+     * without a target (a workspace-rooted command may touch any checkout), a
+     * mount without a token (a pending deletion), or pending deletion work all
+     * require a real cycle.
+     */
+    answerFromLastCycle(input: {
+        targetMountIds: ReadonlyArray<string | null>;
+        mounts: readonly WorkspaceProjectionLedgerMount[];
+        pendingDeletions: boolean;
+    }): Result | null;
+}

package/dist/types/workspace-sync-coalescer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Batches ordinary workspace synchronization requests into one exclusive
+ * cycle each. A request that arrives while a batch is queued but not yet
+ * running joins that batch; a request that arrives while a batch is running
+ * opens the next one, because the running cycle may have selected its mounts
+ * before the request's command finished. Every request in a batch receives
+ * the same settlement, and the caller fans that out per attempt.
+ *
+ * Before this, every finished command queued its own full cycle behind every
+ * earlier one, so queue time grew without bound under a steady arrival rate
+ * even though each cycle finished in seconds.
+ */
+export declare class WorkspaceSyncCoalescer<Request, Settlement> {
+    private readonly options;
+    private pendingBatch;
+    private batchesStarted;
+    constructor(options: {
+        /** The exclusive sync lease; the batch body runs inside it. */
+        runExclusive: <T>(operation: () => Promise<T>) => Promise<T>;
+        /** Runs (or answers without running) one cycle for the whole batch. */
+        runBatch: (requests: readonly Request[]) => Promise<Settlement>;
+    });
+    /** Requests attached to the batch that has not started yet. */
+    get queuedRequestCount(): number;
+    /** Batches whose body has been entered, whether or not they ran a cycle. */
+    get startedBatchCount(): number;
+    request(request: Request): Promise<Settlement>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.100",
+  "version": "0.0.103",
   "type": "module",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/mjs/main.mjs",