@lostgradient/weft 0.2.0

package/dist/core/engine/persisted-data-version.js

@@ -0,0 +1,25 @@
+import {
+  CURRENT_PERSISTED_DATA_SCHEMA_VERSION,
+  PERSISTED_DATA_SCHEMA_VERSION_KEY,
+  PersistedDataIncompatibleError
+} from "../persisted-data-incompatible-error.js";
+const SCHEMA_VERSION_PATTERN = /^(?:0|[1-9]\d*)$/, USER_DATA_PREFIXES = ["wf:", "op:", "schedule:", "ev:", "sig:", "upd:", "idx:"];
+export async function assertCompatiblePersistedDataVersion(storage, options = {}) {
+  const raw = await storage.get(PERSISTED_DATA_SCHEMA_VERSION_KEY);
+  if (raw !== null) {
+    const text = new TextDecoder().decode(raw);
+    if (!SCHEMA_VERSION_PATTERN.test(text))
+      throw new PersistedDataIncompatibleError(null, CURRENT_PERSISTED_DATA_SCHEMA_VERSION);
+    const parsed = Number(text);
+    if (!Number.isSafeInteger(parsed))
+      throw new PersistedDataIncompatibleError(null, CURRENT_PERSISTED_DATA_SCHEMA_VERSION);
+    if (parsed !== CURRENT_PERSISTED_DATA_SCHEMA_VERSION)
+      throw new PersistedDataIncompatibleError(parsed, CURRENT_PERSISTED_DATA_SCHEMA_VERSION);
+    return;
+  }
+  if (!options.allowLegacyData)
+    for (const prefix of USER_DATA_PREFIXES)
+      for await (const _entry of storage.scan(prefix, { limit: 1 }))
+        throw new PersistedDataIncompatibleError(null, CURRENT_PERSISTED_DATA_SCHEMA_VERSION);
+  await storage.put(PERSISTED_DATA_SCHEMA_VERSION_KEY, new TextEncoder().encode(String(CURRENT_PERSISTED_DATA_SCHEMA_VERSION)));
+}

package/dist/core/engine/queries.d.ts

@@ -0,0 +1,3 @@
+import type { EngineInternals } from './internals.ts';
+/** Resolve a workflow query from built-in progress state or exposed inline accessors. */
+export declare function query(internals: EngineInternals, workflowId: string, name: string, input?: unknown): Promise<unknown>;

package/dist/core/engine/queries.js

@@ -0,0 +1,17 @@
+export async function query(internals, workflowId, name, input) {
+  if (name === "activityProgress")
+    return internals.heartbeatDetails.get(workflowId);
+  const inlineStrategy = internals.inlineStrategy;
+  if (!inlineStrategy)
+    throw Error("Workflow queries are not supported when using the worker execution strategy.");
+  const context = inlineStrategy.getContext(workflowId);
+  if (!context)
+    return;
+  const queryHandler = context.queryHandlers.get(name);
+  if (queryHandler)
+    return queryHandler(input);
+  const accessor = context.exposedAccessors.get(name);
+  if (!accessor)
+    return;
+  return accessor();
+}

package/dist/core/engine/registration.d.ts

@@ -0,0 +1,6 @@
+import type { EngineInternals } from './internals.ts';
+export type RegistrationCallbacks = {
+    ensureRetentionSweepInterval: () => void;
+};
+export declare function register(internals: EngineInternals, definition: unknown, callbacks: RegistrationCallbacks): void;
+export declare function resolveWorkflowTypeTarget(internals: EngineInternals, target: string | Function, _callbacks: RegistrationCallbacks): string;

package/dist/core/engine/registration.js

@@ -0,0 +1,107 @@
+import { ActivityRegistry } from "../activity-registry.js";
+import {
+  activity,
+  validateDefinitionSchemaMetadata
+} from "../types.js";
+import { clonePlain } from "../types/clone-plain.js";
+import { validateWorkflowOrActivityName } from "../types/name-grammar.js";
+import { normalizeRetentionPolicy } from "./validation.js";
+function copiedTags(tags) {
+  return tags === void 0 ? void 0 : [...tags];
+}
+function isWorkflowDefinition(value) {
+  return typeof value === "object" && value !== null && "name" in value && "handler" in value;
+}
+function assertConstraintsSupported(internals, name, registration) {
+  if (!registration.constraints || registration.constraints.length === 0)
+    return;
+  if (internals.inlineStrategy === null)
+    throw Error(`Cannot register workflow "${name}" with constraints: constraints are not supported in worker execution mode. The engine was constructed with \`workerExecution\`, which runs workflows in a Web Worker where the inline execution context required by constraint evaluation is unavailable. Remove the \`constraints\` option, or construct the engine without \`workerExecution\` to run workflows inline.`);
+}
+function buildBaseRegistrationEntry(name, registration) {
+  const tags = copiedTags(registration.tags), normalizedRetention = normalizeRetentionPolicy(registration.retention, `registration("${name}").retention`);
+  return {
+    handler: registration.handler,
+    version: registration.version ?? "1",
+    ...registration.description === void 0 ? {} : { description: registration.description },
+    ...tags === void 0 ? {} : { tags },
+    ...registration.inputSchema === void 0 ? {} : {
+      inputSchema: validateDefinitionSchemaMetadata(registration.inputSchema, `registration("${name}").inputSchema`)
+    },
+    ...registration.outputSchema === void 0 ? {} : {
+      outputSchema: validateDefinitionSchemaMetadata(registration.outputSchema, `registration("${name}").outputSchema`)
+    },
+    ...normalizedRetention !== null && { retention: normalizedRetention }
+  };
+}
+function applyOptionalRegistrationFields(entry, registration) {
+  if (registration.migrate)
+    entry.migrate = registration.migrate;
+  if (registration.searchAttributes && Object.keys(registration.searchAttributes).length > 0)
+    entry.searchAttributes = registration.searchAttributes;
+  if (registration.constraints && registration.constraints.length > 0)
+    entry.constraints = registration.constraints;
+}
+function buildRegistrationEntry(name, registration) {
+  const entry = buildBaseRegistrationEntry(name, registration);
+  applyOptionalRegistrationFields(entry, registration);
+  return entry;
+}
+function commitWorkflowDefinition(internals, definition, callbacks) {
+  const name = definition.name;
+  validateWorkflowOrActivityName(name, "workflow");
+  assertConstraintsSupported(internals, name, definition);
+  const entry = buildRegistrationEntry(name, definition);
+  internals.registrations.set(name, entry);
+  callbacks.ensureRetentionSweepInterval();
+  internals.workflowTypesByHandler.set(definition.handler, name);
+}
+function hasNonNullObjectField(value, key) {
+  if (!(key in value))
+    return !1;
+  const fieldValue = value[key];
+  return typeof fieldValue === "object" && fieldValue !== null;
+}
+function isBuilderWorkflowDefinition(value) {
+  if (!isWorkflowDefinition(value))
+    return !1;
+  return hasNonNullObjectField(value, "activities") && hasNonNullObjectField(value, "signals") && hasNonNullObjectField(value, "updates") && hasNonNullObjectField(value, "queries") && hasNonNullObjectField(value, "searchAttributes");
+}
+function buildPerWorkflowActivityRegistry(activities) {
+  const registry = new ActivityRegistry;
+  for (const definition of Object.values(activities)) {
+    const clonedDefinition = clonePlain(definition), callable = activity(clonedDefinition);
+    registry.register(callable.name, callable);
+  }
+  return registry;
+}
+function checkWorkflowCollision(internals, name, definition) {
+  const existing = internals.workflowDefinitionsByName.get(name);
+  if (existing === void 0)
+    return { kind: "register" };
+  if (existing === definition)
+    return { kind: "idempotent" };
+  throw Error(`Workflow "${name}" is already registered with a different definition`);
+}
+export function register(internals, definition, callbacks) {
+  if (!isWorkflowDefinition(definition))
+    throw TypeError("engine.register() expects a WorkflowDefinition (produced by `workflow({ name }).execute(fn)`) or an ActivityDefinition.");
+  if (isBuilderWorkflowDefinition(definition)) {
+    if (checkWorkflowCollision(internals, definition.name, definition).kind === "idempotent")
+      return;
+    const perWorkflowRegistry = buildPerWorkflowActivityRegistry(definition.activities);
+    commitWorkflowDefinition(internals, definition, callbacks);
+    internals.workflowDefinitionsByName.set(definition.name, definition);
+    internals.activityRegistriesByWorkflow.set(definition.name, perWorkflowRegistry);
+    return;
+  }
+  commitWorkflowDefinition(internals, definition, callbacks);
+}
+export function resolveWorkflowTypeTarget(internals, target, _callbacks) {
+  if (typeof target === "string")
+    return target;
+  const registeredType = internals.workflowTypesByHandler.get(target);
+  if (registeredType)
+    return registeredType;
+  throw Error("Workflow functions used in composition operators must be registered before use. Pass the registered workflow type string or register the function on the engine first.");
+}

package/dist/core/engine/retention.d.ts

@@ -0,0 +1,15 @@
+import type { RetentionOverview, WorkflowTypeRetentionPolicy } from '../types.ts';
+import type { EngineInternals } from './internals.ts';
+type CleanupWaiters = (workflowId: string) => void;
+type RetentionSweepCallbacks = {
+    hasConfiguredRetention: () => boolean;
+    runRetentionSweep: () => Promise<void>;
+    setNextRetentionSweepAt: () => void;
+};
+export declare function hasConfiguredRetention(internals: EngineInternals): boolean;
+export declare function setNextRetentionSweepAt(internals: EngineInternals): void;
+export declare function ensureRetentionSweepInterval(internals: EngineInternals, callbacks: RetentionSweepCallbacks): void;
+export declare function runRetentionSweep(internals: EngineInternals, handleCleanupError: (source: string, error: unknown) => void, cleanupWaiters: CleanupWaiters): Promise<void>;
+export declare function resolveWorkflowTypeRetention(internals: EngineInternals, type: string): WorkflowTypeRetentionPolicy;
+export declare function getRetentionOverview(internals: EngineInternals, resolveRetentionForType?: (type: string) => WorkflowTypeRetentionPolicy): RetentionOverview;
+export {};

package/dist/core/engine/retention.js

@@ -0,0 +1,76 @@
+import { purgeInternal } from "./bulk-operations.js";
+export function hasConfiguredRetention(internals) {
+  if (internals.options.retention !== null)
+    return !0;
+  for (const registration of internals.registrations.values())
+    if (registration.retention !== void 0 && registration.retention !== null)
+      return !0;
+  return !1;
+}
+export function setNextRetentionSweepAt(internals) {
+  internals.nextRetentionSweepAt = internals.options.getNow() + internals.options.retentionSweepIntervalMs;
+}
+export function ensureRetentionSweepInterval(internals, callbacks) {
+  if (!callbacks.hasConfiguredRetention()) {
+    if (internals.retentionSweepInterval !== null) {
+      clearInterval(internals.retentionSweepInterval ?? void 0);
+      internals.retentionSweepInterval = null;
+    }
+    internals.nextRetentionSweepAt = null;
+    return;
+  }
+  if (internals.retentionSweepInterval !== null)
+    return;
+  callbacks.setNextRetentionSweepAt();
+  internals.retentionSweepInterval = setInterval(() => {
+    callbacks.setNextRetentionSweepAt();
+    if (internals.retentionSweepInFlight !== null)
+      return;
+    const settledSweepPromise = callbacks.runRetentionSweep().finally(() => {
+      if (internals.retentionSweepInFlight === settledSweepPromise)
+        internals.retentionSweepInFlight = null;
+    });
+    internals.retentionSweepInFlight = settledSweepPromise;
+  }, internals.options.retentionSweepIntervalMs);
+}
+export async function runRetentionSweep(internals, handleCleanupError, cleanupWaiters) {
+  try {
+    await purgeInternal(internals, void 0, {
+      expiredOnly: !0,
+      limit: internals.options.retentionSweepBatchSize,
+      now: internals.options.getNow()
+    }, cleanupWaiters);
+  } catch (error) {
+    handleCleanupError("retentionSweep", error);
+  }
+}
+export function resolveWorkflowTypeRetention(internals, type) {
+  const registration = internals.registrations.get(type);
+  if (registration?.retention)
+    return {
+      type,
+      source: "workflow",
+      retention: registration.retention
+    };
+  if (internals.options.retention !== null)
+    return {
+      type,
+      source: "engine",
+      retention: internals.options.retention
+    };
+  return {
+    type,
+    source: "none",
+    retention: null
+  };
+}
+export function getRetentionOverview(internals, resolveRetentionForType = (type) => resolveWorkflowTypeRetention(internals, type)) {
+  const workflowTypes = [...internals.registrations.keys()].toSorted().map((type) => resolveRetentionForType(type));
+  return {
+    defaultRetention: internals.options.retention,
+    sweepIntervalMs: internals.options.retentionSweepIntervalMs,
+    sweepBatchSize: internals.options.retentionSweepBatchSize,
+    nextSweepAt: internals.nextRetentionSweepAt,
+    workflowTypes
+  };
+}

package/dist/core/engine/review-list-entries.d.ts

@@ -0,0 +1,6 @@
+import type { HumanReviewResult, ReviewRequest } from '../review/index.ts';
+import type { CompletedReviewEntry, PendingReviewEntry } from '../types.ts';
+export declare function toPendingReviewEntry(review: ReviewRequest): PendingReviewEntry;
+export declare function parseStoredReviewRequest(value: Uint8Array): ReviewRequest | null;
+export declare function toCompletedReviewEntry(review: ReviewRequest, decisionResult: HumanReviewResult): CompletedReviewEntry;
+export declare function parseCompletedReviewEntry(value: Uint8Array): CompletedReviewEntry | null;

package/dist/core/engine/review-list-entries.js

@@ -0,0 +1,117 @@
+import { z } from "zod";
+import { decode } from "../codec.js";
+const storedReviewRequestSchema = z.object({
+  reviewId: z.string(),
+  workflowId: z.string(),
+  artifact: z.unknown().nonoptional(),
+  reviewType: z.string(),
+  reviewers: z.array(z.string()),
+  allowPartial: z.boolean(),
+  timeout: z.number().optional(),
+  webhookUrl: z.string().optional(),
+  createdAt: z.number()
+}), persistedCompletedReviewEntrySchema = z.object({
+  status: z.literal("completed"),
+  reviewId: z.string(),
+  workflowId: z.string(),
+  artifact: z.unknown().nonoptional(),
+  reviewType: z.string(),
+  reviewers: z.array(z.string()),
+  allowPartial: z.boolean(),
+  timeout: z.number().optional(),
+  webhookUrl: z.string().optional(),
+  createdAt: z.number(),
+  decision: z.enum(["approved", "rejected", "needs-changes"]),
+  reviewer: z.string(),
+  feedback: z.string().optional(),
+  sectionDecisions: z.record(z.string(), z.enum(["approved", "rejected"])).optional(),
+  timestamp: z.number()
+});
+function assignWhenDefined(target, key, value) {
+  if (value !== void 0)
+    target[key] = value;
+}
+export function toPendingReviewEntry(review) {
+  return {
+    status: "pending",
+    ...review
+  };
+}
+function normalizeStoredReviewRequest(review) {
+  const normalizedReview = {
+    reviewId: review.reviewId,
+    workflowId: review.workflowId,
+    artifact: review.artifact,
+    reviewType: review.reviewType,
+    reviewers: review.reviewers,
+    allowPartial: review.allowPartial,
+    createdAt: review.createdAt
+  };
+  assignWhenDefined(normalizedReview, "timeout", review.timeout);
+  assignWhenDefined(normalizedReview, "webhookUrl", review.webhookUrl);
+  return normalizedReview;
+}
+export function parseStoredReviewRequest(value) {
+  let decodedValue;
+  try {
+    decodedValue = decode(value);
+  } catch {
+    return null;
+  }
+  const parsedReview = storedReviewRequestSchema.safeParse(decodedValue);
+  if (!parsedReview.success)
+    return null;
+  return normalizeStoredReviewRequest(parsedReview.data);
+}
+export function toCompletedReviewEntry(review, decisionResult) {
+  const completedReview = {
+    status: "completed",
+    reviewId: review.reviewId,
+    workflowId: review.workflowId,
+    artifact: review.artifact,
+    reviewType: review.reviewType,
+    reviewers: review.reviewers,
+    allowPartial: review.allowPartial,
+    createdAt: review.createdAt,
+    decision: decisionResult.decision,
+    reviewer: decisionResult.reviewer,
+    timestamp: decisionResult.timestamp
+  };
+  assignWhenDefined(completedReview, "timeout", review.timeout);
+  assignWhenDefined(completedReview, "webhookUrl", review.webhookUrl);
+  assignWhenDefined(completedReview, "feedback", decisionResult.feedback);
+  assignWhenDefined(completedReview, "sectionDecisions", decisionResult.sectionDecisions);
+  return completedReview;
+}
+function normalizeCompletedReviewEntry(persistedReview) {
+  const completedReview = {
+    status: "completed",
+    reviewId: persistedReview.reviewId,
+    workflowId: persistedReview.workflowId,
+    artifact: persistedReview.artifact,
+    reviewType: persistedReview.reviewType,
+    reviewers: persistedReview.reviewers,
+    allowPartial: persistedReview.allowPartial,
+    createdAt: persistedReview.createdAt,
+    decision: persistedReview.decision,
+    reviewer: persistedReview.reviewer,
+    timestamp: persistedReview.timestamp
+  };
+  assignWhenDefined(completedReview, "timeout", persistedReview.timeout);
+  assignWhenDefined(completedReview, "webhookUrl", persistedReview.webhookUrl);
+  assignWhenDefined(completedReview, "feedback", persistedReview.feedback);
+  assignWhenDefined(completedReview, "sectionDecisions", persistedReview.sectionDecisions);
+  return completedReview;
+}
+export function parseCompletedReviewEntry(value) {
+  let decodedValue;
+  try {
+    decodedValue = decode(value);
+  } catch {
+    return null;
+  }
+  const parsedReview = persistedCompletedReviewEntrySchema.safeParse(decodedValue);
+  if (!parsedReview.success)
+    return null;
+  return normalizeCompletedReviewEntry(parsedReview.data);
+}

package/dist/core/engine/reviews.d.ts

@@ -0,0 +1,34 @@
+import { type HumanReviewOptions, type HumanReviewResult, type ReviewRequest } from '../review/index.ts';
+import type { OperationOutcome, ReviewListEntry, ReviewListFilter, SubmitReviewOptions } from '../types.ts';
+import type { EngineInternals } from './internals.ts';
+type ReviewOperationOutcome = {
+    ok: true;
+    value: HumanReviewResult;
+} | {
+    ok: false;
+    error: Error;
+};
+export type SubmitReviewCallbacks = {
+    dispatchEvent: (event: Event) => boolean;
+};
+export type ReviewOperationCallbacks = {
+    dispatchEvent: (event: Event) => boolean;
+    failWorkflow: (workflowId: string, error: Error) => Promise<void>;
+    feedOperationResult: (workflowId: string, result: OperationOutcome) => void;
+    ensureTerminalCleanupTracked: (workflowId: string) => Promise<void>;
+};
+/** List pending reviews by default, or completed reviews when explicitly requested. */
+export declare function listReviews(internals: EngineInternals, filter?: ReviewListFilter): Promise<ReviewListEntry[]>;
+/** Retrieve a specific review by workflowId and reviewId. */
+export declare function getReview(internals: EngineInternals, workflowId: string, reviewId: string): Promise<ReviewRequest | null>;
+export declare function submitReview(internals: EngineInternals, reviewId: string, options: SubmitReviewOptions, callbacks: SubmitReviewCallbacks): Promise<void>;
+export declare function resolveReviewDecision(resolve: (result: ReviewOperationOutcome) => void, decision: HumanReviewResult): void;
+export declare function handleReviewEscalationTimer(internals: EngineInternals, workflowId: string, reviewId: string, waiterKey: string, reviewRequest: ReviewRequest, options: HumanReviewOptions, resolve: (result: ReviewOperationOutcome) => void, entry: {
+    id: string;
+    workflowId: string;
+}, callbacks: Pick<ReviewOperationCallbacks, 'dispatchEvent' | 'failWorkflow'>): Promise<boolean>;
+export declare function sendReviewWebhook(internals: EngineInternals, workflowId: string, reviewRequest: ReviewRequest, webhookUrl: string, webhookAbort: AbortController): Promise<void>;
+/** Remove all pending review entries from storage for a given workflow. */
+export declare function cleanupReviews(internals: EngineInternals, workflowId: string): Promise<void>;
+export declare function processReviewOperation(internals: EngineInternals, workflowId: string, options: HumanReviewOptions, callbacks: ReviewOperationCallbacks): Promise<void>;
+export {};

package/dist/core/engine/reviews.js

@@ -0,0 +1,242 @@
+import { KEYS, encodeStorageKeyComponent } from "../../storage/interface.js";
+import { ReviewCompletedEvent, ReviewRequestedEvent } from "../review/events.js";
+import {
+  ReviewTimeoutError
+} from "../review/index.js";
+import {
+  deleteCompletedReviewsForWorkflow,
+  listCompletedReviewsFromStorage,
+  matchesReviewListFilter,
+  persistCompletedReviewRecord
+} from "./completed-review-storage.js";
+import { parseStoredReviewRequest, toPendingReviewEntry } from "./review-list-entries.js";
+import { trackWaiterKey, untrackWaiterKey } from "./signals.js";
+function reviewScanPrefix(filter) {
+  if (filter.workflowId === void 0)
+    return "review:";
+  return `review:${encodeStorageKeyComponent(filter.workflowId)}:`;
+}
+async function listPendingReviews(internals, filter) {
+  const reviews = [];
+  for await (const [, value] of internals.storage.scan(reviewScanPrefix(filter))) {
+    const review = parseStoredReviewRequest(value);
+    if (review !== null && matchesReviewListFilter(review, filter))
+      reviews.push(toPendingReviewEntry(review));
+  }
+  return reviews;
+}
+async function dispatchCompletedReview(internals, reviewKey, reviewData, decisionResult, dispatchEvent) {
+  await persistCompletedReviewRecord(internals.storage, reviewKey, reviewData, decisionResult);
+  dispatchEvent(new ReviewCompletedEvent(reviewData.workflowId, reviewData.reviewId, decisionResult.decision, decisionResult.reviewer, decisionResult.timestamp - reviewData.createdAt));
+}
+export async function listReviews(internals, filter = {}) {
+  if (filter.status === "completed")
+    return listCompletedReviewsFromStorage(internals.storage, filter);
+  return listPendingReviews(internals, filter);
+}
+export async function getReview(internals, workflowId, reviewId) {
+  return internals.reviewCoordinator.getReview(workflowId, reviewId);
+}
+async function findReviewByScan(internals, reviewId) {
+  for await (const [reviewKey, value] of internals.storage.scan("review:")) {
+    const reviewData = parseStoredReviewRequest(value);
+    if (reviewData !== null && reviewData.reviewId === reviewId)
+      return {
+        reviewKey,
+        reviewData,
+        workflowId: reviewData.workflowId
+      };
+  }
+  return null;
+}
+async function findStoredReview(internals, reviewId, workflowId) {
+  if (workflowId !== void 0) {
+    const reviewKey = KEYS.review(workflowId, reviewId), existing = await internals.storage.get(reviewKey);
+    return existing === null ? null : { reviewKey, reviewData: parseStoredReviewRequest(existing), workflowId };
+  }
+  return findReviewByScan(internals, reviewId);
+}
+function createHumanReviewResult(reviewId, options, timestamp) {
+  const { decision, reviewer, feedback, sectionDecisions } = options, decisionResult = {
+    reviewId,
+    decision,
+    reviewer,
+    timestamp
+  };
+  if (feedback !== void 0)
+    decisionResult.feedback = feedback;
+  if (sectionDecisions !== void 0)
+    decisionResult.sectionDecisions = sectionDecisions;
+  return decisionResult;
+}
+function resolveWaitingReview(internals, workflowId, reviewId, decisionResult) {
+  const waiterKey = `${workflowId}:${reviewId}`, waiter = internals.reviewWaiters.get(waiterKey);
+  if (!waiter)
+    return;
+  internals.reviewWaiters.delete(waiterKey);
+  untrackWaiterKey(internals.reviewWaitersByWorkflow, workflowId, waiterKey);
+  waiter(decisionResult);
+}
+export async function submitReview(internals, reviewId, options, callbacks) {
+  const storedReview = await findStoredReview(internals, reviewId, options.workflowId);
+  if (storedReview === null)
+    throw Error(`Review "${reviewId}" not found`);
+  if (storedReview.reviewData === null)
+    throw Error(`Review "${reviewId}" could not be loaded`);
+  const decisionResult = createHumanReviewResult(reviewId, options, internals.options.getNow());
+  await dispatchCompletedReview(internals, storedReview.reviewKey, storedReview.reviewData, decisionResult, callbacks.dispatchEvent);
+  resolveWaitingReview(internals, storedReview.workflowId, reviewId, decisionResult);
+}
+export function resolveReviewDecision(resolve, decision) {
+  resolve({ ok: !0, value: decision });
+}
+export async function handleReviewEscalationTimer(internals, workflowId, reviewId, waiterKey, reviewRequest, options, resolve, entry, callbacks) {
+  if (!entry.id.startsWith(`review-escalation:${reviewId}:`) && entry.id !== `review-timeout:${reviewId}`)
+    return !1;
+  if (entry.id === `review-timeout:${reviewId}`) {
+    internals.reviewWaiters.delete(waiterKey);
+    untrackWaiterKey(internals.reviewWaitersByWorkflow, workflowId, waiterKey);
+    const elapsed = internals.options.getNow() - reviewRequest.createdAt;
+    await internals.storage.delete(KEYS.review(workflowId, reviewId));
+    const timeoutError = new ReviewTimeoutError(reviewId, elapsed);
+    await callbacks.failWorkflow(workflowId, timeoutError);
+    resolve({ ok: !1, error: timeoutError });
+    return !0;
+  }
+  if (!options.escalation)
+    return !1;
+  const action = internals.reviewCoordinator.checkEscalations(reviewRequest, options.escalation, internals.options.getNow());
+  if (!action)
+    return !1;
+  if (action.type === "escalate") {
+    options.onEscalation?.(action);
+    return !1;
+  }
+  internals.reviewWaiters.delete(waiterKey);
+  untrackWaiterKey(internals.reviewWaitersByWorkflow, workflowId, waiterKey);
+  const autoResult = {
+    reviewId,
+    decision: action.decision,
+    reviewer: "system",
+    feedback: action.auditReason,
+    timestamp: internals.options.getNow()
+  };
+  await dispatchCompletedReview(internals, KEYS.review(workflowId, reviewId), reviewRequest, autoResult, callbacks.dispatchEvent);
+  resolve({ ok: !0, value: autoResult });
+  return !0;
+}
+export async function sendReviewWebhook(internals, workflowId, reviewRequest, webhookUrl, webhookAbort) {
+  try {
+    await fetch(webhookUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        workflowId,
+        reviewId: reviewRequest.reviewId,
+        reviewType: reviewRequest.reviewType,
+        reviewers: reviewRequest.reviewers,
+        artifact: reviewRequest.artifact
+      }),
+      signal: webhookAbort.signal
+    });
+  } catch (error) {
+    if (!(error instanceof DOMException && error.name === "AbortError"))
+      console.warn(`[weft] Failed to send review webhook for ${reviewRequest.reviewId}`, error);
+  } finally {
+    internals.pendingWebhooks.delete(webhookAbort);
+  }
+}
+export async function cleanupReviews(internals, workflowId) {
+  const pendingPrefix = `review:${encodeStorageKeyComponent(workflowId)}:`, deleteOperations = [];
+  if (internals.storage.deletePrefix)
+    await internals.storage.deletePrefix(pendingPrefix);
+  else
+    for await (const [key] of internals.storage.scan(pendingPrefix))
+      deleteOperations.push({ type: "delete", key });
+  if (deleteOperations.length > 0)
+    await internals.storage.batch(deleteOperations);
+  await deleteCompletedReviewsForWorkflow(internals.storage, workflowId);
+}
+function setReviewOption(reviewOptions, key, value) {
+  if (value !== void 0)
+    reviewOptions[key] = value;
+}
+function createReviewOptions(options) {
+  const reviewOptions = { artifact: options.artifact };
+  setReviewOption(reviewOptions, "reviewType", options.reviewType);
+  setReviewOption(reviewOptions, "reviewers", options.reviewers);
+  setReviewOption(reviewOptions, "allowPartial", options.allowPartial);
+  setReviewOption(reviewOptions, "timeout", options.timeout);
+  setReviewOption(reviewOptions, "escalation", options.escalation);
+  setReviewOption(reviewOptions, "webhookUrl", options.webhookUrl);
+  return reviewOptions;
+}
+async function scheduleReviewTimers(internals, workflowId, reviewId, options, now) {
+  const timerIds = [];
+  for (const step of options.escalation ?? []) {
+    const timerId = `review-escalation:${reviewId}:${step.after}`;
+    timerIds.push(timerId);
+    await internals.scheduler.schedule({
+      id: timerId,
+      workflowId,
+      fireAt: now + step.after,
+      kind: "sleep"
+    });
+  }
+  if (options.timeout !== void 0) {
+    const timerId = `review-timeout:${reviewId}`;
+    timerIds.push(timerId);
+    await internals.scheduler.schedule({
+      id: timerId,
+      workflowId,
+      fireAt: now + options.timeout,
+      kind: "sleep"
+    });
+  }
+  return timerIds;
+}
+function createReviewWaiter(internals, workflowId, reviewId) {
+  const { promise, resolve } = Promise.withResolvers(), waiterKey = `${workflowId}:${reviewId}`;
+  internals.reviewWaiters.set(waiterKey, (decision) => resolveReviewDecision(resolve, decision));
+  trackWaiterKey(internals.reviewWaitersByWorkflow, workflowId, waiterKey);
+  return { promise, resolve, waiterKey };
+}
+function registerReviewLifecycleTracking(internals, workflowId, reviewId, timerIds, handler) {
+  let reviewIdSet = internals.workflowReviewIds.get(workflowId);
+  internals.reviewEscalationHandlers.set(reviewId, handler);
+  if (timerIds.length > 0)
+    internals.reviewTimerIds.set(reviewId, timerIds);
+  if (!reviewIdSet) {
+    reviewIdSet = new Set;
+    internals.workflowReviewIds.set(workflowId, reviewIdSet);
+  }
+  reviewIdSet.add(reviewId);
+}
+function cleanupReviewLifecycleTracking(internals, workflowId, reviewId) {
+  const trackedIds = internals.workflowReviewIds.get(workflowId);
+  internals.reviewEscalationHandlers.delete(reviewId);
+  internals.reviewTimerIds.delete(reviewId);
+  trackedIds?.delete(reviewId);
+  if (trackedIds?.size === 0)
+    internals.workflowReviewIds.delete(workflowId);
+}
+export async function processReviewOperation(internals, workflowId, options, callbacks) {
+  const now = internals.options.getNow();
+  await callbacks.ensureTerminalCleanupTracked(workflowId);
+  const reviewRequest = await internals.reviewCoordinator.createReview(workflowId, createReviewOptions(options)), reviewId = reviewRequest.reviewId;
+  callbacks.dispatchEvent(new ReviewRequestedEvent(workflowId, reviewId, reviewRequest.reviewType, reviewRequest.reviewers));
+  if (options.webhookUrl !== void 0) {
+    const webhookAbort = new AbortController;
+    internals.pendingWebhooks.add(webhookAbort);
+    sendReviewWebhook(internals, workflowId, reviewRequest, options.webhookUrl, webhookAbort);
+  }
+  const timerIds = await scheduleReviewTimers(internals, workflowId, reviewId, options, now), { promise, resolve, waiterKey } = createReviewWaiter(internals, workflowId, reviewId);
+  registerReviewLifecycleTracking(internals, workflowId, reviewId, timerIds, (entry) => handleReviewEscalationTimer(internals, workflowId, reviewId, waiterKey, reviewRequest, options, resolve, entry, callbacks));
+  const outcome = await promise;
+  cleanupReviewLifecycleTracking(internals, workflowId, reviewId);
+  for (const timerId of timerIds)
+    await internals.scheduler.cancel(timerId, workflowId);
+  if (!outcome.ok)
+    return;
+  callbacks.feedOperationResult(workflowId, { status: "completed", value: outcome.value });
+}