@jangts/agent-core 0.1.1 → 0.2.0

package/dist/esm/kits/answering/tasks.js

@@ -1,33 +1,81 @@
+/**
+ * Answering Kit: answer tasks, their readers, schemas and metadata.
+ *
+ * Place in the package: part of the `answering` Kit. A task binds an intent set, a scope, an
+ * output contract, check ids and a reader; this module compiles that binding, validates the
+ * reader ids and exposes read/describe entry points. Readers stay App-owned I/O.
+ *
+ * Exports: `defineAnswerReaderCatalog`, `defineAnswerTaskCatalog`, and the task/reader types.
+ */
 import { readonlyCatalog } from '../../utils/catalog.js';
 import { assertion, synchronous } from '../../utils/synchronous.js';
 import { freezeSchema } from '../../utils/object.js';
 import { awaitWithSignal } from '../../utils/cancellation.js';
 import { snapshotSchemaAdapter } from '../../utils/schema-adapter.js';
-/** Task ids, schema, readers, outputs and checks have one compiled authority. */
+/**
+ * Compile a reader catalog.
+ *
+ * @param definitions - Readers with unique ids and a `read` handler.
+ * @returns A frozen catalog; unknown ids fail through `require`.
+ * @throws TypeError When a reader has no `read` handler.
+ */
 export function defineAnswerReaderCatalog(definitions) {
-    return readonlyCatalog(definitions.map(reader => {
+    return readonlyCatalog(definitions.map((reader) => {
         if (typeof reader.read !== 'function')
             throw new TypeError('Invalid answer reader');
         return Object.freeze({ id: reader.id, read: reader.read.bind(reader) });
-    }), id => new TypeError(`Unknown answer reader: ${id}`));
+    }), (id) => new TypeError(`Unknown answer reader: ${id}`));
 }
+/**
+ * Compile the answer task catalog from its declarations and shared ports.
+ *
+ * Task ids, schemas, readers, outputs and checks have one compiled authority: a task can only
+ * reference a reader or check that the ports actually registered, and metadata is cloned and
+ * frozen so later mutation by the caller cannot change a registered task.
+ *
+ * @param definitions - Task declarations with identity, reader/output/scope references,
+ *   intent ids, check ids, input schema and metadata.
+ * @param ports - Registered readers, checks, outputs and an optional definition assertion.
+ * @returns A frozen catalog extended with `describe`, `read` and `readAsync`.
+ * @throws TypeError For a task with missing identity, an unknown reader/output/check, empty or
+ *   duplicate intent ids, a duplicate check id, or a failed definition assertion.
+ */
 export function defineAnswerTaskCatalog(definitions, ports) {
     const readers = defineAnswerReaderCatalog([...ports.readers.values()]);
     const checkIds = ports.checks.ids();
     const assertDefinition = ports.assertDefinition?.bind(ports);
     const outputs = new Set(ports.outputs.ids());
-    const tasks = definitions.map(definition => {
-        if (!definition.id?.trim() || !definition.description?.trim() || !readers.has(definition.readerId) || !outputs.has(definition.outputId)
-            || !Array.isArray(definition.intentIds) || !definition.intentIds.length || definition.intentIds.some(id => typeof id !== 'string' || !id.trim()) || new Set(definition.intentIds).size !== definition.intentIds.length
-            || !Array.isArray(definition.checkIds) || new Set(definition.checkIds).size !== definition.checkIds.length || definition.checkIds.some(id => !checkIds.includes(id)))
+    const tasks = definitions.map((definition) => {
+        if (!definition.id?.trim() ||
+            !definition.description?.trim() ||
+            !readers.has(definition.readerId) ||
+            !outputs.has(definition.outputId) ||
+            !Array.isArray(definition.intentIds) ||
+            !definition.intentIds.length ||
+            definition.intentIds.some((id) => typeof id !== 'string' || !id.trim()) ||
+            new Set(definition.intentIds).size !== definition.intentIds.length ||
+            !Array.isArray(definition.checkIds) ||
+            new Set(definition.checkIds).size !== definition.checkIds.length ||
+            definition.checkIds.some((id) => !checkIds.includes(id)))
             throw new TypeError(`Invalid answer task: ${definition.id}`);
         const metadata = structuredClone(definition.metadata);
         freezeSchema(metadata);
-        const task = Object.freeze({ ...definition, id: definition.id, description: definition.description, readerId: definition.readerId, outputId: definition.outputId, scopeId: definition.scopeId, intentIds: Object.freeze([...definition.intentIds]), checkIds: Object.freeze([...definition.checkIds]), inputSchema: snapshotSchemaAdapter(definition.inputSchema), metadata });
+        const task = Object.freeze({
+            ...definition,
+            id: definition.id,
+            description: definition.description,
+            readerId: definition.readerId,
+            outputId: definition.outputId,
+            scopeId: definition.scopeId,
+            intentIds: Object.freeze([...definition.intentIds]),
+            checkIds: Object.freeze([...definition.checkIds]),
+            inputSchema: snapshotSchemaAdapter(definition.inputSchema),
+            metadata,
+        });
         assertion(assertDefinition?.(task), 'Task assertions must return void synchronously');
         return task;
     });
-    const catalog = readonlyCatalog(tasks, id => new TypeError(`Unknown answer task: ${id}`));
+    const catalog = readonlyCatalog(tasks, (id) => new TypeError(`Unknown answer task: ${id}`));
     const prepare = (request, context) => {
         context.signal.throwIfAborted();
         const task = catalog.require(request.taskId);
@@ -35,17 +83,44 @@ export function defineAnswerTaskCatalog(definitions, ports) {
         context.signal.throwIfAborted();
         return { input, task, reader: readers.require(task.readerId) };
     };
-    return Object.freeze({ ...catalog,
-        describe: () => tasks.map(({ inputSchema, ...task }) => ({ ...task, inputJsonSchema: inputSchema.jsonSchema })),
+    return Object.freeze({
+        ...catalog,
+        /** Task metadata with the JSON schema flattened for model or admin presentation. */
+        describe: () => tasks.map(({ inputSchema, ...task }) => ({
+            ...task,
+            inputJsonSchema: inputSchema.jsonSchema,
+        })),
+        /**
+         * Read evidence through a task's registered reader, synchronously.
+         *
+         * @throws TypeError For an unknown task, a parse failure, or a reader returning a Promise.
+         */
         read(request, context) {
             const { input, task, reader } = prepare(request, context);
-            const value = synchronous(reader.read(input, { ...context, app: context.app, signal: context.signal, diagnostics: context.diagnostics, task }), 'Synchronous answer readers must not return a Promise');
+            const value = synchronous(reader.read(input, {
+                ...context,
+                app: context.app,
+                signal: context.signal,
+                diagnostics: context.diagnostics,
+                task,
+            }), 'Synchronous answer readers must not return a Promise');
             context.signal.throwIfAborted();
             return value;
         },
+        /**
+         * Read evidence through a task's registered reader, awaiting an async reader.
+         *
+         * @throws TypeError For an unknown task or a parse failure; aborts with the caller's signal.
+         */
         async readAsync(request, context) {
             const { input, task, reader } = prepare(request, context);
-            const value = await awaitWithSignal(reader.read(input, { ...context, app: context.app, signal: context.signal, diagnostics: context.diagnostics, task }), context.signal);
+            const value = await awaitWithSignal(reader.read(input, {
+                ...context,
+                app: context.app,
+                signal: context.signal,
+                diagnostics: context.diagnostics,
+                task,
+            }), context.signal);
             context.signal.throwIfAborted();
             return value;
         },

package/dist/esm/kits/artifacts.d.ts

@@ -1,5 +1,15 @@
 import type { OperationContext } from '../structs/common.js';
 import type { ArtifactReference, ArtifactResolver } from '../structs/kits/artifacts.js';
+/**
+ * Compile a catalog of artifact resolvers plus a checked `resolve` entry point.
+ *
+ * @param definitions - Resolvers keyed by their own non-empty `id`; duplicate ids are rejected
+ *   by the underlying catalog.
+ * @returns A frozen catalog (`ids`/`has`/`get`/`require`/`values`/`entries`) extended with
+ *   `resolve(reference, context)`.
+ * @throws TypeError At construction for malformed resolver definitions, and from `resolve`
+ *   for an unknown resolver, an invalid reference snapshot, or a missing `OperationContext`.
+ */
 export declare function defineArtifactCatalog<Value, App>(definitions: readonly ArtifactResolver<Value, App>[]): Readonly<{
     resolve: (reference: ArtifactReference, context: OperationContext<App>) => Promise<Value>;
     definitions: readonly Readonly<{
@@ -26,6 +36,7 @@ export declare function defineArtifactCatalog<Value, App>(definitions: readonly
     }>;
 }>;
 export type * from '../structs/kits/artifacts.js';
+/** Namespace object for callers that prefer one import over named helpers. */
 export declare const Artifacts: Readonly<{
     defineArtifactCatalog: typeof defineArtifactCatalog;
 }>;

package/dist/esm/kits/artifacts.js

@@ -1,16 +1,38 @@
+/**
+ * Artifacts Kit: resolve opaque artifact references through App-registered resolvers.
+ *
+ * Place in the package: an optional App-side library. A reference only names a resolver and
+ * an artifact; the resolver, not this module, establishes access, provenance and whether the
+ * referenced revision is still current. Nothing is cached or persisted here.
+ *
+ * Exports: `defineArtifactCatalog`, `Artifacts`, and the artifact reference/resolver types.
+ */
 import { awaitWithSignal } from '../utils/cancellation.js';
 import { readonlyCatalog } from '../utils/catalog.js';
 function snapshotArtifactReference(reference) {
     if (!reference || typeof reference !== 'object')
         throw new TypeError('Invalid artifact reference');
     const { resolverId, artifactId, revision } = reference;
-    if (typeof resolverId !== 'string' || !resolverId.trim() || typeof artifactId !== 'string' || !artifactId.trim()
-        || (revision !== undefined && (typeof revision !== 'string' || !revision.trim())))
+    if (typeof resolverId !== 'string' ||
+        !resolverId.trim() ||
+        typeof artifactId !== 'string' ||
+        !artifactId.trim() ||
+        (revision !== undefined && (typeof revision !== 'string' || !revision.trim())))
         throw new TypeError('Invalid artifact reference');
     return Object.freeze({ resolverId, artifactId, ...(revision === undefined ? {} : { revision }) });
 }
+/**
+ * Compile a catalog of artifact resolvers plus a checked `resolve` entry point.
+ *
+ * @param definitions - Resolvers keyed by their own non-empty `id`; duplicate ids are rejected
+ *   by the underlying catalog.
+ * @returns A frozen catalog (`ids`/`has`/`get`/`require`/`values`/`entries`) extended with
+ *   `resolve(reference, context)`.
+ * @throws TypeError At construction for malformed resolver definitions, and from `resolve`
+ *   for an unknown resolver, an invalid reference snapshot, or a missing `OperationContext`.
+ */
 export function defineArtifactCatalog(definitions) {
-    const compiled = definitions.map(definition => {
+    const compiled = definitions.map((definition) => {
         if (!definition || typeof definition !== 'object')
             throw new TypeError('Use an artifact resolver id and OperationContext');
         const { id, resolve } = definition;
@@ -18,7 +40,16 @@ export function defineArtifactCatalog(definitions) {
             throw new TypeError('Invalid artifact resolver');
         return Object.freeze({ id, resolve: resolve.bind(definition) });
     });
-    const catalog = readonlyCatalog(compiled, id => new TypeError(`Unregistered artifact resolver: ${id}`));
+    const catalog = readonlyCatalog(compiled, (id) => new TypeError(`Unregistered artifact resolver: ${id}`));
+    /**
+     * Resolve one reference through its registered resolver.
+     *
+     * @param reference - Resolver id, artifact id and optional revision; snapshotted and frozen
+     *   before the call so a handler cannot observe later mutation.
+     * @param context - Operation context supplying the abort signal.
+     * @returns The resolver's value.
+     * @throws TypeError For a malformed reference or context, or an unknown resolver id.
+     */
     async function resolve(reference, context) {
         if (!context?.signal)
             throw new TypeError('Artifact resolution requires OperationContext');
@@ -31,4 +62,5 @@ export function defineArtifactCatalog(definitions) {
     }
     return Object.freeze({ ...catalog, resolve });
 }
+/** Namespace object for callers that prefer one import over named helpers. */
 export const Artifacts = Object.freeze({ defineArtifactCatalog });

package/dist/esm/kits/candidates.d.ts

@@ -1,5 +1,26 @@
+/**
+ * Candidates Kit: accept, bound and unpack an alternative-proposal envelope.
+ *
+ * Place in the package: an optional App-side validator for a model reply that may offer
+ * several alternatives under one named field. It only narrows the shape; which alternatives
+ * are acceptable, and what happens after the user picks one, stays with the App.
+ *
+ * Exports: `defineCandidateSelection`, `Candidates`, `CandidateSelectionDefinition`.
+ */
 import type { CandidateSelectionDefinition } from '../structs/kits/candidates.js';
-/** Alternative proposals are bounded and shallow; accepting a task closes this capability. */
+/**
+ * Compile an alternative-proposal envelope contract.
+ *
+ * Alternative proposals are bounded and shallow; accepting a task closes this capability.
+ * A value that is not an object, or that does not carry the candidate field, is treated as a
+ * single implicit candidate and returned as-is. Once the envelope is present it must contain
+ * only that field, and its array must hold between `minCandidates` (default 1) and
+ * `maxCandidates` distinct candidate objects that do not themselves repeat the field.
+ *
+ * @param definition - Field name, bounds, optional error wording and diagnostic tags.
+ * @returns A frozen selector exposing `field`, the resolved bounds and `parse`.
+ * @throws TypeError When the field name or bounds are invalid.
+ */
 export declare function defineCandidateSelection(definition: CandidateSelectionDefinition): Readonly<{
     field: string;
     minCandidates: number;
@@ -10,6 +31,7 @@ export declare function defineCandidateSelection(definition: CandidateSelectionD
     }) => unknown[];
 }>;
 export type { CandidateSelectionDefinition } from '../structs/kits/candidates.js';
+/** Namespace object for callers that prefer one import over named helpers. */
 export declare const Candidates: Readonly<{
     defineCandidateSelection: typeof defineCandidateSelection;
 }>;

package/dist/esm/kits/candidates.js

@@ -1,5 +1,17 @@
 import { breakWhile } from '../utils/rules.js';
-/** Alternative proposals are bounded and shallow; accepting a task closes this capability. */
+/**
+ * Compile an alternative-proposal envelope contract.
+ *
+ * Alternative proposals are bounded and shallow; accepting a task closes this capability.
+ * A value that is not an object, or that does not carry the candidate field, is treated as a
+ * single implicit candidate and returned as-is. Once the envelope is present it must contain
+ * only that field, and its array must hold between `minCandidates` (default 1) and
+ * `maxCandidates` distinct candidate objects that do not themselves repeat the field.
+ *
+ * @param definition - Field name, bounds, optional error wording and diagnostic tags.
+ * @returns A frozen selector exposing `field`, the resolved bounds and `parse`.
+ * @throws TypeError When the field name or bounds are invalid.
+ */
 export function defineCandidateSelection(definition) {
     const { field, error: configuredError, maxCandidates: max } = definition;
     const error = typeof configuredError === 'function' ? configuredError.bind(definition) : configuredError;
@@ -7,8 +19,22 @@ export function defineCandidateSelection(definition) {
     const tags = [...(definition.tags ?? [])];
     breakWhile([
         { occur: () => !field.trim(), error: 'Missing candidate field' },
-        { occur: [() => !Number.isSafeInteger(min) || !Number.isSafeInteger(max), () => min < 1 || max < min], error: 'Invalid candidate bounds' },
+        {
+            occur: [
+                () => !Number.isSafeInteger(min) || !Number.isSafeInteger(max),
+                () => min < 1 || max < min,
+            ],
+            error: 'Invalid candidate bounds',
+        },
     ]);
+    /**
+     * Unpack the candidates from one parsed reply value.
+     *
+     * @param request - The raw value plus whether proposals are still allowed at this point.
+     * @returns The candidate list, or `[value]` when no envelope is present.
+     * @throws TypeError When `allowed` is not boolean, or when the envelope is disallowed,
+     *   malformed, out of bounds or contains nested candidate envelopes.
+     */
     function parse({ value, allowed }) {
         if (typeof allowed !== 'boolean')
             throw new TypeError('Candidate availability must be boolean');
@@ -17,9 +43,24 @@ export function defineCandidateSelection(definition) {
         const candidates = value[field];
         breakWhile([
             { occur: () => !allowed, error, tags: ['availability'] },
-            { occur: () => Array.isArray(value) || Object.keys(value).length !== 1, error, tags: ['envelope'] },
-            { occur: [() => !Array.isArray(candidates), () => candidates.length < min || candidates.length > max], error, tags: ['selection'] },
-            { occur: () => candidates.some(candidate => invalidCandidate(candidate, field)), error, tags: ['members'] },
+            {
+                occur: () => Array.isArray(value) || Object.keys(value).length !== 1,
+                error,
+                tags: ['envelope'],
+            },
+            {
+                occur: [
+                    () => !Array.isArray(candidates),
+                    () => candidates.length < min || candidates.length > max,
+                ],
+                error,
+                tags: ['selection'],
+            },
+            {
+                occur: () => candidates.some((candidate) => invalidCandidate(candidate, field)),
+                error,
+                tags: ['members'],
+            },
         ], tags);
         return candidates;
     }
@@ -30,4 +71,5 @@ function invalidCandidate(value, field) {
         return true;
     return Object.hasOwn(value, field);
 }
+/** Namespace object for callers that prefer one import over named helpers. */
 export const Candidates = Object.freeze({ defineCandidateSelection });

package/dist/esm/kits/delivery.d.ts

@@ -1,12 +1,46 @@
+/**
+ * Delivery Kit: run an ordered, synchronous stage pipeline that ends with one result.
+ *
+ * Place in the package: an optional App-side delivery pipeline (for example formatting and
+ * sending one reply). The Kit owns ordering, cancellation checks and outcome validation; the
+ * stages, their state and the actual side effects belong to the App.
+ *
+ * Exports: `defineDelivery`, `Delivery`, and the delivery option/outcome types.
+ */
 import type { DeliveryOptions } from '../structs/kits/delivery.js';
 import type { ExecutionContext } from '../structs/common.js';
+/**
+ * Compile a delivery pipeline from its declared stages.
+ *
+ * Stages are registered once, in declaration order, and must have unique non-blank ids. A
+ * stage without a `handle` is a named hook only, so `beforeStage` can observe it.
+ *
+ * @param options - Stage list, state factory, optional pre-stage hook and the error factory
+ *   used when every stage chose `continue`.
+ * @returns A frozen plan exposing the stage ids and `deliver(input, execution)`.
+ * @throws TypeError At construction for duplicate/blank ids or a non-function handler; from
+ *   `deliver` when any handler returns a thenable, when a stage outcome is neither `continue`
+ *   nor `complete`, or when `complete` carries no value.
+ */
 export declare function defineDelivery<Input, State, Result, StageId extends string>(options: DeliveryOptions<Input, State, Result, StageId>): Readonly<{
     stages: readonly {
         id: StageId;
     }[];
+    /**
+     * Build the state and run the stages in order.
+     *
+     * The first `complete` outcome ends the pipeline and returns its value; if none completes,
+     * `missingResult` supplies the error.
+     *
+     * @param input - Host input; it is exposed to stages as `context.app`.
+     * @param execution - Execution context; cancellation is checked before every hook.
+     * @throws The configured error when no stage completes, or a `TypeError` for invalid
+     *   handler results.
+     */
     deliver(input: Input, execution: ExecutionContext): Result;
 }>;
 export type * from '../structs/kits/delivery.js';
+/** Namespace object for callers that prefer one import over named helpers. */
 export declare const Delivery: Readonly<{
     defineDelivery: typeof defineDelivery;
 }>;

package/dist/esm/kits/delivery.js

@@ -1,19 +1,51 @@
 import { synchronous } from '../utils/synchronous.js';
+/**
+ * Compile a delivery pipeline from its declared stages.
+ *
+ * Stages are registered once, in declaration order, and must have unique non-blank ids. A
+ * stage without a `handle` is a named hook only, so `beforeStage` can observe it.
+ *
+ * @param options - Stage list, state factory, optional pre-stage hook and the error factory
+ *   used when every stage chose `continue`.
+ * @returns A frozen plan exposing the stage ids and `deliver(input, execution)`.
+ * @throws TypeError At construction for duplicate/blank ids or a non-function handler; from
+ *   `deliver` when any handler returns a thenable, when a stage outcome is neither `continue`
+ *   nor `complete`, or when `complete` carries no value.
+ */
 export function defineDelivery(options) {
     const ids = new Set();
-    const stages = options.stages.map(stage => {
+    const stages = options.stages.map((stage) => {
         const { id } = stage;
-        if (!id?.trim() || ids.has(id) || (stage.handle !== undefined && typeof stage.handle !== 'function'))
+        if (!id?.trim() ||
+            ids.has(id) ||
+            (stage.handle !== undefined && typeof stage.handle !== 'function'))
             throw new TypeError('Invalid or duplicate delivery stage');
         ids.add(id);
         return Object.freeze({ id, handle: stage.handle?.bind(stage) });
     });
     const createState = options.createState.bind(options), beforeStage = options.beforeStage?.bind(options), missingResult = options.missingResult.bind(options);
-    return Object.freeze({ stages: Object.freeze(stages.map(stage => ({ id: stage.id }))),
+    return Object.freeze({
+        stages: Object.freeze(stages.map((stage) => ({ id: stage.id }))),
+        /**
+         * Build the state and run the stages in order.
+         *
+         * The first `complete` outcome ends the pipeline and returns its value; if none completes,
+         * `missingResult` supplies the error.
+         *
+         * @param input - Host input; it is exposed to stages as `context.app`.
+         * @param execution - Execution context; cancellation is checked before every hook.
+         * @throws The configured error when no stage completes, or a `TypeError` for invalid
+         *   handler results.
+         */
         deliver(input, execution) {
             execution.signal.throwIfAborted();
             const state = synchronous(createState(input, execution), 'Delivery state creation must be synchronous');
-            const context = { ...execution, signal: execution.signal, diagnostics: execution.diagnostics, app: input };
+            const context = {
+                ...execution,
+                signal: execution.signal,
+                diagnostics: execution.diagnostics,
+                app: input,
+            };
             for (const stage of stages) {
                 execution.signal.throwIfAborted();
                 synchronous(beforeStage?.({ stageId: stage.id, state }, context), 'Delivery hooks must be synchronous');
@@ -22,7 +54,9 @@ export function defineDelivery(options) {
                     continue;
                 const outcome = synchronous(stage.handle(state, context), 'Delivery handlers must be synchronous');
                 execution.signal.throwIfAborted();
-                if (!outcome || !['continue', 'complete'].includes(outcome.type) || (outcome.type === 'complete' && !('value' in outcome)))
+                if (!outcome ||
+                    !['continue', 'complete'].includes(outcome.type) ||
+                    (outcome.type === 'complete' && !('value' in outcome)))
                     throw new TypeError('Delivery handlers require explicit continue/complete');
                 if (outcome.type === 'complete') {
                     const value = outcome.value;
@@ -34,4 +68,5 @@ export function defineDelivery(options) {
         },
     });
 }
+/** Namespace object for callers that prefer one import over named helpers. */
 export const Delivery = Object.freeze({ defineDelivery });

package/dist/esm/kits/durable.d.ts

@@ -1,7 +1,26 @@
 import type { DurableTask, DurableTaskDefinition, DurableTaskOptions } from '../structs/kits/durable.js';
+/**
+ * Compile a durable task definition into a resumable runner.
+ *
+ * Each `run` call locks the task id in the store, loads the checkpoint and resumes at
+ * `nextStepIndex`. A checkpoint from another definition id or revision, or one that fails the
+ * predicates below, is rejected instead of being repaired, because silently accepting it would
+ * replay App side effects under a different contract.
+ *
+ * @param definition - Task identity, state predicate, ordered steps and optional authorization.
+ * @param options - Fallback store plus optional clock; both are bound to their owners.
+ * @returns A frozen task with `run({ taskId, store? }, context)`.
+ * @throws TypeError At construction for an invalid identity, step list, replay policy or
+ *   duplicate step id; from `run` for a malformed request/context/store, an invalid
+ *   checkpoint, or a step whose returned state fails the predicate. Also throws when the
+ *   deadline passed, the attempt budget is exhausted, or the model-call budget cannot fund
+ *   one more attempt.
+ */
 export declare function defineDurableTask<State, App>(definition: DurableTaskDefinition<State, App>, options?: DurableTaskOptions<State>): DurableTask<State, App>;
 export type * from '../structs/kits/durable.js';
+/** Namespace object for callers that prefer one import over named helpers. */
 export declare const Durable: Readonly<{
     defineDurableTask: typeof defineDurableTask;
 }>;
+/** Allowed checkpoint lifecycle states; re-exported so hosts can validate their own stores. */
 export { durableStatuses, durableReplayPolicies } from '../structs/kits/durable.js';