@astrosheep/keiyaku 2.9.12 → 2.9.13

package/build/core/projection/akuma-name.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+const WINDOWS_RESERVED_NAME = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\..*)?$/i;
+const FORBIDDEN_CODE_POINT = /[\u0000-\u001f\u007f-\u009f\uD800-\uDFFF]/u;
+const FORBIDDEN_PORTABLE_PATH_CHARACTER = /[\\/<>:"|?*]/u;
+const MAX_AKUMA_NAME_BYTES = 255;
+export function canonicalizeAkumaName(value) {
+    return value.normalize("NFC");
+}
+export function akumaNameProblem(value) {
+    if (value.length === 0)
+        return "must not be empty.";
+    if (value !== canonicalizeAkumaName(value))
+        return "must use Unicode NFC normalization.";
+    if (value === "." || value === ".." || value.startsWith(".")) {
+        return "must not be a dot path or hidden filesystem name.";
+    }
+    if (FORBIDDEN_CODE_POINT.test(value))
+        return "must not contain control characters or unpaired surrogates.";
+    if (/\p{White_Space}/u.test(value))
+        return "must not contain whitespace.";
+    if (FORBIDDEN_PORTABLE_PATH_CHARACTER.test(value))
+        return "must not contain portable filesystem separators or reserved punctuation.";
+    if (/[. ]$/u.test(value))
+        return "must not end with a dot or space.";
+    if (WINDOWS_RESERVED_NAME.test(value))
+        return "must not be a reserved Windows filename.";
+    if (Buffer.byteLength(value, "utf8") > MAX_AKUMA_NAME_BYTES) {
+        return `must contain at most ${MAX_AKUMA_NAME_BYTES} UTF-8 bytes.`;
+    }
+    return null;
+}
+/**
+ * Akuma identity is exact NFC text. Case, variation selectors, ZWJ sequences,
+ * and visually confusable code points are intentionally not folded.
+ */
+export const akumaNameSchema = z.string().superRefine((value, ctx) => {
+    const problem = akumaNameProblem(value);
+    if (problem !== null)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: problem });
+});
+export function isAkumaName(value) {
+    return akumaNameProblem(value) === null;
+}

package/build/core/projection/generation/database.js

@@ -1,20 +1,22 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { DatabaseSync } from "node:sqlite";
+import { ProjectionStateError } from "../../atomic-publish.js";
 import { configureHeartBusyTimeout } from "../heart.js";
 import { ProjectionGenerationStoreError, parseStoredRow, validateHistory, } from "./model.js";
+import { ProjectionGenerationLedger } from "./ledger.js";
 export const PROJECTION_GENERATION_STORE_FILE = "heart";
-export const PROJECTION_GENERATION_SCHEMA_VERSION = 4;
-const SCHEMA_TABLE_SQL = `
+export const PROJECTION_GENERATION_SCHEMA_VERSION = 6;
+const GENERATION_SCHEMA_SQL = `
   CREATE TABLE generation_schema (
     singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
     version INTEGER NOT NULL CHECK (version = ${PROJECTION_GENERATION_SCHEMA_VERSION})
   ) STRICT
 `;
-const RECORD_TABLE_SQL = `
+const GENERATION_RECORD_SQL = `
   CREATE TABLE generation_records (
     seq INTEGER PRIMARY KEY CHECK (seq > 0),
-    kind TEXT NOT NULL CHECK (kind IN ('launch', 'adoption', 'kill-intent', 'interrupt-intent', 'verdict')),
+    activity_kind TEXT NOT NULL CHECK (activity_kind IN ('launch', 'adoption', 'kill-intent', 'interrupt-intent', 'verdict')),
     execution_id TEXT NOT NULL CHECK (length(trim(execution_id)) > 0),
     facts_json TEXT NOT NULL CHECK (json_valid(facts_json))
   ) STRICT
@@ -92,6 +94,34 @@ const TELL_LAUNCH_COORDINATE_TABLE_SQL = `
   ) STRICT
 `;
 const closedDatabases = new WeakSet();
+function projectionHeartPath(projectionDirectory) {
+    return path.join(projectionDirectory, PROJECTION_GENERATION_STORE_FILE);
+}
+function openHeartConnection(databasePath, readOnly, foreignKeys = false) {
+    const database = new DatabaseSync(databasePath, {
+        readOnly,
+        ...(foreignKeys ? { enableForeignKeyConstraints: true } : {}),
+        enableDoubleQuotedStringLiterals: false,
+        allowExtension: false,
+    });
+    try {
+        configureHeartBusyTimeout(database);
+        if (!readOnly) {
+            database.exec("PRAGMA journal_mode = DELETE");
+            database.exec("PRAGMA synchronous = FULL");
+            database.exec("PRAGMA foreign_keys = ON");
+            database.exec("PRAGMA trusted_schema = OFF");
+        }
+        return database;
+    }
+    catch (error) {
+        try {
+            database.close();
+        }
+        catch { /* preserve configuration failure */ }
+        throw error;
+    }
+}
 /** Classify only proved missing schema evidence as historical incompatibility. */
 export function projectionGenerationStoreInspectionError(databasePath, error) {
     if (error instanceof ProjectionGenerationStoreError)
@@ -153,14 +183,16 @@ function validateSchemaShape(database) {
         throw new ProjectionGenerationStoreError(`projection generation schema contains unexpected objects: ${signature || "none"}`, { observation: "incompatible" });
     }
     const metadata = database.prepare("SELECT singleton, version FROM generation_schema").all();
-    if (metadata.length !== 1 || Number(metadata[0].singleton) !== 1 || Number(metadata[0].version) !== PROJECTION_GENERATION_SCHEMA_VERSION) {
+    if (metadata.length !== 1
+        || Number(metadata[0].singleton) !== 1
+        || Number(metadata[0].version) !== PROJECTION_GENERATION_SCHEMA_VERSION) {
         throw new ProjectionGenerationStoreError("projection generation schema metadata is malformed", { observation: "incompatible" });
     }
-    const recordColumns = database.prepare("PRAGMA table_info(generation_records)").all();
-    const columnSignature = recordColumns
+    const generationColumns = database.prepare("PRAGMA table_info(generation_records)").all();
+    const generationSignature = generationColumns
         .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
         .join(",");
-    if (columnSignature !== "seq:INTEGER:0:1,kind:TEXT:1:0,execution_id:TEXT:1:0,facts_json:TEXT:1:0") {
+    if (generationSignature !== "seq:INTEGER:0:1,activity_kind:TEXT:1:0,execution_id:TEXT:1:0,facts_json:TEXT:1:0") {
         throw new ProjectionGenerationStoreError("projection generation record schema is malformed", { observation: "incompatible" });
     }
     const identityColumns = database.prepare("PRAGMA table_info(projection_identity)").all();
@@ -228,8 +260,10 @@ function initializeOrValidateSchema(database) {
       ORDER BY name
     `).all();
         if (version === 0 && objects.length === 0) {
-            database.exec(SCHEMA_TABLE_SQL);
-            database.exec(RECORD_TABLE_SQL);
+            database.exec(GENERATION_SCHEMA_SQL);
+            database.exec(GENERATION_RECORD_SQL);
+            database.prepare("INSERT INTO generation_schema (singleton, version) VALUES (1, ?)")
+                .run(PROJECTION_GENERATION_SCHEMA_VERSION);
             database.exec(IDENTITY_TABLE_SQL);
             database.exec(TELL_TABLE_SQL);
             database.exec(TELL_RECEIPT_TABLE_SQL);
@@ -237,8 +271,6 @@ function initializeOrValidateSchema(database) {
             database.exec(TELL_LAUNCH_BATCH_TABLE_SQL);
             database.exec(TELL_LAUNCH_ADMISSION_TABLE_SQL);
             database.exec(TELL_LAUNCH_COORDINATE_TABLE_SQL);
-            database.prepare("INSERT INTO generation_schema (singleton, version) VALUES (1, ?)")
-                .run(PROJECTION_GENERATION_SCHEMA_VERSION);
             database.exec(`PRAGMA user_version = ${PROJECTION_GENERATION_SCHEMA_VERSION}`);
         }
         else if (version !== PROJECTION_GENERATION_SCHEMA_VERSION) {
@@ -256,22 +288,10 @@ export function openMutableDatabase(projectionDirectory) {
     const stat = fs.statSync(projectionDirectory);
     if (!stat.isDirectory())
         throw new ProjectionGenerationStoreError("projection generation store parent must be a directory");
-    const databasePath = path.join(projectionDirectory, PROJECTION_GENERATION_STORE_FILE);
+    const databasePath = projectionHeartPath(projectionDirectory);
     let database;
     try {
-        database = new DatabaseSync(databasePath, {
-            enableForeignKeyConstraints: true,
-            enableDoubleQuotedStringLiterals: false,
-            allowExtension: false,
-        });
-        configureHeartBusyTimeout(database);
-        // Rollback journal keeps observers genuinely read-only. A read-only WAL
-        // connection creates/updates -wal and -shm coordination files, while
-        // immutable WAL reads can miss concurrently committed facts.
-        database.exec("PRAGMA journal_mode = DELETE");
-        database.exec("PRAGMA synchronous = FULL");
-        database.exec("PRAGMA foreign_keys = ON");
-        database.exec("PRAGMA trusted_schema = OFF");
+        database = openHeartConnection(databasePath, false, true);
     }
     catch (error) {
         try {
@@ -282,7 +302,7 @@ export function openMutableDatabase(projectionDirectory) {
     }
     try {
         initializeOrValidateSchema(database);
-        readValidatedHistory(database);
+        readValidatedHistory(database, false);
         return { databasePath, database };
     }
     catch (error) {
@@ -296,7 +316,7 @@ export function openReadOnlyDatabase(projectionDirectory) {
     const stat = fs.statSync(projectionDirectory);
     if (!stat.isDirectory())
         throw new ProjectionGenerationStoreError("projection generation store parent must be a directory");
-    const databasePath = path.join(projectionDirectory, PROJECTION_GENERATION_STORE_FILE);
+    const databasePath = projectionHeartPath(projectionDirectory);
     try {
         if (!fs.lstatSync(databasePath).isFile()) {
             throw new ProjectionGenerationStoreError("projection generation store must be a regular file", { observation: "incompatible" });
@@ -307,14 +327,9 @@ export function openReadOnlyDatabase(projectionDirectory) {
     }
     let database;
     try {
-        database = new DatabaseSync(databasePath, {
-            readOnly: true,
-            enableDoubleQuotedStringLiterals: false,
-            allowExtension: false,
-        });
-        configureHeartBusyTimeout(database);
+        database = openHeartConnection(databasePath, true);
         validateSchemaShape(database);
-        readValidatedHistory(database);
+        readValidatedHistory(database, true);
         return { databasePath, database };
     }
     catch (error) {
@@ -325,13 +340,14 @@ export function openReadOnlyDatabase(projectionDirectory) {
         throw projectionGenerationStoreReadError(databasePath, error);
     }
 }
-/** Read the validated heart through one consistent SQLite snapshot. */
-export function withGenerationReadSnapshot(projectionDirectory, read) {
-    const { database } = openReadOnlyDatabase(projectionDirectory);
+function withProjectionHeartOperation(open, mode, operation) {
+    const database = open();
     try {
-        database.exec("BEGIN");
+        if (mode === "read")
+            return operation(database);
+        database.exec(mode === "snapshot" ? "BEGIN" : "BEGIN IMMEDIATE");
         try {
-            const result = read(database);
+            const result = operation(database);
             database.exec("COMMIT");
             return result;
         }
@@ -344,64 +360,110 @@ export function withGenerationReadSnapshot(projectionDirectory, read) {
         closeDatabase(database);
     }
 }
+/** Read the validated heart through one consistent SQLite snapshot. */
+export function withGenerationReadSnapshot(projectionDirectory, read) {
+    return withProjectionHeartOperation(() => openReadOnlyDatabase(projectionDirectory).database, "snapshot", read);
+}
+function openProjectionHeartDatabase(projectionDirectory, readOnly) {
+    const databasePath = projectionHeartPath(projectionDirectory);
+    if (!fs.lstatSync(databasePath).isFile()) {
+        throw new ProjectionStateError("projection heart must be a regular file");
+    }
+    return openHeartConnection(databasePath, readOnly, true);
+}
+export function withProjectionHeartRead(projectionDirectory, read) {
+    return withProjectionHeartOperation(() => openProjectionHeartDatabase(projectionDirectory, true), "read", read);
+}
+export function withProjectionHeartReadSnapshot(projectionDirectory, read) {
+    return withProjectionHeartOperation(() => openProjectionHeartDatabase(projectionDirectory, true), "snapshot", read);
+}
+export function withProjectionHeartWrite(projectionDirectory, write) {
+    return withProjectionHeartOperation(() => openProjectionHeartDatabase(projectionDirectory, false), "write", write);
+}
+export function openProjectionTellObserver(projectionDirectory) {
+    const database = openProjectionHeartDatabase(projectionDirectory, true);
+    let closed = false;
+    let observedDataVersion;
+    const assertOpen = () => {
+        if (closed)
+            throw new ProjectionStateError("projection tell observer is closed");
+    };
+    const readDataVersion = () => {
+        assertOpen();
+        const row = database.prepare("PRAGMA data_version").get();
+        const raw = row?.data_version;
+        const value = typeof raw === "bigint" ? Number(raw) : raw;
+        if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+            throw new ProjectionStateError("PRAGMA data_version returned an invalid value");
+        }
+        return value;
+    };
+    return {
+        hasDataVersionChanged() {
+            const current = readDataVersion();
+            if (current === observedDataVersion)
+                return false;
+            observedDataVersion = current;
+            return true;
+        },
+        hasInbox() {
+            assertOpen();
+            return database.prepare(`
+        SELECT 1
+        FROM projection_tells
+        WHERE state = 'inbox'
+        LIMIT 1
+      `).get() !== undefined;
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            closeDatabase(database);
+        },
+    };
+}
 export function assertDatabaseOpen(database) {
     if (closedDatabases.has(database))
         throw new ProjectionGenerationStoreError("projection generation store is closed");
 }
-export function readValidatedHistory(database) {
-    const rows = database.prepare(`
-    SELECT seq, kind, execution_id, facts_json
-    FROM generation_records
-    ORDER BY seq
-  `).all();
-    const records = rows.map(parseStoredRow);
+export function connectionBoundGenerationStore(database, readOnly) {
+    return new ProjectionGenerationLedger(database, readOnly);
+}
+export function readValidatedHistory(database, readOnly) {
+    const records = connectionBoundGenerationStore(database, readOnly).readRecords().map((record) => parseStoredRow({
+        seq: record.seq,
+        kind: record.kind,
+        execution_id: record.executionId,
+        facts_json: JSON.stringify(record.facts),
+    }));
     return { records, current: validateHistory(records) };
 }
 export function appendRecord(database, kind, executionId, facts, seq) {
-    const encoded = JSON.stringify(facts);
-    database.prepare(`
-    INSERT INTO generation_records (seq, kind, execution_id, facts_json)
-    VALUES (?, ?, ?, ?)
-  `).run(seq, kind, executionId, encoded);
-    return { seq, kind, executionId, facts: JSON.parse(encoded) };
+    const record = connectionBoundGenerationStore(database, false)
+        .appendRecord(kind, executionId, facts, seq);
+    return {
+        seq: record.seq,
+        kind: record.kind,
+        executionId: record.executionId,
+        facts: record.facts,
+    };
 }
 export function writeTransition(database, readOnly, run) {
     assertDatabaseOpen(database);
-    if (readOnly) {
-        throw new ProjectionGenerationStoreError("projection generation store is read-only");
-    }
-    if (database.isTransaction)
-        return run();
-    database.exec("BEGIN IMMEDIATE");
-    try {
-        const result = run();
-        database.exec("COMMIT");
-        return result;
-    }
-    catch (error) {
-        rollbackQuietly(database);
-        throw error;
-    }
+    return connectionBoundGenerationStore(database, readOnly).write(run);
 }
 export function beginGenerationWriteTransaction(database, readOnly) {
     assertDatabaseOpen(database);
-    if (readOnly)
-        throw new ProjectionGenerationStoreError("projection generation store is read-only");
-    if (database.isTransaction)
-        throw new ProjectionGenerationStoreError("projection generation write transaction is already open");
-    database.exec("BEGIN IMMEDIATE");
+    connectionBoundGenerationStore(database, readOnly).beginWriteTransaction();
 }
 export function commitGenerationWriteTransaction(database) {
     assertDatabaseOpen(database);
-    if (!database.isTransaction)
-        throw new ProjectionGenerationStoreError("projection generation write transaction is not open");
-    database.exec("COMMIT");
+    connectionBoundGenerationStore(database, false).commitWriteTransaction();
 }
 export function rollbackGenerationWriteTransaction(database) {
     assertDatabaseOpen(database);
-    if (!database.isTransaction)
-        return;
-    rollbackQuietly(database);
+    connectionBoundGenerationStore(database, false).rollbackWriteTransaction();
 }
 export function closeDatabase(database) {
     if (closedDatabases.has(database))

package/build/core/projection/generation/ledger.js

@@ -0,0 +1,91 @@
+import { assertExecutionId, assertPositiveSafeInteger, cloneFacts, ProjectionGenerationStoreError, } from "./model.js";
+const RECORD_KINDS = new Set([
+    "launch", "adoption", "kill-intent", "interrupt-intent", "verdict",
+]);
+/** The projection-owned persistence adapter for generation facts in heart. */
+export class ProjectionGenerationLedger {
+    #database;
+    #readOnly;
+    constructor(database, readOnly) {
+        this.#database = database;
+        this.#readOnly = readOnly;
+    }
+    readRecords() {
+        const rows = this.#database.prepare(`
+      SELECT seq, activity_kind, execution_id, facts_json
+      FROM generation_records
+      ORDER BY seq
+    `).all();
+        return rows.map((row) => {
+            const seq = assertPositiveSafeInteger(Number(row.seq), "generation row seq");
+            if (typeof row.activity_kind !== "string" || !RECORD_KINDS.has(row.activity_kind)) {
+                throw new ProjectionGenerationStoreError(`generation row ${seq} has unknown kind '${String(row.activity_kind)}'`);
+            }
+            if (typeof row.execution_id !== "string")
+                throw new ProjectionGenerationStoreError(`generation row ${seq} has invalid execution_id`);
+            const executionId = assertExecutionId(row.execution_id);
+            if (typeof row.facts_json !== "string")
+                throw new ProjectionGenerationStoreError(`generation row ${seq} facts_json must be text`);
+            let facts;
+            try {
+                facts = cloneFacts(JSON.parse(row.facts_json), `generation row ${seq} facts`);
+            }
+            catch (cause) {
+                if (cause instanceof Error && cause.message.startsWith(`generation row ${seq}`))
+                    throw cause;
+                throw new ProjectionGenerationStoreError(`generation row ${seq} facts_json is invalid JSON`, { cause });
+            }
+            return { seq, kind: row.activity_kind, executionId, facts };
+        });
+    }
+    appendRecord(kind, executionId, facts, seq) {
+        if (this.#readOnly)
+            throw new ProjectionGenerationStoreError("projection generation store is read-only");
+        const encoded = JSON.stringify(facts);
+        this.#database.prepare(`
+      INSERT INTO generation_records (seq, activity_kind, execution_id, facts_json)
+      VALUES (?, ?, ?, ?)
+    `).run(seq, kind, executionId, encoded);
+        return { seq, kind, executionId, facts: JSON.parse(encoded) };
+    }
+    write(run) {
+        if (this.#readOnly)
+            throw new ProjectionGenerationStoreError("projection generation store is read-only");
+        if (this.#database.isTransaction)
+            return run();
+        this.#database.exec("BEGIN IMMEDIATE");
+        try {
+            const result = run();
+            this.#database.exec("COMMIT");
+            return result;
+        }
+        catch (error) {
+            this.rollback();
+            throw error;
+        }
+    }
+    beginWriteTransaction() {
+        if (this.#readOnly)
+            throw new ProjectionGenerationStoreError("projection generation store is read-only");
+        if (this.#database.isTransaction)
+            throw new ProjectionGenerationStoreError("projection generation write transaction is already open");
+        this.#database.exec("BEGIN IMMEDIATE");
+    }
+    commitWriteTransaction() {
+        if (!this.#database.isTransaction)
+            throw new ProjectionGenerationStoreError("projection generation write transaction is not open");
+        this.#database.exec("COMMIT");
+    }
+    rollbackWriteTransaction() {
+        if (this.#database.isTransaction)
+            this.rollback();
+    }
+    rollback() {
+        try {
+            this.#database.exec("ROLLBACK");
+        }
+        catch {
+            // Preserve the failure that caused rollback.
+        }
+    }
+}

package/build/core/projection/generation/model.js

@@ -1,6 +1,13 @@
-import { GENERATION_VERDICT_STATES, } from "../projection-life-protocol.js";
 import { OutcomeErrorValidationError, parseCurrentOutcomeError, } from "../../../agents/harness/index.js";
-export { GENERATION_VERDICT_STATES };
+export const GENERATION_VERDICT_STATES = [
+    "completed",
+    "failed",
+    "launch-failed",
+    "lost-runner",
+    "dismissed",
+    "interrupted",
+    "killed",
+];
 export const VERDICTS = new Set(GENERATION_VERDICT_STATES);
 export class ProjectionGenerationStoreError extends Error {
     code = "PROJECTION_GENERATION_STORE_ERROR";
@@ -12,17 +19,17 @@ export class ProjectionGenerationStoreError extends Error {
         this.observation = options?.observation ?? "unknown";
     }
 }
-export function isIncompatibleProjectionGenerationStoreError(error) {
-    return error instanceof ProjectionGenerationStoreError
-        && error.observation === "incompatible";
-}
-export function isPlainObject(value) {
+function isPlainObject(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value))
         return false;
     const prototype = Object.getPrototypeOf(value);
     return prototype === Object.prototype || prototype === null;
 }
-export function assertJsonValue(value, location, ancestors) {
+export function isIncompatibleProjectionGenerationStoreError(error) {
+    return error instanceof ProjectionGenerationStoreError
+        && error.observation === "incompatible";
+}
+export function assertJsonValue(value, location, ancestors = new Set()) {
     if (value === null || typeof value === "string" || typeof value === "boolean")
         return;
     if (typeof value === "number") {
@@ -30,9 +37,8 @@ export function assertJsonValue(value, location, ancestors) {
             throw new ProjectionGenerationStoreError(`${location} contains a non-finite number`);
         return;
     }
-    if (typeof value !== "object") {
+    if (typeof value !== "object")
         throw new ProjectionGenerationStoreError(`${location} contains a non-JSON value`);
-    }
     if (ancestors.has(value))
         throw new ProjectionGenerationStoreError(`${location} contains a cycle`);
     ancestors.add(value);
@@ -43,9 +49,8 @@ export function assertJsonValue(value, location, ancestors) {
         }
         if (!isPlainObject(value))
             throw new ProjectionGenerationStoreError(`${location} must contain only plain JSON objects`);
-        for (const [key, item] of Object.entries(value)) {
+        for (const [key, item] of Object.entries(value))
             assertJsonValue(item, `${location}.${key}`, ancestors);
-        }
     }
     finally {
         ancestors.delete(value);
@@ -54,7 +59,7 @@ export function assertJsonValue(value, location, ancestors) {
 export function cloneFacts(value, location) {
     if (!isPlainObject(value))
         throw new ProjectionGenerationStoreError(`${location} must be a JSON object`);
-    assertJsonValue(value, location, new Set());
+    assertJsonValue(value, location);
     return JSON.parse(JSON.stringify(value));
 }
 export function assertExecutionId(executionId) {

package/build/core/projection/generation/projection-generation-continuation.js

@@ -52,7 +52,7 @@ function readContinuationFromDatabase(database, limit = 10) {
 /** One heart snapshot owns generation selection and all continuation facts. */
 export function readProjectionGenerationContinuationSnapshot(projectionDirectory, limit = 10) {
     return withGenerationReadSnapshot(projectionDirectory, (database) => {
-        const { records, current } = readValidatedHistory(database);
+        const { records, current } = readValidatedHistory(database, true);
         const continuation = readContinuationFromDatabase(database, limit);
         return {
             records,

package/build/core/projection/generation/projection-generation-doorbell.js

@@ -0,0 +1,88 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as net from "node:net";
+const CONNECT_TIMEOUT_MS = 50;
+const POSIX_PREFIX = "/tmp/keiyaku-doorbell-";
+const WINDOWS_PREFIX = "\\\\.\\pipe\\keiyaku-doorbell-";
+function endpointDigest(identity, executionId) {
+    return createHash("sha256")
+        .update(JSON.stringify(identity))
+        .update("\0")
+        .update(executionId)
+        .digest("hex");
+}
+/** A bounded, deterministic endpoint with no projection-directory pathname. */
+export function projectionGenerationDoorbellAddress(identity, executionId) {
+    const digest = endpointDigest(identity, executionId);
+    return process.platform === "win32"
+        ? `${WINDOWS_PREFIX}${digest}`
+        : `${POSIX_PREFIX}${digest}.sock`;
+}
+function removeStalePosixSocket(address) {
+    try {
+        const stat = fs.lstatSync(address);
+        if (!stat.isSocket())
+            throw new Error(`doorbell endpoint is not a socket: ${address}`);
+        fs.unlinkSync(address);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+}
+function listen(server, address) {
+    return new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.off("listening", onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            server.off("error", onError);
+            resolve();
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        server.listen(address);
+    });
+}
+export async function openProjectionGenerationDoorbell(input) {
+    const address = projectionGenerationDoorbellAddress(input.identity, input.executionId);
+    if (process.platform !== "win32")
+        removeStalePosixSocket(address);
+    const server = net.createServer((socket) => {
+        socket.destroy();
+        input.onRing();
+    });
+    await listen(server, address);
+    return {
+        address,
+        close: async () => {
+            await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+            if (process.platform !== "win32") {
+                try {
+                    fs.unlinkSync(address);
+                }
+                catch (error) {
+                    if (error.code !== "ENOENT")
+                        throw error;
+                }
+            }
+        },
+    };
+}
+/**
+ * Best-effort wake only. Connection result is deliberately discarded: heart
+ * durability and leash evidence remain the only product/liveness authority.
+ */
+export function ringProjectionGenerationDoorbell(identity, executionId) {
+    const socket = net.createConnection(projectionGenerationDoorbellAddress(identity, executionId));
+    const timeout = setTimeout(() => socket.destroy(), CONNECT_TIMEOUT_MS);
+    timeout.unref?.();
+    const finish = () => {
+        clearTimeout(timeout);
+        socket.destroy();
+    };
+    socket.once("connect", finish);
+    socket.once("error", finish);
+}