@workflow/world-local 5.0.0-beta.23 → 5.0.0-beta.25

package/dist/storage/helpers.d.ts

@@ -2,6 +2,43 @@
  * Hash a hook token to produce a filesystem-safe constraint filename.
  */
 export declare function hashToken(token: string): string;
+/**
+ * Path of the exclusive-create lock file that commits a hook's disposal.
+ * The `hook_disposed` handler writes this lock BEFORE deleting the token
+ * claim and hook entity (and before appending the event to the log), so
+ * its existence is the earliest durable evidence that the hook can never
+ * be live again.
+ */
+export declare function hookDisposeLockPath(basedir: string, hookId: string, tag?: string): string;
+/**
+ * Whether a hook's disposal has been committed (its dispose lock exists).
+ * Mirrors event visibility for tagged worlds: an untagged lock is visible
+ * to every tag, a tagged lock only to its own tag.
+ */
+export declare function isHookDisposalCommitted(basedir: string, hookId: string, tag?: string): Promise<boolean>;
+/**
+ * Path of the exclusive-create claim file that reserves a hook token.
+ */
+export declare function hookTokenClaimPath(basedir: string, token: string): string;
+/**
+ * Release (delete) a token claim only if it still points at the releasing
+ * hook's own `(runId, hookId)`.
+ *
+ * Both in-flight releasers — the `hook_disposed` handler and the
+ * terminal-run `deleteAllHooksForRun` cleanup — read the hook entity and
+ * then delete the claim file. Deleting unconditionally is unsafe across
+ * processes: a releaser that stalls between those two operations can
+ * outlive a force-release of its stale claim (see
+ * `isHookTokenClaimReleasable`) and then delete the NEXT claimant's live
+ * claim, transiently breaking token uniqueness. Re-reading the claim and
+ * matching its identity here shrinks that window from "a stall of any
+ * length" to the adjacent read/delete file ops.
+ *
+ * A claim that is missing, unreadable, or owned by someone else is left
+ * alone — if it is genuinely stale debris, the claimant-side force-release
+ * path reaps it.
+ */
+export declare function releaseHookTokenClaimIfOwnedBy(basedir: string, token: string, runId: string, hookId: string): Promise<void>;
 /**
  * Compute the path of the recovery-marker sidecar for a specific
  * `(token, runId, hookId)` triple. Identity is encoded in the

package/dist/storage/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/storage/helpers.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,MAAM,CAQR;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,4BAAwC,CAAC;AAEnE;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAC5B,UAAU,MAAM,MAChB,UAAU,MAAM,KAAG,IAAI,GAAG,IAyB1B,CAAC"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/storage/helpers.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,GAAG,CAAC,EAAE,MAAM,GACX,MAAM,CAGR;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,CAAC,CAclB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAYf;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,MAAM,CAQR;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,4BAAwC,CAAC;AAEnE;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAAI,UAAU,MAAM,MAIzC,UAAU,MAAM,KAAG,IAAI,GAAG,IAyBnC,CAAC"}

package/dist/storage/helpers.js

@@ -1,13 +1,84 @@
 import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
 import path from 'node:path';
 import { monotonicFactory } from 'ulid';
-import { stripTag, ulidToDate } from '../fs.js';
+import { resolveWithinBase, stripTag, ulidToDate } from '../fs.js';
 /**
  * Hash a hook token to produce a filesystem-safe constraint filename.
  */
 export function hashToken(token) {
     return createHash('sha256').update(token).digest('hex');
 }
+/**
+ * Path of the exclusive-create lock file that commits a hook's disposal.
+ * The `hook_disposed` handler writes this lock BEFORE deleting the token
+ * claim and hook entity (and before appending the event to the log), so
+ * its existence is the earliest durable evidence that the hook can never
+ * be live again.
+ */
+export function hookDisposeLockPath(basedir, hookId, tag) {
+    const name = tag ? `${hookId}.disposed.${tag}` : `${hookId}.disposed`;
+    return resolveWithinBase(basedir, '.locks', 'hooks', name);
+}
+/**
+ * Whether a hook's disposal has been committed (its dispose lock exists).
+ * Mirrors event visibility for tagged worlds: an untagged lock is visible
+ * to every tag, a tagged lock only to its own tag.
+ */
+export async function isHookDisposalCommitted(basedir, hookId, tag) {
+    const candidates = [hookDisposeLockPath(basedir, hookId)];
+    if (tag) {
+        candidates.push(hookDisposeLockPath(basedir, hookId, tag));
+    }
+    for (const lockPath of candidates) {
+        try {
+            await fs.access(lockPath);
+            return true;
+        }
+        catch {
+            // lock not present at this path
+        }
+    }
+    return false;
+}
+/**
+ * Path of the exclusive-create claim file that reserves a hook token.
+ */
+export function hookTokenClaimPath(basedir, token) {
+    return path.join(basedir, 'hooks', 'tokens', `${hashToken(token)}.json`);
+}
+/**
+ * Release (delete) a token claim only if it still points at the releasing
+ * hook's own `(runId, hookId)`.
+ *
+ * Both in-flight releasers — the `hook_disposed` handler and the
+ * terminal-run `deleteAllHooksForRun` cleanup — read the hook entity and
+ * then delete the claim file. Deleting unconditionally is unsafe across
+ * processes: a releaser that stalls between those two operations can
+ * outlive a force-release of its stale claim (see
+ * `isHookTokenClaimReleasable`) and then delete the NEXT claimant's live
+ * claim, transiently breaking token uniqueness. Re-reading the claim and
+ * matching its identity here shrinks that window from "a stall of any
+ * length" to the adjacent read/delete file ops.
+ *
+ * A claim that is missing, unreadable, or owned by someone else is left
+ * alone — if it is genuinely stale debris, the claimant-side force-release
+ * path reaps it.
+ */
+export async function releaseHookTokenClaimIfOwnedBy(basedir, token, runId, hookId) {
+    const claimPath = hookTokenClaimPath(basedir, token);
+    let claim;
+    try {
+        claim = JSON.parse(await fs.readFile(claimPath, 'utf8'));
+    }
+    catch {
+        return;
+    }
+    if (claim.runId !== runId || claim.hookId !== hookId) {
+        return;
+    }
+    await fs.unlink(claimPath).catch(() => { });
+}
 /**
  * Compute the path of the recovery-marker sidecar for a specific
  * `(token, runId, hookId)` triple. Identity is encoded in the
@@ -41,26 +112,29 @@ export const monotonicUlid = monotonicFactory(() => Math.random());
  * @param idPrefix - The prefix to strip from filenames (e.g., 'wrun', 'evnt', 'step')
  * @returns A function that extracts Date from filename, or null if not extractable
  */
-export const getObjectCreatedAt = (idPrefix) => (filename) => {
-    // Strip tag suffix before ULID extraction
-    // e.g., "wrun_ABC.vitest-0.json" → "wrun_ABC.json"
-    const cleanName = stripTag(filename.replace(/\.json$/, '')) + '.json';
+export const getObjectCreatedAt = (idPrefix) => {
+    // Compiled once per query instead of once per filename.
     const replaceRegex = new RegExp(`^${idPrefix}_`, 'g');
-    const dashIndex = cleanName.indexOf('-');
-    if (dashIndex === -1) {
-        // No dash - extract ULID from the filename (e.g., wrun_ULID.json, evnt_ULID.json)
-        const ulid = cleanName.replace(/\.json$/, '').replace(replaceRegex, '');
+    return (filename) => {
+        // Strip tag suffix before ULID extraction
+        // e.g., "wrun_ABC.vitest-0.json" → "wrun_ABC.json"
+        const cleanName = stripTag(filename.replace(/\.json$/, '')) + '.json';
+        const dashIndex = cleanName.indexOf('-');
+        if (dashIndex === -1) {
+            // No dash - extract ULID from the filename (e.g., wrun_ULID.json, evnt_ULID.json)
+            const ulid = cleanName.replace(/\.json$/, '').replace(replaceRegex, '');
+            return ulidToDate(ulid);
+        }
+        // For composite keys like {runId}-{stepId}, extract from the appropriate part
+        if (idPrefix === 'step') {
+            // Steps use sequential IDs (step_0, step_1, etc.) - no timestamp in filename.
+            // Return null to skip filename-based optimization and defer to JSON-based filtering.
+            return null;
+        }
+        // For events: wrun_ULID-evnt_ULID.json - extract from the eventId part
+        const id = cleanName.substring(dashIndex + 1).replace(/\.json$/, '');
+        const ulid = id.replace(replaceRegex, '');
         return ulidToDate(ulid);
-    }
-    // For composite keys like {runId}-{stepId}, extract from the appropriate part
-    if (idPrefix === 'step') {
-        // Steps use sequential IDs (step_0, step_1, etc.) - no timestamp in filename.
-        // Return null to skip filename-based optimization and defer to JSON-based filtering.
-        return null;
-    }
-    // For events: wrun_ULID-evnt_ULID.json - extract from the eventId part
-    const id = cleanName.substring(dashIndex + 1).replace(/\.json$/, '');
-    const ulid = id.replace(replaceRegex, '');
-    return ulidToDate(ulid);
+    };
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/storage/helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash } from 'node:crypto';\nimport fs from 'node:fs/promises';\nimport path from 'node:path';\nimport { monotonicFactory } from 'ulid';\nimport { resolveWithinBase, stripTag, ulidToDate } from '../fs.js';\n\n/**\n * Hash a hook token to produce a filesystem-safe constraint filename.\n */\nexport function hashToken(token: string): string {\n  return createHash('sha256').update(token).digest('hex');\n}\n\n/**\n * Path of the exclusive-create lock file that commits a hook's disposal.\n * The `hook_disposed` handler writes this lock BEFORE deleting the token\n * claim and hook entity (and before appending the event to the log), so\n * its existence is the earliest durable evidence that the hook can never\n * be live again.\n */\nexport function hookDisposeLockPath(\n  basedir: string,\n  hookId: string,\n  tag?: string\n): string {\n  const name = tag ? `${hookId}.disposed.${tag}` : `${hookId}.disposed`;\n  return resolveWithinBase(basedir, '.locks', 'hooks', name);\n}\n\n/**\n * Whether a hook's disposal has been committed (its dispose lock exists).\n * Mirrors event visibility for tagged worlds: an untagged lock is visible\n * to every tag, a tagged lock only to its own tag.\n */\nexport async function isHookDisposalCommitted(\n  basedir: string,\n  hookId: string,\n  tag?: string\n): Promise<boolean> {\n  const candidates = [hookDisposeLockPath(basedir, hookId)];\n  if (tag) {\n    candidates.push(hookDisposeLockPath(basedir, hookId, tag));\n  }\n  for (const lockPath of candidates) {\n    try {\n      await fs.access(lockPath);\n      return true;\n    } catch {\n      // lock not present at this path\n    }\n  }\n  return false;\n}\n\n/**\n * Path of the exclusive-create claim file that reserves a hook token.\n */\nexport function hookTokenClaimPath(basedir: string, token: string): string {\n  return path.join(basedir, 'hooks', 'tokens', `${hashToken(token)}.json`);\n}\n\n/**\n * Release (delete) a token claim only if it still points at the releasing\n * hook's own `(runId, hookId)`.\n *\n * Both in-flight releasers — the `hook_disposed` handler and the\n * terminal-run `deleteAllHooksForRun` cleanup — read the hook entity and\n * then delete the claim file. Deleting unconditionally is unsafe across\n * processes: a releaser that stalls between those two operations can\n * outlive a force-release of its stale claim (see\n * `isHookTokenClaimReleasable`) and then delete the NEXT claimant's live\n * claim, transiently breaking token uniqueness. Re-reading the claim and\n * matching its identity here shrinks that window from \"a stall of any\n * length\" to the adjacent read/delete file ops.\n *\n * A claim that is missing, unreadable, or owned by someone else is left\n * alone — if it is genuinely stale debris, the claimant-side force-release\n * path reaps it.\n */\nexport async function releaseHookTokenClaimIfOwnedBy(\n  basedir: string,\n  token: string,\n  runId: string,\n  hookId: string\n): Promise<void> {\n  const claimPath = hookTokenClaimPath(basedir, token);\n  let claim: { runId?: unknown; hookId?: unknown };\n  try {\n    claim = JSON.parse(await fs.readFile(claimPath, 'utf8'));\n  } catch {\n    return;\n  }\n  if (claim.runId !== runId || claim.hookId !== hookId) {\n    return;\n  }\n  await fs.unlink(claimPath).catch(() => {});\n}\n\n/**\n * Compute the path of the recovery-marker sidecar for a specific\n * `(token, runId, hookId)` triple. Identity is encoded in the\n * filename hash so different token lifetimes (e.g. the same token\n * reused by a later run after the first run was deleted) never\n * contend on a single sidecar — without per-lifetime identity, a\n * stale marker surviving prior-run cleanup could \"leak\" its\n * eventId into the new lifetime's recovery and cause divergent\n * publication.\n *\n * See `events-storage.ts` for the full recovery-marker rationale.\n */\nexport function hookRecoveryMarkerPath(\n  basedir: string,\n  token: string,\n  runId: string,\n  hookId: string\n): string {\n  // Distinct from `hashToken(token)` so a token's claim file and\n  // its recovery marker live at different paths AND a different\n  // lifetime's recovery marker never collides with this one.\n  const key = createHash('sha256')\n    .update(`${token}\\x00${runId}\\x00${hookId}`)\n    .digest('hex');\n  return path.join(basedir, 'hooks', 'tokens', `${key}.recovery.json`);\n}\n\n/**\n * Create a monotonic ULID factory that ensures ULIDs are always increasing\n * even when generated within the same millisecond.\n */\nexport const monotonicUlid = monotonicFactory(() => Math.random());\n\n/**\n * Creates a function to extract createdAt date from a filename based on ULID.\n * Used for efficient pagination without reading file contents.\n *\n * @param idPrefix - The prefix to strip from filenames (e.g., 'wrun', 'evnt', 'step')\n * @returns A function that extracts Date from filename, or null if not extractable\n */\nexport const getObjectCreatedAt = (idPrefix: string) => {\n  // Compiled once per query instead of once per filename.\n  const replaceRegex = new RegExp(`^${idPrefix}_`, 'g');\n\n  return (filename: string): Date | null => {\n    // Strip tag suffix before ULID extraction\n    // e.g., \"wrun_ABC.vitest-0.json\" → \"wrun_ABC.json\"\n    const cleanName = stripTag(filename.replace(/\\.json$/, '')) + '.json';\n\n    const dashIndex = cleanName.indexOf('-');\n\n    if (dashIndex === -1) {\n      // No dash - extract ULID from the filename (e.g., wrun_ULID.json, evnt_ULID.json)\n      const ulid = cleanName.replace(/\\.json$/, '').replace(replaceRegex, '');\n      return ulidToDate(ulid);\n    }\n\n    // For composite keys like {runId}-{stepId}, extract from the appropriate part\n    if (idPrefix === 'step') {\n      // Steps use sequential IDs (step_0, step_1, etc.) - no timestamp in filename.\n      // Return null to skip filename-based optimization and defer to JSON-based filtering.\n      return null;\n    }\n\n    // For events: wrun_ULID-evnt_ULID.json - extract from the eventId part\n    const id = cleanName.substring(dashIndex + 1).replace(/\\.json$/, '');\n    const ulid = id.replace(replaceRegex, '');\n    return ulidToDate(ulid);\n  };\n};\n"]}

package/dist/storage/hook-index.d.ts

@@ -0,0 +1,50 @@
+import type { Event } from '@workflow/world';
+/** Same visibility rule as event files: untagged is visible to all. */
+export declare function isVisibleToTag(fileId: string, tag: string | undefined): boolean;
+/**
+ * Record a `hook_created` event in the token- and id-indexes. Must be
+ * called before the event is published. Idempotent (`writeExclusive`).
+ */
+export declare function writeHookCreatedIndexEntries(basedir: string, token: string, runId: string, hookId: string, eventId: string, tag?: string): Promise<void>;
+export declare function hookByRunMarkerPath(basedir: string, runId: string, hookId: string, tag?: string): string;
+/**
+ * Record a by-run marker for a hook entity. Must be called before the
+ * entity write. Idempotent (`writeExclusive`).
+ */
+export declare function writeHookByRunMarker(basedir: string, runId: string, hookId: string, tag?: string): Promise<void>;
+/**
+ * Delete the by-run marker(s) for a hook. A tagged world also removes
+ * the untagged variant, since entity reads fall back tagged→untagged.
+ */
+export declare function deleteHookByRunMarker(basedir: string, runId: string, hookId: string, tag?: string): Promise<void>;
+export interface HookByRunMarker {
+    /** fileId of the marker (without `.json`), for deletion. */
+    fileId: string;
+    /** Parsed marker content, or null when the file is unreadable debris. */
+    hookId: string | null;
+    tag?: string;
+}
+export declare function listHookByRunMarkers(basedir: string, runId: string): Promise<HookByRunMarker[]>;
+export declare function deleteHookByRunMarkerFile(basedir: string, fileId: string): Promise<void>;
+/** Forget completed backfills (data-dir reset / tests). */
+export declare function resetHookIndexEnsureCache(): void;
+/**
+ * One-time backfill of the indexes for data directories created before
+ * they existed — a single full scan, guarded by a completion marker.
+ * Concurrent backfills are safe: all writes are idempotent
+ * `writeExclusive` calls with byte-identical content.
+ */
+export declare function ensureHookIndexes(basedir: string): Promise<void>;
+/**
+ * Find the newest visible `hook_created` event for a token or hookId.
+ * Entries are iterated newest-first (eventIds are ULIDs); dangling or
+ * non-matching entries are skipped. Liveness is the caller's job.
+ */
+export declare function findNewestIndexedHookCreatedEvent(basedir: string, index: {
+    kind: 'token';
+    token: string;
+} | {
+    kind: 'id';
+    hookId: string;
+}, matches: (event: Event) => boolean, tag?: string): Promise<Event | null>;
+//# sourceMappingURL=hook-index.d.ts.map

package/dist/storage/hook-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook-index.d.ts","sourceRoot":"","sources":["../../src/storage/hook-index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAoE7C,uEAAuE;AACvE,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,GAAG,SAAS,GACtB,OAAO,CAET;AAaD;;;GAGG;AACH,wBAAsB,4BAA4B,CAChD,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAUf;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,GAAG,CAAC,EAAE,MAAM,GACX,MAAM,CAER;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAKf;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAKf;AAED,MAAM,WAAW,eAAe;IAC9B,4DAA4D;IAC5D,MAAM,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,eAAe,EAAE,CAAC,CAyB5B;AAED,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAEf;AAKD,2DAA2D;AAC3D,wBAAgB,yBAAyB,IAAI,IAAI,CAEhD;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAWtE;AA0ED;;;;GAIG;AACH,wBAAsB,iCAAiC,CACrD,OAAO,EAAE,MAAM,EACf,KAAK,EAAE;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EACxE,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,EAClC,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,CAkDvB"}

package/dist/storage/hook-index.js

@@ -0,0 +1,259 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { EventSchema, HookSchema } from '@workflow/world';
+import { z } from 'zod';
+import { assertSafeEntityId, deleteJSON, hasTag, isUntagged, listJSONFiles, readJSON, resolveWithinBase, stripTag, taggedPath, writeExclusive, } from '../fs.js';
+import { hashToken } from './helpers.js';
+/**
+ * Durable secondary indexes for hook lookups. Event files are keyed by
+ * `{runId}-{eventId}`, so answering "find the live hook_created event
+ * for this token/hookId" used to require scanning the entire global
+ * event log — O(total history) on every first-time hook creation.
+ *
+ * Indexes maintained here:
+ *   - `hooks/token-index/{sha256(token)}/{eventId}[.tag].json` → `{runId}`
+ *   - `hooks/id-index/{hookId}/{eventId}[.tag].json` → `{runId}`
+ *   - `hooks/by-run/{runId}-{hookId}[.tag].json` → `{hookId, tag?}`
+ *     (per live hook entity, for run-termination cleanup)
+ *
+ * Crash-ordering invariant: entries are written BEFORE the write they
+ * index (event publish / entity write), so a crash can only leave a
+ * dangling entry pointing at a write that never landed — readers skip
+ * those. A committed event/entity invisible to the index cannot occur.
+ *
+ * Pre-index data directories are handled by a one-time backfill
+ * (`ensureHookIndexes`) guarded by a completion marker.
+ */
+const IndexEntrySchema = z.object({
+    runId: z.string(),
+});
+const ByRunMarkerSchema = z.object({
+    hookId: z.string(),
+    tag: z.string().optional(),
+});
+// No `.json` extension so entity listings never pick it up.
+const INDEX_COMPLETE_MARKER = '.hook-index-complete';
+function tokenIndexDir(basedir, token) {
+    return resolveWithinBase(basedir, 'hooks', 'token-index', hashToken(token));
+}
+function idIndexDir(basedir, hookId) {
+    assertSafeEntityId('hookId', hookId);
+    return resolveWithinBase(basedir, 'hooks', 'id-index', hookId);
+}
+function byRunDir(basedir) {
+    return resolveWithinBase(basedir, 'hooks', 'by-run');
+}
+function tagOf(fileId) {
+    const stripped = stripTag(fileId);
+    return stripped === fileId ? undefined : fileId.slice(stripped.length + 1);
+}
+/** Same visibility rule as event files: untagged is visible to all. */
+export function isVisibleToTag(fileId, tag) {
+    return tag ? isUntagged(fileId) || hasTag(fileId, tag) : isUntagged(fileId);
+}
+async function readEventLenient(filePath) {
+    try {
+        return await readJSON(filePath, EventSchema);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError || error instanceof z.ZodError) {
+            return null;
+        }
+        throw error;
+    }
+}
+/**
+ * Record a `hook_created` event in the token- and id-indexes. Must be
+ * called before the event is published. Idempotent (`writeExclusive`).
+ */
+export async function writeHookCreatedIndexEntries(basedir, token, runId, hookId, eventId, tag) {
+    assertSafeEntityId('runId', runId);
+    assertSafeEntityId('eventId', eventId);
+    if (tag !== undefined)
+        assertSafeEntityId('tag', tag);
+    const fileName = tag ? `${eventId}.${tag}.json` : `${eventId}.json`;
+    const content = JSON.stringify({ runId });
+    await Promise.all([
+        writeExclusive(path.join(tokenIndexDir(basedir, token), fileName), content),
+        writeExclusive(path.join(idIndexDir(basedir, hookId), fileName), content),
+    ]);
+}
+export function hookByRunMarkerPath(basedir, runId, hookId, tag) {
+    return taggedPath(basedir, 'hooks/by-run', `${runId}-${hookId}`, tag);
+}
+/**
+ * Record a by-run marker for a hook entity. Must be called before the
+ * entity write. Idempotent (`writeExclusive`).
+ */
+export async function writeHookByRunMarker(basedir, runId, hookId, tag) {
+    await writeExclusive(hookByRunMarkerPath(basedir, runId, hookId, tag), JSON.stringify(tag ? { hookId, tag } : { hookId }));
+}
+/**
+ * Delete the by-run marker(s) for a hook. A tagged world also removes
+ * the untagged variant, since entity reads fall back tagged→untagged.
+ */
+export async function deleteHookByRunMarker(basedir, runId, hookId, tag) {
+    await deleteJSON(hookByRunMarkerPath(basedir, runId, hookId, tag));
+    if (tag) {
+        await deleteJSON(hookByRunMarkerPath(basedir, runId, hookId));
+    }
+}
+export async function listHookByRunMarkers(basedir, runId) {
+    assertSafeEntityId('runId', runId);
+    const dir = byRunDir(basedir);
+    const prefix = `${runId}-`;
+    const out = [];
+    for (const fileId of await listJSONFiles(dir)) {
+        if (!fileId.startsWith(prefix))
+            continue;
+        let marker = null;
+        try {
+            marker = await readJSON(path.join(dir, `${fileId}.json`), ByRunMarkerSchema);
+        }
+        catch (error) {
+            if (!(error instanceof SyntaxError || error instanceof z.ZodError)) {
+                throw error;
+            }
+        }
+        out.push({
+            fileId,
+            hookId: marker?.hookId ?? null,
+            tag: marker?.tag,
+        });
+    }
+    return out;
+}
+export async function deleteHookByRunMarkerFile(basedir, fileId) {
+    await deleteJSON(path.join(byRunDir(basedir), `${fileId}.json`));
+}
+// Per-process ensure cache; only successful backfills are cached.
+const ensuredBasedirs = new Map();
+/** Forget completed backfills (data-dir reset / tests). */
+export function resetHookIndexEnsureCache() {
+    ensuredBasedirs.clear();
+}
+/**
+ * One-time backfill of the indexes for data directories created before
+ * they existed — a single full scan, guarded by a completion marker.
+ * Concurrent backfills are safe: all writes are idempotent
+ * `writeExclusive` calls with byte-identical content.
+ */
+export async function ensureHookIndexes(basedir) {
+    const key = path.resolve(basedir);
+    let pending = ensuredBasedirs.get(key);
+    if (!pending) {
+        pending = ensureHookIndexesImpl(key).catch((error) => {
+            ensuredBasedirs.delete(key);
+            throw error;
+        });
+        ensuredBasedirs.set(key, pending);
+    }
+    return pending;
+}
+async function forEachConcurrent(items, concurrency, fn) {
+    for (let start = 0; start < items.length; start += concurrency) {
+        await Promise.all(items.slice(start, start + concurrency).map(fn));
+    }
+}
+async function ensureHookIndexesImpl(basedir) {
+    const markerPath = path.join(basedir, 'hooks', INDEX_COMPLETE_MARKER);
+    try {
+        await fs.access(markerPath);
+        return;
+    }
+    catch {
+        // Marker absent — backfill below.
+    }
+    const eventsDir = path.join(basedir, 'events');
+    await forEachConcurrent(await listJSONFiles(eventsDir), 32, async (fileId) => {
+        const event = await readEventLenient(path.join(eventsDir, `${fileId}.json`));
+        if (!event || event.eventType !== 'hook_created')
+            return;
+        if (typeof event.correlationId !== 'string')
+            return;
+        const token = event.eventData?.token;
+        if (typeof token !== 'string')
+            return;
+        try {
+            await writeHookCreatedIndexEntries(basedir, token, event.runId, event.correlationId, event.eventId, tagOf(fileId));
+        }
+        catch {
+            // Unsafe ids cannot have been written by this storage layer; skip.
+        }
+    });
+    const hooksDir = path.join(basedir, 'hooks');
+    await forEachConcurrent(await listJSONFiles(hooksDir), 32, async (fileId) => {
+        let hook = null;
+        try {
+            hook = await readJSON(path.join(hooksDir, `${fileId}.json`), HookSchema);
+        }
+        catch (error) {
+            if (!(error instanceof SyntaxError || error instanceof z.ZodError)) {
+                throw error;
+            }
+        }
+        if (!hook)
+            return;
+        try {
+            await writeHookByRunMarker(basedir, hook.runId, hook.hookId, tagOf(fileId));
+        }
+        catch {
+            // Unsafe ids cannot have been written by this storage layer; skip.
+        }
+    });
+    await writeExclusive(markerPath, '');
+}
+/**
+ * Find the newest visible `hook_created` event for a token or hookId.
+ * Entries are iterated newest-first (eventIds are ULIDs); dangling or
+ * non-matching entries are skipped. Liveness is the caller's job.
+ */
+export async function findNewestIndexedHookCreatedEvent(basedir, index, matches, tag) {
+    await ensureHookIndexes(basedir);
+    let dir;
+    try {
+        dir =
+            index.kind === 'token'
+                ? tokenIndexDir(basedir, index.token)
+                : idIndexDir(basedir, index.hookId);
+    }
+    catch {
+        return null;
+    }
+    const entryIds = (await listJSONFiles(dir))
+        .filter((fileId) => isVisibleToTag(fileId, tag))
+        .sort((a, b) => stripTag(b).localeCompare(stripTag(a)));
+    for (const entryId of entryIds) {
+        let entry = null;
+        try {
+            entry = await readJSON(path.join(dir, `${entryId}.json`), IndexEntrySchema);
+        }
+        catch (error) {
+            if (!(error instanceof SyntaxError || error instanceof z.ZodError)) {
+                throw error;
+            }
+        }
+        if (!entry)
+            continue;
+        const eventId = stripTag(entryId);
+        let eventPath;
+        try {
+            eventPath = taggedPath(basedir, 'events', `${entry.runId}-${eventId}`, tagOf(entryId));
+        }
+        catch {
+            continue;
+        }
+        const event = await readEventLenient(eventPath);
+        if (!event)
+            continue;
+        if (event.eventType !== 'hook_created')
+            continue;
+        if (typeof event.correlationId !== 'string')
+            continue;
+        if (!matches(event))
+            continue;
+        return event;
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hook-index.js","sourceRoot":"","sources":["../../src/storage/hook-index.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from 'node:fs/promises';\nimport path from 'node:path';\nimport type { Event } from '@workflow/world';\nimport { EventSchema, HookSchema } from '@workflow/world';\nimport { z } from 'zod';\nimport {\n  assertSafeEntityId,\n  deleteJSON,\n  hasTag,\n  isUntagged,\n  listJSONFiles,\n  readJSON,\n  resolveWithinBase,\n  stripTag,\n  taggedPath,\n  writeExclusive,\n} from '../fs.js';\nimport { hashToken } from './helpers.js';\n\n/**\n * Durable secondary indexes for hook lookups. Event files are keyed by\n * `{runId}-{eventId}`, so answering \"find the live hook_created event\n * for this token/hookId\" used to require scanning the entire global\n * event log — O(total history) on every first-time hook creation.\n *\n * Indexes maintained here:\n *   - `hooks/token-index/{sha256(token)}/{eventId}[.tag].json` → `{runId}`\n *   - `hooks/id-index/{hookId}/{eventId}[.tag].json` → `{runId}`\n *   - `hooks/by-run/{runId}-{hookId}[.tag].json` → `{hookId, tag?}`\n *     (per live hook entity, for run-termination cleanup)\n *\n * Crash-ordering invariant: entries are written BEFORE the write they\n * index (event publish / entity write), so a crash can only leave a\n * dangling entry pointing at a write that never landed — readers skip\n * those. A committed event/entity invisible to the index cannot occur.\n *\n * Pre-index data directories are handled by a one-time backfill\n * (`ensureHookIndexes`) guarded by a completion marker.\n */\n\nconst IndexEntrySchema = z.object({\n  runId: z.string(),\n});\n\nconst ByRunMarkerSchema = z.object({\n  hookId: z.string(),\n  tag: z.string().optional(),\n});\n\n// No `.json` extension so entity listings never pick it up.\nconst INDEX_COMPLETE_MARKER = '.hook-index-complete';\n\nfunction tokenIndexDir(basedir: string, token: string): string {\n  return resolveWithinBase(basedir, 'hooks', 'token-index', hashToken(token));\n}\n\nfunction idIndexDir(basedir: string, hookId: string): string {\n  assertSafeEntityId('hookId', hookId);\n  return resolveWithinBase(basedir, 'hooks', 'id-index', hookId);\n}\n\nfunction byRunDir(basedir: string): string {\n  return resolveWithinBase(basedir, 'hooks', 'by-run');\n}\n\nfunction tagOf(fileId: string): string | undefined {\n  const stripped = stripTag(fileId);\n  return stripped === fileId ? undefined : fileId.slice(stripped.length + 1);\n}\n\n/** Same visibility rule as event files: untagged is visible to all. */\nexport function isVisibleToTag(\n  fileId: string,\n  tag: string | undefined\n): boolean {\n  return tag ? isUntagged(fileId) || hasTag(fileId, tag) : isUntagged(fileId);\n}\n\nasync function readEventLenient(filePath: string): Promise<Event | null> {\n  try {\n    return await readJSON(filePath, EventSchema);\n  } catch (error) {\n    if (error instanceof SyntaxError || error instanceof z.ZodError) {\n      return null;\n    }\n    throw error;\n  }\n}\n\n/**\n * Record a `hook_created` event in the token- and id-indexes. Must be\n * called before the event is published. Idempotent (`writeExclusive`).\n */\nexport async function writeHookCreatedIndexEntries(\n  basedir: string,\n  token: string,\n  runId: string,\n  hookId: string,\n  eventId: string,\n  tag?: string\n): Promise<void> {\n  assertSafeEntityId('runId', runId);\n  assertSafeEntityId('eventId', eventId);\n  if (tag !== undefined) assertSafeEntityId('tag', tag);\n  const fileName = tag ? `${eventId}.${tag}.json` : `${eventId}.json`;\n  const content = JSON.stringify({ runId });\n  await Promise.all([\n    writeExclusive(path.join(tokenIndexDir(basedir, token), fileName), content),\n    writeExclusive(path.join(idIndexDir(basedir, hookId), fileName), content),\n  ]);\n}\n\nexport function hookByRunMarkerPath(\n  basedir: string,\n  runId: string,\n  hookId: string,\n  tag?: string\n): string {\n  return taggedPath(basedir, 'hooks/by-run', `${runId}-${hookId}`, tag);\n}\n\n/**\n * Record a by-run marker for a hook entity. Must be called before the\n * entity write. Idempotent (`writeExclusive`).\n */\nexport async function writeHookByRunMarker(\n  basedir: string,\n  runId: string,\n  hookId: string,\n  tag?: string\n): Promise<void> {\n  await writeExclusive(\n    hookByRunMarkerPath(basedir, runId, hookId, tag),\n    JSON.stringify(tag ? { hookId, tag } : { hookId })\n  );\n}\n\n/**\n * Delete the by-run marker(s) for a hook. A tagged world also removes\n * the untagged variant, since entity reads fall back tagged→untagged.\n */\nexport async function deleteHookByRunMarker(\n  basedir: string,\n  runId: string,\n  hookId: string,\n  tag?: string\n): Promise<void> {\n  await deleteJSON(hookByRunMarkerPath(basedir, runId, hookId, tag));\n  if (tag) {\n    await deleteJSON(hookByRunMarkerPath(basedir, runId, hookId));\n  }\n}\n\nexport interface HookByRunMarker {\n  /** fileId of the marker (without `.json`), for deletion. */\n  fileId: string;\n  /** Parsed marker content, or null when the file is unreadable debris. */\n  hookId: string | null;\n  tag?: string;\n}\n\nexport async function listHookByRunMarkers(\n  basedir: string,\n  runId: string\n): Promise<HookByRunMarker[]> {\n  assertSafeEntityId('runId', runId);\n  const dir = byRunDir(basedir);\n  const prefix = `${runId}-`;\n  const out: HookByRunMarker[] = [];\n  for (const fileId of await listJSONFiles(dir)) {\n    if (!fileId.startsWith(prefix)) continue;\n    let marker: z.infer<typeof ByRunMarkerSchema> | null = null;\n    try {\n      marker = await readJSON(\n        path.join(dir, `${fileId}.json`),\n        ByRunMarkerSchema\n      );\n    } catch (error) {\n      if (!(error instanceof SyntaxError || error instanceof z.ZodError)) {\n        throw error;\n      }\n    }\n    out.push({\n      fileId,\n      hookId: marker?.hookId ?? null,\n      tag: marker?.tag,\n    });\n  }\n  return out;\n}\n\nexport async function deleteHookByRunMarkerFile(\n  basedir: string,\n  fileId: string\n): Promise<void> {\n  await deleteJSON(path.join(byRunDir(basedir), `${fileId}.json`));\n}\n\n// Per-process ensure cache; only successful backfills are cached.\nconst ensuredBasedirs = new Map<string, Promise<void>>();\n\n/** Forget completed backfills (data-dir reset / tests). */\nexport function resetHookIndexEnsureCache(): void {\n  ensuredBasedirs.clear();\n}\n\n/**\n * One-time backfill of the indexes for data directories created before\n * they existed — a single full scan, guarded by a completion marker.\n * Concurrent backfills are safe: all writes are idempotent\n * `writeExclusive` calls with byte-identical content.\n */\nexport async function ensureHookIndexes(basedir: string): Promise<void> {\n  const key = path.resolve(basedir);\n  let pending = ensuredBasedirs.get(key);\n  if (!pending) {\n    pending = ensureHookIndexesImpl(key).catch((error) => {\n      ensuredBasedirs.delete(key);\n      throw error;\n    });\n    ensuredBasedirs.set(key, pending);\n  }\n  return pending;\n}\n\nasync function forEachConcurrent<T>(\n  items: T[],\n  concurrency: number,\n  fn: (item: T) => Promise<void>\n): Promise<void> {\n  for (let start = 0; start < items.length; start += concurrency) {\n    await Promise.all(items.slice(start, start + concurrency).map(fn));\n  }\n}\n\nasync function ensureHookIndexesImpl(basedir: string): Promise<void> {\n  const markerPath = path.join(basedir, 'hooks', INDEX_COMPLETE_MARKER);\n  try {\n    await fs.access(markerPath);\n    return;\n  } catch {\n    // Marker absent — backfill below.\n  }\n\n  const eventsDir = path.join(basedir, 'events');\n  await forEachConcurrent(\n    await listJSONFiles(eventsDir),\n    32,\n    async (fileId) => {\n      const event = await readEventLenient(\n        path.join(eventsDir, `${fileId}.json`)\n      );\n      if (!event || event.eventType !== 'hook_created') return;\n      if (typeof event.correlationId !== 'string') return;\n      const token = (event.eventData as { token?: unknown } | undefined)?.token;\n      if (typeof token !== 'string') return;\n      try {\n        await writeHookCreatedIndexEntries(\n          basedir,\n          token,\n          event.runId,\n          event.correlationId,\n          event.eventId,\n          tagOf(fileId)\n        );\n      } catch {\n        // Unsafe ids cannot have been written by this storage layer; skip.\n      }\n    }\n  );\n\n  const hooksDir = path.join(basedir, 'hooks');\n  await forEachConcurrent(await listJSONFiles(hooksDir), 32, async (fileId) => {\n    let hook: z.infer<typeof HookSchema> | null = null;\n    try {\n      hook = await readJSON(path.join(hooksDir, `${fileId}.json`), HookSchema);\n    } catch (error) {\n      if (!(error instanceof SyntaxError || error instanceof z.ZodError)) {\n        throw error;\n      }\n    }\n    if (!hook) return;\n    try {\n      await writeHookByRunMarker(\n        basedir,\n        hook.runId,\n        hook.hookId,\n        tagOf(fileId)\n      );\n    } catch {\n      // Unsafe ids cannot have been written by this storage layer; skip.\n    }\n  });\n\n  await writeExclusive(markerPath, '');\n}\n\n/**\n * Find the newest visible `hook_created` event for a token or hookId.\n * Entries are iterated newest-first (eventIds are ULIDs); dangling or\n * non-matching entries are skipped. Liveness is the caller's job.\n */\nexport async function findNewestIndexedHookCreatedEvent(\n  basedir: string,\n  index: { kind: 'token'; token: string } | { kind: 'id'; hookId: string },\n  matches: (event: Event) => boolean,\n  tag?: string\n): Promise<Event | null> {\n  await ensureHookIndexes(basedir);\n  let dir: string;\n  try {\n    dir =\n      index.kind === 'token'\n        ? tokenIndexDir(basedir, index.token)\n        : idIndexDir(basedir, index.hookId);\n  } catch {\n    return null;\n  }\n\n  const entryIds = (await listJSONFiles(dir))\n    .filter((fileId) => isVisibleToTag(fileId, tag))\n    .sort((a, b) => stripTag(b).localeCompare(stripTag(a)));\n\n  for (const entryId of entryIds) {\n    let entry: z.infer<typeof IndexEntrySchema> | null = null;\n    try {\n      entry = await readJSON(\n        path.join(dir, `${entryId}.json`),\n        IndexEntrySchema\n      );\n    } catch (error) {\n      if (!(error instanceof SyntaxError || error instanceof z.ZodError)) {\n        throw error;\n      }\n    }\n    if (!entry) continue;\n\n    const eventId = stripTag(entryId);\n    let eventPath: string;\n    try {\n      eventPath = taggedPath(\n        basedir,\n        'events',\n        `${entry.runId}-${eventId}`,\n        tagOf(entryId)\n      );\n    } catch {\n      continue;\n    }\n    const event = await readEventLenient(eventPath);\n    if (!event) continue;\n    if (event.eventType !== 'hook_created') continue;\n    if (typeof event.correlationId !== 'string') continue;\n    if (!matches(event)) continue;\n    return event;\n  }\n  return null;\n}\n"]}

package/dist/storage/hooks-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks-storage.d.ts","sourceRoot":"","sources":["../../src/storage/hooks-storage.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,IAAI,EAIJ,OAAO,EACR,MAAM,iBAAiB,CAAC;AA4KzB,wBAAsB,kCAAkC,CACtD,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAOtB;AAeD;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,CAAC,CA+FlB;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CA0Bf"}
+{"version":3,"file":"hooks-storage.d.ts","sourceRoot":"","sources":["../../src/storage/hooks-storage.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,IAAI,EAIJ,OAAO,EACR,MAAM,iBAAiB,CAAC;AA+JzB,wBAAsB,kCAAkC,CACtD,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAQtB;AAgBD;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,CAAC,CAmIlB;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAsCf"}