@craft-ts/core 0.7.0-beta.13

package/src/lib/craft-machine-history.js

@@ -0,0 +1,276 @@
+import { inject } from './host/craft-compat';
+import { craftComputed as createCraftComputed, craftSignal } from './host/craft-signal';
+import { StorageService } from './browser-boundaries';
+import { CRAFT_PRIMITIVE_REGISTRY, } from './craft-primitive-registry';
+import { ɵwithCraftReplay } from './craft-replay';
+import { createYieldableReactiveValue, isYieldableReactiveValue, rawReactiveValue, } from './reactive-read';
+/** Reserved prefix for the primitives named through `include`. */
+const EXTERNAL_KEY_PREFIX = '#include/';
+const DEFAULT_LIMIT = 50;
+export function withStateMachineHistory(optionsOrFeature, ...rest) {
+    const options = typeof optionsOrFeature === 'function' || optionsOrFeature === undefined
+        ? {}
+        : optionsOrFeature;
+    const features = typeof optionsOrFeature === 'function'
+        ? [optionsOrFeature, ...rest]
+        : rest;
+    const limit = options.limit ?? DEFAULT_LIMIT;
+    return function* ({ currentStep, machine }) {
+        const storage = yield* StorageService();
+        const registry = inject(CRAFT_PRIMITIVE_REGISTRY);
+        const persistence = options.persist;
+        const storageKey = persistence
+            ? `craft-ts-${persistence.storeName}-history-${typeof persistence.key === 'function'
+                ? persistence.key()
+                : persistence.key}`
+            : undefined;
+        const restored = readPersisted(storage, storageKey);
+        const entries = craftSignal(restored?.entries ?? []);
+        const cursor = craftSignal(restored?.cursor ?? 0);
+        const includedRefs = options.include ?? [];
+        const machinePrefix = machine.hostTags.join(' / ');
+        /**
+         * Keys an entry relative to the machine, re-indexing occurrences within
+         * the current set rather than reusing the registry's global counter. That
+         * counter only ever grows, so it would drift the moment a machine is
+         * destroyed and rebuilt inside the same host — and a persisted key must not
+         * depend on how many times the page has already built this primitive.
+         */
+        const relativeKeys = () => {
+            const seen = new Map();
+            return registry.under(machine.hostTags).map((entry) => {
+                const base = stripOccurrence(entry.address).slice(machinePrefix.length === 0 ? 0 : machinePrefix.length + 3);
+                const occurrence = (seen.get(base) ?? 0) + 1;
+                seen.set(base, occurrence);
+                return { entry, key: `${base}#${occurrence}` };
+            });
+        };
+        const capture = () => {
+            const snapshot = {};
+            for (const { entry, key } of relativeKeys()) {
+                const captured = registry.capture([entry]);
+                if (entry.address in captured && isRecordable(entry, captured[entry.address])) {
+                    snapshot[key] = captured[entry.address];
+                }
+            }
+            // Primitives declared outside the machine are keyed by their position in
+            // the declared `include` list, which is stable by construction.
+            includedRefs.forEach((ref, index) => {
+                const address = registry.addressOf(ref);
+                const entry = address ? registry.get(address) : undefined;
+                if (!entry)
+                    return;
+                const captured = registry.capture([entry]);
+                if (entry.address in captured && isRecordable(entry, captured[entry.address])) {
+                    snapshot[`${EXTERNAL_KEY_PREFIX}${index}`] = captured[entry.address];
+                }
+            });
+            return snapshot;
+        };
+        /** Resolves relative keys back onto the primitives present right now. */
+        const restore = (snapshot) => {
+            const current = new Map(relativeKeys().map(({ entry, key }) => [key, entry]));
+            const writes = [];
+            for (const [key, value] of Object.entries(snapshot)) {
+                const entry = key.startsWith(EXTERNAL_KEY_PREFIX)
+                    ? externalEntry(Number(key.slice(EXTERNAL_KEY_PREFIX.length)))
+                    : current.get(key);
+                if (entry)
+                    writes.push({ entry, value });
+            }
+            // The whole restore runs under the replay flag, so a resource claims its
+            // restored parameter without reloading over the value being restored
+            // with it — and so tooling can tell a rewind from user activity.
+            ɵwithCraftReplay(() => {
+                for (const { entry, value } of writes) {
+                    entry.write(value);
+                }
+            });
+            // A resource the snapshot does not cover was still loading when the
+            // moment was recorded, so there is no value to put back. Left frozen it
+            // would keep showing what belongs to another parameter; reloading it is
+            // the honest answer.
+            const restored = new Set(writes.map(({ entry }) => entry.address));
+            for (const entry of registry.under(machine.hostTags)) {
+                if (entry.kind === 'state' || restored.has(entry.address))
+                    continue;
+                entry.reload?.();
+            }
+        };
+        const externalEntry = (index) => {
+            const address = registry.addressOf(includedRefs[index]);
+            return address ? registry.get(address) : undefined;
+        };
+        const append = (entry) => {
+            // A moment identical to the one the machine already sits on is not a
+            // moment. Remounting a component — or reloading a page onto a machine
+            // that starts where it left off — would otherwise stack the same state
+            // over and over, and `back()` would walk through duplicates.
+            if (isSameMoment(entries()[cursor()], entry))
+                return;
+            entries.update((current) => {
+                // Recording after a rewind drops the forward entries: the machine took
+                // a different branch, and keeping the old one would let `forward()`
+                // walk into a future that no longer happened.
+                const kept = current.slice(0, cursor() + 1);
+                const next = [...kept, entry];
+                return next.length > limit ? next.slice(next.length - limit) : next;
+            });
+            cursor.set(entries().length - 1);
+            writePersisted(storage, storageKey, entries(), cursor());
+        };
+        // The machine has already taken its initial step by the time an insertion
+        // runs, so the first entry records where it started.
+        const initialStep = readRaw(currentStep);
+        if (initialStep === undefined) {
+            throw new Error('Cannot create history for an uninitialised state machine.');
+        }
+        append({
+            step: initialStep,
+            from: undefined,
+            event: undefined,
+            at: Date.now(),
+            snapshot: capture(),
+        });
+        machine.onTransition((transition) => {
+            if (!transition.accepted)
+                return;
+            append({
+                step: transition.to,
+                from: transition.from,
+                event: transition.event,
+                at: Date.now(),
+                snapshot: capture(),
+            });
+        });
+        const goTo = (index) => {
+            const recorded = entries();
+            const entry = recorded[index];
+            if (!entry)
+                return false;
+            machine.suspended(() => {
+                restore(entry.snapshot);
+                ɵwithCraftReplay(() => machine.restoreStep(entry.step));
+            });
+            cursor.set(index);
+            writePersisted(storage, storageKey, entries(), cursor());
+            return true;
+        };
+        const entriesReader = createYieldableReactiveValue(entries.asReadonly(), 'entries');
+        const cursorReader = createYieldableReactiveValue(cursor.asReadonly(), 'cursor');
+        const featureContext = {
+            entries: entriesReader,
+            cursor: cursorReader,
+            goTo,
+            controls: machine,
+        };
+        return Object.assign({
+            history: createYieldableReactiveValue(entries.asReadonly(), 'history'),
+            historyCursor: createYieldableReactiveValue(cursor.asReadonly(), 'historyCursor'),
+        }, ...features.map((feature) => feature(featureContext)));
+    };
+}
+/**
+ * Step-by-step navigation through a machine's history. Composes into
+ * {@link withStateMachineHistory}, which owns the entries it walks:
+ *
+ * ```ts
+ * withStateMachineHistory(withBackNavigation())
+ * ```
+ *
+ * `back()` and `forward()` restore a recorded moment without asking the
+ * guards: that state was accepted once already.
+ */
+export function withBackNavigation() {
+    return ({ entries, cursor, goTo }) => {
+        const rawEntries = () => readRaw(entries) ?? [];
+        const rawCursor = () => readRaw(cursor) ?? 0;
+        return {
+            canGoBack: createYieldableReactiveValue(createCraftComputed(() => rawCursor() > 0), 'canGoBack'),
+            canGoForward: createYieldableReactiveValue(createCraftComputed(() => rawCursor() < rawEntries().length - 1), 'canGoForward'),
+            back: () => goTo(rawCursor() - 1),
+            forward: () => goTo(rawCursor() + 1),
+        };
+    };
+}
+/**
+ * Reads a craft reactive value as a plain signal. A yieldable reader IS its own
+ * generator factory, so calling it hands back a generator rather than a value —
+ * the raw source is the way through.
+ */
+function readRaw(reader) {
+    return isYieldableReactiveValue(reader)
+        ? rawReactiveValue(reader)()
+        : undefined;
+}
+/**
+ * Whether two recorded moments describe the same state. Compared by value:
+ * a snapshot is already required to survive JSON to be persisted.
+ */
+function isSameMoment(previous, next) {
+    if (!previous || previous.step !== next.step)
+        return false;
+    try {
+        return JSON.stringify(previous.snapshot) === JSON.stringify(next.snapshot);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Whether a captured value is worth recording.
+ *
+ * A resource read before its loader has settled holds `undefined`, and writing
+ * `undefined` back into it does not restore anything — it pins the resource to
+ * a local value and detaches it from its loader for good. An unsettled
+ * resource records nothing instead, and a restore leaves the live one alone.
+ */
+function isRecordable(entry, value) {
+    return entry.kind === 'state' || value !== undefined;
+}
+/** Drops the registry's global occurrence suffix from an address. */
+function stripOccurrence(address) {
+    return address.replace(/#\d+$/, '');
+}
+function readPersisted(storage, storageKey) {
+    if (!storage || !storageKey)
+        return undefined;
+    try {
+        const raw = storage.getItem(storageKey);
+        if (!raw)
+            return undefined;
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed?.entries))
+            return undefined;
+        if (parsed.entries.some((entry) => !entry || typeof entry !== 'object' || typeof entry.step !== 'string')) {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        // A history that cannot be read back is a history that never existed.
+        return undefined;
+    }
+}
+function writePersisted(storage, storageKey, entries, cursor) {
+    if (!storage || !storageKey)
+        return;
+    try {
+        storage.setItem(storageKey, JSON.stringify({ entries, cursor }));
+    }
+    catch {
+        // An event can carry anything, a DOM event included. A moment that cannot
+        // be serialised is dropped from the persisted copy rather than taking the
+        // whole history down with it; the in-memory history keeps it.
+        try {
+            storage.setItem(storageKey, JSON.stringify({
+                entries: entries.map((entry) => ({ ...entry, event: undefined })),
+                cursor,
+            }));
+        }
+        catch {
+            storage.removeItem(storageKey);
+        }
+    }
+}
+//# sourceMappingURL=craft-machine-history.js.map

package/src/lib/craft-machine-history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"craft-machine-history.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/craft-machine-history.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject } from './host/craft-compat';\nimport { craftComputed as createCraftComputed, craftSignal } from './host/craft-signal';\nimport { StorageService } from './browser-boundaries';\nimport type { CraftUnique } from './craft-unique';\nimport type { GetServiceYields } from './craft-service';\nimport {\n  CRAFT_PRIMITIVE_REGISTRY,\n  type CraftPrimitiveEntry,\n  type CraftPrimitiveSnapshot,\n} from './craft-primitive-registry';\nimport { ɵwithCraftReplay } from './craft-replay';\nimport {\n  createYieldableReactiveValue,\n  isYieldableReactiveValue,\n  rawReactiveValue,\n  type YieldableReactiveValue,\n} from './reactive-read';\nimport type {\n  CraftMachineControls,\n  CraftMachineInsertionContext,\n} from './craft-state-machine';\n\n/**\n * One recorded moment of a machine: the transition that produced it, and the\n * value of every primitive the machine owns at that point.\n *\n * The step and the values are captured AFTER the transition was applied, so\n * restoring an entry restores the state the machine was in once it had moved.\n *\n * Snapshot keys are RELATIVE to the machine, not absolute registry addresses.\n * An absolute address starts with the host chain of the component that happens\n * to hold the machine, and that prefix carries a creation ordinal which means\n * nothing after a reload. Below the machine everything is deterministic — the\n * same code creates the same primitives in the same order — so a relative key\n * survives, and re-anchors onto whichever instance is restoring it.\n */\nexport type CraftHistoryEntry<Steps extends string = string> = Readonly<{\n  step: Steps;\n  from: Steps | undefined;\n  event: unknown;\n  at: number;\n  snapshot: CraftPrimitiveSnapshot;\n}>;\n\n/**\n * What a history feature composed into {@link withStateMachineHistory} receives. It is\n * deliberately narrow: a feature navigates the recorded entries, it does not\n * decide what gets recorded.\n */\nexport type CraftHistoryFeatureContext<Steps extends string = string> =\n  Readonly<{\n    entries: YieldableReactiveValue<\n      readonly CraftHistoryEntry<Steps>[],\n      'entries'\n    >;\n    /** Index of the entry the machine currently sits on. */\n    cursor: YieldableReactiveValue<number, 'cursor'>;\n    /**\n     * Restores the recorded entry at `index`. Returns `false` when the index\n     * is out of range. Guards are NOT consulted: a recorded state was already\n     * accepted once, and replaying it must not depend on today's permissions.\n     */\n    goTo(index: number): boolean;\n    controls: CraftMachineControls<Steps>;\n  }>;\n\nexport type CraftHistoryFeature<Output extends object> = (\n  context: CraftHistoryFeatureContext<any>,\n) => Output;\n\ntype HistoryOptions = Readonly<{\n  /**\n   * How many entries to keep. The oldest are dropped first. `Infinity` keeps\n   * everything, which is fine for a debug session and not for production.\n   */\n  limit?: number;\n  /**\n   * Primitives declared OUTSIDE the machine that belong to the story being\n   * recorded. A machine captures what it owns by itself; anything else has to\n   * be named, so a replay stays reproducible instead of depending on whatever\n   * happened to be in the injector.\n   *\n   * ```ts\n   * withStateMachineHistory({ include: [sharedFilters] }, withBackNavigation())\n   * ```\n   */\n  include?: readonly unknown[];\n  /**\n   * Keeps the history across a reload, under an anchor the application names.\n   *\n   * Only the ANCHOR needs a stable identity: everything the machine owns is\n   * addressed relative to it, and those keys are deterministic. `key` may be a\n   * function when the anchor comes from data — a row of a list anchors on the\n   * entity it edits, not on the order it happened to be created in.\n   *\n   * ```ts\n   * withStateMachineHistory(\n   *   { persist: craftUnique({ storeName: 'app', key: 'book-editor' }) },\n   *   withBackNavigation(),\n   * )\n   * ```\n   */\n  persist?:\n    | CraftUnique<CraftHistoryPersistenceStatic>\n    | CraftHistoryPersistenceDynamic;\n}>;\n\n/** The slice of the injected storage service a persisted history needs. */\ntype CraftHistoryStorage = Readonly<{\n  getItem(key: string): string | null;\n  setItem(key: string, value: string): void;\n  removeItem(key: string): void;\n}>;\n\nexport type CraftHistoryPersistenceStatic = Readonly<{\n  storeName: string;\n  key: string;\n}>;\n\n/** A data-dependent anchor cannot be verified as a static unique identity. */\nexport type CraftHistoryPersistenceDynamic = Readonly<{\n  storeName: string;\n  /** Resolved once, when the machine is built. */\n  key: () => string;\n}>;\n\nexport type CraftHistoryPersistence =\n  | CraftHistoryPersistenceStatic\n  | CraftHistoryPersistenceDynamic;\n\n/** Reserved prefix for the primitives named through `include`. */\nconst EXTERNAL_KEY_PREFIX = '#include/';\n\ntype HistoryOutput<Steps extends string> = {\n  readonly history: YieldableReactiveValue<\n    readonly CraftHistoryEntry<Steps>[],\n    'history'\n  >;\n  readonly historyCursor: YieldableReactiveValue<number, 'historyCursor'>;\n};\n\nconst DEFAULT_LIMIT = 50;\n\n/** What `withStateMachineHistory(...)` resolves to: an insertion for `craftStateMachine`. */\ntype HistoryInsertion<Steps extends string, Features> = (\n  context: CraftMachineInsertionContext<any, Steps, any>,\n) => Generator<\n  GetServiceYields<typeof StorageService>,\n  HistoryOutput<Steps> & Features,\n  unknown\n>;\n\n/**\n * Records the machine's history, and composes features on top of it.\n *\n * History is not part of the machine core — it is an insertion, exactly like\n * the derived values and step flags beside it:\n *\n * ```ts\n * craftStateMachine(\n *   contextFactory,\n *   transitions,\n *   stepContexts,\n *   withStateMachineHistory(withBackNavigation()),\n * );\n * ```\n *\n * Every accepted transition appends an entry holding the new step and a\n * snapshot of every primitive the machine owns, read through\n * `CRAFT_PRIMITIVE_REGISTRY` and scoped to the machine's host chain. A\n * primitive declared OUTSIDE the machine is not captured: pass it explicitly\n * through `include` when it belongs to the story being replayed.\n */\nexport function withStateMachineHistory<Steps extends string = string>(): HistoryInsertion<\n  Steps,\n  object\n>;\nexport function withStateMachineHistory<Feature1 extends object, Steps extends string = string>(\n  feature1: CraftHistoryFeature<Feature1>,\n): HistoryInsertion<Steps, Feature1>;\nexport function withStateMachineHistory<\n  Feature1 extends object,\n  Feature2 extends object,\n  Steps extends string = string,\n>(\n  feature1: CraftHistoryFeature<Feature1>,\n  feature2: CraftHistoryFeature<Feature2>,\n): HistoryInsertion<Steps, Feature1 & Feature2>;\nexport function withStateMachineHistory<\n  Feature1 extends object,\n  Feature2 extends object,\n  Feature3 extends object,\n  Steps extends string = string,\n>(\n  feature1: CraftHistoryFeature<Feature1>,\n  feature2: CraftHistoryFeature<Feature2>,\n  feature3: CraftHistoryFeature<Feature3>,\n): HistoryInsertion<Steps, Feature1 & Feature2 & Feature3>;\nexport function withStateMachineHistory<Steps extends string = string>(\n  options: HistoryOptions,\n): HistoryInsertion<Steps, object>;\nexport function withStateMachineHistory<Feature1 extends object, Steps extends string = string>(\n  options: HistoryOptions,\n  feature1: CraftHistoryFeature<Feature1>,\n): HistoryInsertion<Steps, Feature1>;\nexport function withStateMachineHistory<\n  Feature1 extends object,\n  Feature2 extends object,\n  Steps extends string = string,\n>(\n  options: HistoryOptions,\n  feature1: CraftHistoryFeature<Feature1>,\n  feature2: CraftHistoryFeature<Feature2>,\n): HistoryInsertion<Steps, Feature1 & Feature2>;\nexport function withStateMachineHistory<\n  Feature1 extends object,\n  Feature2 extends object,\n  Feature3 extends object,\n  Steps extends string = string,\n>(\n  options: HistoryOptions,\n  feature1: CraftHistoryFeature<Feature1>,\n  feature2: CraftHistoryFeature<Feature2>,\n  feature3: CraftHistoryFeature<Feature3>,\n): HistoryInsertion<Steps, Feature1 & Feature2 & Feature3>;\nexport function withStateMachineHistory(\n  optionsOrFeature?: HistoryOptions | CraftHistoryFeature<object>,\n  ...rest: CraftHistoryFeature<object>[]\n): (\n  context: CraftMachineInsertionContext<any, string, any>,\n) => Generator<unknown, unknown, unknown> {\n  const options =\n    typeof optionsOrFeature === 'function' || optionsOrFeature === undefined\n      ? {}\n      : optionsOrFeature;\n  const features =\n    typeof optionsOrFeature === 'function'\n      ? [optionsOrFeature, ...rest]\n      : rest;\n  const limit = options.limit ?? DEFAULT_LIMIT;\n\n  return function* ({ currentStep, machine }) {\n    const storage = yield* StorageService();\n    const registry = inject(CRAFT_PRIMITIVE_REGISTRY);\n    const persistence = options.persist;\n    const storageKey = persistence\n      ? `craft-ts-${persistence.storeName}-history-${\n          typeof persistence.key === 'function'\n            ? persistence.key()\n            : persistence.key\n        }`\n      : undefined;\n\n    const restored = readPersisted(storage, storageKey);\n    const entries = craftSignal<readonly CraftHistoryEntry[]>(\n      restored?.entries ?? [],\n    );\n    const cursor = craftSignal(restored?.cursor ?? 0);\n\n    const includedRefs = options.include ?? [];\n    const machinePrefix = machine.hostTags.join(' / ');\n\n    /**\n     * Keys an entry relative to the machine, re-indexing occurrences within\n     * the current set rather than reusing the registry's global counter. That\n     * counter only ever grows, so it would drift the moment a machine is\n     * destroyed and rebuilt inside the same host — and a persisted key must not\n     * depend on how many times the page has already built this primitive.\n     */\n    const relativeKeys = () => {\n      const seen = new Map<string, number>();\n\n      return registry.under(machine.hostTags).map((entry) => {\n        const base = stripOccurrence(entry.address).slice(\n          machinePrefix.length === 0 ? 0 : machinePrefix.length + 3,\n        );\n        const occurrence = (seen.get(base) ?? 0) + 1;\n        seen.set(base, occurrence);\n        return { entry, key: `${base}#${occurrence}` };\n      });\n    };\n\n    const capture = (): CraftPrimitiveSnapshot => {\n      const snapshot: Record<string, unknown> = {};\n\n      for (const { entry, key } of relativeKeys()) {\n        const captured = registry.capture([entry]);\n        if (entry.address in captured && isRecordable(entry, captured[entry.address])) {\n          snapshot[key] = captured[entry.address];\n        }\n      }\n\n      // Primitives declared outside the machine are keyed by their position in\n      // the declared `include` list, which is stable by construction.\n      includedRefs.forEach((ref, index) => {\n        const address = registry.addressOf(ref);\n        const entry = address ? registry.get(address) : undefined;\n        if (!entry) return;\n        const captured = registry.capture([entry]);\n        if (entry.address in captured && isRecordable(entry, captured[entry.address])) {\n          snapshot[`${EXTERNAL_KEY_PREFIX}${index}`] = captured[entry.address];\n        }\n      });\n\n      return snapshot;\n    };\n\n    /** Resolves relative keys back onto the primitives present right now. */\n    const restore = (snapshot: CraftPrimitiveSnapshot): void => {\n      const current = new Map(\n        relativeKeys().map(({ entry, key }) => [key, entry]),\n      );\n\n      const writes: { entry: CraftPrimitiveEntry; value: unknown }[] = [];\n\n      for (const [key, value] of Object.entries(snapshot)) {\n        const entry = key.startsWith(EXTERNAL_KEY_PREFIX)\n          ? externalEntry(Number(key.slice(EXTERNAL_KEY_PREFIX.length)))\n          : current.get(key);\n        if (entry) writes.push({ entry, value });\n      }\n\n      // The whole restore runs under the replay flag, so a resource claims its\n      // restored parameter without reloading over the value being restored\n      // with it — and so tooling can tell a rewind from user activity.\n      ɵwithCraftReplay(() => {\n        for (const { entry, value } of writes) {\n          entry.write(value);\n        }\n      });\n\n      // A resource the snapshot does not cover was still loading when the\n      // moment was recorded, so there is no value to put back. Left frozen it\n      // would keep showing what belongs to another parameter; reloading it is\n      // the honest answer.\n      const restored = new Set(writes.map(({ entry }) => entry.address));\n      for (const entry of registry.under(machine.hostTags)) {\n        if (entry.kind === 'state' || restored.has(entry.address)) continue;\n        entry.reload?.();\n      }\n    };\n\n    const externalEntry = (index: number): CraftPrimitiveEntry | undefined => {\n      const address = registry.addressOf(includedRefs[index]);\n      return address ? registry.get(address) : undefined;\n    };\n\n    const append = (entry: CraftHistoryEntry) => {\n      // A moment identical to the one the machine already sits on is not a\n      // moment. Remounting a component — or reloading a page onto a machine\n      // that starts where it left off — would otherwise stack the same state\n      // over and over, and `back()` would walk through duplicates.\n      if (isSameMoment(entries()[cursor()], entry)) return;\n\n      entries.update((current) => {\n        // Recording after a rewind drops the forward entries: the machine took\n        // a different branch, and keeping the old one would let `forward()`\n        // walk into a future that no longer happened.\n        const kept = current.slice(0, cursor() + 1);\n        const next = [...kept, entry];\n        return next.length > limit ? next.slice(next.length - limit) : next;\n      });\n      cursor.set(entries().length - 1);\n      writePersisted(storage, storageKey, entries(), cursor());\n    };\n\n    // The machine has already taken its initial step by the time an insertion\n    // runs, so the first entry records where it started.\n    const initialStep = readRaw<string>(currentStep);\n    if (initialStep === undefined) {\n      throw new Error('Cannot create history for an uninitialised state machine.');\n    }\n\n    append({\n      step: initialStep,\n      from: undefined,\n      event: undefined,\n      at: Date.now(),\n      snapshot: capture(),\n    });\n\n    machine.onTransition((transition) => {\n      if (!transition.accepted) return;\n      append({\n        step: transition.to,\n        from: transition.from,\n        event: transition.event,\n        at: Date.now(),\n        snapshot: capture(),\n      });\n    });\n\n    const goTo = (index: number): boolean => {\n      const recorded = entries();\n      const entry = recorded[index];\n      if (!entry) return false;\n\n      machine.suspended(() => {\n        restore(entry.snapshot);\n        ɵwithCraftReplay(() => machine.restoreStep(entry.step));\n      });\n      cursor.set(index);\n      writePersisted(storage, storageKey, entries(), cursor());\n      return true;\n    };\n\n    const entriesReader = createYieldableReactiveValue(\n      entries.asReadonly(),\n      'entries',\n    );\n    const cursorReader = createYieldableReactiveValue(\n      cursor.asReadonly(),\n      'cursor',\n    );\n\n    const featureContext: CraftHistoryFeatureContext = {\n      entries: entriesReader,\n      cursor: cursorReader,\n      goTo,\n      controls: machine,\n    };\n\n    return Object.assign(\n      {\n        history: createYieldableReactiveValue(entries.asReadonly(), 'history'),\n        historyCursor: createYieldableReactiveValue(\n          cursor.asReadonly(),\n          'historyCursor',\n        ),\n      },\n      ...features.map((feature) => feature(featureContext)),\n    ) as object;\n  };\n}\n\ntype BackNavigationOutput = {\n  readonly canGoBack: YieldableReactiveValue<boolean, 'canGoBack'>;\n  readonly canGoForward: YieldableReactiveValue<boolean, 'canGoForward'>;\n  readonly back: () => boolean;\n  readonly forward: () => boolean;\n};\n\n/**\n * Step-by-step navigation through a machine's history. Composes into\n * {@link withStateMachineHistory}, which owns the entries it walks:\n *\n * ```ts\n * withStateMachineHistory(withBackNavigation())\n * ```\n *\n * `back()` and `forward()` restore a recorded moment without asking the\n * guards: that state was accepted once already.\n */\nexport function withBackNavigation(): CraftHistoryFeature<BackNavigationOutput> {\n  return ({ entries, cursor, goTo }) => {\n    const rawEntries = () =>\n      readRaw<readonly CraftHistoryEntry[]>(entries) ?? [];\n    const rawCursor = () => readRaw<number>(cursor) ?? 0;\n\n    return {\n      canGoBack: createYieldableReactiveValue(\n        createCraftComputed(() => rawCursor() > 0),\n        'canGoBack',\n      ),\n      canGoForward: createYieldableReactiveValue(\n        createCraftComputed(() => rawCursor() < rawEntries().length - 1),\n        'canGoForward',\n      ),\n      back: () => goTo(rawCursor() - 1),\n      forward: () => goTo(rawCursor() + 1),\n    };\n  };\n}\n\n/**\n * Reads a craft reactive value as a plain signal. A yieldable reader IS its own\n * generator factory, so calling it hands back a generator rather than a value —\n * the raw source is the way through.\n */\nfunction readRaw<Value>(reader: unknown): Value | undefined {\n  return isYieldableReactiveValue(reader)\n    ? (rawReactiveValue(reader)() as Value)\n    : undefined;\n}\n\n\n/**\n * Whether two recorded moments describe the same state. Compared by value:\n * a snapshot is already required to survive JSON to be persisted.\n */\nfunction isSameMoment(\n  previous: CraftHistoryEntry | undefined,\n  next: CraftHistoryEntry,\n): boolean {\n  if (!previous || previous.step !== next.step) return false;\n  try {\n    return JSON.stringify(previous.snapshot) === JSON.stringify(next.snapshot);\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Whether a captured value is worth recording.\n *\n * A resource read before its loader has settled holds `undefined`, and writing\n * `undefined` back into it does not restore anything — it pins the resource to\n * a local value and detaches it from its loader for good. An unsettled\n * resource records nothing instead, and a restore leaves the live one alone.\n */\nfunction isRecordable(entry: CraftPrimitiveEntry, value: unknown): boolean {\n  return entry.kind === 'state' || value !== undefined;\n}\n\n/** Drops the registry's global occurrence suffix from an address. */\nfunction stripOccurrence(address: string): string {\n  return address.replace(/#\\d+$/, '');\n}\n\ntype PersistedHistory = Readonly<{\n  entries: readonly CraftHistoryEntry[];\n  cursor: number;\n}>;\n\nfunction readPersisted(\n  storage: CraftHistoryStorage | undefined,\n  storageKey: string | undefined,\n): PersistedHistory | undefined {\n  if (!storage || !storageKey) return undefined;\n  try {\n    const raw = storage.getItem(storageKey);\n    if (!raw) return undefined;\n    const parsed = JSON.parse(raw) as PersistedHistory;\n    if (!Array.isArray(parsed?.entries)) return undefined;\n    if (\n      parsed.entries.some(\n        (entry) =>\n          !entry || typeof entry !== 'object' || typeof entry.step !== 'string',\n      )\n    ) {\n      return undefined;\n    }\n    return parsed;\n  } catch {\n    // A history that cannot be read back is a history that never existed.\n    return undefined;\n  }\n}\n\nfunction writePersisted(\n  storage: CraftHistoryStorage | undefined,\n  storageKey: string | undefined,\n  entries: readonly CraftHistoryEntry[],\n  cursor: number,\n): void {\n  if (!storage || !storageKey) return;\n  try {\n    storage.setItem(storageKey, JSON.stringify({ entries, cursor }));\n  } catch {\n    // An event can carry anything, a DOM event included. A moment that cannot\n    // be serialised is dropped from the persisted copy rather than taking the\n    // whole history down with it; the in-memory history keeps it.\n    try {\n      storage.setItem(\n        storageKey,\n        JSON.stringify({\n          entries: entries.map((entry) => ({ ...entry, event: undefined })),\n          cursor,\n        }),\n      );\n    } catch {\n      storage.removeItem(storageKey);\n    }\n  }\n}\n"]}

package/src/lib/craft-match.d.ts

@@ -0,0 +1,49 @@
+/**
+ * A handler map over a literal union: exactly one handler per member, each
+ * receiving its own narrowed literal.
+ */
+export type CraftMatchHandlers<Value extends string | number, R> = {
+    [K in Value]: (value: K) => R;
+};
+interface CraftMatch {
+    /**
+     * Matches a single case of a literal union. When `value` equals `matchCase`
+     * the handler runs (with `value` narrowed to `matchCase`) and its result is
+     * returned; otherwise the result is `undefined`.
+     */
+    <Value extends string | number, Case extends Value, R>(value: Value, matchCase: Case, handler: (value: Case) => R): R | undefined;
+    /**
+     * Matches **every** member of a literal union through a handler map covering
+     * exactly that union — a missing member or a key outside the union is a
+     * compile error, and each handler receives its own narrowed literal. The
+     * result is the union of the handlers' return types.
+     */
+    exhaustive<Value extends string | number, Handlers extends {
+        [K in Value]: (value: K) => unknown;
+    }>(value: Value, handlers: Handlers): ReturnType<Handlers[Value]>;
+    /**
+     * Exhaustively matches a discriminated object union. The callback receives
+     * the member narrowed by `key`, including its exact payload.
+     */
+    exhaustive<Value extends object, Key extends {
+        [K in keyof Value]-?: Value[K] extends string | number ? K : never;
+    }[keyof Value], Handlers extends {
+        [Code in Value[Key] & (string | number)]: (value: Extract<Value, Record<Key, Code>>) => unknown;
+    }>(value: Value | undefined, key: Key, handlers: Handlers): ReturnType<Handlers[Value[Key] & (string | number)]> | undefined;
+    exhaustive<Value extends object, Key extends {
+        [K in keyof Value]-?: Value[K] extends string | number ? K : never;
+    }[keyof Value], Handlers extends {
+        [Code in Value[Key] & (string | number)]: (value: Extract<Value, Record<Key, Code>>) => unknown;
+    }>(value: () => Value | undefined, key: Key, handlers: Handlers): ReturnType<Handlers[Value[Key] & (string | number)]> | undefined;
+}
+/**
+ * Type-safe pattern matching over a bare literal union. Call it with a single
+ * case (`craftMatch(value, 'a', handler)`) for an optional match, or use
+ * {@link CraftMatch.exhaustive | `craftMatch.exhaustive`} with a handler map
+ * for a compile-time-exhaustive match.
+ */
+export declare const craftMatch: CraftMatch;
+/** Preferred short name for value and discriminated-union matching. */
+export declare const match: CraftMatch;
+export {};
+//# sourceMappingURL=craft-match.d.ts.map

package/src/lib/craft-match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"craft-match.d.ts","sourceRoot":"","sources":["../../../../../libs/core/src/lib/craft-match.ts"],"names":[],"mappings":"AA2BA;;;GAGG;AACH,MAAM,MAAM,kBAAkB,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,EAAE,CAAC,IAAI;KAChE,CAAC,IAAI,KAAK,GAAG,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC;CAC9B,CAAC;AAEF,UAAU,UAAU;IAClB;;;;OAIG;IACH,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,EAAE,IAAI,SAAS,KAAK,EAAE,CAAC,EACnD,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,IAAI,EACf,OAAO,EAAE,CAAC,KAAK,EAAE,IAAI,KAAK,CAAC,GAC1B,CAAC,GAAG,SAAS,CAAC;IAEjB;;;;;OAKG;IACH,UAAU,CACR,KAAK,SAAS,MAAM,GAAG,MAAM,EAC7B,QAAQ,SAAS;SACd,CAAC,IAAI,KAAK,GAAG,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO;KACpC,EAED,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,QAAQ,GACjB,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;IAE/B;;;OAGG;IACH,UAAU,CACR,KAAK,SAAS,MAAM,EACpB,GAAG,SAAS;SACT,CAAC,IAAI,MAAM,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,CAAC,GAAG,KAAK;KACnE,CAAC,MAAM,KAAK,CAAC,EACd,QAAQ,SAAS;SACd,IAAI,IAAI,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,CACxC,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,KACrC,OAAO;KACb,EAED,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,QAAQ,GACjB,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IAEpE,UAAU,CACR,KAAK,SAAS,MAAM,EACpB,GAAG,SAAS;SACT,CAAC,IAAI,MAAM,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,CAAC,GAAG,KAAK;KACnE,CAAC,MAAM,KAAK,CAAC,EACd,QAAQ,SAAS;SACd,IAAI,IAAI,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,CACxC,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,KACrC,OAAO;KACb,EAED,KAAK,EAAE,MAAM,KAAK,GAAG,SAAS,EAC9B,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,QAAQ,GACjB,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;CACrE;AAqCD;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,UAyBxB,CAAC;AAEF,uEAAuE;AACvE,eAAO,MAAM,KAAK,YAAa,CAAC"}

package/src/lib/craft-match.js

@@ -0,0 +1,58 @@
+// ---------------------------------------------------------------------------
+// Value-level pattern matching over a bare literal union (string/number/enum),
+// the value counterpart to the exception-level `catchTag` / `catchTag.exhaustive`
+// pair in `craft-program-operators`.
+//
+// ```ts
+// type Status = 'active' | 'idle' | 'error';
+//
+// // Single case — runs the handler only when `status === 'active'`,
+// // otherwise `undefined`.
+// const label = craftMatch(status, 'active', () => 'Running');
+//
+// // Exhaustive — every member of the union needs a handler; a missing key
+// // (or a key outside the union) is a compile error, and each handler
+// // receives its own narrowed literal.
+// const label = craftMatch.exhaustive(status, {
+//   active: () => 'Running',
+//   idle: () => 'Waiting',
+//   error: () => 'Failed',
+// });
+// ```
+//
+// Exhaustiveness is enforced natively by the mapped handler type
+// `{ [K in Value]: (value: K) => R }` — no `Exclude` gymnastics are needed
+// because the union members *are* the required keys.
+// ---------------------------------------------------------------------------
+function craftMatchImpl(value, matchCase, handler) {
+    return value === matchCase ? handler(value) : undefined;
+}
+function craftMatchExhaustiveImpl(value, handlers) {
+    const handler = handlers[value];
+    return handler(value);
+}
+function craftMatchObjectExhaustiveImpl(value, key, handlers) {
+    const current = typeof value === 'function' ? value() : value;
+    if (current === undefined)
+        return undefined;
+    const code = Reflect.get(current, key);
+    const handler = handlers[code];
+    if (!handler) {
+        throw new Error(`match.exhaustive(...) has no handler for discriminant "${String(code)}".`);
+    }
+    return handler(current);
+}
+/**
+ * Type-safe pattern matching over a bare literal union. Call it with a single
+ * case (`craftMatch(value, 'a', handler)`) for an optional match, or use
+ * {@link CraftMatch.exhaustive | `craftMatch.exhaustive`} with a handler map
+ * for a compile-time-exhaustive match.
+ */
+export const craftMatch = Object.assign(craftMatchImpl, {
+    exhaustive: ((value, keyOrHandlers, maybeHandlers) => maybeHandlers === undefined
+        ? craftMatchExhaustiveImpl(value, keyOrHandlers)
+        : craftMatchObjectExhaustiveImpl(value, keyOrHandlers, maybeHandlers)),
+});
+/** Preferred short name for value and discriminated-union matching. */
+export const match = craftMatch;
+//# sourceMappingURL=craft-match.js.map

package/src/lib/craft-match.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"craft-match.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/craft-match.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,+EAA+E;AAC/E,kFAAkF;AAClF,qCAAqC;AACrC,EAAE;AACF,QAAQ;AACR,6CAA6C;AAC7C,EAAE;AACF,qEAAqE;AACrE,4BAA4B;AAC5B,+DAA+D;AAC/D,EAAE;AACF,2EAA2E;AAC3E,uEAAuE;AACvE,wCAAwC;AACxC,gDAAgD;AAChD,6BAA6B;AAC7B,2BAA2B;AAC3B,2BAA2B;AAC3B,MAAM;AACN,MAAM;AACN,EAAE;AACF,iEAAiE;AACjE,2EAA2E;AAC3E,qDAAqD;AACrD,8EAA8E;AA2E9E,SAAS,cAAc,CACrB,KAAY,EACZ,SAAe,EACf,OAA2B;IAE3B,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,KAAa,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAClE,CAAC;AAED,SAAS,wBAAwB,CAG/B,KAAY,EAAE,QAAkB;IAChC,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,CAEE,CAAC;IACjC,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC;AACxB,CAAC;AAED,SAAS,8BAA8B,CACrC,KAAsD,EACtD,GAAgB,EAChB,QAA6D;IAE7D,MAAM,OAAO,GAAG,OAAO,KAAK,KAAK,UAAU,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;IAC9D,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC5C,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,CAAoB,CAAC;IAC1D,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC/B,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CACb,0DAA0D,MAAM,CAAC,IAAI,CAAC,IAAI,CAC3E,CAAC;IACJ,CAAC;IACD,OAAO,OAAO,CAAC,OAAO,CAAC,CAAC;AAC1B,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,UAAU,GAAe,MAAM,CAAC,MAAM,CACjD,cAA4B,EAC5B;IACE,UAAU,EAAE,CAAC,CACX,KAAc,EACd,aAAsB,EACtB,aAAuB,EACvB,EAAE,CACF,aAAa,KAAK,SAAS;QACzB,CAAC,CAAC,wBAAwB,CACtB,KAAwB,EACxB,aAGC,CACF;QACH,CAAC,CAAC,8BAA8B,CAC5B,KAA2B,EAC3B,aAA4B,EAC5B,aAGC,CACF,CAA6B;CACrC,CACF,CAAC;AAEF,uEAAuE;AACvE,MAAM,CAAC,MAAM,KAAK,GAAG,UAAU,CAAC","sourcesContent":["// ---------------------------------------------------------------------------\n// Value-level pattern matching over a bare literal union (string/number/enum),\n// the value counterpart to the exception-level `catchTag` / `catchTag.exhaustive`\n// pair in `craft-program-operators`.\n//\n// ```ts\n// type Status = 'active' | 'idle' | 'error';\n//\n// // Single case — runs the handler only when `status === 'active'`,\n// // otherwise `undefined`.\n// const label = craftMatch(status, 'active', () => 'Running');\n//\n// // Exhaustive — every member of the union needs a handler; a missing key\n// // (or a key outside the union) is a compile error, and each handler\n// // receives its own narrowed literal.\n// const label = craftMatch.exhaustive(status, {\n//   active: () => 'Running',\n//   idle: () => 'Waiting',\n//   error: () => 'Failed',\n// });\n// ```\n//\n// Exhaustiveness is enforced natively by the mapped handler type\n// `{ [K in Value]: (value: K) => R }` — no `Exclude` gymnastics are needed\n// because the union members *are* the required keys.\n// ---------------------------------------------------------------------------\n\n/**\n * A handler map over a literal union: exactly one handler per member, each\n * receiving its own narrowed literal.\n */\nexport type CraftMatchHandlers<Value extends string | number, R> = {\n  [K in Value]: (value: K) => R;\n};\n\ninterface CraftMatch {\n  /**\n   * Matches a single case of a literal union. When `value` equals `matchCase`\n   * the handler runs (with `value` narrowed to `matchCase`) and its result is\n   * returned; otherwise the result is `undefined`.\n   */\n  <Value extends string | number, Case extends Value, R>(\n    value: Value,\n    matchCase: Case,\n    handler: (value: Case) => R,\n  ): R | undefined;\n\n  /**\n   * Matches **every** member of a literal union through a handler map covering\n   * exactly that union — a missing member or a key outside the union is a\n   * compile error, and each handler receives its own narrowed literal. The\n   * result is the union of the handlers' return types.\n   */\n  exhaustive<\n    Value extends string | number,\n    Handlers extends {\n      [K in Value]: (value: K) => unknown;\n    },\n  >(\n    value: Value,\n    handlers: Handlers,\n  ): ReturnType<Handlers[Value]>;\n\n  /**\n   * Exhaustively matches a discriminated object union. The callback receives\n   * the member narrowed by `key`, including its exact payload.\n   */\n  exhaustive<\n    Value extends object,\n    Key extends {\n      [K in keyof Value]-?: Value[K] extends string | number ? K : never;\n    }[keyof Value],\n    Handlers extends {\n      [Code in Value[Key] & (string | number)]: (\n        value: Extract<Value, Record<Key, Code>>,\n      ) => unknown;\n    },\n  >(\n    value: Value | undefined,\n    key: Key,\n    handlers: Handlers,\n  ): ReturnType<Handlers[Value[Key] & (string | number)]> | undefined;\n\n  exhaustive<\n    Value extends object,\n    Key extends {\n      [K in keyof Value]-?: Value[K] extends string | number ? K : never;\n    }[keyof Value],\n    Handlers extends {\n      [Code in Value[Key] & (string | number)]: (\n        value: Extract<Value, Record<Key, Code>>,\n      ) => unknown;\n    },\n  >(\n    value: () => Value | undefined,\n    key: Key,\n    handlers: Handlers,\n  ): ReturnType<Handlers[Value[Key] & (string | number)]> | undefined;\n}\n\nfunction craftMatchImpl<Value extends string | number, Case extends Value, R>(\n  value: Value,\n  matchCase: Case,\n  handler: (value: Case) => R,\n): R | undefined {\n  return value === matchCase ? handler(value as Case) : undefined;\n}\n\nfunction craftMatchExhaustiveImpl<\n  Value extends string | number,\n  Handlers extends CraftMatchHandlers<Value, any>,\n>(value: Value, handlers: Handlers): ReturnType<Handlers[Value]> {\n  const handler = handlers[value] as (\n    value: Value,\n  ) => ReturnType<Handlers[Value]>;\n  return handler(value);\n}\n\nfunction craftMatchObjectExhaustiveImpl(\n  value: object | (() => object | undefined) | undefined,\n  key: PropertyKey,\n  handlers: Record<string | number, (value: object) => unknown>,\n): unknown {\n  const current = typeof value === 'function' ? value() : value;\n  if (current === undefined) return undefined;\n  const code = Reflect.get(current, key) as string | number;\n  const handler = handlers[code];\n  if (!handler) {\n    throw new Error(\n      `match.exhaustive(...) has no handler for discriminant \"${String(code)}\".`,\n    );\n  }\n  return handler(current);\n}\n\n/**\n * Type-safe pattern matching over a bare literal union. Call it with a single\n * case (`craftMatch(value, 'a', handler)`) for an optional match, or use\n * {@link CraftMatch.exhaustive | `craftMatch.exhaustive`} with a handler map\n * for a compile-time-exhaustive match.\n */\nexport const craftMatch: CraftMatch = Object.assign(\n  craftMatchImpl as CraftMatch,\n  {\n    exhaustive: ((\n      value: unknown,\n      keyOrHandlers: unknown,\n      maybeHandlers?: unknown,\n    ) =>\n      maybeHandlers === undefined\n        ? craftMatchExhaustiveImpl(\n            value as string | number,\n            keyOrHandlers as Record<\n              string | number,\n              (value: string | number) => unknown\n            >,\n          )\n        : craftMatchObjectExhaustiveImpl(\n            value as object | undefined,\n            keyOrHandlers as PropertyKey,\n            maybeHandlers as Record<\n              string | number,\n              (value: object) => unknown\n            >,\n          )) as CraftMatch['exhaustive'],\n  },\n);\n\n/** Preferred short name for value and discriminated-union matching. */\nexport const match = craftMatch;\n"]}

package/src/lib/craft-method.d.ts

@@ -0,0 +1,28 @@
+import { Provider } from './host/craft-compat';
+import type { BrandedServiceProvider, SERVICE_HELPER_DEPENDENCIES, ServiceDependencyMapFromYielded } from './craft-service';
+import { YIELDABLE_METHOD } from './yieldable';
+type CraftMethodGenerator<This, Args extends unknown[], Yielded, Result> = (this: This, ...args: Args) => Generator<Yielded, Result, unknown>;
+type CraftMethodWithReceiver<This, Args extends unknown[], Result> = (this: This, ...args: Args) => Result;
+type CraftMethodWithoutReceiver<Args extends unknown[], Result> = (...args: Args) => Result;
+type CraftMethodNameConfig<Name extends string> = Name | {
+    name: Name;
+    providers?: readonly Provider[];
+};
+type CraftMethodConfigProviderNames<Config> = Config extends {
+    providers: readonly (infer P)[];
+} ? P extends BrandedServiceProvider<infer N, any, any> ? N : never : never;
+type SatisfyDependencies<Deps, SatisfiedNames extends string> = {
+    [K in keyof Deps as K extends SatisfiedNames ? never : K]: Deps[K];
+};
+type TrackedCraftMethod<Callable, Yielded, Config = never> = Callable & {
+    readonly [YIELDABLE_METHOD]: {
+        readonly yielded?: Yielded;
+    };
+    readonly [SERVICE_HELPER_DEPENDENCIES]?: [
+        CraftMethodConfigProviderNames<Config>
+    ] extends [never] ? ServiceDependencyMapFromYielded<Yielded> : SatisfyDependencies<ServiceDependencyMapFromYielded<Yielded>, CraftMethodConfigProviderNames<Config>>;
+};
+export declare function craftMethod<Name extends string, This, Args extends unknown[], Yielded, Result, Config extends CraftMethodNameConfig<Name> = Name>(name: Config, factory: CraftMethodGenerator<This, Args, Yielded, Result>): TrackedCraftMethod<CraftMethodWithReceiver<This, Args, Result>, Yielded, Config>;
+export declare function craftMethod<Name extends string, This, Args extends unknown[], Yielded, Result, Config extends CraftMethodNameConfig<Name> = Name>(name: Config, self: This, factory: CraftMethodGenerator<This, Args, Yielded, Result>): TrackedCraftMethod<CraftMethodWithoutReceiver<Args, Result>, Yielded, Config>;
+export {};
+//# sourceMappingURL=craft-method.d.ts.map

package/src/lib/craft-method.d.ts.map

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

package/src/lib/craft-method.js

@@ -0,0 +1,45 @@
+import { assertInInjectionContext, inject, Injector, runInInjectionContext, } from './host/craft-compat';
+import { ɵcreateHostTaggedInjector } from './craft-service';
+import { isGenerator, runCraftGenerator } from './craft-generator-runtime';
+import { injectFnWrapper } from './fn-wrapper';
+import { markYieldableMethod, YIELDABLE_METHOD } from './yieldable';
+function resolveCraftMethodName(nameOrConfig) {
+    return typeof nameOrConfig === 'string' ? nameOrConfig : nameOrConfig.name;
+}
+function resolveCraftMethodProviders(nameOrConfig) {
+    return typeof nameOrConfig === 'string' ? [] : (nameOrConfig.providers ?? []);
+}
+export function craftMethod(nameOrConfig, selfOrFactory, maybeFactory) {
+    assertInInjectionContext(craftMethod);
+    const injector = inject(Injector);
+    const resolvedName = resolveCraftMethodName(nameOrConfig);
+    const extraProviders = resolveCraftMethodProviders(nameOrConfig);
+    const methodInjector = ɵcreateHostTaggedInjector(injector, `method:${resolvedName}`, extraProviders);
+    const wrapFn = runInInjectionContext(methodInjector, () => injectFnWrapper());
+    if (maybeFactory) {
+        const self = selfOrFactory;
+        const factory = wrapFn(maybeFactory);
+        return markYieldableMethod(((...args) => executeCraftMethod(factory, methodInjector, self, args)));
+    }
+    const factory = wrapFn(selfOrFactory);
+    return markYieldableMethod(function (...args) {
+        return executeCraftMethod(factory, methodInjector, this, args);
+    });
+}
+function executeCraftMethod(factory, injector, self, args) {
+    return runInInjectionContext(injector, () => {
+        const result = factory.apply(self, args);
+        if (!isGenerator(result)) {
+            return result;
+        }
+        return runCraftGenerator({
+            iterator: result,
+            injector,
+            hostScope: 'function',
+            invalidYieldErrorMessage: 'craftMethod generators can only yield craftService dependencies or exposed dependency helpers.',
+            multipleAppStartErrorMessage: 'craftMethod generators cannot declare onAppStart(...) more than once.',
+            onAppStartNotSupportedErrorMessage: 'craftMethod(...) does not support onAppStart(...). Use onAppStart(...) only inside craftService({ appStart: true }, ...) generators.',
+        }).value;
+    });
+}
+//# sourceMappingURL=craft-method.js.map

package/src/lib/craft-method.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"craft-method.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/craft-method.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,MAAM,EACN,QAAQ,EAER,qBAAqB,GACtB,MAAM,qBAAqB,CAAC;AAM7B,OAAO,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC3E,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AA8CpE,SAAS,sBAAsB,CAC7B,YAAyC;IAEzC,OAAO,OAAO,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC;AAC7E,CAAC;AAED,SAAS,2BAA2B,CAClC,YAA2C;IAE3C,OAAO,OAAO,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC;AAChF,CAAC;AAiCD,MAAM,UAAU,WAAW,CACzB,YAA2C,EAC3C,aAAuE,EACvE,YAAgE;IAOhE,wBAAwB,CAAC,WAAW,CAAC,CAAC;IACtC,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAClC,MAAM,YAAY,GAAG,sBAAsB,CAAC,YAAY,CAAC,CAAC;IAC1D,MAAM,cAAc,GAAG,2BAA2B,CAAC,YAAY,CAAC,CAAC;IACjE,MAAM,cAAc,GAAG,yBAAyB,CAC9C,QAAQ,EACR,UAAU,YAAY,EAAE,EACxB,cAAc,CACf,CAAC;IACF,MAAM,MAAM,GAAG,qBAAqB,CAAC,cAAc,EAAE,GAAG,EAAE,CAAC,eAAe,EAAE,CAAC,CAAC;IAE9E,IAAI,YAAY,EAAE,CAAC;QACjB,MAAM,IAAI,GAAG,aAAqB,CAAC;QACnC,MAAM,OAAO,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;QAErC,OAAO,mBAAmB,CAAC,CAAC,CAAC,GAAG,IAAU,EAAE,EAAE,CAC5C,kBAAkB,CAChB,OAAO,EACP,cAAc,EACd,IAAI,EACJ,IAAI,CACL,CAA0E,CAAC,CAAC;IACjF,CAAC;IAED,MAAM,OAAO,GAAG,MAAM,CACpB,aAAkE,CACnE,CAAC;IAEF,OAAO,mBAAmB,CAAC,UAAsB,GAAG,IAAU;QAC5D,OAAO,kBAAkB,CAAC,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IACjE,CAA6E,CAAC,CAAC;AACjF,CAAC;AAED,SAAS,kBAAkB,CACzB,OAA0D,EAC1D,QAAkB,EAClB,IAAU,EACV,IAAU;IAEV,OAAO,qBAAqB,CAAC,QAAQ,EAAE,GAAG,EAAE;QAC1C,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAEzC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC;YACzB,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,OAAO,iBAAiB,CAAC;YACvB,QAAQ,EAAE,MAAM;YAChB,QAAQ;YACR,SAAS,EAAE,UAAU;YACrB,wBAAwB,EACtB,gGAAgG;YAClG,4BAA4B,EAC1B,uEAAuE;YACzE,kCAAkC,EAChC,sIAAsI;SACzI,CAAC,CAAC,KAAe,CAAC;IACrB,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import {\n  assertInInjectionContext,\n  inject,\n  Injector,\n  Provider,\n  runInInjectionContext,\n} from './host/craft-compat';\nimport type {\n  BrandedServiceProvider,\n  SERVICE_HELPER_DEPENDENCIES,\n  ServiceDependencyMapFromYielded,\n} from './craft-service';\nimport { ɵcreateHostTaggedInjector } from './craft-service';\nimport { isGenerator, runCraftGenerator } from './craft-generator-runtime';\nimport { injectFnWrapper } from './fn-wrapper';\nimport { markYieldableMethod, YIELDABLE_METHOD } from './yieldable';\n\ntype CraftMethodGenerator<This, Args extends unknown[], Yielded, Result> = (\n  this: This,\n  ...args: Args\n) => Generator<Yielded, Result, unknown>;\n\ntype CraftMethodWithReceiver<This, Args extends unknown[], Result> = (\n  this: This,\n  ...args: Args\n) => Result;\n\ntype CraftMethodWithoutReceiver<Args extends unknown[], Result> = (\n  ...args: Args\n) => Result;\n\ntype CraftMethodNameConfig<Name extends string> =\n  | Name\n  | { name: Name; providers?: readonly Provider[] };\n\ntype CraftMethodConfigProviderNames<Config> = Config extends {\n  providers: readonly (infer P)[];\n}\n  ? P extends BrandedServiceProvider<infer N, any, any>\n    ? N\n    : never\n  : never;\n\ntype SatisfyDependencies<Deps, SatisfiedNames extends string> = {\n  [K in keyof Deps as K extends SatisfiedNames ? never : K]: Deps[K];\n};\n\ntype TrackedCraftMethod<Callable, Yielded, Config = never> = Callable & {\n  readonly [YIELDABLE_METHOD]: {\n    readonly yielded?: Yielded;\n  };\n  readonly [SERVICE_HELPER_DEPENDENCIES]?: [\n    CraftMethodConfigProviderNames<Config>,\n  ] extends [never]\n    ? ServiceDependencyMapFromYielded<Yielded>\n    : SatisfyDependencies<\n        ServiceDependencyMapFromYielded<Yielded>,\n        CraftMethodConfigProviderNames<Config>\n      >;\n};\n\nfunction resolveCraftMethodName<Name extends string>(\n  nameOrConfig: CraftMethodNameConfig<Name>,\n): Name {\n  return typeof nameOrConfig === 'string' ? nameOrConfig : nameOrConfig.name;\n}\n\nfunction resolveCraftMethodProviders(\n  nameOrConfig: CraftMethodNameConfig<string>,\n): readonly Provider[] {\n  return typeof nameOrConfig === 'string' ? [] : (nameOrConfig.providers ?? []);\n}\n\nexport function craftMethod<\n  Name extends string,\n  This,\n  Args extends unknown[],\n  Yielded,\n  Result,\n  Config extends CraftMethodNameConfig<Name> = Name,\n>(\n  name: Config,\n  factory: CraftMethodGenerator<This, Args, Yielded, Result>,\n): TrackedCraftMethod<\n  CraftMethodWithReceiver<This, Args, Result>,\n  Yielded,\n  Config\n>;\nexport function craftMethod<\n  Name extends string,\n  This,\n  Args extends unknown[],\n  Yielded,\n  Result,\n  Config extends CraftMethodNameConfig<Name> = Name,\n>(\n  name: Config,\n  self: This,\n  factory: CraftMethodGenerator<This, Args, Yielded, Result>,\n): TrackedCraftMethod<\n  CraftMethodWithoutReceiver<Args, Result>,\n  Yielded,\n  Config\n>;\nexport function craftMethod<This, Args extends unknown[], Yielded, Result>(\n  nameOrConfig: CraftMethodNameConfig<string>,\n  selfOrFactory: This | CraftMethodGenerator<This, Args, Yielded, Result>,\n  maybeFactory?: CraftMethodGenerator<This, Args, Yielded, Result>,\n):\n  | TrackedCraftMethod<\n      CraftMethodWithReceiver<This, Args, Result>,\n      Yielded\n    >\n  | TrackedCraftMethod<CraftMethodWithoutReceiver<Args, Result>, Yielded> {\n  assertInInjectionContext(craftMethod);\n  const injector = inject(Injector);\n  const resolvedName = resolveCraftMethodName(nameOrConfig);\n  const extraProviders = resolveCraftMethodProviders(nameOrConfig);\n  const methodInjector = ɵcreateHostTaggedInjector(\n    injector,\n    `method:${resolvedName}`,\n    extraProviders,\n  );\n  const wrapFn = runInInjectionContext(methodInjector, () => injectFnWrapper());\n\n  if (maybeFactory) {\n    const self = selfOrFactory as This;\n    const factory = wrapFn(maybeFactory);\n\n    return markYieldableMethod(((...args: Args) =>\n      executeCraftMethod(\n        factory,\n        methodInjector,\n        self,\n        args,\n      )) as TrackedCraftMethod<CraftMethodWithoutReceiver<Args, Result>, Yielded>);\n  }\n\n  const factory = wrapFn(\n    selfOrFactory as CraftMethodGenerator<This, Args, Yielded, Result>,\n  );\n\n  return markYieldableMethod(function (this: This, ...args: Args) {\n    return executeCraftMethod(factory, methodInjector, this, args);\n  } as TrackedCraftMethod<CraftMethodWithReceiver<This, Args, Result>, Yielded>);\n}\n\nfunction executeCraftMethod<This, Args extends unknown[], Yielded, Result>(\n  factory: CraftMethodGenerator<This, Args, Yielded, Result>,\n  injector: Injector,\n  self: This,\n  args: Args,\n): Result {\n  return runInInjectionContext(injector, () => {\n    const result = factory.apply(self, args);\n\n    if (!isGenerator(result)) {\n      return result;\n    }\n\n    return runCraftGenerator({\n      iterator: result,\n      injector,\n      hostScope: 'function',\n      invalidYieldErrorMessage:\n        'craftMethod generators can only yield craftService dependencies or exposed dependency helpers.',\n      multipleAppStartErrorMessage:\n        'craftMethod generators cannot declare onAppStart(...) more than once.',\n      onAppStartNotSupportedErrorMessage:\n        'craftMethod(...) does not support onAppStart(...). Use onAppStart(...) only inside craftService({ appStart: true }, ...) generators.',\n    }).value as Result;\n  });\n}\n"]}

package/src/lib/craft-node-directive.d.ts

@@ -0,0 +1,32 @@
+import { InjectionToken, type EffectRef, type Injector } from './host/craft-compat';
+import { type CraftRegistrationTarget } from './craft-register-for-runtime';
+import type { CraftDomAdapter } from './host/craft-dom';
+/** Runtime marker shared by core-authored DOM directives and the Craft renderer. */
+export declare const CRAFT_NODE_DIRECTIVE: unique symbol;
+/** Creates a reactive effect owned by the current node-directive mount. */
+export type CraftNodeEffectFactory = (name: string, effectFn: () => void) => EffectRef;
+export declare const CRAFT_NODE_EFFECT_FACTORY: InjectionToken<CraftNodeEffectFactory>;
+/** The element-scoped services and reactive inputs available to a DOM directive. */
+export interface CraftNodeDirectiveContext<Props extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>> {
+    readonly element: Element;
+    readonly injector: Injector;
+    readonly renderer: CraftDomAdapter;
+    /**
+     * The current directive inputs. Reading this property inside an effect tracks
+     * input updates without remounting the directive.
+     */
+    readonly props: Props;
+}
+export type CraftNodeDirectiveMount<Props extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>> = (context: CraftNodeDirectiveContext<Props>) => void | (() => void);
+export interface CraftNodeDirectiveDefinition<Props extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>> {
+    readonly name: string;
+    readonly inputs: readonly (keyof Props & string)[];
+    readonly mount: CraftNodeDirectiveMount<Props>;
+}
+export interface CraftNodeDirective<Props extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>> extends CraftRegistrationTarget<string, 'directive', CraftNodeDirectiveContext<Props>> {
+    readonly [CRAFT_NODE_DIRECTIVE]: CraftNodeDirectiveDefinition<Props>;
+}
+/** Creates a functional directive mounted directly on a rendered DOM node. */
+export declare function craftNodeDirective<const Props extends Readonly<Record<string, unknown>>>(name: string, inputs: readonly (keyof Props & string)[], mount: CraftNodeDirectiveMount<Props>): CraftNodeDirective<Props>;
+export declare function isCraftNodeDirective(value: unknown): value is CraftNodeDirective<any>;
+//# sourceMappingURL=craft-node-directive.d.ts.map

package/src/lib/craft-node-directive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"craft-node-directive.d.ts","sourceRoot":"","sources":["../../../../../libs/core/src/lib/craft-node-directive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,KAAK,SAAS,EACd,KAAK,QAAQ,EACd,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,oFAAoF;AACpF,eAAO,MAAM,oBAAoB,eAEhC,CAAC;AAEF,2EAA2E;AAC3E,MAAM,MAAM,sBAAsB,GAAG,CACnC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,IAAI,KACjB,SAAS,CAAC;AAEf,eAAO,MAAM,yBAAyB,wCACmC,CAAC;AAE1E,oFAAoF;AACpF,MAAM,WAAW,yBAAyB,CACxC,KAAK,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,QAAQ,CACxD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACxB;IAED,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;CACvB;AAED,MAAM,MAAM,uBAAuB,CACjC,KAAK,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,QAAQ,CACxD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACxB,IACC,CAAC,OAAO,EAAE,yBAAyB,CAAC,KAAK,CAAC,KAAK,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC;AAEvE,MAAM,WAAW,4BAA4B,CAC3C,KAAK,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,QAAQ,CACxD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACxB;IAED,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,EAAE,CAAC;IACnD,QAAQ,CAAC,KAAK,EAAE,uBAAuB,CAAC,KAAK,CAAC,CAAC;CAChD;AAED,MAAM,WAAW,kBAAkB,CACjC,KAAK,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,QAAQ,CACxD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACxB,CACD,SAAQ,uBAAuB,CAC7B,MAAM,EACN,WAAW,EACX,yBAAyB,CAAC,KAAK,CAAC,CACjC;IACD,QAAQ,CAAC,CAAC,oBAAoB,CAAC,EAAE,4BAA4B,CAAC,KAAK,CAAC,CAAC;CACtE;AAED,8EAA8E;AAC9E,wBAAgB,kBAAkB,CAChC,KAAK,CAAC,KAAK,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAErD,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,SAAS,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,EAAE,EACzC,KAAK,EAAE,uBAAuB,CAAC,KAAK,CAAC,GACpC,kBAAkB,CAAC,KAAK,CAAC,CAa3B;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,kBAAkB,CAAC,GAAG,CAAC,CAElC"}