@forgeax/engine-ddc 0.1.2 → 0.1.4

package/dist/index.mjs

@@ -1,8 +1,70 @@
+import { existsSync } from 'fs';
+import { resolve, join, dirname, isAbsolute, normalize } from 'path';
 import { createHash, randomUUID } from 'crypto';
-import { mkdir, writeFile, stat, rm, rename, readdir, readFile } from 'fs/promises';
-import { join, isAbsolute, normalize } from 'path';
+import { mkdir, writeFile, rm, stat, rename, readdir, readFile } from 'fs/promises';
+import { err, ok } from '@forgeax/engine-types';
 
-// src/entry-store.ts
+// src/build-cache.ts
+function canonicalDdcJson(value) {
+  const sorted = sortValue(value);
+  return JSON.stringify(sorted) ?? "null";
+}
+function sortValue(value) {
+  if (value instanceof Uint8Array) {
+    return { encoding: "base64", bytes: Buffer.from(value).toString("base64") };
+  }
+  if (Array.isArray(value)) return value.map(sortValue);
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const key of Object.keys(value).sort()) {
+      result[key] = sortValue(value[key]);
+    }
+    return result;
+  }
+  return value;
+}
+function semanticDdcKey(input) {
+  const semantic = {
+    schemaVersion: input.schemaVersion,
+    importer: input.importer,
+    codec: input.codec,
+    settings: input.settings,
+    sourceBytes: input.sourceBytes,
+    declaredGuids: [...input.declaredGuids].sort(),
+    targetProfile: input.targetProfile,
+    producer: input.producer
+  };
+  return createHash("sha256").update(canonicalDdcJson(semantic)).digest("hex");
+}
+
+// src/build-cache.ts
+function resolveDdcRoot(cwd) {
+  let current = resolve(cwd);
+  while (true) {
+    if (existsSync(join(current, "pnpm-workspace.yaml"))) {
+      return join(current, "node_modules/.cache/forgeax-ddc");
+    }
+    const parent = dirname(current);
+    if (parent === current) return join(resolve(cwd), "node_modules/.cache/forgeax-ddc");
+    current = parent;
+  }
+}
+function semanticBuildKey(input) {
+  const hasSourceOverrides = input.sourceOverrides !== void 0 && typeof input.sourceOverrides === "object" && input.sourceOverrides !== null && !Array.isArray(input.sourceOverrides) && Object.keys(input.sourceOverrides).length > 0;
+  const settings = hasSourceOverrides ? { settings: input.settings, sourceOverrides: input.sourceOverrides } : input.settings;
+  return semanticDdcKey({
+    schemaVersion: input.schemaVersion,
+    importer: input.importerVersion,
+    codec: input.codecVersion,
+    settings,
+    sourceBytes: input.sourceDependencies.map(
+      (dependency) => typeof dependency === "string" ? dependency.replaceAll("\\", "/").replace(/^.*\/(assets\/)/, "$1") : dependency.digest
+    ).sort().map((digest3) => new TextEncoder().encode(digest3)),
+    declaredGuids: input.declaredGuids,
+    targetProfile: input.cookProfile,
+    producer: input.importerVersion
+  });
+}
 
 // src/errors.ts
 var DDC_ERROR_CODES = [
@@ -109,37 +171,6 @@ var DdcStoreError = class extends Error {
     };
   }
 };
-function canonicalDdcJson(value) {
-  const sorted = sortValue(value);
-  return JSON.stringify(sorted) ?? "null";
-}
-function sortValue(value) {
-  if (value instanceof Uint8Array) {
-    return { encoding: "base64", bytes: Buffer.from(value).toString("base64") };
-  }
-  if (Array.isArray(value)) return value.map(sortValue);
-  if (value !== null && typeof value === "object") {
-    const result = {};
-    for (const key of Object.keys(value).sort()) {
-      result[key] = sortValue(value[key]);
-    }
-    return result;
-  }
-  return value;
-}
-function semanticDdcKey(input) {
-  const semantic = {
-    schemaVersion: input.schemaVersion,
-    importer: input.importer,
-    codec: input.codec,
-    settings: input.settings,
-    sourceBytes: input.sourceBytes,
-    declaredGuids: [...input.declaredGuids].sort(),
-    targetProfile: input.targetProfile,
-    producer: input.producer
-  };
-  return createHash("sha256").update(canonicalDdcJson(semantic)).digest("hex");
-}
 
 // src/entry-store.ts
 function digest(value) {
@@ -238,30 +269,39 @@ var DdcEntryStore = class {
       throw new DdcStoreError("ddc-entry-invalid", "receipt output digest does not match entry");
     }
     const path = join(this.staging, `${entry.key}-${randomUUID()}`);
-    await mkdir(join(path, "artifacts"), { recursive: true });
-    await writeFile(join(path, "payload.json"), canonicalDdcJson(entry.payload));
-    await writeFile(join(path, "refs.json"), canonicalDdcJson(entry.refs));
-    await writeFile(join(path, "receipt.json"), canonicalDdcJson(entry.receipt));
-    const artifacts = {};
-    for (const [key, artifact] of sortedArtifacts(entry)) {
-      const file = artifactFile(key);
-      artifacts[key] = { mediaType: artifact.mediaType, file };
-      await writeFile(join(path, "artifacts", `${file}.bin`), artifact.bytes);
+    try {
+      await mkdir(join(path, "artifacts"), { recursive: true });
+      await writeFile(join(path, "payload.json"), canonicalDdcJson(entry.payload));
+      await writeFile(join(path, "refs.json"), canonicalDdcJson(entry.refs));
+      await writeFile(join(path, "receipt.json"), canonicalDdcJson(entry.receipt));
+      const artifacts = {};
+      for (const [key, artifact] of sortedArtifacts(entry)) {
+        const file = artifactFile(key);
+        artifacts[key] = { mediaType: artifact.mediaType, file };
+        await writeFile(join(path, "artifacts", `${file}.bin`), artifact.bytes);
+      }
+      await writeFile(join(path, "artifacts.json"), canonicalDdcJson(artifacts));
+      await writeFile(join(path, "integrity.json"), canonicalDdcJson(integrityFor(entry)));
+      return { key: entry.key, path };
+    } catch (error) {
+      await rm(path, { recursive: true, force: true }).catch(() => {
+      });
+      throw error;
     }
-    await writeFile(join(path, "artifacts.json"), canonicalDdcJson(artifacts));
-    await writeFile(join(path, "integrity.json"), canonicalDdcJson(integrityFor(entry)));
-    return { key: entry.key, path };
   }
   async publish(staged) {
     validateKey(staged.key);
     const candidate = await this.readDirectory(staged.path, true);
     const target = join(this.entries, staged.key);
     await mkdir(this.entries, { recursive: true });
-    try {
-      await stat(target);
+    const useExisting = async () => {
       const existing = await this.readDirectory(target, false);
       await rm(staged.path, { recursive: true, force: true });
       return existingResult(existing, candidate, staged.key);
+    };
+    try {
+      await stat(target);
+      return useExisting();
     } catch (error) {
       if (error instanceof DdcStoreError) throw error;
       if (errorCode(error) !== "ENOENT") throw error;
@@ -271,11 +311,12 @@ var DdcEntryStore = class {
       return { result: "published", key: staged.key };
     } catch (error) {
       if (!["EEXIST", "ENOTEMPTY", "EISDIR"].includes(errorCode(error) ?? "")) throw error;
-      const existing = await this.readDirectory(target, false);
-      await rm(staged.path, { recursive: true, force: true });
-      return existingResult(existing, candidate, staged.key);
+      return useExisting();
     }
   }
+  async discard(staged) {
+    await rm(staged.path, { recursive: true, force: true });
+  }
   async write(entry) {
     const staged = await this.stage(entry);
     return this.publish(staged);
@@ -513,9 +554,9 @@ var DdcLifecycle = class {
     const recordedFailure = record.failure?.desiredKey === desiredKey ? { code: record.failure.code, detail: record.failure.detail } : void 0;
     const currentEntry = record.currentKey === void 0 ? null : await this.entries.readChecked(record.currentKey);
     const entryFailure = currentEntry !== null && !currentEntry.ok ? { code: currentEntry.error.code, detail: currentEntry.error.detail } : void 0;
-    const failure = recordedFailure ?? entryFailure;
+    const failure2 = recordedFailure ?? entryFailure;
     const currentValue = currentEntry?.ok === true ? currentEntry.value : null;
-    const state = failure !== void 0 ? "failed" : record.currentKey === desiredKey && currentValue?.guid === guid ? "current" : record.stale === true ? "stale" : record.active?.desiredKey === desiredKey ? "cooking" : "stale";
+    const state = failure2 !== void 0 ? "failed" : record.currentKey === desiredKey && currentValue?.guid === guid ? "current" : record.stale === true ? "stale" : record.active?.desiredKey === desiredKey ? "cooking" : "stale";
     return {
       guid,
       desiredKey,
@@ -525,7 +566,7 @@ var DdcLifecycle = class {
       revision: record.revision,
       ...record.generation === void 0 ? {} : { generation: record.generation },
       ...record.active === void 0 ? {} : { activeLease: record.active },
-      ...failure === void 0 ? {} : { failure }
+      ...failure2 === void 0 ? {} : { failure: failure2 }
     };
   }
   async begin(guid, desiredKey) {
@@ -617,7 +658,7 @@ var DdcLifecycle = class {
       return withRevision({ result: "current", key: validatedKey }, nextRevision);
     });
   }
-  async fail(lease, failure) {
+  async fail(lease, failure2) {
     await withDdcLock(this.root, `head-${lease.guid}`, async () => {
       const current = await this.read(lease.guid);
       if (current?.active?.attempt !== lease.attempt) return;
@@ -628,7 +669,7 @@ var DdcLifecycle = class {
         generation: lease.generation,
         ...current.currentKey === void 0 ? {} : { currentKey: current.currentKey },
         ...current.lastKnownGoodKey === void 0 ? {} : { lastKnownGoodKey: current.lastKnownGoodKey },
-        failure: { desiredKey: lease.desiredKey, ...failure }
+        failure: { desiredKey: lease.desiredKey, ...failure2 }
       });
     });
   }
@@ -663,6 +704,40 @@ var DdcLifecycle = class {
       });
     });
   }
+  async discard(lease) {
+    await withDdcLock(this.root, `head-${lease.guid}`, async () => {
+      const current = await this.read(lease.guid);
+      if (current?.active?.attempt !== lease.attempt) return;
+      const { active: _active, ...withoutActive } = current;
+      await this.write({
+        ...withoutActive,
+        revision: current.revision + 1,
+        generation: lease.generation,
+        stale: current.currentKey === void 0
+      });
+    });
+  }
+  /** Restore the last accepted head after a failed multi-owner generation commit. */
+  async restore(head) {
+    await withDdcLock(this.root, `head-${head.guid}`, async () => {
+      const path = headFile(this.heads, head.guid);
+      if (head.state === "missing") {
+        await rm(path, { force: true });
+        return;
+      }
+      await this.write({
+        guid: head.guid,
+        desiredKey: head.desiredKey,
+        revision: head.revision ?? 0,
+        ...head.currentKey === void 0 ? {} : { currentKey: head.currentKey },
+        ...head.lastKnownGoodKey === void 0 ? {} : { lastKnownGoodKey: head.lastKnownGoodKey },
+        ...head.generation === void 0 ? {} : { generation: head.generation },
+        ...head.activeLease === void 0 ? {} : { active: head.activeLease },
+        ...head.state === "stale" ? { stale: true } : {},
+        ...head.failure === void 0 ? {} : { failure: { desiredKey: head.desiredKey, ...head.failure } }
+      });
+    });
+  }
   async revoke(lease) {
     await this.fail(lease, {
       code: "lease-lost",
@@ -814,6 +889,299 @@ function resolveDdcLayout(options) {
 function isDdcLayout(value) {
   return value !== null && typeof value === "object" && value.version === DDC_LAYOUT_VERSION;
 }
+function stable(value) {
+  if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stable(record[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function digest2(value) {
+  return `sha256:${createHash("sha256").update(stable(value)).digest("hex")}`;
+}
+function scriptablePackOutputSetDigest(outputs) {
+  return digest2(
+    outputs.map((output) => ({
+      guid: output.guid.toLowerCase(),
+      sourceKey: output.sourceKey,
+      kind: output.kind,
+      digest: output.digest,
+      refs: [...output.refs].map((guid) => guid.toLowerCase())
+    }))
+  );
+}
+function scriptablePackPublicationGeneration(input) {
+  const hash = createHash("sha256").update(input.sourceRevision).update("\n").update(input.digest).update("\n").update(input.outputSetDigest).digest("hex");
+  const generation = Number.parseInt(hash.slice(0, 8), 16);
+  return generation > 0 ? generation : 1;
+}
+function createAcceptedPublication(input) {
+  const outputSetDigest = scriptablePackOutputSetDigest(input.outputs);
+  const publicationGeneration = input.generation ?? scriptablePackPublicationGeneration({
+    sourceRevision: input.sourceRevision,
+    digest: input.digest,
+    outputSetDigest
+  });
+  return {
+    schemaVersion: "asset-publication/1",
+    sourcePath: input.sourcePath,
+    sourceRevision: input.sourceRevision,
+    generation: publicationGeneration,
+    digest: input.digest,
+    outputSetDigest,
+    outputs: input.outputs,
+    receipt: {
+      schemaVersion: "asset-publication-receipt/1",
+      sourcePath: input.sourcePath,
+      sourceRevision: input.sourceRevision,
+      inputFingerprint: input.inputFingerprint,
+      outputDigest: input.digest,
+      outputSetDigest,
+      externalEvidence: input.externalEvidence
+    },
+    externalEvidence: input.externalEvidence,
+    current: {
+      generation: publicationGeneration,
+      digest: input.digest,
+      outputSetDigest,
+      packageUrl: input.packageUrl,
+      receiptKey: input.inputFingerprint
+    }
+  };
+}
+function locatorFor(envelope) {
+  return {
+    generation: envelope.generation,
+    digest: envelope.digest,
+    outputSetDigest: envelope.outputSetDigest,
+    packageUrl: envelope.current?.packageUrl ?? "",
+    receiptKey: envelope.receipt.inputFingerprint
+  };
+}
+function recoveryFor(retryable, useLastKnownGood) {
+  return {
+    retryable,
+    preserveCurrent: true,
+    useLastKnownGood,
+    actions: retryable ? ["inspect-publication-failure", "retry-rebuild", "continue-last-known-good"] : ["inspect-publication-failure", "edit-source", "continue-last-known-good"]
+  };
+}
+function failure(envelope, code, stage, reason, retryable, current, lastKnownGood) {
+  return {
+    code,
+    stage,
+    sourcePath: envelope.sourcePath,
+    sourceRevision: envelope.sourceRevision,
+    generation: envelope.generation,
+    reason,
+    recovery: recoveryFor(retryable, lastKnownGood !== void 0),
+    ...current === void 0 ? {} : { current: locatorFor(current) },
+    ...lastKnownGood === void 0 ? {} : { lastKnownGood: locatorFor(lastKnownGood) }
+  };
+}
+function validateOutputs(envelope, current, lastKnownGood) {
+  const guids = /* @__PURE__ */ new Set();
+  const sourceKeys = /* @__PURE__ */ new Set();
+  for (const output of envelope.outputs) {
+    const guid = output.guid.toLowerCase();
+    if (guids.has(guid) || sourceKeys.has(output.sourceKey)) {
+      return failure(
+        envelope,
+        "asset-publication-output-duplicate",
+        "output",
+        "publication output GUIDs and sourceKeys must be unique",
+        false,
+        current,
+        lastKnownGood
+      );
+    }
+    guids.add(guid);
+    sourceKeys.add(output.sourceKey);
+  }
+  if (envelope.outputs.length === 0 || scriptablePackOutputSetDigest(envelope.outputs) !== envelope.outputSetDigest) {
+    return failure(
+      envelope,
+      "asset-publication-output-set-mismatch",
+      "receipt",
+      "receipt outputSetDigest does not match the complete output tuple",
+      false,
+      current,
+      lastKnownGood
+    );
+  }
+  return void 0;
+}
+function validateReceipt(envelope, current, lastKnownGood) {
+  const receipt = envelope.receipt;
+  if (receipt.schemaVersion !== "asset-publication-receipt/1" || receipt.sourcePath !== envelope.sourcePath || receipt.sourceRevision !== envelope.sourceRevision || receipt.outputSetDigest !== envelope.outputSetDigest || receipt.outputDigest !== envelope.digest || stable(receipt.externalEvidence) !== stable(envelope.externalEvidence)) {
+    return failure(
+      envelope,
+      "asset-publication-receipt-mismatch",
+      "receipt",
+      "publication receipt does not match the candidate output tuple",
+      false,
+      current,
+      lastKnownGood
+    );
+  }
+  return void 0;
+}
+function validateEnvelope(envelope, current, lastKnownGood) {
+  if (envelope.schemaVersion !== "asset-publication/1") {
+    return failure(
+      envelope,
+      "asset-publication-schema-invalid",
+      "receipt",
+      "publication envelope schemaVersion is not supported",
+      false,
+      current,
+      lastKnownGood
+    );
+  }
+  if (!Number.isSafeInteger(envelope.generation) || envelope.generation < 1) {
+    return failure(
+      envelope,
+      "asset-publication-generation-invalid",
+      "receipt",
+      "publication generation must be a positive integer",
+      false,
+      current,
+      lastKnownGood
+    );
+  }
+  const outputError = validateOutputs(envelope, current, lastKnownGood);
+  if (outputError !== void 0) return outputError;
+  const receiptError = validateReceipt(envelope, current, lastKnownGood);
+  if (receiptError !== void 0) return receiptError;
+  const sameTuple = current !== void 0 && envelope.generation === current.generation && envelope.sourcePath === current.sourcePath && envelope.sourceRevision === current.sourceRevision && envelope.digest === current.digest && envelope.outputSetDigest === current.outputSetDigest;
+  if (sameTuple) return void 0;
+  if (current !== void 0 && envelope.generation <= current.generation) {
+    return failure(
+      envelope,
+      "asset-publication-stale",
+      "cancelled",
+      `candidate generation ${envelope.generation} is not newer than current ${current.generation}`,
+      true,
+      current,
+      lastKnownGood
+    );
+  }
+  return void 0;
+}
+function validateCandidate(state, candidate, cancelledReason) {
+  const current = state.snapshot.current;
+  const lastKnownGood = state.snapshot.lastKnownGood ?? current;
+  if (candidate.cancelled === true) {
+    return failure(
+      candidate.envelope,
+      "asset-publication-cancelled",
+      "cancelled",
+      cancelledReason,
+      true,
+      current,
+      lastKnownGood
+    );
+  }
+  return validateEnvelope(candidate.envelope, current, lastKnownGood);
+}
+async function publishCandidate(state, candidate, commitRoute) {
+  const current = state.snapshot.current;
+  const lastKnownGood = state.snapshot.lastKnownGood ?? current;
+  const invalid = validateCandidate(
+    state,
+    candidate,
+    "publication request was cancelled before route commit"
+  );
+  if (invalid !== void 0) {
+    state.snapshot = { ...state.snapshot, failure: invalid };
+    return err(invalid);
+  }
+  try {
+    await commitRoute();
+  } catch (error) {
+    const failed = failure(
+      candidate.envelope,
+      "asset-publication-route-failed",
+      "route",
+      error instanceof Error ? error.message : String(error),
+      true,
+      current,
+      lastKnownGood
+    );
+    state.snapshot = { ...state.snapshot, failure: failed };
+    return err(failed);
+  }
+  const published = {
+    ...candidate.envelope,
+    current: locatorFor(candidate.envelope),
+    ...current === void 0 ? {} : { lastKnownGood: locatorFor(current) },
+    recovery: recoveryFor(false, current !== void 0)
+  };
+  state.snapshot = {
+    current: published,
+    ...current === void 0 ? {} : { lastKnownGood: current }
+  };
+  return ok(state.snapshot);
+}
+function createAcceptedPublicationStore() {
+  const states = /* @__PURE__ */ new Map();
+  function stateFor(sourcePath) {
+    const existing = states.get(sourcePath);
+    if (existing !== void 0) return existing;
+    const created = { snapshot: {}, staged: /* @__PURE__ */ new Map() };
+    states.set(sourcePath, created);
+    return created;
+  }
+  function candidateKey(candidate) {
+    return `${candidate.generation}\0${candidate.digest}\0${candidate.outputSetDigest}`;
+  }
+  return {
+    observe(sourcePath) {
+      return stateFor(sourcePath).snapshot;
+    },
+    stage(sourcePath, candidate) {
+      const invalid = validateCandidate(
+        stateFor(sourcePath),
+        candidate,
+        "publication request was cancelled before DDC commit"
+      );
+      if (invalid !== void 0) return err(invalid);
+      stateFor(sourcePath).staged.set(candidateKey(candidate.envelope), candidate.envelope);
+      return ok(void 0);
+    },
+    async commit(sourcePath, candidate, commitRoute) {
+      const key = candidateKey(candidate.envelope);
+      const state = stateFor(sourcePath);
+      if (!state.staged.has(key)) {
+        const current = state.snapshot.current;
+        const lastKnownGood = state.snapshot.lastKnownGood ?? current;
+        return err(
+          failure(
+            candidate.envelope,
+            "asset-publication-cancelled",
+            "cancelled",
+            "publication candidate was discarded before DDC commit",
+            true,
+            current,
+            lastKnownGood
+          )
+        );
+      }
+      const result = await publishCandidate(state, candidate, commitRoute);
+      state.staged.delete(key);
+      return result;
+    },
+    discard(sourcePath, candidate) {
+      stateFor(sourcePath).staged.delete(candidateKey(candidate));
+    },
+    restore(sourcePath, snapshot) {
+      const state = stateFor(sourcePath);
+      state.staged.clear();
+      state.snapshot = snapshot;
+    }
+  };
+}
 function scopeHash(scopeId) {
   return createHash("sha256").update(scopeId, "utf8").digest("hex");
 }
@@ -874,6 +1242,196 @@ async function assertRuntimeScope(root, scope) {
   return createRuntimeScope(root, scope.scopeId);
 }
 
+// src/session.ts
+var DdcGenerationSession = class {
+  generation;
+  lifecycle;
+  entries;
+  candidates = /* @__PURE__ */ new Map();
+  heartbeatTimers = /* @__PURE__ */ new Map();
+  counters = {
+    hitCount: 0,
+    missCount: 0,
+    corruptCount: 0,
+    writeFailureCount: 0
+  };
+  accepting = true;
+  constructor(root, options) {
+    if (!Number.isSafeInteger(options.generation) || options.generation < 1) {
+      throw new TypeError("DDC generation must be a positive safe integer");
+    }
+    this.generation = options.generation;
+    this.lifecycle = new DdcLifecycle(
+      root,
+      options.leaseTtlMs === void 0 ? void 0 : { leaseTtlMs: options.leaseTtlMs }
+    );
+    this.entries = new DdcEntryStore(root);
+  }
+  async beginCandidate(guid, desiredKey) {
+    const head = await this.inspect(guid, desiredKey);
+    const lease = await this.lifecycle.begin(guid, desiredKey);
+    const candidate = {
+      generation: this.generation,
+      lease,
+      previousHead: head
+    };
+    this.candidates.set(lease.attempt, candidate);
+    this.scheduleHeartbeat(candidate);
+    return candidate;
+  }
+  async stageEntry(entry) {
+    this.assertOpen();
+    const candidate = await this.beginCandidate(
+      entry.guid,
+      entry.key
+    );
+    try {
+      const staged = await this.entries.stage(entry);
+      const entryCandidate = Object.assign(candidate, {
+        staged
+      });
+      this.candidates.set(candidate.lease.attempt, entryCandidate);
+      return entryCandidate;
+    } catch (error) {
+      await this.lifecycle.fail(candidate.lease, {
+        code: "ddc-entry-stage-failed",
+        detail: error instanceof Error ? error.message : String(error)
+      });
+      this.stopHeartbeat(candidate);
+      this.candidates.delete(candidate.lease.attempt);
+      this.counters.writeFailureCount += 1;
+      throw error;
+    }
+  }
+  async inspect(guid, desiredKey) {
+    this.assertOpen();
+    const head = await this.lifecycle.inspect(guid, desiredKey);
+    if (head.state === "current") this.counters.hitCount += 1;
+    else this.counters.missCount += 1;
+    return head;
+  }
+  async commitCandidate(candidate, validatedKey) {
+    const registered = this.assertCandidate(candidate);
+    try {
+      const result = await this.lifecycle.commit(registered.lease, validatedKey);
+      if (result.result === "invalid") this.counters.corruptCount += 1;
+      this.stopHeartbeat(registered);
+      this.candidates.delete(registered.lease.attempt);
+      return result;
+    } catch (error) {
+      this.stopHeartbeat(registered);
+      this.counters.writeFailureCount += 1;
+      throw error;
+    }
+  }
+  async commitEntry(candidate, validatedKey) {
+    const registered = this.assertCandidate(candidate);
+    try {
+      await this.entries.publish(candidate.staged);
+      const result = await this.lifecycle.commit(registered.lease, validatedKey);
+      this.stopHeartbeat(registered);
+      this.candidates.delete(registered.lease.attempt);
+      return result;
+    } catch (error) {
+      this.stopHeartbeat(registered);
+      await this.lifecycle.fail(registered.lease, {
+        code: "ddc-entry-publish-failed",
+        detail: error instanceof Error ? error.message : String(error)
+      });
+      await this.entries.discard(candidate.staged).catch(() => {
+      });
+      this.candidates.delete(registered.lease.attempt);
+      this.counters.writeFailureCount += 1;
+      throw error;
+    }
+  }
+  async discardCandidate(candidate) {
+    const registered = this.candidates.get(candidate.lease.attempt);
+    if (registered === void 0) return;
+    try {
+      this.stopHeartbeat(registered);
+      await this.lifecycle.discard(registered.lease);
+      this.candidates.delete(registered.lease.attempt);
+    } catch (error) {
+      this.counters.writeFailureCount += 1;
+      throw error;
+    }
+  }
+  async discardEntry(candidate) {
+    await Promise.all([this.discardCandidate(candidate), this.entries.discard(candidate.staged)]);
+  }
+  async restoreEntry(candidate) {
+    const registered = this.candidates.get(candidate.lease.attempt);
+    let restoreError;
+    try {
+      await this.lifecycle.restore(candidate.previousHead);
+    } catch (error) {
+      restoreError = error;
+    } finally {
+      await this.entries.discard(candidate.staged).catch(() => {
+      });
+      if (registered !== void 0) {
+        this.stopHeartbeat(registered);
+        this.candidates.delete(registered.lease.attempt);
+      }
+    }
+    if (restoreError !== void 0) throw restoreError;
+  }
+  metrics() {
+    return { ...this.counters };
+  }
+  async close() {
+    if (!this.accepting) return;
+    this.accepting = false;
+    for (const timer of this.heartbeatTimers.values()) clearTimeout(timer);
+    this.heartbeatTimers.clear();
+    const pending = [...this.candidates.values()];
+    for (const candidate of pending) {
+      try {
+        await this.lifecycle.discard(candidate.lease);
+      } catch {
+        this.counters.writeFailureCount += 1;
+      }
+    }
+    this.candidates.clear();
+  }
+  assertOpen() {
+    if (!this.accepting) throw new Error("DDC generation session is closed");
+  }
+  assertCandidate(candidate) {
+    this.assertOpen();
+    const registered = this.candidates.get(candidate.lease.attempt);
+    if (candidate.generation !== this.generation || registered === void 0) {
+      throw new Error("DDC candidate belongs to another generation session");
+    }
+    return registered;
+  }
+  scheduleHeartbeat(candidate) {
+    const attempt = candidate.lease.attempt;
+    this.stopHeartbeat(candidate);
+    const delay2 = Math.max(1, Math.floor((candidate.lease.expiresAt - Date.now()) / 2));
+    const timer = setTimeout(() => {
+      this.heartbeatTimers.delete(attempt);
+      if (!this.accepting || this.candidates.get(attempt) !== candidate) return;
+      void this.lifecycle.heartbeat(candidate.lease).then((lease) => {
+        if (!this.accepting || this.candidates.get(attempt) !== candidate) return;
+        candidate.lease = lease;
+        this.scheduleHeartbeat(candidate);
+      }).catch(() => {
+        this.stopHeartbeat(candidate);
+      });
+    }, delay2);
+    timer.unref?.();
+    this.heartbeatTimers.set(attempt, timer);
+  }
+  stopHeartbeat(candidate) {
+    const timer = this.heartbeatTimers.get(candidate.lease.attempt);
+    if (timer === void 0) return;
+    clearTimeout(timer);
+    this.heartbeatTimers.delete(candidate.lease.attempt);
+  }
+};
+
 // src/status.ts
 var DDC_STATUS_SCHEMA = "forgeax-ddc-status/v2";
 function serializeDdcStatus(status) {
@@ -891,6 +1449,6 @@ function projectDdcStatusForBrowser(status) {
 }
 var toBrowserDdcStatus = projectDdcStatusForBrowser;
 
-export { DDC_ERROR_CODES, DDC_LAYOUT_VERSION, DDC_STATUS_SCHEMA, DdcEntryStore, DdcLifecycle, DdcStoreError, assertRuntimeScope, collectDdcGarbage, createRuntimeScope, ddcOutputDigest, isDdcLayout, projectDdcStatusForBrowser, resolveBuildDdcLayout, resolveDdcLayout, runtimeScopeHash, semanticDdcKey, serializeDdcStatus, toBrowserDdcStatus };
+export { DDC_ERROR_CODES, DDC_LAYOUT_VERSION, DDC_STATUS_SCHEMA, DdcEntryStore, DdcGenerationSession, DdcLifecycle, DdcStoreError, assertRuntimeScope, collectDdcGarbage, createAcceptedPublication, createAcceptedPublicationStore, createRuntimeScope, ddcOutputDigest, isDdcLayout, projectDdcStatusForBrowser, resolveBuildDdcLayout, resolveDdcLayout, resolveDdcRoot, runtimeScopeHash, scriptablePackOutputSetDigest, scriptablePackPublicationGeneration, semanticBuildKey, semanticDdcKey, serializeDdcStatus, toBrowserDdcStatus };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map