@craft-ts/core 0.7.0-beta.13

package/src/lib/craft-until-settled.d.ts

@@ -0,0 +1,99 @@
+import type { Signal } from './host/craft-compat';
+import { type AnyCraftException, type ExtractCraftException } from './craft-exception';
+import { type CraftGenExceptionMarker, type CraftPipeableProgram } from './craft-gen';
+import type { CraftHttpClientError } from './craft-http-client';
+import { type YieldableReactiveValue } from './reactive-read';
+type ReactiveResourceValue<T> = Signal<T> | YieldableReactiveValue<T>;
+/**
+ * The minimal shape a craft resource (`query` / `mutation` / `asyncProcess`)
+ * exposes that {@link craftUntilSettled} relies on: the `status`/`value` signals to
+ * read the settled outcome, and the `hasException`/`exceptions` signals to surface
+ * a loader `craftException`.
+ *
+ * `error` is the internal Angular channel: it is no longer part of the public craft
+ * façade type, but the raw signal remains on the ref at runtime (spread by the
+ * primitive's `Object.assign`). It is kept optional here so `craftUntilSettled` can
+ * re-throw a residual technical failure while public refs still match this shape.
+ */
+export type ResourceLike = {
+    status: ReactiveResourceValue<string>;
+    value: ReactiveResourceValue<unknown>;
+    error?: Signal<Error | undefined>;
+    hasException: ReactiveResourceValue<boolean>;
+    exceptions: ReactiveResourceValue<{
+        list: readonly AnyCraftException[];
+    }>;
+};
+/** The union of `craftException`s a resource may carry (its loader/params exceptions). */
+export type ResourceExceptionUnion<R> = R extends {
+    exceptions: YieldableReactiveValue<{
+        list: (infer Exception)[];
+    }>;
+} ? Extract<Exception, AnyCraftException> : R extends {
+    exceptions: Signal<{
+        list: (infer Exception)[];
+    }>;
+} ? Extract<Exception, AnyCraftException> : never;
+/** The settled (non-undefined) value a resource resolves to. */
+export type ResourceResolvedValue<R> = R extends {
+    value: YieldableReactiveValue<infer Value>;
+} ? Exclude<Value, undefined> : R extends {
+    value: Signal<infer Value>;
+} ? Exclude<Value, undefined> : unknown;
+/** The descriptor a `CraftHttpClient.*` call generator returns. */
+type HttpCallDescriptor<G> = G extends Generator<any, infer Descriptor, any> ? Descriptor : never;
+/** The yields relayed by a `CraftHttpClient.*` call generator (its tracked request). */
+type HttpCallYielded<G> = G extends Generator<infer Yielded, any, any> ? Yielded : never;
+/** What the HTTP descriptor resolves to: `Success | CustomException | CraftHttpClientError`. */
+type HttpResolved<G> = Awaited<HttpCallDescriptor<G>>;
+/**
+ * The business `craftException`s an HTTP call may produce, excluding the generic
+ * {@link CraftHttpClientError} (which `craftUntilSettled` rethrows rather than routing
+ * through the guard resolvers).
+ */
+type HttpCallException<G> = Exclude<ExtractCraftException<HttpResolved<G>>, CraftHttpClientError>;
+/** The success value of an HTTP call (its resolved value with every exception stripped). */
+type HttpCallSuccess<G> = Exclude<HttpResolved<G>, AnyCraftException>;
+/**
+ * Suspends a composing route guard until a craft async operation settles, then
+ * returns its success value. The operation's `craftException`s flow into the
+ * guard's exhaustive resolvers (compiler-enforced via the yielded
+ * {@link CraftGenExceptionMarker}).
+ *
+ * Two forms, both `yield*`-composable across the suspension:
+ *
+ * - **Resource** — a `query` / `mutation` / `asyncProcess` ref. Settles when its
+ *   `status` reaches `'resolved'` or `'exception'`. A loader `craftException`
+ *   short-circuits to the resolvers; a residual technical failure rethrows;
+ *   otherwise the resolved value is returned.
+ *
+ *   ```ts
+ *   const user = yield* craftUntilSettled(
+ *     query({ params: () => true, loader: async () => fetchUser() }),
+ *   );
+ *   ```
+ *
+ * - **HTTP call** — a `CraftHttpClient.*` call generator, awaited directly (no
+ *   resource needed). Its declared `exceptions` flow into the resolvers; the
+ *   generic `HttpError` is rethrown.
+ *
+ *   ```ts
+ *   const user = yield* craftUntilSettled(
+ *     CraftHttpClient.get(({ response }) => ({
+ *       url: `/api/users/${userId}`,
+ *       success: response<User>(),
+ *       exceptions: [...],
+ *     })),
+ *   );
+ *   ```
+ */
+export declare function craftUntilSettled<R extends ResourceLike>(resource: R): CraftPipeableProgram<CraftGenExceptionMarker<ResourceExceptionUnion<R>>, ResourceResolvedValue<R>>;
+export declare function craftUntilSettled<G extends Generator<any, any, any>>(call: G): CraftPipeableProgram<HttpCallYielded<G> | CraftGenExceptionMarker<HttpCallException<G>>, HttpCallSuccess<G>>;
+/**
+ * Suspends a composing route guard until `signal()` is no longer `undefined`,
+ * then returns its (non-nullable) value. Unlike {@link craftUntilSettled} there is no
+ * exception channel — use it to wait on a plain readiness signal.
+ */
+export declare function craftUntilDefined<T>(signal: Signal<T>): CraftPipeableProgram<never, NonNullable<T>>;
+export {};
+//# sourceMappingURL=craft-until-settled.d.ts.map

package/src/lib/craft-until-settled.d.ts.map

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

package/src/lib/craft-until-settled.js

@@ -0,0 +1,81 @@
+import { isCraftException, } from './craft-exception';
+import { CraftGenShortCircuit, ɵcreateCraftProgram, } from './craft-gen';
+import { GUARD_AWAIT_REQUEST_MARKER, isGenerator, } from './craft-generator-runtime';
+import { isYieldableReactiveValue, rawReactiveValue, } from './reactive-read';
+function guardAwaitRequest(request) {
+    return {
+        [GUARD_AWAIT_REQUEST_MARKER]: true,
+        ...request,
+    };
+}
+function* craftUntilSettledResource(resource) {
+    const adapter = {
+        status: () => readResourceValue(resource.status),
+        value: () => readResourceValue(resource.value),
+        error: () => resource.error?.(),
+        hasException: () => readResourceValue(resource.hasException),
+        exceptions: () => readResourceValue(resource.exceptions),
+    };
+    yield guardAwaitRequest({
+        kind: 'settle',
+        resource: adapter,
+    });
+    if (adapter.hasException()) {
+        throw new CraftGenShortCircuit(adapter.exceptions().list[0]);
+    }
+    if (adapter.status() === 'exception') {
+        // No business `craftException` present but the status is `'exception'` — a
+        // residual technical failure. Rethrow the raw Angular error (internal channel).
+        throw resource.error?.();
+    }
+    return adapter.value();
+}
+function readResourceValue(value) {
+    return isYieldableReactiveValue(value) ? rawReactiveValue(value)() : value();
+}
+function* craftUntilSettledHttp(call) {
+    const descriptor = yield* call;
+    const resolved = yield guardAwaitRequest({
+        kind: 'promise',
+        value: descriptor,
+    });
+    if (isCraftException(resolved)) {
+        if (resolved._tag === 'HttpError' && resolved.scope === 'HttpClient') {
+            // Generic network/transport failure — rethrow so it surfaces as a
+            // navigation error rather than a resolvable business case.
+            throw resolved;
+        }
+        // A declared business exception — route it through the guard's resolvers.
+        throw new CraftGenShortCircuit(resolved);
+    }
+    return resolved;
+}
+export function craftUntilSettled(source) {
+    return ɵcreateCraftProgram(() => isGenerator(source)
+        ? craftUntilSettledHttp(source)
+        : craftUntilSettledResource(source));
+}
+function signalSettleAdapter(signal) {
+    return {
+        status: () => (signal() !== undefined ? 'resolved' : 'loading'),
+        value: () => signal(),
+        error: () => undefined,
+        hasException: () => false,
+        exceptions: () => ({ list: [] }),
+    };
+}
+/**
+ * Suspends a composing route guard until `signal()` is no longer `undefined`,
+ * then returns its (non-nullable) value. Unlike {@link craftUntilSettled} there is no
+ * exception channel — use it to wait on a plain readiness signal.
+ */
+export function craftUntilDefined(signal) {
+    return ɵcreateCraftProgram(function* () {
+        yield guardAwaitRequest({
+            kind: 'settle',
+            resource: signalSettleAdapter(signal),
+        });
+        return signal();
+    });
+}
+//# sourceMappingURL=craft-until-settled.js.map

package/src/lib/craft-until-settled.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"craft-until-settled.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/craft-until-settled.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Signal } from './host/craft-compat';\nimport {\n  isCraftException,\n  type AnyCraftException,\n  type ExtractCraftException,\n} from './craft-exception';\nimport {\n  CraftGenShortCircuit,\n  ɵcreateCraftProgram,\n  type CraftGenExceptionMarker,\n  type CraftPipeableProgram,\n} from './craft-gen';\nimport {\n  GUARD_AWAIT_REQUEST_MARKER,\n  isGenerator,\n  type GuardAwaitResourceLike,\n  type RuntimeGuardAwaitRequest,\n} from './craft-generator-runtime';\nimport type { CraftHttpClientError } from './craft-http-client';\nimport {\n  isYieldableReactiveValue,\n  rawReactiveValue,\n  type YieldableReactiveValue,\n} from './reactive-read';\n\ntype ReactiveResourceValue<T> = Signal<T> | YieldableReactiveValue<T>;\n\n/**\n * The minimal shape a craft resource (`query` / `mutation` / `asyncProcess`)\n * exposes that {@link craftUntilSettled} relies on: the `status`/`value` signals to\n * read the settled outcome, and the `hasException`/`exceptions` signals to surface\n * a loader `craftException`.\n *\n * `error` is the internal Angular channel: it is no longer part of the public craft\n * façade type, but the raw signal remains on the ref at runtime (spread by the\n * primitive's `Object.assign`). It is kept optional here so `craftUntilSettled` can\n * re-throw a residual technical failure while public refs still match this shape.\n */\nexport type ResourceLike = {\n  status: ReactiveResourceValue<string>;\n  value: ReactiveResourceValue<unknown>;\n  error?: Signal<Error | undefined>;\n  hasException: ReactiveResourceValue<boolean>;\n  exceptions: ReactiveResourceValue<{ list: readonly AnyCraftException[] }>;\n};\n\n/** The union of `craftException`s a resource may carry (its loader/params exceptions). */\nexport type ResourceExceptionUnion<R> = R extends {\n  exceptions: YieldableReactiveValue<{ list: (infer Exception)[] }>;\n}\n  ? Extract<Exception, AnyCraftException>\n  : R extends { exceptions: Signal<{ list: (infer Exception)[] }> }\n    ? Extract<Exception, AnyCraftException>\n    : never;\n\n/** The settled (non-undefined) value a resource resolves to. */\nexport type ResourceResolvedValue<R> = R extends {\n  value: YieldableReactiveValue<infer Value>;\n}\n  ? Exclude<Value, undefined>\n  : R extends { value: Signal<infer Value> }\n    ? Exclude<Value, undefined>\n    : unknown;\n\n/** The descriptor a `CraftHttpClient.*` call generator returns. */\ntype HttpCallDescriptor<G> =\n  G extends Generator<any, infer Descriptor, any> ? Descriptor : never;\n\n/** The yields relayed by a `CraftHttpClient.*` call generator (its tracked request). */\ntype HttpCallYielded<G> =\n  G extends Generator<infer Yielded, any, any> ? Yielded : never;\n\n/** What the HTTP descriptor resolves to: `Success | CustomException | CraftHttpClientError`. */\ntype HttpResolved<G> = Awaited<HttpCallDescriptor<G>>;\n\n/**\n * The business `craftException`s an HTTP call may produce, excluding the generic\n * {@link CraftHttpClientError} (which `craftUntilSettled` rethrows rather than routing\n * through the guard resolvers).\n */\ntype HttpCallException<G> = Exclude<\n  ExtractCraftException<HttpResolved<G>>,\n  CraftHttpClientError\n>;\n\n/** The success value of an HTTP call (its resolved value with every exception stripped). */\ntype HttpCallSuccess<G> = Exclude<HttpResolved<G>, AnyCraftException>;\n\nfunction guardAwaitRequest(\n  request:\n    | { kind: 'settle'; resource: GuardAwaitResourceLike }\n    | { kind: 'promise'; value: PromiseLike<unknown> },\n): RuntimeGuardAwaitRequest {\n  return {\n    [GUARD_AWAIT_REQUEST_MARKER]: true,\n    ...request,\n  } as RuntimeGuardAwaitRequest;\n}\n\nfunction* craftUntilSettledResource(\n  resource: ResourceLike,\n): Generator<unknown, unknown, unknown> {\n  const adapter = {\n    status: () => readResourceValue(resource.status),\n    value: () => readResourceValue(resource.value),\n    error: () => resource.error?.(),\n    hasException: () => readResourceValue(resource.hasException),\n    exceptions: () => readResourceValue(resource.exceptions),\n  } satisfies GuardAwaitResourceLike;\n  yield guardAwaitRequest({\n    kind: 'settle',\n    resource: adapter,\n  });\n\n  if (adapter.hasException()) {\n    throw new CraftGenShortCircuit(adapter.exceptions().list[0]);\n  }\n\n  if (adapter.status() === 'exception') {\n    // No business `craftException` present but the status is `'exception'` — a\n    // residual technical failure. Rethrow the raw Angular error (internal channel).\n    throw resource.error?.();\n  }\n\n  return adapter.value();\n}\n\nfunction readResourceValue<T>(value: ReactiveResourceValue<T>): T {\n  return isYieldableReactiveValue(value) ? rawReactiveValue(value)() : value();\n}\n\nfunction* craftUntilSettledHttp(\n  call: Generator<unknown, unknown, unknown>,\n): Generator<unknown, unknown, unknown> {\n  const descriptor = yield* call;\n  const resolved = yield guardAwaitRequest({\n    kind: 'promise',\n    value: descriptor as PromiseLike<unknown>,\n  });\n\n  if (isCraftException(resolved)) {\n    if (resolved._tag === 'HttpError' && resolved.scope === 'HttpClient') {\n      // Generic network/transport failure — rethrow so it surfaces as a\n      // navigation error rather than a resolvable business case.\n      throw resolved;\n    }\n\n    // A declared business exception — route it through the guard's resolvers.\n    throw new CraftGenShortCircuit(resolved);\n  }\n\n  return resolved;\n}\n\n/**\n * Suspends a composing route guard until a craft async operation settles, then\n * returns its success value. The operation's `craftException`s flow into the\n * guard's exhaustive resolvers (compiler-enforced via the yielded\n * {@link CraftGenExceptionMarker}).\n *\n * Two forms, both `yield*`-composable across the suspension:\n *\n * - **Resource** — a `query` / `mutation` / `asyncProcess` ref. Settles when its\n *   `status` reaches `'resolved'` or `'exception'`. A loader `craftException`\n *   short-circuits to the resolvers; a residual technical failure rethrows;\n *   otherwise the resolved value is returned.\n *\n *   ```ts\n *   const user = yield* craftUntilSettled(\n *     query({ params: () => true, loader: async () => fetchUser() }),\n *   );\n *   ```\n *\n * - **HTTP call** — a `CraftHttpClient.*` call generator, awaited directly (no\n *   resource needed). Its declared `exceptions` flow into the resolvers; the\n *   generic `HttpError` is rethrown.\n *\n *   ```ts\n *   const user = yield* craftUntilSettled(\n *     CraftHttpClient.get(({ response }) => ({\n *       url: `/api/users/${userId}`,\n *       success: response<User>(),\n *       exceptions: [...],\n *     })),\n *   );\n *   ```\n */\nexport function craftUntilSettled<R extends ResourceLike>(\n  resource: R,\n): CraftPipeableProgram<\n  CraftGenExceptionMarker<ResourceExceptionUnion<R>>,\n  ResourceResolvedValue<R>\n>;\nexport function craftUntilSettled<G extends Generator<any, any, any>>(\n  call: G,\n): CraftPipeableProgram<\n  HttpCallYielded<G> | CraftGenExceptionMarker<HttpCallException<G>>,\n  HttpCallSuccess<G>\n>;\nexport function craftUntilSettled(\n  source: ResourceLike | Generator<unknown, unknown, unknown>,\n): CraftPipeableProgram<unknown, unknown> {\n  return ɵcreateCraftProgram(() =>\n    isGenerator(source)\n      ? craftUntilSettledHttp(source)\n      : craftUntilSettledResource(source),\n  ) as CraftPipeableProgram<unknown, unknown>;\n}\n\nfunction signalSettleAdapter<T>(signal: Signal<T>): GuardAwaitResourceLike {\n  return {\n    status: () => (signal() !== undefined ? 'resolved' : 'loading'),\n    value: () => signal(),\n    error: () => undefined,\n    hasException: () => false,\n    exceptions: () => ({ list: [] }),\n  };\n}\n\n/**\n * Suspends a composing route guard until `signal()` is no longer `undefined`,\n * then returns its (non-nullable) value. Unlike {@link craftUntilSettled} there is no\n * exception channel — use it to wait on a plain readiness signal.\n */\nexport function craftUntilDefined<T>(\n  signal: Signal<T>,\n): CraftPipeableProgram<never, NonNullable<T>> {\n  return ɵcreateCraftProgram(function* () {\n    yield guardAwaitRequest({\n      kind: 'settle',\n      resource: signalSettleAdapter(signal),\n    });\n\n    return signal();\n  }) as unknown as CraftPipeableProgram<never, NonNullable<T>>;\n}\n"]}

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

@@ -0,0 +1,26 @@
+/**
+ * Drives any craft generator synchronously outside a generator host and
+ * returns its result — the imperative counterpart of `yield*`.
+ *
+ * Its main use is consuming a craft primitive (`state`, `query`, `mutation`,
+ * `asyncProcess`, `queryParams`) outside a generator host. Like `yield*`, it
+ * resolves to the primitive reference itself:
+ *
+ * ```ts
+ * const users = craftUse(query('users', { loader: ... }));
+ * const counter = craftUse(state('counter', 0));
+ * ```
+ *
+ * It also accepts a `craftGen` invocation, an inline generator, or an
+ * argument-less generator function. Dependency yields are resolved through the
+ * ambient injection context when one is available; a `CraftGenShortCircuit`
+ * thrown by a composed `craftGen` propagates unchanged.
+ *
+ * A generator is single-use: passing the same invocation to `craftUse` twice
+ * (or after a `yield*`) drives an exhausted generator and returns `undefined`.
+ */
+export declare function craftUse<Yielded, Output>(invocation: Generator<Yielded, Output, unknown>): Output;
+export declare function craftUse<Yielded, Output>(invocation: Generator<Yielded, Output, unknown> | undefined): Output | undefined;
+export declare function craftUse<Yielded, Output>(factory: () => Generator<Yielded, Output, unknown>): Output;
+export declare function craftUse<Value>(value: Value): Value;
+//# sourceMappingURL=craft-use.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"craft-use.d.ts","sourceRoot":"","sources":["../../../../../libs/core/src/lib/craft-use.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EACtC,UAAU,EAAE,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,GAC9C,MAAM,CAAC;AACV,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EACtC,UAAU,EAAE,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAC1D,MAAM,GAAG,SAAS,CAAC;AACtB,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EACtC,OAAO,EAAE,MAAM,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,GACjD,MAAM,CAAC;AACV,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC"}

package/src/lib/craft-use.js

@@ -0,0 +1,37 @@
+import { inject, Injector, runInInjectionContext } from './host/craft-compat';
+import { isGenerator, runCraftGenerator } from './craft-generator-runtime';
+const INVALID_YIELD_ERROR_MESSAGE = 'craftUse(...) generators can only yield craft primitives, exposed dependency helpers, or craftService dependencies.';
+const ON_APP_START_ERROR_MESSAGE = 'craftUse(...) does not support onAppStart(...): it is only available inside a craftService factory.';
+const GUARD_AWAIT_ERROR_MESSAGE = 'craftUse(...) does not support craftUntilSettled(...)/craftUntilDefined(...): they are only available inside route guards.';
+export function craftUse(input) {
+    if (input === undefined)
+        return undefined;
+    if (!isGenerator(input) && typeof input !== 'function')
+        return input;
+    const iterator = isGenerator(input) ? input : input();
+    // Capture the ambient injector when available. Driving a trivial primitive
+    // generator needs none, so `craftUse` stays usable outside an injection
+    // context (leniency aligned with the primitives' own eager capture).
+    let injector;
+    try {
+        injector = inject(Injector);
+    }
+    catch {
+        injector = undefined;
+    }
+    // A generator may yield a dependency request whose resolver does not need
+    // Angular DI. Keep that valid outside an injection context while still
+    // giving the runtime an injector for wrapper lookup and resolver shape.
+    const runtimeInjector = injector ?? Injector.create({ providers: [] });
+    const drive = () => runCraftGenerator({
+        iterator,
+        injector: runtimeInjector,
+        hostScope: 'function',
+        invalidYieldErrorMessage: INVALID_YIELD_ERROR_MESSAGE,
+        multipleAppStartErrorMessage: ON_APP_START_ERROR_MESSAGE,
+        onAppStartNotSupportedErrorMessage: ON_APP_START_ERROR_MESSAGE,
+        guardAwaitNotSupportedErrorMessage: GUARD_AWAIT_ERROR_MESSAGE,
+    }).value;
+    return injector ? runInInjectionContext(injector, drive) : drive();
+}
+//# sourceMappingURL=craft-use.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"craft-use.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/craft-use.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE3E,MAAM,2BAA2B,GAC/B,qHAAqH,CAAC;AACxH,MAAM,0BAA0B,GAC9B,qGAAqG,CAAC;AACxG,MAAM,yBAAyB,GAC7B,4HAA4H,CAAC;AAiC/H,MAAM,UAAU,QAAQ,CACtB,KAIW;IAEX,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC1C,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,OAAO,KAAK,KAAK,UAAU;QAAE,OAAO,KAAK,CAAC;IACrE,MAAM,QAAQ,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;IAEtD,2EAA2E;IAC3E,wEAAwE;IACxE,qEAAqE;IACrE,IAAI,QAA8B,CAAC;IACnC,IAAI,CAAC;QACH,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC9B,CAAC;IAAC,MAAM,CAAC;QACP,QAAQ,GAAG,SAAS,CAAC;IACvB,CAAC;IAED,0EAA0E;IAC1E,uEAAuE;IACvE,wEAAwE;IACxE,MAAM,eAAe,GAAG,QAAQ,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,CAAC;IAEvE,MAAM,KAAK,GAAG,GAAG,EAAE,CACjB,iBAAiB,CAAC;QAChB,QAAQ;QACR,QAAQ,EAAE,eAAe;QACzB,SAAS,EAAE,UAAU;QACrB,wBAAwB,EAAE,2BAA2B;QACrD,4BAA4B,EAAE,0BAA0B;QACxD,kCAAkC,EAAE,0BAA0B;QAC9D,kCAAkC,EAAE,yBAAyB;KAC9D,CAAC,CAAC,KAAK,CAAC;IAEX,OAAO,QAAQ,CAAC,CAAC,CAAC,qBAAqB,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;AACrE,CAAC","sourcesContent":["import { inject, Injector, runInInjectionContext } from './host/craft-compat';\nimport { isGenerator, runCraftGenerator } from './craft-generator-runtime';\n\nconst INVALID_YIELD_ERROR_MESSAGE =\n  'craftUse(...) generators can only yield craft primitives, exposed dependency helpers, or craftService dependencies.';\nconst ON_APP_START_ERROR_MESSAGE =\n  'craftUse(...) does not support onAppStart(...): it is only available inside a craftService factory.';\nconst GUARD_AWAIT_ERROR_MESSAGE =\n  'craftUse(...) does not support craftUntilSettled(...)/craftUntilDefined(...): they are only available inside route guards.';\n\n/**\n * Drives any craft generator synchronously outside a generator host and\n * returns its result — the imperative counterpart of `yield*`.\n *\n * Its main use is consuming a craft primitive (`state`, `query`, `mutation`,\n * `asyncProcess`, `queryParams`) outside a generator host. Like `yield*`, it\n * resolves to the primitive reference itself:\n *\n * ```ts\n * const users = craftUse(query('users', { loader: ... }));\n * const counter = craftUse(state('counter', 0));\n * ```\n *\n * It also accepts a `craftGen` invocation, an inline generator, or an\n * argument-less generator function. Dependency yields are resolved through the\n * ambient injection context when one is available; a `CraftGenShortCircuit`\n * thrown by a composed `craftGen` propagates unchanged.\n *\n * A generator is single-use: passing the same invocation to `craftUse` twice\n * (or after a `yield*`) drives an exhausted generator and returns `undefined`.\n */\nexport function craftUse<Yielded, Output>(\n  invocation: Generator<Yielded, Output, unknown>,\n): Output;\nexport function craftUse<Yielded, Output>(\n  invocation: Generator<Yielded, Output, unknown> | undefined,\n): Output | undefined;\nexport function craftUse<Yielded, Output>(\n  factory: () => Generator<Yielded, Output, unknown>,\n): Output;\nexport function craftUse<Value>(value: Value): Value;\nexport function craftUse(\n  input:\n    | Generator<unknown, unknown, unknown>\n    | undefined\n    | (() => Generator<unknown, unknown, unknown>)\n    | unknown,\n): unknown {\n  if (input === undefined) return undefined;\n  if (!isGenerator(input) && typeof input !== 'function') return input;\n  const iterator = isGenerator(input) ? input : input();\n\n  // Capture the ambient injector when available. Driving a trivial primitive\n  // generator needs none, so `craftUse` stays usable outside an injection\n  // context (leniency aligned with the primitives' own eager capture).\n  let injector: Injector | undefined;\n  try {\n    injector = inject(Injector);\n  } catch {\n    injector = undefined;\n  }\n\n  // A generator may yield a dependency request whose resolver does not need\n  // Angular DI. Keep that valid outside an injection context while still\n  // giving the runtime an injector for wrapper lookup and resolver shape.\n  const runtimeInjector = injector ?? Injector.create({ providers: [] });\n\n  const drive = () =>\n    runCraftGenerator({\n      iterator,\n      injector: runtimeInjector,\n      hostScope: 'function',\n      invalidYieldErrorMessage: INVALID_YIELD_ERROR_MESSAGE,\n      multipleAppStartErrorMessage: ON_APP_START_ERROR_MESSAGE,\n      onAppStartNotSupportedErrorMessage: ON_APP_START_ERROR_MESSAGE,\n      guardAwaitNotSupportedErrorMessage: GUARD_AWAIT_ERROR_MESSAGE,\n    }).value;\n\n  return injector ? runInInjectionContext(injector, drive) : drive();\n}\n"]}

package/src/lib/craft-view-transition.d.ts

@@ -0,0 +1,102 @@
+import { InjectionToken, type Signal } from './host/craft-compat';
+import { type CraftLoadingFeature } from './craft-pending';
+/**
+ * The marker a route stores in `withLoaderViewTransitionImage` to declare the
+ * shape `T` of its shared-element payload — the view-transition analogue of how
+ * `queryParams` declares the shape of a route's query params. `T` flows into:
+ * the REQUIRED `viewTransition` field on every `craftRouterLink` / `navigate`
+ * targeting the route (as `T | null`), and the generated, typed
+ * `injectXxxViewTransition(): Signal<T | null>` helper the pending skeleton (or
+ * target) reads.
+ *
+ * The phantom property is a plain (string-keyed, required) brand rather than a
+ * `unique symbol`: this marker rides along inside the route definition that the
+ * parent `app.routes` path registry materializes through `loadChildren`, and
+ * that registry sits at TypeScript's instantiation-depth ceiling — a symbol-
+ * keyed phantom measurably costs more there. The required key also keeps a bare
+ * `{}` from structurally matching the marker.
+ */
+export interface ViewTransitionPayloadDef<T> {
+    readonly __craftViewTransitionPayload: T;
+}
+/**
+ * Declares the shared-element payload shape `T` for a view-transition route.
+ * Place it on `withLoaderViewTransitionImage` exactly like `queryParams`:
+ *
+ * ```ts
+ * craftRoute(':photoId', {
+ *   withLoaderViewTransitionImage: viewTransitionPayload<{ name: string; image: string | null }>(),
+ *   // ...
+ * })
+ * ```
+ *
+ * Returns an empty runtime marker — `T` lives purely at the type level (carried
+ * by the phantom {@link ViewTransitionPayloadDef} brand).
+ */
+export declare function viewTransitionPayload<T>(): ViewTransitionPayloadDef<T>;
+/**
+ * What a navigation transports for a view-transition route. Deliberately loose
+ * at the transport layer ({@link CRAFT_VIEW_TRANSITION} is a single global sink
+ * shared by every view-transition route): the per-route generated helpers
+ * narrow it to the declared `T | null`. `null` opts out of the morph explicitly.
+ */
+export type CraftViewTransitionInput = unknown;
+/**
+ * Key under which the view-transition payload travels in Angular's navigation
+ * `state` (history state). The outlet reads it from the current navigation and
+ * republishes it through {@link CRAFT_VIEW_TRANSITION}.
+ */
+export declare const CRAFT_VIEW_TRANSITION_STATE_KEY = "__craftViewTransition";
+/**
+ * The view-transition payload for the current navigation, as a signal the
+ * outlet writes and the skeleton/target read (via {@link
+ * injectCraftViewTransition}). `null` between/without view-transition
+ * navigations.
+ */
+export declare const CRAFT_VIEW_TRANSITION: InjectionToken<Signal<unknown>>;
+/** Reads the current navigation's view-transition payload (see {@link CRAFT_VIEW_TRANSITION}). */
+export declare function injectCraftViewTransition(): Signal<CraftViewTransitionInput>;
+/** Whether the outlet should drive `document.startViewTransition()` around its swaps. */
+export declare const CRAFT_VIEW_TRANSITIONS_ENABLED: InjectionToken<boolean>;
+/**
+ * Whether the outlet should skip the `'blank'` phase while view transitions are
+ * enabled. A blank surface between the previous page and the skeleton breaks the
+ * shared-element morph, so routes that declare a `withLoaderViewTransitionImage`
+ * payload always skip blank; this token lets `withCraftViewTransitions({ skipBlank })`
+ * extend that to every route.
+ */
+export declare const CRAFT_VIEW_TRANSITION_SKIP_BLANK: InjectionToken<boolean>;
+/** Runs `cb` inside a view transition. The seam tests override to capture the callback. */
+export type CraftStartViewTransition = (cb: () => void) => void;
+/**
+ * The function the outlet uses to bracket a swap in a view transition. The
+ * default wraps `document.startViewTransition()`, but falls back to running
+ * `cb` directly when the API is missing or the user prefers reduced motion.
+ * Overridable in tests to capture the callback deterministically.
+ */
+export declare const CRAFT_START_VIEW_TRANSITION: InjectionToken<CraftStartViewTransition>;
+/**
+ * Hands the {@link CraftRouterOutletController} control of the browser View
+ * Transitions
+ * API. Unlike Angular's `withViewTransitions()` — which brackets only the
+ * synchronous URL commit — this drives `document.startViewTransition()` around
+ * the outlet's *own* swaps (`previous page → skeleton → target`), so a
+ * shared-element morph survives a slow guard/resolve chain.
+ *
+ * Routes that declare a `withLoaderViewTransitionImage` payload (via {@link
+ * viewTransitionPayload}) additionally skip the `'blank'` phase (a blank surface
+ * would break the morph) and require every `craftRouterLink` / `navigate`
+ * targeting them to pass a typed `viewTransition` payload. Pass
+ * `{ skipBlank: true }` to extend the blank-skip to all routes.
+ *
+ * ```ts
+ * provideCraftRouter(
+ *   demoRoutes.toRoutes(),
+ *   withCraftViewTransitions(),
+ * )
+ * ```
+ */
+export declare function withCraftViewTransitions(options?: {
+    skipBlank?: boolean;
+}): CraftLoadingFeature;
+//# sourceMappingURL=craft-view-transition.d.ts.map

package/src/lib/craft-view-transition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"craft-view-transition.d.ts","sourceRoot":"","sources":["../../../../../libs/core/src/lib/craft-view-transition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,cAAc,EAAU,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClF,OAAO,EAAuB,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAEhF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,wBAAwB,CAAC,CAAC;IACzC,QAAQ,CAAC,4BAA4B,EAAE,CAAC,CAAC;CAC1C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,KAAK,wBAAwB,CAAC,CAAC,CAAC,CAEtE;AAED;;;;;GAKG;AACH,MAAM,MAAM,wBAAwB,GAAG,OAAO,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,+BAA+B,0BAA0B,CAAC;AAEvE;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,iCAKhC,CAAC;AAEH,kGAAkG;AAClG,wBAAgB,yBAAyB,IAAI,MAAM,CAAC,wBAAwB,CAAC,CAE5E;AAED,yFAAyF;AACzF,eAAO,MAAM,8BAA8B,yBAG1C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,gCAAgC,yBAG5C,CAAC;AAEF,2FAA2F;AAC3F,MAAM,MAAM,wBAAwB,GAAG,CAAC,EAAE,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;AAMhE;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,0CAIpC,CAAC;AAuDL;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,CAAC,EAAE;IACjD,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,GAAG,mBAAmB,CAQtB"}

package/src/lib/craft-view-transition.js

@@ -0,0 +1,130 @@
+import { inject, InjectionToken, signal } from './host/craft-compat';
+import { craftLoadingFeature } from './craft-pending';
+/**
+ * Declares the shared-element payload shape `T` for a view-transition route.
+ * Place it on `withLoaderViewTransitionImage` exactly like `queryParams`:
+ *
+ * ```ts
+ * craftRoute(':photoId', {
+ *   withLoaderViewTransitionImage: viewTransitionPayload<{ name: string; image: string | null }>(),
+ *   // ...
+ * })
+ * ```
+ *
+ * Returns an empty runtime marker — `T` lives purely at the type level (carried
+ * by the phantom {@link ViewTransitionPayloadDef} brand).
+ */
+export function viewTransitionPayload() {
+    return {};
+}
+/**
+ * Key under which the view-transition payload travels in Angular's navigation
+ * `state` (history state). The outlet reads it from the current navigation and
+ * republishes it through {@link CRAFT_VIEW_TRANSITION}.
+ */
+export const CRAFT_VIEW_TRANSITION_STATE_KEY = '__craftViewTransition';
+/**
+ * The view-transition payload for the current navigation, as a signal the
+ * outlet writes and the skeleton/target read (via {@link
+ * injectCraftViewTransition}). `null` between/without view-transition
+ * navigations.
+ */
+export const CRAFT_VIEW_TRANSITION = new InjectionToken('CRAFT_VIEW_TRANSITION', {
+    providedIn: 'root',
+    factory: () => signal(null),
+});
+/** Reads the current navigation's view-transition payload (see {@link CRAFT_VIEW_TRANSITION}). */
+export function injectCraftViewTransition() {
+    return inject(CRAFT_VIEW_TRANSITION);
+}
+/** Whether the outlet should drive `document.startViewTransition()` around its swaps. */
+export const CRAFT_VIEW_TRANSITIONS_ENABLED = new InjectionToken('CRAFT_VIEW_TRANSITIONS_ENABLED', { providedIn: 'root', factory: () => false });
+/**
+ * Whether the outlet should skip the `'blank'` phase while view transitions are
+ * enabled. A blank surface between the previous page and the skeleton breaks the
+ * shared-element morph, so routes that declare a `withLoaderViewTransitionImage`
+ * payload always skip blank; this token lets `withCraftViewTransitions({ skipBlank })`
+ * extend that to every route.
+ */
+export const CRAFT_VIEW_TRANSITION_SKIP_BLANK = new InjectionToken('CRAFT_VIEW_TRANSITION_SKIP_BLANK', { providedIn: 'root', factory: () => false });
+/**
+ * The function the outlet uses to bracket a swap in a view transition. The
+ * default wraps `document.startViewTransition()`, but falls back to running
+ * `cb` directly when the API is missing or the user prefers reduced motion.
+ * Overridable in tests to capture the callback deterministically.
+ */
+export const CRAFT_START_VIEW_TRANSITION = new InjectionToken('CRAFT_START_VIEW_TRANSITION', {
+    providedIn: 'root',
+    factory: () => defaultStartViewTransition,
+});
+function defaultStartViewTransition(cb) {
+    const doc = typeof document !== 'undefined'
+        ? document
+        : undefined;
+    const prefersReducedMotion = typeof window !== 'undefined' &&
+        typeof window.matchMedia === 'function' &&
+        window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+    if (!doc?.startViewTransition || prefersReducedMotion) {
+        cb();
+        return;
+    }
+    // Chromium can expose the API while failing to invoke the update callback
+    // when a transition is started during router activation. Never leave the
+    // outlet waiting forever for that callback: the fallback still commits the
+    // new DOM, while the idempotent wrapper prevents a later native callback
+    // from committing twice.
+    let callbackCalled = false;
+    const runOnce = () => {
+        if (callbackCalled) {
+            return;
+        }
+        callbackCalled = true;
+        cb();
+    };
+    const transition = doc.startViewTransition(runOnce);
+    for (const promise of [
+        transition?.ready,
+        transition?.updateCallbackDone,
+        transition?.finished,
+    ]) {
+        void promise?.catch(() => undefined);
+    }
+    queueMicrotask(() => {
+        if (callbackCalled) {
+            return;
+        }
+        runOnce();
+        transition?.skipTransition?.();
+    });
+}
+/**
+ * Hands the {@link CraftRouterOutletController} control of the browser View
+ * Transitions
+ * API. Unlike Angular's `withViewTransitions()` — which brackets only the
+ * synchronous URL commit — this drives `document.startViewTransition()` around
+ * the outlet's *own* swaps (`previous page → skeleton → target`), so a
+ * shared-element morph survives a slow guard/resolve chain.
+ *
+ * Routes that declare a `withLoaderViewTransitionImage` payload (via {@link
+ * viewTransitionPayload}) additionally skip the `'blank'` phase (a blank surface
+ * would break the morph) and require every `craftRouterLink` / `navigate`
+ * targeting them to pass a typed `viewTransition` payload. Pass
+ * `{ skipBlank: true }` to extend the blank-skip to all routes.
+ *
+ * ```ts
+ * provideCraftRouter(
+ *   demoRoutes.toRoutes(),
+ *   withCraftViewTransitions(),
+ * )
+ * ```
+ */
+export function withCraftViewTransitions(options) {
+    return craftLoadingFeature([
+        { provide: CRAFT_VIEW_TRANSITIONS_ENABLED, useValue: true },
+        {
+            provide: CRAFT_VIEW_TRANSITION_SKIP_BLANK,
+            useValue: options?.skipBlank ?? false,
+        },
+    ]);
+}
+//# sourceMappingURL=craft-view-transition.js.map

package/src/lib/craft-view-transition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"craft-view-transition.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/craft-view-transition.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, InjectionToken, signal, type Signal } from './host/craft-compat';\nimport { craftLoadingFeature, type CraftLoadingFeature } from './craft-pending';\n\n/**\n * The marker a route stores in `withLoaderViewTransitionImage` to declare the\n * shape `T` of its shared-element payload — the view-transition analogue of how\n * `queryParams` declares the shape of a route's query params. `T` flows into:\n * the REQUIRED `viewTransition` field on every `craftRouterLink` / `navigate`\n * targeting the route (as `T | null`), and the generated, typed\n * `injectXxxViewTransition(): Signal<T | null>` helper the pending skeleton (or\n * target) reads.\n *\n * The phantom property is a plain (string-keyed, required) brand rather than a\n * `unique symbol`: this marker rides along inside the route definition that the\n * parent `app.routes` path registry materializes through `loadChildren`, and\n * that registry sits at TypeScript's instantiation-depth ceiling — a symbol-\n * keyed phantom measurably costs more there. The required key also keeps a bare\n * `{}` from structurally matching the marker.\n */\nexport interface ViewTransitionPayloadDef<T> {\n  readonly __craftViewTransitionPayload: T;\n}\n\n/**\n * Declares the shared-element payload shape `T` for a view-transition route.\n * Place it on `withLoaderViewTransitionImage` exactly like `queryParams`:\n *\n * ```ts\n * craftRoute(':photoId', {\n *   withLoaderViewTransitionImage: viewTransitionPayload<{ name: string; image: string | null }>(),\n *   // ...\n * })\n * ```\n *\n * Returns an empty runtime marker — `T` lives purely at the type level (carried\n * by the phantom {@link ViewTransitionPayloadDef} brand).\n */\nexport function viewTransitionPayload<T>(): ViewTransitionPayloadDef<T> {\n  return {} as ViewTransitionPayloadDef<T>;\n}\n\n/**\n * What a navigation transports for a view-transition route. Deliberately loose\n * at the transport layer ({@link CRAFT_VIEW_TRANSITION} is a single global sink\n * shared by every view-transition route): the per-route generated helpers\n * narrow it to the declared `T | null`. `null` opts out of the morph explicitly.\n */\nexport type CraftViewTransitionInput = unknown;\n\n/**\n * Key under which the view-transition payload travels in Angular's navigation\n * `state` (history state). The outlet reads it from the current navigation and\n * republishes it through {@link CRAFT_VIEW_TRANSITION}.\n */\nexport const CRAFT_VIEW_TRANSITION_STATE_KEY = '__craftViewTransition';\n\n/**\n * The view-transition payload for the current navigation, as a signal the\n * outlet writes and the skeleton/target read (via {@link\n * injectCraftViewTransition}). `null` between/without view-transition\n * navigations.\n */\nexport const CRAFT_VIEW_TRANSITION = new InjectionToken<\n  Signal<CraftViewTransitionInput>\n>('CRAFT_VIEW_TRANSITION', {\n  providedIn: 'root',\n  factory: () => signal<CraftViewTransitionInput>(null),\n});\n\n/** Reads the current navigation's view-transition payload (see {@link CRAFT_VIEW_TRANSITION}). */\nexport function injectCraftViewTransition(): Signal<CraftViewTransitionInput> {\n  return inject(CRAFT_VIEW_TRANSITION);\n}\n\n/** Whether the outlet should drive `document.startViewTransition()` around its swaps. */\nexport const CRAFT_VIEW_TRANSITIONS_ENABLED = new InjectionToken<boolean>(\n  'CRAFT_VIEW_TRANSITIONS_ENABLED',\n  { providedIn: 'root', factory: () => false },\n);\n\n/**\n * Whether the outlet should skip the `'blank'` phase while view transitions are\n * enabled. A blank surface between the previous page and the skeleton breaks the\n * shared-element morph, so routes that declare a `withLoaderViewTransitionImage`\n * payload always skip blank; this token lets `withCraftViewTransitions({ skipBlank })`\n * extend that to every route.\n */\nexport const CRAFT_VIEW_TRANSITION_SKIP_BLANK = new InjectionToken<boolean>(\n  'CRAFT_VIEW_TRANSITION_SKIP_BLANK',\n  { providedIn: 'root', factory: () => false },\n);\n\n/** Runs `cb` inside a view transition. The seam tests override to capture the callback. */\nexport type CraftStartViewTransition = (cb: () => void) => void;\n\ninterface ViewTransitionDocument {\n  startViewTransition?: (cb: () => void) => unknown;\n}\n\n/**\n * The function the outlet uses to bracket a swap in a view transition. The\n * default wraps `document.startViewTransition()`, but falls back to running\n * `cb` directly when the API is missing or the user prefers reduced motion.\n * Overridable in tests to capture the callback deterministically.\n */\nexport const CRAFT_START_VIEW_TRANSITION =\n  new InjectionToken<CraftStartViewTransition>('CRAFT_START_VIEW_TRANSITION', {\n    providedIn: 'root',\n    factory: () => defaultStartViewTransition,\n  });\n\nfunction defaultStartViewTransition(cb: () => void): void {\n  const doc =\n    typeof document !== 'undefined'\n      ? (document as unknown as ViewTransitionDocument)\n      : undefined;\n  const prefersReducedMotion =\n    typeof window !== 'undefined' &&\n    typeof window.matchMedia === 'function' &&\n    window.matchMedia('(prefers-reduced-motion: reduce)').matches;\n\n  if (!doc?.startViewTransition || prefersReducedMotion) {\n    cb();\n    return;\n  }\n\n  // Chromium can expose the API while failing to invoke the update callback\n  // when a transition is started during router activation. Never leave the\n  // outlet waiting forever for that callback: the fallback still commits the\n  // new DOM, while the idempotent wrapper prevents a later native callback\n  // from committing twice.\n  let callbackCalled = false;\n  const runOnce = () => {\n    if (callbackCalled) {\n      return;\n    }\n    callbackCalled = true;\n    cb();\n  };\n\n  const transition = doc.startViewTransition(runOnce) as\n    | {\n        skipTransition?: () => void;\n        ready?: Promise<unknown>;\n        updateCallbackDone?: Promise<unknown>;\n        finished?: Promise<unknown>;\n      }\n    | undefined;\n  for (const promise of [\n    transition?.ready,\n    transition?.updateCallbackDone,\n    transition?.finished,\n  ]) {\n    void promise?.catch(() => undefined);\n  }\n  queueMicrotask(() => {\n    if (callbackCalled) {\n      return;\n    }\n    runOnce();\n    transition?.skipTransition?.();\n  });\n}\n\n/**\n * Hands the {@link CraftRouterOutletController} control of the browser View\n * Transitions\n * API. Unlike Angular's `withViewTransitions()` — which brackets only the\n * synchronous URL commit — this drives `document.startViewTransition()` around\n * the outlet's *own* swaps (`previous page → skeleton → target`), so a\n * shared-element morph survives a slow guard/resolve chain.\n *\n * Routes that declare a `withLoaderViewTransitionImage` payload (via {@link\n * viewTransitionPayload}) additionally skip the `'blank'` phase (a blank surface\n * would break the morph) and require every `craftRouterLink` / `navigate`\n * targeting them to pass a typed `viewTransition` payload. Pass\n * `{ skipBlank: true }` to extend the blank-skip to all routes.\n *\n * ```ts\n * provideCraftRouter(\n *   demoRoutes.toRoutes(),\n *   withCraftViewTransitions(),\n * )\n * ```\n */\nexport function withCraftViewTransitions(options?: {\n  skipBlank?: boolean;\n}): CraftLoadingFeature {\n  return craftLoadingFeature([\n    { provide: CRAFT_VIEW_TRANSITIONS_ENABLED, useValue: true },\n    {\n      provide: CRAFT_VIEW_TRANSITION_SKIP_BLANK,\n      useValue: options?.skipBlank ?? false,\n    },\n  ]);\n}\n"]}

package/src/lib/dom-event-hook.d.ts

@@ -0,0 +1,30 @@
+import { InjectionToken, type Provider } from './host/craft-compat';
+/** Metadata describing a DOM event bound from a Craft template. */
+export interface CraftDomEvent {
+    /** The native event received by the binding. */
+    readonly event: Event;
+    /** The normalized DOM event name, for example `click` or `mouseenter`. */
+    readonly eventName: string;
+    /** The element that owns the binding. */
+    readonly element: Element;
+    /** The element tag, normalized to lower case. */
+    readonly elementTag: string;
+    /** The optional local name passed to a named helper, for example `save`. */
+    readonly elementName?: string;
+    /** The Craft component whose template declared the element. */
+    readonly componentName?: string;
+    /** A stable descriptive key for the interaction location. */
+    readonly interactionName: string;
+}
+/**
+ * Cross-cutting behavior around a DOM action declared in a Craft template.
+ *
+ * Hooks compose in registration order. A hook must call `next()` to preserve
+ * the original template action; it may also do work before or after it.
+ */
+export type CraftDomEventHook = (interaction: CraftDomEvent, next: () => unknown) => unknown;
+/** All DOM hooks active in the current component injector. */
+export declare const CRAFT_DOM_EVENT_HOOK: InjectionToken<readonly CraftDomEventHook[]>;
+/** Register one composable DOM event hook. */
+export declare function provideCraftDomEventHook(hook: CraftDomEventHook): Provider;
+//# sourceMappingURL=dom-event-hook.d.ts.map

package/src/lib/dom-event-hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom-event-hook.d.ts","sourceRoot":"","sources":["../../../../../libs/core/src/lib/dom-event-hook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpE,mEAAmE;AACnE,MAAM,WAAW,aAAa;IAC5B,gDAAgD;IAChD,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,0EAA0E;IAC1E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,yCAAyC;IACzC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,iDAAiD;IACjD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,4EAA4E;IAC5E,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,+DAA+D;IAC/D,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,6DAA6D;IAC7D,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAED;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC9B,WAAW,EAAE,aAAa,EAC1B,IAAI,EAAE,MAAM,OAAO,KAChB,OAAO,CAAC;AAEb,8DAA8D;AAC9D,eAAO,MAAM,oBAAoB,8CAM/B,CAAC;AAEH,8CAA8C;AAC9C,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,iBAAiB,GAAG,QAAQ,CAM1E"}

package/src/lib/dom-event-hook.js

@@ -0,0 +1,16 @@
+import { InjectionToken } from './host/craft-compat';
+/** All DOM hooks active in the current component injector. */
+export const CRAFT_DOM_EVENT_HOOK = new InjectionToken('CRAFT_DOM_EVENT_HOOK', {
+    providedIn: 'root',
+    factory: () => [],
+    multi: true,
+});
+/** Register one composable DOM event hook. */
+export function provideCraftDomEventHook(hook) {
+    return {
+        provide: CRAFT_DOM_EVENT_HOOK,
+        useValue: hook,
+        multi: true,
+    };
+}
+//# sourceMappingURL=dom-event-hook.js.map

package/src/lib/dom-event-hook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom-event-hook.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/dom-event-hook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAiB,MAAM,qBAAqB,CAAC;AA+BpE,8DAA8D;AAC9D,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,cAAc,CAEpD,sBAAsB,EAAE;IACxB,UAAU,EAAE,MAAM;IAClB,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE;IACjB,KAAK,EAAE,IAAI;CACZ,CAAC,CAAC;AAEH,8CAA8C;AAC9C,MAAM,UAAU,wBAAwB,CAAC,IAAuB;IAC9D,OAAO;QACL,OAAO,EAAE,oBAAoB;QAC7B,QAAQ,EAAE,IAAI;QACd,KAAK,EAAE,IAAI;KACZ,CAAC;AACJ,CAAC","sourcesContent":["import { InjectionToken, type Provider } from './host/craft-compat';\n\n/** Metadata describing a DOM event bound from a Craft template. */\nexport interface CraftDomEvent {\n  /** The native event received by the binding. */\n  readonly event: Event;\n  /** The normalized DOM event name, for example `click` or `mouseenter`. */\n  readonly eventName: string;\n  /** The element that owns the binding. */\n  readonly element: Element;\n  /** The element tag, normalized to lower case. */\n  readonly elementTag: string;\n  /** The optional local name passed to a named helper, for example `save`. */\n  readonly elementName?: string;\n  /** The Craft component whose template declared the element. */\n  readonly componentName?: string;\n  /** A stable descriptive key for the interaction location. */\n  readonly interactionName: string;\n}\n\n/**\n * Cross-cutting behavior around a DOM action declared in a Craft template.\n *\n * Hooks compose in registration order. A hook must call `next()` to preserve\n * the original template action; it may also do work before or after it.\n */\nexport type CraftDomEventHook = (\n  interaction: CraftDomEvent,\n  next: () => unknown,\n) => unknown;\n\n/** All DOM hooks active in the current component injector. */\nexport const CRAFT_DOM_EVENT_HOOK = new InjectionToken<\n  readonly CraftDomEventHook[]\n>('CRAFT_DOM_EVENT_HOOK', {\n  providedIn: 'root',\n  factory: () => [],\n  multi: true,\n});\n\n/** Register one composable DOM event hook. */\nexport function provideCraftDomEventHook(hook: CraftDomEventHook): Provider {\n  return {\n    provide: CRAFT_DOM_EVENT_HOOK,\n    useValue: hook,\n    multi: true,\n  };\n}\n"]}

package/src/lib/fn-wrapper.d.ts

@@ -0,0 +1,13 @@
+import { InjectionToken, type Provider } from './host/craft-compat';
+export { isGenerator, isGeneratorFunction } from './craft-generator-runtime';
+type AnyFactory = (...args: any[]) => any;
+type AnyGeneratorFactory = (...args: any[]) => Generator<unknown, unknown, unknown>;
+export type FnWrapper = (factory: AnyGeneratorFactory, thisArg: unknown, args: unknown[]) => Generator<unknown, unknown, unknown>;
+export type FnFactoryAdapter = <F extends AnyFactory>(factory: F) => F;
+export type FnWrapObserver = (factory: AnyFactory) => void;
+export declare const FN_WRAPPER: InjectionToken<readonly FnWrapper[]>;
+export declare const FN_WRAP_OBSERVER: InjectionToken<readonly FnWrapObserver[]>;
+export declare function provideFnWrapper(_warning: string, wrapper: FnWrapper): Provider;
+export declare function provideFnWrapObserver(observer: FnWrapObserver): Provider;
+export declare function injectFnWrapper(): FnFactoryAdapter;
+//# sourceMappingURL=fn-wrapper.d.ts.map

package/src/lib/fn-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fn-wrapper.d.ts","sourceRoot":"","sources":["../../../../../libs/core/src/lib/fn-wrapper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,cAAc,EAAE,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAG5E,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAE7E,KAAK,UAAU,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;AAC1C,KAAK,mBAAmB,GAAG,CACzB,GAAG,IAAI,EAAE,GAAG,EAAE,KACX,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AAE1C,MAAM,MAAM,SAAS,GAAG,CACtB,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,OAAO,EAAE,KACZ,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AAE1C,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,SAAS,UAAU,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;AACvE,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,EAAE,UAAU,KAAK,IAAI,CAAC;AAK3D,eAAO,MAAM,UAAU,sCAOtB,CAAC;AAEF,eAAO,MAAM,gBAAgB,2CAO5B,CAAC;AAIF,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,SAAS,GACjB,QAAQ,CAEV;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,cAAc,GAAG,QAAQ,CAExE;AAED,wBAAgB,eAAe,IAAI,gBAAgB,CAwBlD"}