@craft-ts/core 0.7.0-beta.13 → 0.7.0-beta.15

package/src/lib/craft-computed.js

@@ -1,10 +1,10 @@
-import { assertInInjectionContext, DestroyRef, inject, Injector, runInInjectionContext, } from './host/craft-compat';
-import { takeUntilDestroyed } from './host/craft-compat';
-import { craftComputed as createCraftComputed } from './host/craft-signal';
-import { ɵcreateHostTaggedInjector, ɵHOST_TAG_LIST } from './craft-service';
-import { isGeneratorFunction, runCraftGenerator, } from './craft-generator-runtime';
-import { APP_SNAPSHOT_REGISTRY } from './take-app-snapshot';
-import { createYieldableReactiveValue, REACTIVE_DEPENDENCIES, ɵactiveReactiveReader, } from './reactive-read';
+import { assertInInjectionContext, DestroyRef, inject, Injector, runInInjectionContext, } from './host/craft-compat.js';
+import { takeUntilDestroyed } from './host/craft-compat.js';
+import { craftComputed as createCraftComputed } from './host/craft-signal.js';
+import { ɵcreateHostTaggedInjector, ɵHOST_TAG_LIST } from './craft-service.js';
+import { isGeneratorFunction, runCraftGenerator, } from './craft-generator-runtime.js';
+import { APP_SNAPSHOT_REGISTRY } from './take-app-snapshot.js';
+import { createYieldableReactiveValue, REACTIVE_DEPENDENCIES, ɵactiveReactiveReader, } from './reactive-read.js';
 const createComputedWithOptions = createCraftComputed;
 export function craftComputed(nameOrComputation, hostOrComputation, factoryOrOptions, maybeOptions) {
     const hasName = typeof nameOrComputation === 'string';
@@ -78,4 +78,3 @@ export function craftComputed(nameOrComputation, hostOrComputation, factoryOrOpt
         path: name,
     });
 }
-//# sourceMappingURL=craft-computed.js.map

package/src/lib/craft-control-flow.d.ts

@@ -11,4 +11,3 @@
  * observable.
  */
 export declare function isCraftControlFlow(value: unknown): boolean;
-//# sourceMappingURL=craft-control-flow.d.ts.map

package/src/lib/craft-control-flow.js

@@ -1,5 +1,5 @@
-import { isCraftGenShortCircuit } from './craft-gen';
-import { isCraftNotSettled } from './craft-settled';
+import { isCraftGenShortCircuit } from './craft-gen.js';
+import { isCraftNotSettled } from './craft-settled.js';
 /**
  * Returns whether `value` is an internal CraftTS control-flow throw.
  *
@@ -15,4 +15,3 @@ import { isCraftNotSettled } from './craft-settled';
 export function isCraftControlFlow(value) {
     return isCraftGenShortCircuit(value) || isCraftNotSettled(value);
 }
-//# sourceMappingURL=craft-control-flow.js.map

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

@@ -1,5 +1,5 @@
-import { type CreateEffectOptions, type EffectCleanupRegisterFn, type EffectRef } from './host/craft-compat';
-import type { SERVICE_HELPER_DEPENDENCIES, ServiceDependencyMapFromYielded } from './craft-service';
+import { type CreateEffectOptions, type EffectCleanupRegisterFn, type EffectRef } from './host/craft-compat.js';
+import type { SERVICE_HELPER_DEPENDENCIES, ServiceDependencyMapFromYielded } from './craft-service.js';
 type CraftEffectFn = (onCleanup: EffectCleanupRegisterFn) => void;
 type CraftEffectGenerator<This, Yielded> = (this: This) => Generator<Yielded, CraftEffectFn, unknown>;
 type TrackedCraftEffect<E, Yielded> = E & {
@@ -10,4 +10,3 @@ export declare function craftEffect<Name extends string, Yielded>(name: Name, fa
 export declare function craftEffect<Name extends string, This>(name: Name, host: This, effectFn: (this: This, onCleanup: EffectCleanupRegisterFn) => void, options?: CreateEffectOptions): EffectRef;
 export declare function craftEffect<Name extends string>(name: Name, effectFn: CraftEffectFn, options?: CreateEffectOptions): EffectRef;
 export {};
-//# sourceMappingURL=craft-effect.d.ts.map

package/src/lib/craft-effect.js

@@ -1,10 +1,10 @@
-import { assertInInjectionContext, DestroyRef, effect, inject, Injector, runInInjectionContext, signal, untracked, } from './host/craft-compat';
-import { takeUntilDestroyed } from './host/craft-compat';
-import { ɵcraftInjectorFromHost } from './host/craft-injector-host';
-import { craftWatch } from './host/craft-signal';
-import { ɵcreateHostTaggedInjector, ɵHOST_TAG_LIST } from './craft-service';
-import { isGeneratorFunction, runCraftGenerator, } from './craft-generator-runtime';
-import { APP_SNAPSHOT_REGISTRY } from './take-app-snapshot';
+import { assertInInjectionContext, DestroyRef, effect, inject, Injector, runInInjectionContext, signal, untracked, } from './host/craft-compat.js';
+import { takeUntilDestroyed } from './host/craft-compat.js';
+import { ɵcraftInjectorFromHost } from './host/craft-injector-host.js';
+import { craftWatch } from './host/craft-signal.js';
+import { ɵcreateHostTaggedInjector, ɵHOST_TAG_LIST } from './craft-service.js';
+import { isGeneratorFunction, runCraftGenerator, } from './craft-generator-runtime.js';
+import { APP_SNAPSHOT_REGISTRY } from './take-app-snapshot.js';
 export function craftEffect(name, hostOrFn, fnOrOptions, maybeOptions) {
     // The host form is recognized by its 3rd argument being the factory —
     // `options` is never a function.
@@ -90,4 +90,3 @@ export function craftEffect(name, hostOrFn, fnOrOptions, maybeOptions) {
     }
     return ref;
 }
-//# sourceMappingURL=craft-effect.js.map

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

@@ -37,4 +37,3 @@ export type InsertMetaInCraftExceptionIfExists<Exception, Scope extends string |
 }, Payload> : Exception;
 export type ExtractCodeFromCraftResultUnion<T> = T extends CraftExceptionResult<infer E, any> ? E['_tag'] : never;
 export type ExcludeByCode<T, C> = T extends CraftExceptionResult<infer E, any> ? E['_tag'] extends C ? never : T : never;
-//# sourceMappingURL=craft-exception.d.ts.map

package/src/lib/craft-exception.js

@@ -13,4 +13,3 @@ export function craftException(meta, payload) {
 export function isCraftException(value) {
     return (!!value && typeof value === 'object' && CRAFT_EXCEPTION_SYMBOL in value);
 }
-//# sourceMappingURL=craft-exception.js.map

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

@@ -1,4 +1,4 @@
-import { type AnyCraftException, type ExtractCraftException, type StripCraftException } from './craft-exception';
+import { type AnyCraftException, type ExtractCraftException, type StripCraftException } from './craft-exception.js';
 declare const CRAFT_GEN_EXCEPTION_MARKER: unique symbol;
 declare const CRAFT_GEN_SHORT_CIRCUIT: unique symbol;
 declare const CRAFT_PROGRAM_RECREATE: unique symbol;
@@ -120,4 +120,3 @@ export declare function ɵcreateCraftProgram(makeIterator: ProgramFactory): Runt
  */
 export declare function craftGen<GenFn extends AnyGeneratorFactory>(generatorFn: GenFn): CraftGenInvoker<GeneratorFactoryArgs<GenFn>, GenFn>;
 export {};
-//# sourceMappingURL=craft-gen.d.ts.map

package/src/lib/craft-gen.js

@@ -1,5 +1,5 @@
-import { isCraftException, } from './craft-exception';
-import { isGenerator } from './craft-generator-runtime';
+import { isCraftException, } from './craft-exception.js';
+import { isGenerator } from './craft-generator-runtime.js';
 const CRAFT_GEN_EXCEPTION_MARKER = Symbol('craft-gen-exception-marker');
 const CRAFT_GEN_SHORT_CIRCUIT = Symbol('craft-gen-short-circuit');
 const CRAFT_PROGRAM_RECREATE = Symbol('craft-program-recreate');
@@ -87,4 +87,3 @@ export function craftGen(generatorFn) {
     });
     return invoker;
 }
-//# sourceMappingURL=craft-gen.js.map

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

@@ -1,13 +1,30 @@
-import { Injector, InjectionToken, type Provider } from './host/craft-compat';
+import { Injector, InjectionToken, type Provider } from './host/craft-compat.js';
 import type { Observable } from 'rxjs';
-import type { ConcreteServiceScope } from './craft-service.shared';
-import { type RuntimeTemporalAwaitRequest } from './temporal-runtime';
-import { type ReactiveReadIdentity } from './reactive-read';
+import type { ConcreteServiceScope } from './craft-service.shared.js';
+import { type RuntimeTemporalAwaitRequest } from './temporal-runtime.js';
+import { type ReactiveReadIdentity } from './reactive-read.js';
 export declare const SERVICE_YIELD_REQUEST_MARKER: unique symbol;
 export declare const SERVICE_DEPENDENCY_ACCESS_MARKER: unique symbol;
 export declare const SERVICE_APP_START_REQUEST_MARKER: unique symbol;
 export declare const SERVICE_TRACKED_DEPS_REQUEST_MARKER: unique symbol;
 export declare const GUARD_AWAIT_REQUEST_MARKER: unique symbol;
+/** The context a synchronous bridge needs to resolve a foreign yield. */
+export type ForeignSyncYieldContext = {
+    /** The injector of the host that yielded — a bridge resolves its runtime from it. */
+    readonly injector: Injector;
+};
+/**
+ * Returns `{ handled: true, value }` for yields it recognises and resolved,
+ * `undefined` for everything else (which then falls through to the usual
+ * invalid-yield error). A bridge that recognises a yield but cannot honour it
+ * synchronously must throw, not return: there is no suspension available here.
+ */
+export type ForeignSyncYieldBridge = (yielded: unknown, context: ForeignSyncYieldContext) => {
+    handled: true;
+    value: unknown;
+} | undefined;
+/** Registers the synchronous bridge; returns a disposer restoring the previous one. */
+export declare function setForeignSyncYieldBridge(bridge: ForeignSyncYieldBridge): () => void;
 export type ServiceYieldContext = Readonly<{
     name: string;
     providedIn: ConcreteServiceScope;
@@ -107,4 +124,3 @@ export declare function resolveCraftGeneratorYield(yielded: unknown, injector: I
 };
 export declare function isServiceAppStartRequest(value: unknown): value is RuntimeServiceAppStartRequest;
 export {};
-//# sourceMappingURL=craft-generator-runtime.d.ts.map

package/src/lib/craft-generator-runtime.js

@@ -1,13 +1,25 @@
-import { InjectionToken } from './host/craft-compat';
-import { injectFnWrapper } from './fn-wrapper';
-import { isTemporalAwaitRequest, } from './temporal-runtime';
-import { isReactiveReadRequest, REACTIVE_READ_OBSERVERS, ɵwithActiveReactiveReader, } from './reactive-read';
-import { ɵcraftInjectorFromHost } from './host/craft-injector-host';
+import { InjectionToken } from './host/craft-compat.js';
+import { injectFnWrapper } from './fn-wrapper.js';
+import { isTemporalAwaitRequest, } from './temporal-runtime.js';
+import { isReactiveReadRequest, REACTIVE_READ_OBSERVERS, ɵwithActiveReactiveReader, } from './reactive-read.js';
+import { ɵcraftInjectorFromHost } from './host/craft-injector-host.js';
 export const SERVICE_YIELD_REQUEST_MARKER = Symbol('service-yield-request-marker');
 export const SERVICE_DEPENDENCY_ACCESS_MARKER = Symbol('service-dependency-access-marker');
 export const SERVICE_APP_START_REQUEST_MARKER = Symbol('service-app-start-request-marker');
 export const SERVICE_TRACKED_DEPS_REQUEST_MARKER = Symbol('service-tracked-deps-request-marker');
 export const GUARD_AWAIT_REQUEST_MARKER = Symbol('guard-await-request-marker');
+let foreignSyncYieldBridge;
+/** Registers the synchronous bridge; returns a disposer restoring the previous one. */
+export function setForeignSyncYieldBridge(bridge) {
+    const previous = foreignSyncYieldBridge;
+    foreignSyncYieldBridge = bridge;
+    return () => {
+        foreignSyncYieldBridge = previous;
+    };
+}
+function resolveForeignSyncYield(yielded, injector) {
+    return foreignSyncYieldBridge?.(yielded, { injector });
+}
 export const SERVICE_YIELD_WRAPPER = new InjectionToken('SERVICE_YIELD_WRAPPER', {
     providedIn: 'root',
     factory: () => [],
@@ -68,6 +80,13 @@ export function runCraftGenerator({ iterator, injector: injectorInput, hostScope
         if (guardAwaitNotSupportedErrorMessage && isGuardAwaitRequest(yielded)) {
             throw new Error(guardAwaitNotSupportedErrorMessage);
         }
+        // Last chance before the invalid-yield error: a foreign yield a bridge can
+        // resolve without suspending (see `setForeignSyncYieldBridge`).
+        const bridged = resolveForeignSyncYield(yielded, injector);
+        if (bridged) {
+            current = iterator.next(bridged.value);
+            continue;
+        }
         throw new Error(invalidYieldErrorMessage);
     }
     return {
@@ -135,6 +154,10 @@ export function resolveCraftGeneratorYield(yielded, injector, hostScope) {
     if (isServiceTrackedDepsRequest(yielded)) {
         return { handled: true, value: undefined };
     }
+    const bridged = resolveForeignSyncYield(yielded, injector);
+    if (bridged) {
+        return bridged;
+    }
     return { handled: false };
 }
 function resolveServiceYield(request, injector, hostScope) {
@@ -188,4 +211,3 @@ function isServiceTrackedDepsRequest(value) {
         value !== null &&
         SERVICE_TRACKED_DEPS_REQUEST_MARKER in value);
 }
-//# sourceMappingURL=craft-generator-runtime.js.map

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

@@ -1,13 +1,13 @@
-import { Injector } from './host/craft-compat';
-import type { CraftUrlTree } from './craft-router';
+import { Injector } from './host/craft-compat.js';
+import type { CraftUrlTree } from './craft-router.js';
 type CraftRouteRouterLike = {
     readonly url?: string;
     createUrlTree: (...args: any[]) => unknown;
     navigate: (...args: any[]) => Promise<boolean>;
     navigateByUrl: (...args: any[]) => Promise<boolean>;
 };
-import { type AnyCraftException } from './craft-exception';
-import { type CraftExceptionComponentInput, type CraftExceptionHandlerContext, type CraftExceptionOutcome, type CraftRoutePhase } from './craft-route-exceptions';
+import { type AnyCraftException } from './craft-exception.js';
+import { type CraftExceptionComponentInput, type CraftExceptionHandlerContext, type CraftExceptionOutcome, type CraftRoutePhase } from './craft-route-exceptions.js';
 /**
  * The result of a synchronous guard re-evaluation (reactive "live" guards):
  * - `valid` — the guard passed without producing an exception;
@@ -67,4 +67,3 @@ export interface CraftRouteChainSteps {
 }
 export declare function runCraftRouteChainAsync(steps: CraftRouteChainSteps, injector: Injector, router: CraftRouteRouterLike, handleExceptions: CraftRouteExceptionHandlerMap, phase?: CraftRoutePhase): Promise<RouteChainOutcome>;
 export {};
-//# sourceMappingURL=craft-guard-runtime.d.ts.map

package/src/lib/craft-guard-runtime.js

@@ -1,9 +1,9 @@
-import { runInInjectionContext } from './host/craft-compat';
-import { isCraftException } from './craft-exception';
-import { craftExceptionOutcomeApi, } from './craft-route-exceptions';
-import { isGenerator } from './craft-generator-runtime';
-import { driveCraftProgramAsync, pumpCraftProgramSync, } from './craft-program-runtime';
-import { executeCraftRouterTrace } from './craft-router-trace';
+import { runInInjectionContext } from './host/craft-compat.js';
+import { isCraftException } from './craft-exception.js';
+import { craftExceptionOutcomeApi, } from './craft-route-exceptions.js';
+import { isGenerator } from './craft-generator-runtime.js';
+import { driveCraftProgramAsync, pumpCraftProgramSync, } from './craft-program-runtime.js';
+import { executeCraftRouterTrace } from './craft-router-trace.js';
 const GUARD_INVALID_YIELD_ERROR_MESSAGE = 'craft route guards can only yield craftService dependencies, exposed dependency helpers, or an craftUntilSettled/craftUntilDefined await request.';
 const GUARD_PUMP_OPTIONS = {
     invalidYieldErrorMessage: GUARD_INVALID_YIELD_ERROR_MESSAGE,
@@ -192,4 +192,3 @@ export function runCraftRouteChainAsync(steps, injector, router, handleException
         url: router.url ?? '',
     }, () => runCraftRouteChainAsyncInternal(steps, injector, router, handleExceptions, phase));
 }
-//# sourceMappingURL=craft-guard-runtime.js.map

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

@@ -1,4 +1,4 @@
-import type { CraftSchema } from './schema-validation';
+import type { CraftSchema } from './schema-validation.js';
 export declare const CRAFT_HANDSHAKE: unique symbol;
 /**
  * Un nom sur lequel les deux côtés de la frontière se mettent d'accord.
@@ -32,4 +32,3 @@ export declare function isCraftHandshake(value: unknown): value is AnyCraftHands
 /** Le nom d'un handshake porté par une valeur, quand il y en a un. */
 export declare function craftHandshakeName(value: unknown): string | undefined;
 export declare function assertHandshakeName(name: string): void;
-//# sourceMappingURL=craft-handshake.d.ts.map

package/src/lib/craft-handshake.js

@@ -31,4 +31,3 @@ export function assertHandshakeName(name) {
         throw new Error(`Invalid handshake name "${name}". Use a stable dotted identifier, the same on both sides.`);
     }
 }
-//# sourceMappingURL=craft-handshake.js.map

package/src/lib/craft-http-client.d.ts

@@ -1,6 +1,6 @@
-import { type AnyCraftException, type CraftExceptionResult } from './craft-exception';
-import { type ServiceTrackingMetadata, type ServiceYieldRequest } from './craft-service';
-import type { CraftDecoder } from './craft-codec';
+import { type AnyCraftException, type CraftExceptionResult } from './craft-exception.js';
+import { type ServiceTrackingMetadata, type ServiceYieldRequest } from './craft-service.js';
+import type { CraftDecoder } from './craft-codec.js';
 declare const CRAFT_HTTP_CLIENT_SUCCESS_MARKER: unique symbol;
 declare const CRAFT_HTTP_CLIENT_EXCEPTIONS_MARKER: unique symbol;
 declare const CRAFT_HTTP_CLIENT_EXCEPTION_TYPE_DEPENDENCIES_MARKER: unique symbol;
@@ -233,4 +233,3 @@ export declare function response<Success>(): CraftHttpClientSuccessToken<Success
 export declare function response<Success>(decoder: CraftDecoder<Success>): CraftHttpClientDecodedSuccessToken<Success>;
 export declare function getCraftHttpRequestExceptionDependencies(request: AnyCraftHttpRequest): CraftHttpClientExceptionDependencies;
 export {};
-//# sourceMappingURL=craft-http-client.d.ts.map

package/src/lib/craft-http-client.js

@@ -1,7 +1,7 @@
-import { craftException, } from './craft-exception';
-import { SERVICE_RUNTIME_OVERRIDES, SERVICE_YIELD_REQUEST_MARKER, } from './craft-service';
-import { executeCraftHttpTrace } from './craft-http-trace';
-import { craftFetchTransport, ɵgetCraftHttpResponseMetadata, } from './host/craft-http';
+import { craftException, } from './craft-exception.js';
+import { SERVICE_RUNTIME_OVERRIDES, SERVICE_YIELD_REQUEST_MARKER, } from './craft-service.js';
+import { executeCraftHttpTrace } from './craft-http-trace.js';
+import { craftFetchTransport, ɵgetCraftHttpResponseMetadata, } from './host/craft-http.js';
 const CRAFT_HTTP_CLIENT_EXCEPTION_DEPENDENCIES_MARKER = Symbol('craft-http-client-exception-dependencies-marker');
 const CRAFT_HTTP_CLIENT_EXCEPTION_DEPENDENCY_REQUEST_MARKER = Symbol('craft-http-client-exception-dependency-request-marker');
 const craftHttpClientBuilderHelpers = {
@@ -434,4 +434,3 @@ function extractDecodeIssues(error) {
     }
     return undefined;
 }
-//# sourceMappingURL=craft-http-client.js.map

package/src/lib/craft-http-trace.d.ts

@@ -1,4 +1,4 @@
-import { InjectionToken, Injector, type Provider } from './host/craft-compat';
+import { InjectionToken, Injector, type Provider } from './host/craft-compat.js';
 export type CraftHttpTraceContext = Readonly<{
     method: string;
     url: string;
@@ -9,4 +9,3 @@ export type CraftHttpTraceWrapper = (context: CraftHttpTraceContext, next: () =>
 export declare const CRAFT_HTTP_TRACE: InjectionToken<readonly CraftHttpTraceWrapper[]>;
 export declare function provideCraftHttpTrace(wrapper: CraftHttpTraceWrapper): Provider;
 export declare function executeCraftHttpTrace<Value>(injector: Injector, context: CraftHttpTraceContext, next: () => Promise<Value>): Promise<Value>;
-//# sourceMappingURL=craft-http-trace.d.ts.map

package/src/lib/craft-http-trace.js

@@ -1,4 +1,5 @@
-import { InjectionToken, runInInjectionContext, } from './host/craft-compat';
+import { InjectionToken, runInInjectionContext, } from './host/craft-compat.js';
+import { isCraftDevelopment } from './craft-runtime-mode.js';
 export const CRAFT_HTTP_TRACE = new InjectionToken('CRAFT_HTTP_TRACE', {
     providedIn: 'root',
     factory: () => [],
@@ -12,6 +13,9 @@ export function provideCraftHttpTrace(wrapper) {
     };
 }
 export function executeCraftHttpTrace(injector, context, next) {
+    if (!isCraftDevelopment(injector)) {
+        return next();
+    }
     const wrappers = injector.get(CRAFT_HTTP_TRACE, []);
     if (wrappers.length === 0) {
         return next();
@@ -25,4 +29,3 @@ export function executeCraftHttpTrace(injector, context, next) {
     };
     return runInInjectionContext(injector, () => run(0));
 }
-//# sourceMappingURL=craft-http-trace.js.map

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

@@ -0,0 +1,11 @@
+/** Coordinates async work that must finish before SSR DOM cleanup. */
+export type CraftHydrationRuntime = Readonly<{
+    track(source: string, work: PromiseLike<unknown>): void;
+    hasPending(): boolean;
+    whenSettled(): Promise<void>;
+}>;
+export declare const CRAFT_HYDRATION_RUNTIME: import("..").CraftToken<Readonly<{
+    track(source: string, work: PromiseLike<unknown>): void;
+    hasPending(): boolean;
+    whenSettled(): Promise<void>;
+}>>;

package/src/lib/craft-hydration.js

@@ -0,0 +1,2 @@
+import { craftToken } from './host/craft-injector.js';
+export const CRAFT_HYDRATION_RUNTIME = craftToken('CraftHydrationRuntime');

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

@@ -1,11 +1,11 @@
-import { type CraftGenInvocation } from './craft-gen';
-import { type CraftLazyLoadHelpers } from './craft-load-retry';
+import { type CraftGenInvocation } from './craft-gen.js';
+import { type CraftLazyLoadHelpers } from './craft-load-retry.js';
 export declare const CRAFT_LAZY_LOAD_ERROR_CODE: "CRAFT_LAZY_LOAD_ERROR";
 export interface CraftLazyLoadErrorPayload {
     readonly cause: unknown;
 }
 /** Builds the `craftException` `craftLazy` returns when an import finally fails. */
-export declare function createCraftLazyLoadError(cause: unknown): import("./craft-exception").CraftExceptionResult<{
+export declare function createCraftLazyLoadError(cause: unknown): import("./craft-exception.js").CraftExceptionResult<{
     _tag: "CRAFT_LAZY_LOAD_ERROR";
     scope: "CraftLazy";
     identifier?: undefined;
@@ -39,4 +39,3 @@ export type CraftLazyLoadError = ReturnType<typeof createCraftLazyLoadError>;
  * ```
  */
 export declare function craftLazy<T>(load: (helpers: CraftLazyLoadHelpers) => Promise<T>): CraftGenInvocation<never, T | CraftLazyLoadError>;
-//# sourceMappingURL=craft-lazy.d.ts.map

package/src/lib/craft-lazy.js

@@ -1,8 +1,8 @@
-import { inject } from './host/craft-compat';
-import { craftException } from './craft-exception';
-import { craftGen } from './craft-gen';
-import { GUARD_AWAIT_REQUEST_MARKER, } from './craft-generator-runtime';
-import { createRetryLazyLoadHelpers, CRAFT_DYNAMIC_IMPORT, CRAFT_LAZY_LOAD_RETRY, INITIAL_LAZY_LOAD_HELPERS, } from './craft-load-retry';
+import { inject } from './host/craft-compat.js';
+import { craftException } from './craft-exception.js';
+import { craftGen } from './craft-gen.js';
+import { GUARD_AWAIT_REQUEST_MARKER, } from './craft-generator-runtime.js';
+import { createRetryLazyLoadHelpers, CRAFT_DYNAMIC_IMPORT, CRAFT_LAZY_LOAD_RETRY, INITIAL_LAZY_LOAD_HELPERS, } from './craft-load-retry.js';
 export const CRAFT_LAZY_LOAD_ERROR_CODE = 'CRAFT_LAZY_LOAD_ERROR';
 /** Builds the `craftException` `craftLazy` returns when an import finally fails. */
 export function createCraftLazyLoadError(cause) {
@@ -80,4 +80,3 @@ export function craftLazy(load) {
     });
     return invoke();
 }
-//# sourceMappingURL=craft-lazy.js.map

package/src/lib/craft-load-retry.d.ts

@@ -1,5 +1,5 @@
-import { InjectionToken, type Type } from './host/craft-compat';
-import { type CraftTemporalRuntime } from './temporal-runtime';
+import { InjectionToken, type Type } from './host/craft-compat.js';
+import { type CraftTemporalRuntime } from './temporal-runtime.js';
 /**
  * The `{ withRetry }` helpers handed to a lazy loader callback. `withRetry`
  * wraps a dynamic `import(...)` so a chunk whose hashed URL went stale after a
@@ -73,4 +73,3 @@ export declare function createRetryLazyLoadHelpers(dynamicImport: (url: string)
  * URL share a single in-flight import.
  */
 export declare function retryFailedDynamicImport<T>(moduleImport: Promise<T>, dynamicImport: (url: string) => Promise<unknown>, retryParam?: string): Promise<T>;
-//# sourceMappingURL=craft-load-retry.d.ts.map

package/src/lib/craft-load-retry.js

@@ -1,12 +1,20 @@
-import { inject, InjectionToken } from './host/craft-compat';
-import { CRAFT_TEMPORAL_RUNTIME, RealCraftTemporalRuntime, } from './temporal-runtime';
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { inject, InjectionToken } from './host/craft-compat.js';
+import { CRAFT_TEMPORAL_RUNTIME, RealCraftTemporalRuntime, } from './temporal-runtime.js';
 /**
  * The injectable dynamic `import(url)`. Overridable in tests to observe the
  * cache-busting URL {@link retryFailedDynamicImport} computes.
  */
 export const CRAFT_DYNAMIC_IMPORT = new InjectionToken('CRAFT_DYNAMIC_IMPORT', {
     providedIn: 'root',
-    factory: () => (url) => import(/* @vite-ignore */ url),
+    factory: () => (url) => import(__rewriteRelativeImportExtension(/* @vite-ignore */ url)),
 });
 export const DEFAULT_CRAFT_LOAD_RETRY_OPTIONS = {
     attempts: 1,
@@ -157,4 +165,3 @@ function failedDynamicImportUrl(error) {
         return undefined;
     }
 }
-//# sourceMappingURL=craft-load-retry.js.map

package/src/lib/craft-machine-history.d.ts

@@ -1,9 +1,9 @@
-import { StorageService } from './browser-boundaries';
-import type { CraftUnique } from './craft-unique';
-import type { GetServiceYields } from './craft-service';
-import { type CraftPrimitiveSnapshot } from './craft-primitive-registry';
-import { type YieldableReactiveValue } from './reactive-read';
-import type { CraftMachineControls, CraftMachineInsertionContext } from './craft-state-machine';
+import { StorageService } from './browser-boundaries.js';
+import type { CraftUnique } from './craft-unique.js';
+import type { GetServiceYields } from './craft-service.js';
+import { type CraftPrimitiveSnapshot } from './craft-primitive-registry.js';
+import { type YieldableReactiveValue } from './reactive-read.js';
+import type { CraftMachineControls, CraftMachineInsertionContext } from './craft-state-machine.js';
 /**
  * One recorded moment of a machine: the transition that produced it, and the
  * value of every primitive the machine owns at that point.
@@ -142,4 +142,3 @@ type BackNavigationOutput = {
  */
 export declare function withBackNavigation(): CraftHistoryFeature<BackNavigationOutput>;
 export {};
-//# sourceMappingURL=craft-machine-history.d.ts.map

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

@@ -1,9 +1,9 @@
-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';
+import { inject } from './host/craft-compat.js';
+import { craftComputed as createCraftComputed, craftSignal } from './host/craft-signal.js';
+import { StorageService } from './browser-boundaries.js';
+import { CRAFT_PRIMITIVE_REGISTRY, } from './craft-primitive-registry.js';
+import { ɵwithCraftReplay } from './craft-replay.js';
+import { createYieldableReactiveValue, isYieldableReactiveValue, rawReactiveValue, } from './reactive-read.js';
 /** Reserved prefix for the primitives named through `include`. */
 const EXTERNAL_KEY_PREFIX = '#include/';
 const DEFAULT_LIMIT = 50;
@@ -273,4 +273,3 @@ function writePersisted(storage, storageKey, entries, cursor) {
         }
     }
 }
-//# sourceMappingURL=craft-machine-history.js.map

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

@@ -46,4 +46,3 @@ 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.js

@@ -55,4 +55,3 @@ export const craftMatch = Object.assign(craftMatchImpl, {
 });
 /** Preferred short name for value and discriminated-union matching. */
 export const match = craftMatch;
-//# sourceMappingURL=craft-match.js.map

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

@@ -1,6 +1,6 @@
-import { Provider } from './host/craft-compat';
-import type { BrandedServiceProvider, SERVICE_HELPER_DEPENDENCIES, ServiceDependencyMapFromYielded } from './craft-service';
-import { YIELDABLE_METHOD } from './yieldable';
+import { Provider } from './host/craft-compat.js';
+import type { BrandedServiceProvider, SERVICE_HELPER_DEPENDENCIES, ServiceDependencyMapFromYielded } from './craft-service.js';
+import { YIELDABLE_METHOD } from './yieldable.js';
 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;
@@ -25,4 +25,3 @@ type TrackedCraftMethod<Callable, Yielded, Config = never> = Callable & {
 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.js

@@ -1,8 +1,8 @@
-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';
+import { assertInInjectionContext, inject, Injector, runInInjectionContext, } from './host/craft-compat.js';
+import { ɵcreateHostTaggedInjector } from './craft-service.js';
+import { isGenerator, runCraftGenerator } from './craft-generator-runtime.js';
+import { injectFnWrapper } from './fn-wrapper.js';
+import { markYieldableMethod, YIELDABLE_METHOD } from './yieldable.js';
 function resolveCraftMethodName(nameOrConfig) {
     return typeof nameOrConfig === 'string' ? nameOrConfig : nameOrConfig.name;
 }
@@ -42,4 +42,3 @@ function executeCraftMethod(factory, injector, self, args) {
         }).value;
     });
 }
-//# sourceMappingURL=craft-method.js.map

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

@@ -1,6 +1,6 @@
-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';
+import { InjectionToken, type EffectRef, type Injector } from './host/craft-compat.js';
+import { type CraftRegistrationTarget } from './craft-register-for-runtime.js';
+import type { CraftDomAdapter } from './host/craft-dom.js';
 /** 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. */
@@ -29,4 +29,3 @@ export interface CraftNodeDirective<Props extends Readonly<Record<string, unknow
 /** 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.js

@@ -1,5 +1,5 @@
-import { InjectionToken, } from './host/craft-compat';
-import { CRAFT_REGISTRATION_TARGET, } from './craft-register-for-runtime';
+import { InjectionToken, } from './host/craft-compat.js';
+import { CRAFT_REGISTRATION_TARGET, } from './craft-register-for-runtime.js';
 /** Runtime marker shared by core-authored DOM directives and the Craft renderer. */
 export const CRAFT_NODE_DIRECTIVE = Symbol.for('@craft-ts/core/craft-node-directive');
 export const CRAFT_NODE_EFFECT_FACTORY = new InjectionToken('CRAFT_NODE_EFFECT_FACTORY');
@@ -19,4 +19,3 @@ export function craftNodeDirective(name, inputs, mount) {
 export function isCraftNodeDirective(value) {
     return typeof value === 'function' && CRAFT_NODE_DIRECTIVE in value;
 }
-//# sourceMappingURL=craft-node-directive.js.map

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

@@ -1,6 +1,6 @@
-import { InjectionToken, type Provider, type Signal } from './host/craft-compat';
-import type { CraftExceptionComponentDescriptor } from './craft-route-exceptions';
-import { type CraftRouteTargetInput } from './craft-route-target';
+import { InjectionToken, type Provider, type Signal } from './host/craft-compat.js';
+import type { CraftExceptionComponentDescriptor } from './craft-route-exceptions.js';
+import { type CraftRouteTargetInput } from './craft-route-target.js';
 /**
  * The text rendered by {@link DefaultCraftPendingComponent}. A `Signal<string>`
  * so a reactive translation source can be plugged in via {@link withLoadingText}.
@@ -112,4 +112,3 @@ export declare function withErrorComponent(component: CraftExceptionComponentDes
  */
 export declare function provideCraftLoading(...features: CraftLoadingFeature[]): Provider[];
 export {};
-//# sourceMappingURL=craft-pending.d.ts.map

package/src/lib/craft-pending.js

@@ -1,5 +1,5 @@
-import { inject, InjectionToken, LOCALE_ID, signal, } from './host/craft-compat';
-import { craftRouteTarget, } from './craft-route-target';
+import { inject, InjectionToken, LOCALE_ID, signal, } from './host/craft-compat.js';
+import { craftRouteTarget, } from './craft-route-target.js';
 /**
  * The non-blocking router outlet ({@link CraftRouterOutletController}) commits
  * the URL
@@ -184,4 +184,3 @@ export function withErrorComponent(component) {
 export function provideCraftLoading(...features) {
     return features.flatMap((feature) => feature.providers);
 }
-//# sourceMappingURL=craft-pending.js.map

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

@@ -1,4 +1,4 @@
-import { type YieldableInsertionMethods } from './yieldable';
+import { type YieldableInsertionMethods } from './yieldable.js';
 type NormalizeIns<T> = [T] extends [never] ? {} : T;
 type CtxWithIns<Ctx, I> = Omit<Ctx, 'insertions'> & {
     insertions: YieldableInsertionMethods<I>;
@@ -60,4 +60,3 @@ export declare function craftPipe<Ctx extends {
     insertions?: any;
 }, I1, I2, I3, I4, I5, I6, I7, Y1 = never, Y2 = never, Y3 = never, Y4 = never, Y5 = never, Y6 = never, Y7 = never>(context: Ctx, m1: (context: NoInfer<Ctx>) => I1 | Generator<Y1, I1, unknown>, m2: (context: CtxWithIns<NoInfer<Ctx>, MergedIns<NoInfer<Ctx>, I1>>) => I2 | Generator<Y2, I2, unknown>, m3: (context: CtxWithIns<NoInfer<Ctx>, MergedIns<NoInfer<Ctx>, I1 & I2>>) => I3 | Generator<Y3, I3, unknown>, m4: (context: CtxWithIns<NoInfer<Ctx>, MergedIns<NoInfer<Ctx>, I1 & I2 & I3>>) => I4 | Generator<Y4, I4, unknown>, m5: (context: CtxWithIns<NoInfer<Ctx>, MergedIns<NoInfer<Ctx>, I1 & I2 & I3 & I4>>) => I5 | Generator<Y5, I5, unknown>, m6: (context: CtxWithIns<NoInfer<Ctx>, MergedIns<NoInfer<Ctx>, I1 & I2 & I3 & I4 & I5>>) => I6 | Generator<Y6, I6, unknown>, m7: (context: CtxWithIns<NoInfer<Ctx>, MergedIns<NoInfer<Ctx>, I1 & I2 & I3 & I4 & I5 & I6>>) => I7 | Generator<Y7, I7, unknown>): Generator<Y1 | Y2 | Y3 | Y4 | Y5 | Y6 | Y7, I1 & I2 & I3 & I4 & I5 & I6 & I7, unknown>;
 export {};
-//# sourceMappingURL=craft-pipe.d.ts.map