@craft-ts/core 0.7.0-beta.13

package/src/lib/craft-primitive-registry.js

@@ -0,0 +1,159 @@
+import { DestroyRef, inject, InjectionToken, } from './host/craft-compat';
+import { ɵHOST_TAG_LIST } from './craft-service';
+export class CraftPrimitiveRegistry {
+    entries = new Map();
+    occurrences = new Map();
+    primedValues = new Map();
+    /** Public primitive ref → address, so a caller can name what it holds. */
+    addresses = new WeakMap();
+    /** Associates the ref an application holds with its registered address. */
+    link(ref, address) {
+        if (ref !== null &&
+            (typeof ref === 'object' || typeof ref === 'function')) {
+            this.addresses.set(ref, address);
+        }
+    }
+    /**
+     * The address of a primitive from the ref an application holds — how a
+     * feature names a primitive declared outside the host it is scoped to.
+     */
+    addressOf(ref) {
+        return ref !== null &&
+            (typeof ref === 'object' || typeof ref === 'function')
+            ? this.addresses.get(ref)
+            : undefined;
+    }
+    /**
+     * Registers one instance under `base`, suffixed with an occurrence number.
+     *
+     * The counter only ever grows: an address is never handed out twice, even
+     * after the instance holding it is destroyed. A snapshot captured against
+     * `…#2` can therefore never be restored into a different primitive that
+     * happened to take the freed slot — it simply finds nothing.
+     */
+    register(base, entry) {
+        const occurrence = (this.occurrences.get(base) ?? 0) + 1;
+        this.occurrences.set(base, occurrence);
+        const address = `${base}#${occurrence}`;
+        const registered = { ...entry, address };
+        this.entries.set(address, registered);
+        if (this.primedValues.has(address)) {
+            registered.write(this.primedValues.get(address));
+            this.primedValues.delete(address);
+        }
+        return {
+            address,
+            release: () => {
+                if (this.entries.get(address) === registered) {
+                    this.entries.delete(address);
+                }
+            },
+        };
+    }
+    list() {
+        return [...this.entries.values()];
+    }
+    get(address) {
+        return this.entries.get(address);
+    }
+    /**
+     * Every entry whose host-tag chain starts with `hostTags` — the primitives a
+     * given host owns, transitively. An empty prefix matches the whole app.
+     */
+    under(hostTags) {
+        return this.list().filter((entry) => hostTags.every((tag, index) => entry.hostTags[index] === tag));
+    }
+    /**
+     * Reads the current value of the given entries. A primitive that throws on
+     * read (a suspended resource, a computation in error) contributes nothing
+     * rather than failing the whole capture.
+     */
+    capture(entries = this.list()) {
+        const snapshot = {};
+        for (const entry of entries) {
+            try {
+                snapshot[entry.address] = entry.read();
+            }
+            catch {
+                // A value that cannot be read cannot be restored either.
+            }
+        }
+        return snapshot;
+    }
+    /**
+     * Writes a captured snapshot back. Addresses the registry no longer knows
+     * are skipped: a row that has been destroyed since the capture has nothing
+     * to restore into.
+     */
+    restore(snapshot) {
+        for (const [address, value] of Object.entries(snapshot)) {
+            this.entries.get(address)?.write(value);
+        }
+    }
+    /**
+     * Restores current entries and remembers future ones. Used by hydration,
+     * where primitives are constructed during the first component render.
+     */
+    prime(snapshot) {
+        for (const [address, value] of Object.entries(snapshot)) {
+            const entry = this.entries.get(address);
+            if (entry) {
+                entry.write(value);
+            }
+            else {
+                this.primedValues.set(address, value);
+            }
+        }
+    }
+}
+export const CRAFT_PRIMITIVE_REGISTRY = new InjectionToken('CRAFT_PRIMITIVE_REGISTRY', {
+    providedIn: 'root',
+    factory: () => new CraftPrimitiveRegistry(),
+});
+/** Builds the address of a primitive from its host chain and its own name. */
+export function ɵcraftPrimitiveAddress(hostTags, kind, name) {
+    return [...hostTags, `${kind}:${name}`].join(' / ');
+}
+/**
+ * Registers a primitive instance so tooling can read and write it by address.
+ * Called by the primitives themselves at creation; a no-op when no injection
+ * context is available, so a primitive built outside one keeps working.
+ */
+export function ɵregisterCraftPrimitive(options) {
+    const resolve = (token, fallback) => {
+        try {
+            return options.injector
+                ? (options.injector.get(token, fallback) ?? fallback)
+                : (inject(token, { optional: true }) ?? fallback);
+        }
+        catch {
+            return fallback;
+        }
+    };
+    const registry = resolve(CRAFT_PRIMITIVE_REGISTRY, null);
+    if (!registry)
+        return { link: () => undefined };
+    const hostTags = resolve(ɵHOST_TAG_LIST, []);
+    const { address, release } = registry.register(ɵcraftPrimitiveAddress(hostTags, options.kind, options.name), {
+        kind: options.kind,
+        name: options.name,
+        hostTags,
+        read: options.read,
+        write: options.write,
+        ...(options.reload ? { reload: options.reload } : {}),
+        ...(options.status ? { status: options.status } : {}),
+        ...(options.error ? { error: options.error } : {}),
+    });
+    let destroyRef = null;
+    try {
+        destroyRef = options.injector
+            ? options.injector.get(DestroyRef, null)
+            : (inject(DestroyRef, { optional: true }) ?? null);
+    }
+    catch {
+        destroyRef = null;
+    }
+    destroyRef?.onDestroy(release);
+    return { link: (ref) => registry.link(ref, address) };
+}
+//# sourceMappingURL=craft-primitive-registry.js.map

package/src/lib/craft-primitive-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"craft-primitive-registry.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/craft-primitive-registry.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  DestroyRef,\n  inject,\n  InjectionToken,\n  type Injector,\n} from './host/craft-compat';\nimport { ɵHOST_TAG_LIST } from './craft-service';\n\n/**\n * Primitives that hold a value the registry can read back and write into.\n * `source$` is deliberately absent: an event stream has no state to restore.\n */\nexport type CraftPrimitiveKind =\n  | 'state'\n  | 'query'\n  | 'mutation'\n  | 'asyncProcess'\n  | 'queryParams';\n\n/**\n * One addressable primitive instance.\n *\n * The address is the host-tag chain plus the primitive's own name, which is\n * already unique per INSTANCE: `provideHostName` stamps a creation ordinal on\n * every component tag, so two rows of the same list read as\n * `component:Row#1 / …` and `component:Row#2 / …`.\n *\n * That ordinal is stable for the lifetime of a session but not across reloads,\n * and a row destroyed and re-created takes a new one. It is enough to replay a\n * machine inside one session; it is not a persistence key.\n */\nexport type CraftPrimitiveEntry = Readonly<{\n  address: string;\n  kind: CraftPrimitiveKind;\n  name: string;\n  hostTags: readonly string[];\n  read(): unknown;\n  write(value: unknown): void;\n  status?(): string;\n  error?(): unknown;\n  /**\n   * Re-runs the primitive's loader, when it has one. A resource the snapshot\n   * does not cover is reloaded rather than left showing data that belongs to\n   * another parameter.\n   */\n  reload?(): boolean;\n}>;\n\n/** A value snapshot of part of the registry, keyed by address. */\nexport type CraftPrimitiveSnapshot = Readonly<Record<string, unknown>>;\n\nexport class CraftPrimitiveRegistry {\n  private readonly entries = new Map<string, CraftPrimitiveEntry>();\n  private readonly occurrences = new Map<string, number>();\n  private readonly primedValues = new Map<string, unknown>();\n  /** Public primitive ref → address, so a caller can name what it holds. */\n  private readonly addresses = new WeakMap<object, string>();\n\n  /** Associates the ref an application holds with its registered address. */\n  link(ref: unknown, address: string): void {\n    if (\n      ref !== null &&\n      (typeof ref === 'object' || typeof ref === 'function')\n    ) {\n      this.addresses.set(ref as object, address);\n    }\n  }\n\n  /**\n   * The address of a primitive from the ref an application holds — how a\n   * feature names a primitive declared outside the host it is scoped to.\n   */\n  addressOf(ref: unknown): string | undefined {\n    return ref !== null &&\n      (typeof ref === 'object' || typeof ref === 'function')\n      ? this.addresses.get(ref as object)\n      : undefined;\n  }\n\n  /**\n   * Registers one instance under `base`, suffixed with an occurrence number.\n   *\n   * The counter only ever grows: an address is never handed out twice, even\n   * after the instance holding it is destroyed. A snapshot captured against\n   * `…#2` can therefore never be restored into a different primitive that\n   * happened to take the freed slot — it simply finds nothing.\n   */\n  register(\n    base: string,\n    entry: Omit<CraftPrimitiveEntry, 'address'>,\n  ): {\n    readonly address: string;\n    readonly release: () => void;\n  } {\n    const occurrence = (this.occurrences.get(base) ?? 0) + 1;\n    this.occurrences.set(base, occurrence);\n    const address = `${base}#${occurrence}`;\n    const registered: CraftPrimitiveEntry = { ...entry, address };\n    this.entries.set(address, registered);\n    if (this.primedValues.has(address)) {\n      registered.write(this.primedValues.get(address));\n      this.primedValues.delete(address);\n    }\n\n    return {\n      address,\n      release: () => {\n        if (this.entries.get(address) === registered) {\n          this.entries.delete(address);\n        }\n      },\n    };\n  }\n\n  list(): readonly CraftPrimitiveEntry[] {\n    return [...this.entries.values()];\n  }\n\n  get(address: string): CraftPrimitiveEntry | undefined {\n    return this.entries.get(address);\n  }\n\n  /**\n   * Every entry whose host-tag chain starts with `hostTags` — the primitives a\n   * given host owns, transitively. An empty prefix matches the whole app.\n   */\n  under(hostTags: readonly string[]): readonly CraftPrimitiveEntry[] {\n    return this.list().filter((entry) =>\n      hostTags.every((tag, index) => entry.hostTags[index] === tag),\n    );\n  }\n\n  /**\n   * Reads the current value of the given entries. A primitive that throws on\n   * read (a suspended resource, a computation in error) contributes nothing\n   * rather than failing the whole capture.\n   */\n  capture(\n    entries: readonly CraftPrimitiveEntry[] = this.list(),\n  ): CraftPrimitiveSnapshot {\n    const snapshot: Record<string, unknown> = {};\n    for (const entry of entries) {\n      try {\n        snapshot[entry.address] = entry.read();\n      } catch {\n        // A value that cannot be read cannot be restored either.\n      }\n    }\n    return snapshot;\n  }\n\n  /**\n   * Writes a captured snapshot back. Addresses the registry no longer knows\n   * are skipped: a row that has been destroyed since the capture has nothing\n   * to restore into.\n   */\n  restore(snapshot: CraftPrimitiveSnapshot): void {\n    for (const [address, value] of Object.entries(snapshot)) {\n      this.entries.get(address)?.write(value);\n    }\n  }\n\n  /**\n   * Restores current entries and remembers future ones. Used by hydration,\n   * where primitives are constructed during the first component render.\n   */\n  prime(snapshot: CraftPrimitiveSnapshot): void {\n    for (const [address, value] of Object.entries(snapshot)) {\n      const entry = this.entries.get(address);\n      if (entry) {\n        entry.write(value);\n      } else {\n        this.primedValues.set(address, value);\n      }\n    }\n  }\n}\n\nexport const CRAFT_PRIMITIVE_REGISTRY =\n  new InjectionToken<CraftPrimitiveRegistry>('CRAFT_PRIMITIVE_REGISTRY', {\n    providedIn: 'root',\n    factory: () => new CraftPrimitiveRegistry(),\n  });\n\n/** Builds the address of a primitive from its host chain and its own name. */\nexport function ɵcraftPrimitiveAddress(\n  hostTags: readonly string[],\n  kind: CraftPrimitiveKind,\n  name: string,\n): string {\n  return [...hostTags, `${kind}:${name}`].join(' / ');\n}\n\ntype RegisterOptions = Readonly<{\n  kind: CraftPrimitiveKind;\n  name: string;\n  read(): unknown;\n  write(value: unknown): void;\n  reload?(): boolean;\n  status?(): string;\n  error?(): unknown;\n  /** Resolved from the ambient injection context when omitted. */\n  injector?: Injector;\n}>;\n\n/** What a primitive gets back from registering itself. */\nexport type CraftPrimitiveRegistration = Readonly<{\n  /** Associates the public ref with this registration. */\n  link(ref: unknown): void;\n}>;\n\n/**\n * Registers a primitive instance so tooling can read and write it by address.\n * Called by the primitives themselves at creation; a no-op when no injection\n * context is available, so a primitive built outside one keeps working.\n */\nexport function ɵregisterCraftPrimitive(\n  options: RegisterOptions,\n): CraftPrimitiveRegistration {\n  const resolve = <T>(token: InjectionToken<T>, fallback: T): T => {\n    try {\n      return options.injector\n        ? (options.injector.get(token, fallback) ?? fallback)\n        : (inject(token, { optional: true }) ?? fallback);\n    } catch {\n      return fallback;\n    }\n  };\n\n  const registry = resolve(\n    CRAFT_PRIMITIVE_REGISTRY,\n    null as never,\n  ) as CraftPrimitiveRegistry | null;\n  if (!registry) return { link: () => undefined };\n\n  const hostTags = resolve(\n    ɵHOST_TAG_LIST as unknown as InjectionToken<readonly string[]>,\n    [] as readonly string[],\n  );\n\n  const { address, release } = registry.register(\n    ɵcraftPrimitiveAddress(hostTags, options.kind, options.name),\n    {\n      kind: options.kind,\n      name: options.name,\n      hostTags,\n      read: options.read,\n      write: options.write,\n      ...(options.reload ? { reload: options.reload } : {}),\n      ...(options.status ? { status: options.status } : {}),\n      ...(options.error ? { error: options.error } : {}),\n    },\n  );\n\n  let destroyRef: DestroyRef | null = null;\n  try {\n    destroyRef = options.injector\n      ? options.injector.get(DestroyRef, null)\n      : (inject(DestroyRef, { optional: true }) ?? null);\n  } catch {\n    destroyRef = null;\n  }\n  destroyRef?.onDestroy(release);\n\n  return { link: (ref: unknown) => registry.link(ref, address) };\n}\n"]}

package/src/lib/craft-program-operators.d.ts

@@ -0,0 +1,101 @@
+import { type AnyCraftException, type ExcludeByCode, type ExtractCraftException, type StripCraftException } from './craft-exception';
+import { type CraftGenExceptionMarker, type ExtractCraftGenExceptions } from './craft-gen';
+import { type CraftTemporalSchedule, type RuntimeTemporalAwaitRequest } from './temporal-runtime';
+/**
+ * A program operator: takes the piped program and returns the derived one.
+ * `YIn`/`AIn` are the source program's yields (markers included) and success
+ * value; `YOut`/`AOut` the derived program's. Use it to type custom operators:
+ *
+ * ```ts
+ * const swallowAll: CraftProgramOperator<Y, A, Y, A | undefined> = (program) => ...
+ * ```
+ */
+export type CraftProgramOperator<YIn, AIn, YOut, AOut> = (program: Generator<YIn, AIn, unknown>) => Generator<YOut, AOut, unknown>;
+/** `Yielded` with the phantom exception markers removed (real runtime yields). */
+type StripGenExceptionMarkers<Yielded> = Exclude<Yielded, CraftGenExceptionMarker<any>>;
+/** Rebuilds a marker for `Exception`, or `never` when nothing remains to advertise. */
+type MarkerFor<Exception> = [Exception] extends [never] ? never : CraftGenExceptionMarker<Exception>;
+type HandlerGen = (exception: any) => Generator<any, any, unknown>;
+type HandlerYielded<Handler> = Handler extends (...args: any[]) => Generator<infer Yielded, any, any> ? Yielded : never;
+type HandlerOutput<Handler> = Handler extends (...args: any[]) => Generator<any, infer Output, any> ? Output : never;
+/** The exceptions a handler may itself produce (nested programs + returned exceptions). */
+type HandlerExceptions<HYielded, HOutput> = Extract<ExtractCraftGenExceptions<HYielded> | ExtractCraftException<HOutput>, AnyCraftException>;
+/**
+ * Compile-time exhaustiveness of a `catchTag.exhaustive` map, checked at the
+ * `.pipe` application site (the program's exception union is only known
+ * there): every reachable code needs a handler, and no handler may target an
+ * unreachable code. On violation the operator's program parameter collapses to
+ * an impossible intersection whose property name spells out the problem.
+ */
+/**
+ * Shared exact-code check used by program and component catchTag adapters.
+ *
+ * The handler value is intentionally not part of this type: each consumer
+ * has a different handler contract (generators for programs, template
+ * children for components), but the reachable-code rules are identical.
+ */
+export type CatchTagExhaustiveCodesCheck<Codes extends PropertyKey, Handlers> = [Exclude<Codes, keyof Handlers>] extends [never] ? [Exclude<keyof Handlers, Codes>] extends [never] ? unknown : {
+    'catchTag.exhaustive has handlers for unreachable codes': Exclude<keyof Handlers, Codes>;
+} : {
+    'catchTag.exhaustive is missing handlers for codes': Exclude<Codes, keyof Handlers>;
+};
+export type CatchTagExhaustiveHandlersCheck<Exception extends AnyCraftException, Handlers> = CatchTagExhaustiveCodesCheck<Exception['_tag'], Handlers>;
+type ExhaustiveHandlersYielded<Handlers> = {
+    [K in keyof Handlers]: HandlerYielded<Handlers[K]>;
+}[keyof Handlers];
+type ExhaustiveHandlersOutput<Handlers> = {
+    [K in keyof Handlers]: HandlerOutput<Handlers[K]>;
+}[keyof Handlers];
+type ExhaustiveHandlersExceptions<Handlers> = {
+    [K in keyof Handlers]: HandlerExceptions<HandlerYielded<Handlers[K]>, HandlerOutput<Handlers[K]>>;
+}[keyof Handlers];
+interface CatchTagOperator {
+    /**
+     * Catches the program's `craftException` of `code`: the handler generator
+     * runs in its place (its yields — craft services, nested programs,
+     * `craftUntilSettled` — are relayed to the driver, so its dependencies stay
+     * tracked) and its success value widens the program's. `code` is removed
+     * from the program's exception union; exceptions the handler itself
+     * produces are added to it.
+     */
+    <const Code extends string, HYielded, HOutput>(code: Code, handler: (exception: AnyCraftException & {
+        code: Code;
+    }) => Generator<HYielded, HOutput, unknown>): <YIn, AIn>(program: Generator<YIn, AIn, unknown>) => Generator<StripGenExceptionMarkers<YIn> | StripGenExceptionMarkers<HYielded> | MarkerFor<Extract<ExcludeByCode<ExtractCraftGenExceptions<YIn>, Code>, AnyCraftException> | HandlerExceptions<HYielded, HOutput>>, AIn | StripCraftException<HOutput>, unknown>;
+    /**
+     * Catches **every** reachable `craftException` of the program through a
+     * handler map covering exactly its exception union — a missing code or a
+     * handler for an unreachable code is a compile error at the `.pipe`
+     * application site. Afterwards the program's exception union is `never`
+     * (plus whatever the handlers themselves may produce).
+     */
+    exhaustive: <Handlers extends Record<string, HandlerGen>>(handlers: Handlers) => <YIn, AIn>(program: Generator<YIn, AIn, unknown> & CatchTagExhaustiveHandlersCheck<Extract<ExtractCraftGenExceptions<YIn>, AnyCraftException>, Handlers>) => Generator<StripGenExceptionMarkers<YIn> | StripGenExceptionMarkers<ExhaustiveHandlersYielded<Handlers>> | MarkerFor<Extract<ExhaustiveHandlersExceptions<Handlers>, AnyCraftException>>, AIn | StripCraftException<ExhaustiveHandlersOutput<Handlers>>, unknown>;
+}
+export declare const catchTag: CatchTagOperator;
+/**
+ * Retry policy for {@link retry}:
+ * - `times` — maximum number of *re*-executions after the initial attempt;
+ * - `while` — only retry these exception codes (all when omitted);
+ * - `backoff`/`delayMs` — wait between attempts: `delayMs` flat (`'none'`,
+ *   the default), `delayMs * attempt` (`'linear'`) or `delayMs * 2^(attempt-1)`
+ *   (`'exponential'`). No wait when `delayMs` is omitted.
+ */
+export type CraftRetryPolicy = {
+    times: number;
+    while?: string[];
+    backoff?: 'none' | 'linear' | 'exponential';
+    delayMs?: number;
+    schedule?: CraftTemporalSchedule;
+};
+/**
+ * Re-executes the program when it fails with a matched `craftException`, up to
+ * `policy.times` extra attempts, then rethrows. Each re-execution replays the
+ * whole upstream `.pipe` chain from the source invocation.
+ *
+ * A non-zero backoff suspends between attempts through an await-request, so it
+ * needs an async driver (a route chain or a primitive loader) — in a purely
+ * synchronous context (`craftUse`, live guard re-check) the suspension raises
+ * the driver's usual await-not-supported/pending behaviour.
+ */
+export declare function retry(policy: CraftRetryPolicy): <YIn, AIn>(program: Generator<YIn, AIn, unknown>) => Generator<YIn | RuntimeTemporalAwaitRequest, AIn, unknown>;
+export {};
+//# sourceMappingURL=craft-program-operators.d.ts.map

package/src/lib/craft-program-operators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"craft-program-operators.d.ts","sourceRoot":"","sources":["../../../../../libs/core/src/lib/craft-program-operators.ts"],"names":[],"mappings":"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"}

package/src/lib/craft-program-operators.js

@@ -0,0 +1,116 @@
+import { isCraftException, } from './craft-exception';
+import { CraftGenShortCircuit, isCraftGenShortCircuit, ɵgetCraftProgramRecreate, } from './craft-gen';
+import { createTemporalSleepRequest, exponentialTemporalSchedule, } from './temporal-runtime';
+import { GUARD_AWAIT_REQUEST_MARKER, isGenerator, } from './craft-generator-runtime';
+const RETRY_REQUIRES_PROGRAM_ERROR_MESSAGE = 'retry(...) needs a re-invocable craft program (a craftGen invocation or a .pipe stage); a bare generator cannot be replayed.';
+function runHandlerOutput(output) {
+    if (isCraftException(output)) {
+        // A handler that resolves to a `craftException` re-enters the exception
+        // channel (mirrors craftGen's own return contract).
+        throw new CraftGenShortCircuit(output);
+    }
+    return output;
+}
+function* catchWithLookup(program, lookupHandler) {
+    try {
+        return yield* program;
+    }
+    catch (error) {
+        if (!isCraftGenShortCircuit(error)) {
+            throw error;
+        }
+        const handler = lookupHandler(error.exception._tag);
+        if (!handler) {
+            throw error;
+        }
+        const result = handler(error.exception);
+        const output = isGenerator(result) ? yield* result : result;
+        return runHandlerOutput(output);
+    }
+}
+function catchTagImpl(code, handler) {
+    return (program) => catchWithLookup(program, (thrownCode) => thrownCode === code ? handler : undefined);
+}
+function catchTagExhaustiveImpl(handlers) {
+    return (program) => 
+    // An unknown code (outside the typed union) finds no handler and is
+    // rethrown — the safety net for exceptions that escaped the types.
+    catchWithLookup(program, (thrownCode) => handlers[thrownCode]);
+}
+export const catchTag = Object.assign(catchTagImpl, {
+    exhaustive: catchTagExhaustiveImpl,
+});
+function retrySchedule(policy) {
+    if (policy.schedule)
+        return policy.schedule;
+    const base = policy.delayMs ?? 0;
+    if (policy.backoff === 'exponential') {
+        return exponentialTemporalSchedule(base, { maxAttempts: policy.times });
+    }
+    return {
+        next: ({ attempt }) => attempt > policy.times
+            ? { done: true }
+            : {
+                done: false,
+                delayMs: policy.backoff === 'linear' ? base * attempt : base,
+            },
+    };
+}
+function delayAwaitRequest(delayMs) {
+    return Object.assign(createTemporalSleepRequest(delayMs), {
+        [GUARD_AWAIT_REQUEST_MARKER]: true,
+        kind: 'promise',
+        value: Promise.resolve(),
+    });
+}
+/**
+ * Re-executes the program when it fails with a matched `craftException`, up to
+ * `policy.times` extra attempts, then rethrows. Each re-execution replays the
+ * whole upstream `.pipe` chain from the source invocation.
+ *
+ * A non-zero backoff suspends between attempts through an await-request, so it
+ * needs an async driver (a route chain or a primitive loader) — in a purely
+ * synchronous context (`craftUse`, live guard re-check) the suspension raises
+ * the driver's usual await-not-supported/pending behaviour.
+ */
+export function retry(policy) {
+    return (program) => (function* () {
+        let attempt = 0;
+        const schedule = retrySchedule(policy);
+        let current = program;
+        for (;;) {
+            try {
+                return yield* current;
+            }
+            catch (error) {
+                if (!isCraftGenShortCircuit(error)) {
+                    throw error;
+                }
+                if (policy.while && !policy.while.includes(error.exception._tag)) {
+                    throw error;
+                }
+                if (attempt >= policy.times) {
+                    throw error;
+                }
+                const recreate = ɵgetCraftProgramRecreate(program);
+                if (!recreate) {
+                    throw new Error(RETRY_REQUIRES_PROGRAM_ERROR_MESSAGE);
+                }
+                attempt += 1;
+                const decision = schedule.next({
+                    attempt,
+                    elapsedMs: 0,
+                    error: error.exception,
+                });
+                if (decision.done)
+                    throw error;
+                const delayMs = decision.delayMs;
+                if (delayMs > 0) {
+                    yield delayAwaitRequest(delayMs);
+                }
+                current = recreate();
+            }
+        }
+    })();
+}
+//# sourceMappingURL=craft-program-operators.js.map

package/src/lib/craft-program-operators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"craft-program-operators.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/craft-program-operators.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  isCraftException,\n  type AnyCraftException,\n  type ExcludeByCode,\n  type ExtractCraftException,\n  type StripCraftException,\n} from './craft-exception';\nimport {\n  CraftGenShortCircuit,\n  isCraftGenShortCircuit,\n  ɵgetCraftProgramRecreate,\n  type CraftGenExceptionMarker,\n  type ExtractCraftGenExceptions,\n} from './craft-gen';\nimport {\n  createTemporalSleepRequest,\n  exponentialTemporalSchedule,\n  type CraftTemporalSchedule,\n  type RuntimeTemporalAwaitRequest,\n} from './temporal-runtime';\nimport {\n  GUARD_AWAIT_REQUEST_MARKER,\n  isGenerator,\n  type RuntimeGuardAwaitRequest,\n} from './craft-generator-runtime';\n\n// ---------------------------------------------------------------------------\n// Program operators, composed through a craft program's `.pipe(...)`:\n//\n// ```ts\n// const user = yield* loadUser(id).pipe(\n//   catchTag('NOT_FOUND', function* () { return GUEST; }),\n//   retry({ times: 3, backoff: 'exponential', delayMs: 200 }),\n// );\n// ```\n//\n// The exception union `E` of a program travels exclusively at the type level\n// (the `CraftGenExceptionMarker` in its `Yielded`); at runtime an exception is\n// a thrown `CraftGenShortCircuit`, so operators are plain generator wrappers\n// and no driver has to know about them.\n//\n// Operators are written *generator-first*: the factory (`catchTag(...)`)\n// captures only its own inputs and returns a **generic** operator, so the\n// program's `Yielded`/`Return` are inferred at the `.pipe` application site.\n// ---------------------------------------------------------------------------\n\n/**\n * A program operator: takes the piped program and returns the derived one.\n * `YIn`/`AIn` are the source program's yields (markers included) and success\n * value; `YOut`/`AOut` the derived program's. Use it to type custom operators:\n *\n * ```ts\n * const swallowAll: CraftProgramOperator<Y, A, Y, A | undefined> = (program) => ...\n * ```\n */\nexport type CraftProgramOperator<YIn, AIn, YOut, AOut> = (\n  program: Generator<YIn, AIn, unknown>,\n) => Generator<YOut, AOut, unknown>;\n\n/** `Yielded` with the phantom exception markers removed (real runtime yields). */\ntype StripGenExceptionMarkers<Yielded> = Exclude<\n  Yielded,\n  CraftGenExceptionMarker<any>\n>;\n\n/** Rebuilds a marker for `Exception`, or `never` when nothing remains to advertise. */\ntype MarkerFor<Exception> = [Exception] extends [never]\n  ? never\n  : CraftGenExceptionMarker<Exception>;\n\ntype HandlerGen = (exception: any) => Generator<any, any, unknown>;\n\ntype HandlerYielded<Handler> = Handler extends (\n  ...args: any[]\n) => Generator<infer Yielded, any, any>\n  ? Yielded\n  : never;\n\ntype HandlerOutput<Handler> = Handler extends (\n  ...args: any[]\n) => Generator<any, infer Output, any>\n  ? Output\n  : never;\n\n/** The exceptions a handler may itself produce (nested programs + returned exceptions). */\ntype HandlerExceptions<HYielded, HOutput> = Extract<\n  ExtractCraftGenExceptions<HYielded> | ExtractCraftException<HOutput>,\n  AnyCraftException\n>;\n\nconst RETRY_REQUIRES_PROGRAM_ERROR_MESSAGE =\n  'retry(...) needs a re-invocable craft program (a craftGen invocation or a .pipe stage); a bare generator cannot be replayed.';\n\nfunction runHandlerOutput(output: unknown): unknown {\n  if (isCraftException(output)) {\n    // A handler that resolves to a `craftException` re-enters the exception\n    // channel (mirrors craftGen's own return contract).\n    throw new CraftGenShortCircuit(output);\n  }\n\n  return output;\n}\n\nfunction* catchWithLookup(\n  program: Generator<unknown, unknown, unknown>,\n  lookupHandler: (code: string) => HandlerGen | undefined,\n): Generator<unknown, unknown, unknown> {\n  try {\n    return yield* program;\n  } catch (error) {\n    if (!isCraftGenShortCircuit(error)) {\n      throw error;\n    }\n\n    const handler = lookupHandler(error.exception._tag);\n\n    if (!handler) {\n      throw error;\n    }\n\n    const result = handler(error.exception);\n    const output: unknown = isGenerator(result) ? yield* result : result;\n\n    return runHandlerOutput(output);\n  }\n}\n\n/**\n * Compile-time exhaustiveness of a `catchTag.exhaustive` map, checked at the\n * `.pipe` application site (the program's exception union is only known\n * there): every reachable code needs a handler, and no handler may target an\n * unreachable code. On violation the operator's program parameter collapses to\n * an impossible intersection whose property name spells out the problem.\n */\n/**\n * Shared exact-code check used by program and component catchTag adapters.\n *\n * The handler value is intentionally not part of this type: each consumer\n * has a different handler contract (generators for programs, template\n * children for components), but the reachable-code rules are identical.\n */\nexport type CatchTagExhaustiveCodesCheck<\n  Codes extends PropertyKey,\n  Handlers,\n> = [Exclude<Codes, keyof Handlers>] extends [never]\n  ? [Exclude<keyof Handlers, Codes>] extends [never]\n    ? unknown\n    : {\n        'catchTag.exhaustive has handlers for unreachable codes': Exclude<\n          keyof Handlers,\n          Codes\n        >;\n      }\n  : {\n      'catchTag.exhaustive is missing handlers for codes': Exclude<\n        Codes,\n        keyof Handlers\n      >;\n    };\n\nexport type CatchTagExhaustiveHandlersCheck<\n  Exception extends AnyCraftException,\n  Handlers,\n> = CatchTagExhaustiveCodesCheck<Exception['_tag'], Handlers>;\n\ntype ExhaustiveHandlersYielded<Handlers> = {\n  [K in keyof Handlers]: HandlerYielded<Handlers[K]>;\n}[keyof Handlers];\n\ntype ExhaustiveHandlersOutput<Handlers> = {\n  [K in keyof Handlers]: HandlerOutput<Handlers[K]>;\n}[keyof Handlers];\n\ntype ExhaustiveHandlersExceptions<Handlers> = {\n  [K in keyof Handlers]: HandlerExceptions<\n    HandlerYielded<Handlers[K]>,\n    HandlerOutput<Handlers[K]>\n  >;\n}[keyof Handlers];\n\ninterface CatchTagOperator {\n  /**\n   * Catches the program's `craftException` of `code`: the handler generator\n   * runs in its place (its yields — craft services, nested programs,\n   * `craftUntilSettled` — are relayed to the driver, so its dependencies stay\n   * tracked) and its success value widens the program's. `code` is removed\n   * from the program's exception union; exceptions the handler itself\n   * produces are added to it.\n   */\n  <const Code extends string, HYielded, HOutput>(\n    code: Code,\n    handler: (\n      exception: AnyCraftException & { code: Code },\n    ) => Generator<HYielded, HOutput, unknown>,\n  ): <YIn, AIn>(\n    program: Generator<YIn, AIn, unknown>,\n  ) => Generator<\n    | StripGenExceptionMarkers<YIn>\n    | StripGenExceptionMarkers<HYielded>\n    | MarkerFor<\n        | Extract<\n            ExcludeByCode<ExtractCraftGenExceptions<YIn>, Code>,\n            AnyCraftException\n          >\n        | HandlerExceptions<HYielded, HOutput>\n      >,\n    AIn | StripCraftException<HOutput>,\n    unknown\n  >;\n\n  /**\n   * Catches **every** reachable `craftException` of the program through a\n   * handler map covering exactly its exception union — a missing code or a\n   * handler for an unreachable code is a compile error at the `.pipe`\n   * application site. Afterwards the program's exception union is `never`\n   * (plus whatever the handlers themselves may produce).\n   */\n  exhaustive: <Handlers extends Record<string, HandlerGen>>(\n    handlers: Handlers,\n  ) => <YIn, AIn>(\n    program: Generator<YIn, AIn, unknown> &\n      CatchTagExhaustiveHandlersCheck<\n        Extract<ExtractCraftGenExceptions<YIn>, AnyCraftException>,\n        Handlers\n      >,\n  ) => Generator<\n    | StripGenExceptionMarkers<YIn>\n    | StripGenExceptionMarkers<ExhaustiveHandlersYielded<Handlers>>\n    | MarkerFor<\n        Extract<ExhaustiveHandlersExceptions<Handlers>, AnyCraftException>\n      >,\n    AIn | StripCraftException<ExhaustiveHandlersOutput<Handlers>>,\n    unknown\n  >;\n}\n\nfunction catchTagImpl(\n  code: string,\n  handler: HandlerGen,\n): (\n  program: Generator<unknown, unknown, unknown>,\n) => Generator<unknown, unknown, unknown> {\n  return (program) =>\n    catchWithLookup(program, (thrownCode) =>\n      thrownCode === code ? handler : undefined,\n    );\n}\n\nfunction catchTagExhaustiveImpl(\n  handlers: Record<string, HandlerGen>,\n): (\n  program: Generator<unknown, unknown, unknown>,\n) => Generator<unknown, unknown, unknown> {\n  return (program) =>\n    // An unknown code (outside the typed union) finds no handler and is\n    // rethrown — the safety net for exceptions that escaped the types.\n    catchWithLookup(program, (thrownCode) => handlers[thrownCode]);\n}\n\nexport const catchTag: CatchTagOperator = Object.assign(\n  catchTagImpl as unknown as CatchTagOperator,\n  {\n    exhaustive: catchTagExhaustiveImpl,\n  },\n) as CatchTagOperator;\n\n/**\n * Retry policy for {@link retry}:\n * - `times` — maximum number of *re*-executions after the initial attempt;\n * - `while` — only retry these exception codes (all when omitted);\n * - `backoff`/`delayMs` — wait between attempts: `delayMs` flat (`'none'`,\n *   the default), `delayMs * attempt` (`'linear'`) or `delayMs * 2^(attempt-1)`\n *   (`'exponential'`). No wait when `delayMs` is omitted.\n */\nexport type CraftRetryPolicy = {\n  times: number;\n  while?: string[];\n  backoff?: 'none' | 'linear' | 'exponential';\n  delayMs?: number;\n  schedule?: CraftTemporalSchedule;\n};\n\nfunction retrySchedule(policy: CraftRetryPolicy): CraftTemporalSchedule {\n  if (policy.schedule) return policy.schedule;\n  const base = policy.delayMs ?? 0;\n  if (policy.backoff === 'exponential') {\n    return exponentialTemporalSchedule(base, { maxAttempts: policy.times });\n  }\n  return {\n    next: ({ attempt }) =>\n      attempt > policy.times\n        ? { done: true }\n        : {\n            done: false,\n            delayMs: policy.backoff === 'linear' ? base * attempt : base,\n          },\n  };\n}\n\nfunction delayAwaitRequest(delayMs: number): RuntimeTemporalAwaitRequest {\n  return Object.assign(createTemporalSleepRequest(delayMs), {\n    [GUARD_AWAIT_REQUEST_MARKER]: true,\n    kind: 'promise' as const,\n    value: Promise.resolve(),\n  }) as unknown as RuntimeTemporalAwaitRequest & RuntimeGuardAwaitRequest;\n}\n\n/**\n * Re-executes the program when it fails with a matched `craftException`, up to\n * `policy.times` extra attempts, then rethrows. Each re-execution replays the\n * whole upstream `.pipe` chain from the source invocation.\n *\n * A non-zero backoff suspends between attempts through an await-request, so it\n * needs an async driver (a route chain or a primitive loader) — in a purely\n * synchronous context (`craftUse`, live guard re-check) the suspension raises\n * the driver's usual await-not-supported/pending behaviour.\n */\nexport function retry(\n  policy: CraftRetryPolicy,\n): <YIn, AIn>(\n  program: Generator<YIn, AIn, unknown>,\n) => Generator<YIn | RuntimeTemporalAwaitRequest, AIn, unknown> {\n  return <YIn, AIn>(program: Generator<YIn, AIn, unknown>) =>\n    (function* (): Generator<YIn | RuntimeTemporalAwaitRequest, AIn, unknown> {\n      let attempt = 0;\n      const schedule = retrySchedule(policy);\n      let current: Generator<YIn, AIn, unknown> = program;\n\n      for (;;) {\n        try {\n          return yield* current;\n        } catch (error) {\n          if (!isCraftGenShortCircuit(error)) {\n            throw error;\n          }\n\n          if (policy.while && !policy.while.includes(error.exception._tag)) {\n            throw error;\n          }\n\n          if (attempt >= policy.times) {\n            throw error;\n          }\n\n          const recreate = ɵgetCraftProgramRecreate(program);\n\n          if (!recreate) {\n            throw new Error(RETRY_REQUIRES_PROGRAM_ERROR_MESSAGE);\n          }\n\n          attempt += 1;\n\n          const decision = schedule.next({\n            attempt,\n            elapsedMs: 0,\n            error: error.exception,\n          });\n          if (decision.done) throw error;\n          const delayMs = decision.delayMs;\n\n          if (delayMs > 0) {\n            yield delayAwaitRequest(delayMs) as never;\n          }\n\n          current = recreate() as Generator<YIn, AIn, unknown>;\n        }\n      }\n    })();\n}\n"]}

package/src/lib/craft-program-runtime.d.ts

@@ -0,0 +1,80 @@
+import { Injector } from './host/craft-compat';
+import type { AnyCraftException } from './craft-exception';
+import { type RuntimeAwaitRequest } from './craft-generator-runtime';
+/** What a foreign yield settled to, once its bridge resolved it. */
+export type ForeignYieldOutcome = {
+    kind: 'value';
+    value: unknown;
+} | {
+    kind: 'exception';
+    exception: AnyCraftException;
+};
+/** The context a bridge needs in order to resolve and run a foreign yield. */
+export type ForeignYieldContext = {
+    /**
+     * The injector of the program that yielded. A bridge resolves its runtime
+     * from here, which is what makes per-route runtimes and their inheritance
+     * possible at all.
+     */
+    readonly injector: Injector;
+    /** Aborted when the owning program is superseded or destroyed. */
+    readonly abortSignal?: AbortSignal;
+};
+/**
+ * Returns a promise for yields it recognises, `undefined` for everything else
+ * (which then falls through to the usual invalid-yield error).
+ */
+export type ForeignYieldBridge = (yielded: unknown, context: ForeignYieldContext) => PromiseLike<ForeignYieldOutcome> | undefined;
+/** Registers the bridge; returns a disposer restoring the previous one. */
+export declare function setForeignYieldBridge(bridge: ForeignYieldBridge): () => void;
+/** @deprecated Prototype spelling, kept for the wave-0 fixtures. */
+export declare const ɵsetForeignYieldBridge: typeof setForeignYieldBridge;
+/** A program's driver step: settled (`done`/`shortCircuit`) or suspended on an await. */
+export type CraftProgramStep = {
+    kind: 'done';
+    value: unknown;
+} | {
+    kind: 'await';
+    request: RuntimeAwaitRequest;
+} | {
+    kind: 'shortCircuit';
+    exception: AnyCraftException;
+};
+/** A settled program step (the `await` suspension already driven through). */
+export type CraftProgramSettledStep = Exclude<CraftProgramStep, {
+    kind: 'await';
+}>;
+export type CraftProgramPumpOptions = {
+    /** Error raised when the program yields something the driver cannot resolve. */
+    invalidYieldErrorMessage: string;
+    /**
+     * When set, an `onAppStart(...)` yield raises this dedicated error instead of
+     * the generic invalid-yield one (primitive loaders keep their historical
+     * message); when omitted, an app-start yield falls through to
+     * `invalidYieldErrorMessage` (route guards).
+     */
+    appStartNotSupportedErrorMessage?: string;
+    /** Abort signal for temporal awaits owned by the current async program. */
+    abortSignal?: AbortSignal;
+};
+export declare function pumpCraftProgramSync(iterator: Generator<unknown, unknown, unknown>, injector: Injector, options: CraftProgramPumpOptions, resumeValue?: unknown): CraftProgramStep;
+export declare function awaitCraftProgramRequest(request: RuntimeAwaitRequest, injector: Injector, abortSignal?: AbortSignal): Promise<unknown>;
+export declare function driveCraftProgramAsync(iterator: Generator<unknown, unknown, unknown>, injector: Injector, step: CraftProgramStep, options: CraftProgramPumpOptions): Promise<CraftProgramSettledStep>;
+/**
+ * Async counterpart of `executeGeneratorCompatibleFactory`: same contract (a
+ * factory that returns either a plain value or a craft generator), but the
+ * generator path is driven by the async program pump — `craftUntilSettled` /
+ * `craftUntilDefined` awaits suspend instead of erroring, and a
+ * `CraftGenShortCircuit` settles as a `shortCircuit` step instead of throwing.
+ * The `done` value is awaited (generator loaders may return a bare promise).
+ */
+export declare function executeGeneratorCompatibleFactoryAsync<This, Args extends unknown[], Result>({ factory, thisArg, getInjector, args, invalidYieldErrorMessage, appStartNotSupportedErrorMessage, abortSignal, }: {
+    factory: (this: This, ...args: Args) => Result;
+    thisArg: This;
+    getInjector: () => Injector | object;
+    args: Args;
+    invalidYieldErrorMessage: string;
+    appStartNotSupportedErrorMessage?: string;
+    abortSignal?: AbortSignal;
+}): Promise<CraftProgramSettledStep>;
+//# sourceMappingURL=craft-program-runtime.d.ts.map

package/src/lib/craft-program-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"craft-program-runtime.d.ts","sourceRoot":"","sources":["../../../../../libs/core/src/lib/craft-program-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,QAAQ,EAET,MAAM,qBAAqB,CAAC;AAG7B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE3D,OAAO,EAOL,KAAK,mBAAmB,EACzB,MAAM,2BAA2B,CAAC;AAqCnC,oEAAoE;AACpE,MAAM,MAAM,mBAAmB,GAC3B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,SAAS,EAAE,iBAAiB,CAAA;CAAE,CAAC;AAgBxD,8EAA8E;AAC9E,MAAM,MAAM,mBAAmB,GAAG;IAChC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,kEAAkE;IAClE,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC;CACpC,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAC/B,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,mBAAmB,KACzB,WAAW,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAAC;AAIlD,2EAA2E;AAC3E,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,IAAI,CAM5E;AAED,oEAAoE;AACpE,eAAO,MAAM,sBAAsB,8BAAwB,CAAC;AAE5D,yFAAyF;AACzF,MAAM,MAAM,gBAAgB,GACxB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,mBAAmB,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,SAAS,EAAE,iBAAiB,CAAA;CAAE,CAAC;AAE3D,8EAA8E;AAC9E,MAAM,MAAM,uBAAuB,GAAG,OAAO,CAC3C,gBAAgB,EAChB;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAClB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,gFAAgF;IAChF,wBAAwB,EAAE,MAAM,CAAC;IACjC;;;;;OAKG;IACH,gCAAgC,CAAC,EAAE,MAAM,CAAC;IAC1C,2EAA2E;IAC3E,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,CAAC;AAQF,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAC9C,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,uBAAuB,EAChC,WAAW,CAAC,EAAE,OAAO,GACpB,gBAAgB,CAsElB;AAcD,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,mBAAmB,EAC5B,QAAQ,EAAE,QAAQ,EAClB,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,OAAO,CAAC,CAuClB;AAMD,wBAAsB,sBAAsB,CAC1C,QAAQ,EAAE,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAC9C,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,uBAAuB,CAAC,CAkBlC;AAED;;;;;;;GAOG;AACH,wBAAsB,sCAAsC,CAC1D,IAAI,EACJ,IAAI,SAAS,OAAO,EAAE,EACtB,MAAM,EACN,EACA,OAAO,EACP,OAAO,EACP,WAAW,EACX,IAAI,EACJ,wBAAwB,EACxB,gCAAgC,EAChC,WAAW,GACZ,EAAE;IACD,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,IAAI,KAAK,MAAM,CAAC;IAC/C,OAAO,EAAE,IAAI,CAAC;IACd,WAAW,EAAE,MAAM,QAAQ,GAAG,MAAM,CAAC;IACrC,IAAI,EAAE,IAAI,CAAC;IACX,wBAAwB,EAAE,MAAM,CAAC;IACjC,gCAAgC,CAAC,EAAE,MAAM,CAAC;IAC1C,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,GAAG,OAAO,CAAC,uBAAuB,CAAC,CA6BnC"}