@craft-ts/core 0.7.0-beta.13

package/src/lib/craft-service.js

@@ -0,0 +1,1072 @@
+import { assertInInjectionContext, createEnvironmentInjector, DestroyRef, EnvironmentInjector, inject, InjectionToken, Injector, isSignal, runInInjectionContext, untracked, } from './host/craft-compat';
+import { isGenerator, runCraftGenerator, SERVICE_APP_START_REQUEST_MARKER, SERVICE_DEPENDENCY_ACCESS_MARKER, SERVICE_YIELD_REQUEST_MARKER, } from './craft-generator-runtime';
+import { registerResolvedService } from './craft-register-for-runtime';
+import { createYieldableReactiveValue, isYieldableReactiveValue, rawReactiveValue, } from './reactive-read';
+export { SERVICE_APP_START_REQUEST_MARKER, SERVICE_DEPENDENCY_ACCESS_MARKER, SERVICE_YIELD_REQUEST_MARKER, } from './craft-generator-runtime';
+import { CRAFT_SERVICE_PROVIDER_BRAND, SERVICE_PROVIDED_INPUT_KEY, SERVICE_ROOT_EXPOSURE_KEY, } from './craft-service.shared';
+import { COMPONENT_REGISTER, ɵfallbackComponentRegister, } from './component-register';
+import { injectFnWrapper } from './fn-wrapper';
+import { markNamedReactiveProperties, markYieldableMethod, yieldableInvocation, } from './yieldable';
+import { craftToken, ɵregisterCraftTokenHostToken, } from './host/craft-injector';
+import { ɵcraftInjectorFromHost } from './host/craft-injector-host';
+export const SERVICE_EXPOSURE_TOKEN_MARKER = Symbol('service-exposure-token-marker');
+export const SERVICE_RUNTIME_META = Symbol('service-runtime-meta');
+const SERVICE_RUNTIME_META_GLOBAL = Symbol.for('@craft-ts/core/service-runtime-meta');
+const SERVICE_RUNTIME_DEFINITION = Symbol('service-runtime-definition');
+const REGISTERED_SERVICES = new Map();
+const REGISTERED_APP_START_SERVICES = new Map();
+const ABSTRACT_SERVICE_MARKER = Symbol('abstract-service-marker');
+const SERVICE_REQUIREMENT_MARKER = Symbol('service-requirement-marker');
+const PROVIDED_ELSEWHERE = 'Provided elsewhere #warn-check-docs:inputs';
+const OMIT_INPUTS_BINDINGS = Symbol('craft-ts.omit-inputs-bindings');
+function wrapOmitInputsHelper(value) {
+    if (typeof value !== 'function') {
+        return value;
+    }
+    return new Proxy(value, {
+        get(target, property, receiver) {
+            const nested = Reflect.get(target, property, receiver);
+            return typeof nested === 'function'
+                ? wrapOmitInputsHelper(nested)
+                : nested;
+        },
+        apply(target, thisArg, args) {
+            return Reflect.apply(target, thisArg, [OMIT_INPUTS_BINDINGS, ...args]);
+        },
+    });
+}
+export const SERVICE_RUNTIME_OVERRIDES = new InjectionToken('service-runtime-overrides', {
+    factory: () => new Map(),
+});
+const SERVICE_INPUT_SOURCE = Symbol('craft-service-input-source');
+export function toValue(value) {
+    if (isServiceInputReader(value)) {
+        return resolveServiceInputSource(value[SERVICE_INPUT_SOURCE]);
+    }
+    if (isYieldableReactiveValue(value)) {
+        return rawReactiveValue(value)();
+    }
+    if (isSignal(value))
+        return value();
+    return value;
+}
+function isServiceInputReader(value) {
+    return typeof value === 'function' && SERVICE_INPUT_SOURCE in value;
+}
+function resolveServiceInputSource(value) {
+    if (isYieldableReactiveValue(value)) {
+        return rawReactiveValue(value)();
+    }
+    if (isSignal(value)) {
+        return value();
+    }
+    if (typeof value === 'function') {
+        return value();
+    }
+    return value;
+}
+export function* onAppStart(run) {
+    yield createAppStartRequest(run);
+}
+export function abstract() {
+    return {
+        [ABSTRACT_SERVICE_MARKER]: () => undefined,
+    };
+}
+export function craftRequirement() {
+    return createServiceRequirement('AnonymousCraftRequirement', new InjectionToken('CraftRequirementToken'));
+}
+export function ɵtoCraftService(options, adaptFactory) {
+    const api = (adaptFactory
+        ? craftService({
+            name: options.name,
+            providedIn: options.providedIn,
+            browserBoundary: options.browserBoundary,
+        }, (inputs) => {
+            const dependencyValue = adaptExternalDependencyValue('inject' in options ? options.inject() : inject(options.token), options.name, true);
+            return adaptFactory(dependencyValue, inputs);
+        })
+        : craftService({
+            name: options.name,
+            providedIn: options.providedIn,
+            browserBoundary: options.browserBoundary,
+        }, () => {
+            const dependencyValue = 'inject' in options ? options.inject() : inject(options.token);
+            return adaptExternalDependencyValue(dependencyValue);
+        }));
+    const internalMetaData = getServiceMetaData(api[capitalize(options.name)]);
+    const runtimeDefinition = internalMetaData[SERVICE_RUNTIME_DEFINITION];
+    if (adaptFactory) {
+        runtimeDefinition.hasPublicInput = adaptFactory.length > 1;
+        runtimeDefinition.hasProvidedInput = factoryUsesProvidedInput(adaptFactory);
+    }
+    if ('provide' in options) {
+        runtimeDefinition.externalProviders = options.provide;
+        runtimeDefinition.hasProvidedInput =
+            runtimeDefinition.hasProvidedInput ||
+                provideFactoryUsesProvidedInput(options.provide);
+    }
+    Reflect.set(internalMetaData, 'usesProvidedInput', runtimeDefinition.hasProvidedInput);
+    return api;
+}
+export function craftService(options, factoryOrMarker) {
+    const capitalizedName = capitalize(options.name);
+    const provideName = `provide${capitalizedName}`;
+    const serviceName = capitalizedName;
+    const requirementName = `${capitalizedName}Requirement`;
+    const toProvideName = `${capitalizedName}ToProvide`;
+    const metaDataName = toMetaDataPropertyName(options.name);
+    if (options.providedIn === 'abstract') {
+        assertAbstractMarker(factoryOrMarker);
+        const token = new InjectionToken(`${capitalizedName}AbstractServiceToken`);
+        const nativeToken = craftToken(`${capitalizedName}AbstractServiceToken`);
+        ɵregisterCraftTokenHostToken(nativeToken, token);
+        const requirement = createServiceRequirement(options.name, token);
+        // A minimal definition so `X()` resolves the requirement token (the
+        // concrete implementation bound through `provideX`) via the injector. The
+        // factory is never invoked: scope is not `function`, so resolution goes
+        // straight to `injector.get(token)` (or a registered test override by name).
+        const abstractYieldDefinition = {
+            factory: () => undefined,
+            name: options.name,
+            providedIn: 'toProvide',
+            browserBoundary: false,
+            appStart: false,
+            token,
+            craftToken: nativeToken,
+            requirement,
+            hasPublicInput: false,
+            hasProvidedInput: false,
+            appStartHooks: new Map(),
+            startedAppStartServices: new Set(),
+        };
+        // The helper closes over metadata that is initialized immediately below.
+        // eslint-disable-next-line prefer-const
+        let abstractMetaData;
+        const abstractInjectHelper = () => {
+            assertInInjectionContext(abstractInject);
+            return inject(token);
+        };
+        const abstractHelper = createHelper(abstractYieldDefinition, () => abstractMetaData);
+        const abstractApi = {
+            [serviceName]: abstractHelper,
+            [requirementName]: requirement,
+            [provideName]: (factory) => {
+                const abstractRuntimeDefinition = {
+                    factory,
+                    name: options.name,
+                    providedIn: 'toProvide',
+                    browserBoundary: false,
+                    appStart: false,
+                    token: new InjectionToken(`${capitalizedName}ServiceToken`),
+                    craftToken: craftToken(`${capitalizedName}ServiceToken`),
+                    requirement,
+                    hasPublicInput: factoryUsesPublicInput(factory),
+                    hasProvidedInput: factoryUsesProvidedInput(factory),
+                    appStartHooks: new Map(),
+                    startedAppStartServices: new Set(),
+                };
+                ɵregisterCraftTokenHostToken(abstractRuntimeDefinition.craftToken, abstractRuntimeDefinition.token);
+                return createProviders(abstractRuntimeDefinition);
+            },
+        };
+        abstractMetaData = createServiceMetaData({
+            name: options.name,
+            providedIn: 'toProvide',
+            inject: abstractInjectHelper,
+            runtimeDefinition: abstractYieldDefinition,
+        });
+        abstractApi[metaDataName] = abstractMetaData;
+        attachServiceRuntimeMeta(abstractHelper, abstractMetaData);
+        attachServiceRuntimeMeta(abstractInjectHelper, abstractMetaData);
+        REGISTERED_SERVICES.set(options.name, abstractInjectHelper);
+        return abstractApi;
+    }
+    const concreteFactory = factoryOrMarker;
+    const runtimeDefinition = {
+        factory: concreteFactory,
+        name: options.name,
+        providedIn: options.providedIn,
+        browserBoundary: options.browserBoundary ?? false,
+        appStart: options.appStart ?? false,
+        providers: options.providers,
+        requirement: options.requirement,
+        hasPublicInput: factoryUsesPublicInput(concreteFactory),
+        hasProvidedInput: factoryUsesProvidedInput(concreteFactory),
+        appStartHooks: new Map(),
+        startedAppStartServices: new Set(),
+    };
+    const token = options.providedIn === 'global'
+        ? new InjectionToken(`${capitalizedName}ServiceToken`, {
+            providedIn: 'root',
+            factory: () => createConcreteServiceInstance(runtimeDefinition, inject(Injector)),
+        })
+        : options.providedIn === 'function'
+            ? undefined
+            : new InjectionToken(options.providedIn === 'manuallyProvidedAtRoot'
+                ? `${capitalizedName}ToProvide`
+                : `${capitalizedName}ServiceToken`);
+    const nativeToken = options.providedIn === 'function'
+        ? undefined
+        : craftToken(options.providedIn === 'manuallyProvidedAtRoot'
+            ? `${capitalizedName}ToProvide`
+            : `${capitalizedName}ServiceToken`);
+    runtimeDefinition.token = token;
+    runtimeDefinition.craftToken = nativeToken;
+    if (token && nativeToken) {
+        ɵregisterCraftTokenHostToken(nativeToken, token);
+    }
+    // The helper closes over metadata that is initialized immediately below.
+    // eslint-disable-next-line prefer-const
+    let serviceMetaData;
+    const api = {
+        [serviceName]: createHelper(runtimeDefinition, () => serviceMetaData),
+    };
+    const injectHelper = createInjectHelper(runtimeDefinition, () => serviceMetaData, concreteInject);
+    if (options.providedIn === 'toProvide' ||
+        options.providedIn === 'manuallyProvidedAtRoot') {
+        api[provideName] = (...provided) => createProviders(runtimeDefinition, provided);
+    }
+    if (options.providedIn === 'manuallyProvidedAtRoot' && token) {
+        api[toProvideName] = token;
+    }
+    serviceMetaData = createServiceMetaData({
+        name: options.name,
+        providedIn: options.providedIn,
+        inject: injectHelper,
+        provide: options.providedIn === 'toProvide' ||
+            options.providedIn === 'manuallyProvidedAtRoot'
+            ? api[provideName]
+            : undefined,
+        token: options.providedIn === 'manuallyProvidedAtRoot'
+            ? token
+            : undefined,
+        runtimeDefinition,
+    });
+    api[metaDataName] = serviceMetaData;
+    attachServiceRuntimeMeta(injectHelper, serviceMetaData);
+    attachServiceRuntimeMeta(api[serviceName], serviceMetaData);
+    REGISTERED_SERVICES.set(runtimeDefinition.name, injectHelper);
+    if (runtimeDefinition.appStart) {
+        REGISTERED_APP_START_SERVICES.set(runtimeDefinition.name, injectHelper);
+    }
+    return api;
+    function abstractInject() {
+        return;
+    }
+    function concreteInject() {
+        return;
+    }
+}
+function createInjectHelper(definition, getMetaData, injectMarker) {
+    const propertyHelpers = new Map();
+    let omitInputsProxy = null;
+    const injectHelper = (bindings, expose) => {
+        assertInInjectionContext(injectMarker);
+        const injector = inject(Injector);
+        const serviceValue = resolveConcreteService(definition, injector, bindings);
+        return expose
+            ? resolveExposedService(serviceValue, expose, injector, definition.providedIn)
+            : serviceValue;
+    };
+    const outerProxy = new Proxy(injectHelper, {
+        get(target, property, receiver) {
+            if (typeof property !== 'string') {
+                return Reflect.get(target, property, receiver);
+            }
+            if (property === 'then' || property in target) {
+                return Reflect.get(target, property, receiver);
+            }
+            if (property === 'OmitInputs') {
+                if (!omitInputsProxy) {
+                    omitInputsProxy = new Proxy({}, {
+                        get(_, subProp, subReceiver) {
+                            return wrapOmitInputsHelper(Reflect.get(outerProxy, subProp, subReceiver));
+                        },
+                    });
+                }
+                return omitInputsProxy;
+            }
+            if (!propertyHelpers.has(property)) {
+                const nestedPropertyHelpers = new Map();
+                const propertyHelperFn = (...args) => {
+                    assertInInjectionContext(injectMarker);
+                    const omitInputs = args[0] === OMIT_INPUTS_BINDINGS;
+                    const callArgs = omitInputs ? args.slice(1) : args;
+                    const isDirectCall = callArgs.length > 0 && !definition.hasPublicInput;
+                    const injector = inject(Injector);
+                    const serviceValue = resolveConcreteService(definition, injector, omitInputs
+                        ? OMIT_INPUTS_BINDINGS
+                        : isDirectCall
+                            ? undefined
+                            : callArgs[0]);
+                    const propertyValue = Reflect.get(Object(serviceValue), property);
+                    if (!isDirectCall) {
+                        return propertyValue;
+                    }
+                    return Reflect.apply(propertyValue, Object(serviceValue), callArgs);
+                };
+                const propertyHelper = new Proxy(propertyHelperFn, {
+                    get(fnTarget, nestedProperty, fnReceiver) {
+                        if (typeof nestedProperty !== 'string') {
+                            return Reflect.get(fnTarget, nestedProperty, fnReceiver);
+                        }
+                        if (nestedProperty === 'then' || nestedProperty in fnTarget) {
+                            return Reflect.get(fnTarget, nestedProperty, fnReceiver);
+                        }
+                        if (!nestedPropertyHelpers.has(nestedProperty)) {
+                            nestedPropertyHelpers.set(nestedProperty, (...nestedArgs) => {
+                                assertInInjectionContext(injectMarker);
+                                const injector = inject(Injector);
+                                const serviceValue = resolveConcreteService(definition, injector, nestedArgs[0] === OMIT_INPUTS_BINDINGS
+                                    ? OMIT_INPUTS_BINDINGS
+                                    : nestedArgs[0]);
+                                const propValue = Reflect.get(Object(serviceValue), property);
+                                return Reflect.get(Object(propValue), nestedProperty);
+                            });
+                        }
+                        return nestedPropertyHelpers.get(nestedProperty);
+                    },
+                });
+                const metaData = getMetaData();
+                if (metaData) {
+                    attachServiceRuntimeMeta(propertyHelper, metaData);
+                }
+                propertyHelpers.set(property, propertyHelper);
+            }
+            return propertyHelpers.get(property);
+        },
+    });
+    return outerProxy;
+}
+function createHelper(definition, getMetaData) {
+    const propertyHelpers = new Map();
+    let omitInputsProxy = null;
+    const toYieldHelper = function* (bindings, expose) {
+        const serviceValue = (yield createYieldRequest(definition, bindings));
+        if (!expose) {
+            return serviceValue;
+        }
+        return (yield* exposeServiceValue(serviceValue, expose));
+    };
+    const outerProxy = new Proxy(toYieldHelper, {
+        get(target, property, receiver) {
+            if (typeof property !== 'string') {
+                return Reflect.get(target, property, receiver);
+            }
+            if (property === 'then' || property in target) {
+                return Reflect.get(target, property, receiver);
+            }
+            if (property === 'OmitInputs') {
+                if (!omitInputsProxy) {
+                    omitInputsProxy = new Proxy({}, {
+                        get(_, subProp, subReceiver) {
+                            return wrapOmitInputsHelper(Reflect.get(outerProxy, subProp, subReceiver));
+                        },
+                    });
+                }
+                return omitInputsProxy;
+            }
+            if (!propertyHelpers.has(property)) {
+                const nestedPropertyHelpers = new Map();
+                const propertyHelperFn = function* (...args) {
+                    const omitInputs = args[0] === OMIT_INPUTS_BINDINGS;
+                    const callArgs = omitInputs ? args.slice(1) : args;
+                    const isDirectCall = callArgs.length > 0 && !definition.hasPublicInput;
+                    const serviceValue = (yield createYieldRequest(definition, omitInputs
+                        ? OMIT_INPUTS_BINDINGS
+                        : isDirectCall
+                            ? undefined
+                            : callArgs[0]));
+                    const propertyValue = Reflect.get(Object(serviceValue), property);
+                    if (!isDirectCall) {
+                        return propertyValue;
+                    }
+                    const result = Reflect.apply(propertyValue, Object(serviceValue), callArgs);
+                    return isGenerator(result) ? yield* result : result;
+                };
+                const propertyHelper = new Proxy(propertyHelperFn, {
+                    get(fnTarget, nestedProperty, fnReceiver) {
+                        if (typeof nestedProperty !== 'string') {
+                            return Reflect.get(fnTarget, nestedProperty, fnReceiver);
+                        }
+                        if (nestedProperty === 'then' || nestedProperty in fnTarget) {
+                            return Reflect.get(fnTarget, nestedProperty, fnReceiver);
+                        }
+                        if (!nestedPropertyHelpers.has(nestedProperty)) {
+                            nestedPropertyHelpers.set(nestedProperty, function* (...nestedArgs) {
+                                const serviceValue = (yield createYieldRequest(definition, nestedArgs[0] === OMIT_INPUTS_BINDINGS
+                                    ? OMIT_INPUTS_BINDINGS
+                                    : nestedArgs[0]));
+                                const propValue = Reflect.get(Object(serviceValue), property);
+                                return Reflect.get(Object(propValue), nestedProperty);
+                            });
+                        }
+                        return nestedPropertyHelpers.get(nestedProperty);
+                    },
+                });
+                const metaData = getMetaData();
+                if (metaData) {
+                    attachServiceRuntimeMeta(propertyHelper, metaData);
+                }
+                propertyHelpers.set(property, propertyHelper);
+            }
+            return propertyHelpers.get(property);
+        },
+    });
+    return outerProxy;
+}
+function createServiceRequirement(name, token) {
+    return {
+        [SERVICE_REQUIREMENT_MARKER]: true,
+        token,
+        name,
+    };
+}
+function createServiceMetaData(config) {
+    const metaData = {
+        kind: 'service-meta-data',
+        name: config.name,
+        providedIn: config.providedIn,
+        browserBoundary: config.runtimeDefinition.browserBoundary,
+        appStart: config.runtimeDefinition.appStart,
+        inject: config.inject,
+        usesProvidedInput: config.runtimeDefinition.hasProvidedInput,
+    };
+    if (config.provide) {
+        metaData['provide'] = config.provide;
+    }
+    if (config.token) {
+        metaData['token'] = config.token;
+    }
+    Object.defineProperty(metaData, SERVICE_RUNTIME_DEFINITION, {
+        value: config.runtimeDefinition,
+        enumerable: false,
+        configurable: false,
+    });
+    Object.defineProperty(metaData, SERVICE_RUNTIME_META, {
+        value: metaData,
+        enumerable: false,
+        configurable: false,
+    });
+    Object.defineProperty(metaData, SERVICE_RUNTIME_META_GLOBAL, {
+        value: metaData,
+        enumerable: false,
+        configurable: false,
+    });
+    return metaData;
+}
+function attachServiceRuntimeMeta(helper, metaData) {
+    if (typeof helper !== 'function') {
+        return;
+    }
+    Object.defineProperty(helper, SERVICE_RUNTIME_META, {
+        value: metaData,
+        enumerable: false,
+        configurable: false,
+    });
+    Object.defineProperty(helper, SERVICE_RUNTIME_META_GLOBAL, {
+        value: metaData,
+        enumerable: false,
+        configurable: false,
+    });
+}
+export function getServiceMetaData(target) {
+    if (isServiceMetaData(target)) {
+        return target;
+    }
+    if (typeof target === 'object' || typeof target === 'function') {
+        const runtimeMeta = (Reflect.get(target, SERVICE_RUNTIME_META) ??
+            Reflect.get(target, SERVICE_RUNTIME_META_GLOBAL));
+        if (runtimeMeta) {
+            return runtimeMeta;
+        }
+    }
+    throw new Error('Expected a craftService/toCraftService service helper or a service metadata object.');
+}
+function isServiceMetaData(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        Reflect.get(value, 'kind') === 'service-meta-data' &&
+        SERVICE_RUNTIME_DEFINITION in value);
+}
+function createProviders(definition, providedArgs = []) {
+    const concreteToken = definition.token;
+    if (!concreteToken) {
+        throw new Error(`craftService("${definition.name}") cannot create providers for scope "${definition.providedIn}".`);
+    }
+    const providers = [];
+    const providedConfig = normalizeProvidedConfig(providedArgs);
+    if (definition.externalProviders) {
+        providers.push(definition.externalProviders(...providedArgs));
+    }
+    const concreteProviders = [
+        {
+            provide: concreteToken,
+            useFactory: () => createConcreteServiceInstance(definition, inject(Injector), undefined, providedConfig),
+        },
+    ];
+    if (definition.craftToken && definition.craftToken !== concreteToken) {
+        concreteProviders.push({
+            provide: definition.craftToken,
+            useExisting: concreteToken,
+        });
+    }
+    if (definition.requirement) {
+        concreteProviders.push({
+            provide: definition.requirement.token,
+            useExisting: concreteToken,
+        });
+    }
+    providers.push(concreteProviders);
+    const brandedProviders = providers;
+    Object.defineProperty(brandedProviders, CRAFT_SERVICE_PROVIDER_BRAND, {
+        value: {
+            name: definition.name,
+            providedIn: definition.providedIn,
+            output: undefined,
+            yielded: undefined,
+        },
+        enumerable: false,
+        configurable: false,
+    });
+    return brandedProviders;
+}
+function normalizeProvidedConfig(providedArgs) {
+    if (providedArgs.length === 0) {
+        return undefined;
+    }
+    return providedArgs.length === 1 ? providedArgs[0] : providedArgs;
+}
+function adaptExternalDependencyValue(value, dependencyName = 'externalDependency', trackReactiveProperties = false) {
+    if (!isObjectLike(value)) {
+        return value;
+    }
+    const target = value;
+    const boundMethods = new Map();
+    const reactiveProperties = new Map();
+    return new Proxy(target, {
+        get(_proxyTarget, property) {
+            const entry = Reflect.get(target, property, target);
+            if (typeof entry === 'function' && !isSignal(entry)) {
+                if (!boundMethods.has(property)) {
+                    boundMethods.set(property, (...args) => untracked(() => Reflect.apply(entry, target, args)));
+                }
+                return boundMethods.get(property);
+            }
+            if (trackReactiveProperties &&
+                isSignal(entry) &&
+                !isYieldableReactiveValue(entry)) {
+                if (!reactiveProperties.has(property)) {
+                    reactiveProperties.set(property, createYieldableReactiveValue(entry, `${dependencyName}.${String(property)}`, {
+                        primitive: 'toCraftService',
+                        path: `${dependencyName}.${String(property)}`,
+                    }));
+                }
+                return reactiveProperties.get(property);
+            }
+            return entry;
+        },
+        apply(proxyTarget, _thisArg, args) {
+            return Reflect.apply(proxyTarget, target, args);
+        },
+    });
+}
+function createYieldRequest(definition, bindings) {
+    return {
+        [SERVICE_YIELD_REQUEST_MARKER]: true,
+        name: definition.name,
+        providedIn: definition.providedIn,
+        resolve: (injector, hostScope) => {
+            assertDependencyScope(hostScope, definition.providedIn, definition.name);
+            return resolveConcreteService(definition, injector, bindings);
+        },
+    };
+}
+function resolveConcreteService(definition, injector, bindings) {
+    const serviceOverride = getServiceRuntimeOverride(injector, definition.name);
+    if (serviceOverride) {
+        if (serviceOverride.kind === 'useValue') {
+            return trackResolvedService(definition, injector, markNamedReactiveProperties(serviceOverride.value));
+        }
+        if (bindings !== undefined &&
+            bindings !== OMIT_INPUTS_BINDINGS &&
+            definition.initialBindings === undefined) {
+            definition.initialBindings = bindings;
+        }
+        if (serviceOverride.instance === undefined) {
+            serviceOverride.instance = createConcreteServiceInstance(definition, injector, bindings, undefined);
+        }
+        return trackResolvedService(definition, injector, markNamedReactiveProperties(serviceOverride.instance));
+    }
+    if (definition.providedIn === 'function') {
+        return trackResolvedService(definition, injector, markNamedReactiveProperties(createConcreteServiceInstance(definition, injector, bindings)));
+    }
+    if (bindings !== undefined &&
+        bindings !== OMIT_INPUTS_BINDINGS &&
+        definition.initialBindings === undefined) {
+        definition.initialBindings = bindings;
+    }
+    return trackResolvedService(definition, injector, markNamedReactiveProperties(ɵcraftInjectorFromHost(injector).get((definition.token ?? definition.craftToken))));
+}
+function trackResolvedService(definition, injector, value) {
+    const hostTags = injector.get(ɵHOST_TAG_LIST, []);
+    registerResolvedService(injector, definition.name, value, hostTags[hostTags.length - 1] ?? `service:${definition.name}`, definition.providedIn);
+    return value;
+}
+function getServiceRuntimeOverride(injector, serviceName) {
+    return injector.get(SERVICE_RUNTIME_OVERRIDES).get(serviceName);
+}
+function createConcreteServiceInstance(definition, injector, bindingsOverride, providedConfig) {
+    const scopedInjector = ɵcreateHostTaggedInjector(injector, `service:${definition.name}`, definition.providers ?? [], {
+        instanced: definition.providedIn === 'function' ||
+            definition.providedIn === 'toProvide',
+    });
+    return runInInjectionContext(scopedInjector, () => ɵcraftInjectorFromHost(scopedInjector).run(() => {
+        const omitInputs = bindingsOverride === OMIT_INPUTS_BINDINGS;
+        const bindings = omitInputs
+            ? {}
+            : (bindingsOverride ?? definition.initialBindings ?? {});
+        const inputs = createInputProxy(bindings, providedConfig, omitInputs, definition.name);
+        const wrappedFactory = injectFnWrapper()(definition.factory);
+        const result = definition.factory.length > 0
+            ? wrappedFactory(inputs)
+            : wrappedFactory();
+        if (!isGenerator(result)) {
+            return result;
+        }
+        const resolved = runCraftGenerator({
+            iterator: result,
+            injector: scopedInjector,
+            hostScope: definition.providedIn,
+            invalidYieldErrorMessage: 'craftService/toCraftService generators can only yield craftService dependencies, exposed dependency helpers, or onAppStart(...).',
+            multipleAppStartErrorMessage: 'craftService generators can only declare onAppStart(...) once.',
+            createAppStartHook: (run) => () => runAppStartCallback(run, scopedInjector, definition.providedIn),
+            reactiveReader: {
+                name: definition.name,
+                primitive: 'craftService',
+                path: `service:${definition.name}`,
+            },
+        });
+        if (resolved.appStartHook) {
+            if (!definition.appStart) {
+                throw new Error(`craftService("${definition.name}") used onAppStart(...) without enabling appStart: true.`);
+            }
+            definition.appStartHooks.set(resolved.value, resolved.appStartHook);
+        }
+        return resolved.value;
+    }));
+}
+function runAppStartCallback(run, injector, hostScope) {
+    const result = run();
+    if (!isGenerator(result)) {
+        return result;
+    }
+    return runCraftGenerator({
+        iterator: result,
+        injector,
+        hostScope,
+        invalidYieldErrorMessage: 'craftService/toCraftService generators can only yield craftService dependencies, exposed dependency helpers, or onAppStart(...).',
+        multipleAppStartErrorMessage: 'craftService generators can only declare onAppStart(...) once.',
+        onAppStartNotSupportedErrorMessage: 'onAppStart(...) generator callbacks cannot declare onAppStart(...) recursively.',
+        reactiveReader: {
+            name: `${hostScope}:appStart`,
+            primitive: 'craftService',
+            path: `appStart:${hostScope}`,
+        },
+    }).value;
+}
+function createInputProxy(bindings, providedConfig, allowMissing = false, serviceName = 'craftService') {
+    const resolvedBindings = providedConfig === undefined
+        ? bindings
+        : {
+            ...bindings,
+            [SERVICE_PROVIDED_INPUT_KEY]: providedConfig,
+        };
+    return new Proxy({}, {
+        get(_target, property) {
+            if (typeof property !== 'string') {
+                return undefined;
+            }
+            if (!Object.prototype.hasOwnProperty.call(resolvedBindings, property)) {
+                if (allowMissing) {
+                    return undefined;
+                }
+                throw new Error(`Inputs Error, ${property} is not provided`);
+            }
+            const value = resolvedBindings[property];
+            if (value === PROVIDED_ELSEWHERE) {
+                throw new Error(`Inputs Error, ${property} is not provided`);
+            }
+            return isReactiveServiceInput(value)
+                ? createServiceInputReader(value, serviceName, property)
+                : value;
+        },
+    });
+}
+function isReactiveServiceInput(value) {
+    return (isSignal(value) ||
+        isYieldableReactiveValue(value) ||
+        typeof value === 'function');
+}
+function createServiceInputReader(source, serviceName, property) {
+    const reactiveSource = isSignal(source) && !isYieldableReactiveValue(source)
+        ? createYieldableReactiveValue(source, `${serviceName}.${property}`, {
+            primitive: 'craftService',
+            path: `service:${serviceName}.input.${property}`,
+        })
+        : source;
+    const reader = markYieldableMethod((...args) => {
+        const value = typeof reactiveSource === 'function'
+            ? reactiveSource(...args)
+            : reactiveSource;
+        return isGenerator(value)
+            ? value
+            : yieldableInvocation(value);
+    });
+    Object.defineProperty(reader, SERVICE_INPUT_SOURCE, {
+        value: reactiveSource,
+        enumerable: false,
+        configurable: false,
+    });
+    return reader;
+}
+function resolveExposedService(serviceValue, expose, injector, hostScope) {
+    const exposure = expose(createExposureTokens(serviceValue));
+    const resolvedExposure = isGenerator(exposure)
+        ? runCraftGenerator({
+            iterator: exposure,
+            injector,
+            hostScope,
+            invalidYieldErrorMessage: 'craftService/toCraftService generators can only yield craftService dependencies, exposed dependency helpers, or onAppStart(...).',
+            multipleAppStartErrorMessage: 'craftService generators can only declare onAppStart(...) once.',
+        }).value
+        : exposure;
+    return createExposedServiceValue(resolvedExposure);
+}
+function* exposeServiceValue(serviceValue, expose) {
+    const exposure = expose(createExposureTokens(serviceValue));
+    const resolvedExposure = isGenerator(exposure)
+        ? yield* exposure
+        : exposure;
+    return createExposedServiceValue(resolvedExposure);
+}
+function createExposureTokens(serviceValue) {
+    return new Proxy({}, {
+        get(_target, property) {
+            if (typeof property !== 'string') {
+                return undefined;
+            }
+            if (property === SERVICE_ROOT_EXPOSURE_KEY &&
+                typeof serviceValue !== 'function') {
+                return undefined;
+            }
+            return createExposureToken(serviceValue, property);
+        },
+    });
+}
+function createExposureToken(serviceValue, key) {
+    const resolve = key === SERVICE_ROOT_EXPOSURE_KEY
+        ? () => serviceValue
+        : () => Reflect.get(Object(serviceValue), key);
+    const token = function* () {
+        return (yield createDependencyAccessRequest(key, resolve));
+    };
+    Object.defineProperty(token, SERVICE_EXPOSURE_TOKEN_MARKER, {
+        value: {
+            key,
+            resolve,
+        },
+        enumerable: false,
+        configurable: false,
+    });
+    return token;
+}
+function createDependencyAccessRequest(key, resolve) {
+    return {
+        [SERVICE_DEPENDENCY_ACCESS_MARKER]: true,
+        key,
+        resolve,
+    };
+}
+function createAppStartRequest(run) {
+    return {
+        [SERVICE_APP_START_REQUEST_MARKER]: true,
+        run,
+    };
+}
+export function runServiceAppStart(reference, serviceValue) {
+    const metaData = getServiceMetaData(reference);
+    const definition = metaData[SERVICE_RUNTIME_DEFINITION];
+    if (!definition.appStart) {
+        throw new Error(`craftService("${definition.name}") is not configured with appStart: true.`);
+    }
+    if (definition.startedAppStartServices.has(serviceValue)) {
+        return;
+    }
+    const hook = definition.appStartHooks.get(serviceValue);
+    if (!hook) {
+        throw new Error(`craftService("${definition.name}") is configured with appStart: true but did not declare onAppStart(...).`);
+    }
+    definition.startedAppStartServices.add(serviceValue);
+    return hook();
+}
+export function getRegisteredAppStartServices() {
+    return Array.from(REGISTERED_APP_START_SERVICES.values());
+}
+export function getRegisteredServices() {
+    return Array.from(REGISTERED_SERVICES.values());
+}
+export function createExposedServiceValue(exposedValue) {
+    const materializedExposure = materializeExposedValue(exposedValue);
+    markNamedReactiveProperties(materializedExposure.value);
+    if (!materializedExposure.rootCallable) {
+        return materializedExposure.value;
+    }
+    if (!isNonCallableObject(materializedExposure.value) ||
+        Reflect.ownKeys(materializedExposure.value).length === 0) {
+        return materializedExposure.rootCallable;
+    }
+    return createCallableExposureProxy(materializedExposure.rootCallable, materializedExposure.value);
+}
+function materializeExposedValue(exposedValue) {
+    if (isRuntimeExposureToken(exposedValue)) {
+        const resolvedValue = exposedValue[SERVICE_EXPOSURE_TOKEN_MARKER].resolve();
+        return isRootRuntimeExposureToken(exposedValue) &&
+            typeof resolvedValue === 'function'
+            ? {
+                value: resolvedValue,
+                rootCallable: resolvedValue,
+            }
+            : { value: resolvedValue };
+    }
+    if (!isNonCallableObject(exposedValue)) {
+        return { value: exposedValue };
+    }
+    const materialized = {};
+    let rootCallable;
+    for (const key of Reflect.ownKeys(exposedValue)) {
+        const resolvedValue = unwrapDirectExposureToken(Reflect.get(exposedValue, key, exposedValue));
+        if (key === SERVICE_ROOT_EXPOSURE_KEY &&
+            typeof resolvedValue === 'function') {
+            rootCallable = resolvedValue;
+            continue;
+        }
+        materialized[key] = resolvedValue;
+    }
+    if (rootCallable && Reflect.ownKeys(materialized).length === 0) {
+        return {
+            value: rootCallable,
+            rootCallable,
+        };
+    }
+    return {
+        value: materialized,
+        rootCallable,
+    };
+}
+function unwrapDirectExposureToken(value) {
+    return isRuntimeExposureToken(value)
+        ? value[SERVICE_EXPOSURE_TOKEN_MARKER].resolve()
+        : value;
+}
+function createCallableExposureProxy(serviceValue, exposedValue) {
+    const exposedKeys = new Set(Reflect.ownKeys(exposedValue));
+    const forwardedTargetKeys = new Set(Reflect.ownKeys(serviceValue).filter((key) => typeof key === 'symbol' ||
+        Reflect.getOwnPropertyDescriptor(serviceValue, key)?.configurable ===
+            false));
+    return new Proxy(serviceValue, {
+        get(target, property, receiver) {
+            if (exposedKeys.has(property)) {
+                return Reflect.get(exposedValue, property, exposedValue);
+            }
+            if (forwardedTargetKeys.has(property) ||
+                (typeof property === 'string' && property in Function.prototype)) {
+                return Reflect.get(target, property, receiver);
+            }
+            return undefined;
+        },
+        has(_target, property) {
+            return (exposedKeys.has(property) ||
+                forwardedTargetKeys.has(property) ||
+                (typeof property === 'string' && property in Function.prototype));
+        },
+        ownKeys() {
+            return Array.from(new Set([
+                ...Array.from(forwardedTargetKeys),
+                ...Reflect.ownKeys(exposedValue),
+            ]));
+        },
+        getOwnPropertyDescriptor(target, property) {
+            if (exposedKeys.has(property)) {
+                return (Reflect.getOwnPropertyDescriptor(exposedValue, property) ?? {
+                    configurable: true,
+                    enumerable: true,
+                    writable: true,
+                    value: Reflect.get(exposedValue, property, exposedValue),
+                });
+            }
+            if (forwardedTargetKeys.has(property)) {
+                return Reflect.getOwnPropertyDescriptor(target, property);
+            }
+            return undefined;
+        },
+    });
+}
+function isObjectLike(value) {
+    return ((typeof value === 'object' && value !== null) || typeof value === 'function');
+}
+function isNonCallableObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isRuntimeExposureToken(value) {
+    return typeof value === 'function' && SERVICE_EXPOSURE_TOKEN_MARKER in value;
+}
+function isRootRuntimeExposureToken(value) {
+    return value[SERVICE_EXPOSURE_TOKEN_MARKER].key === SERVICE_ROOT_EXPOSURE_KEY;
+}
+function assertAbstractMarker(value) {
+    if (typeof value !== 'object' ||
+        value === null ||
+        !(ABSTRACT_SERVICE_MARKER in value)) {
+        throw new Error('craftService scope "abstract" expects abstract<T>().');
+    }
+}
+function assertDependencyScope(hostScope, dependencyScope, dependencyName) {
+    if (hostScope === 'global' && dependencyScope === 'toProvide') {
+        throw new Error(`Global craftService cannot depend on toProvide craftService "${dependencyName}".`);
+    }
+}
+function factoryUsesProvidedInput(factory) {
+    return factory.toString().includes(SERVICE_PROVIDED_INPUT_KEY);
+}
+function factoryUsesPublicInput(factory) {
+    return factory.length > 0;
+}
+function provideFactoryUsesProvidedInput(provideFactory) {
+    return provideFactory.length > 0;
+}
+function capitalize(value) {
+    return value ? value.charAt(0).toUpperCase() + value.slice(1) : value;
+}
+function toMetaDataPropertyName(value) {
+    return `${value
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/[\s-]+/g, '_')
+        .toUpperCase()}_META_DATA`;
+}
+const HOST_TAG_INTERNAL_SERVICE_NAMES = new Set(['service:HostName']);
+export const ɵHOST_TAG_LIST = new InjectionToken('HostTagList', {
+    providedIn: 'root',
+    factory: () => [],
+});
+export const ɵTRACK_TAGS_LIST = new InjectionToken('TrackTagsList', {
+    providedIn: 'root',
+    factory: () => [],
+});
+const hostNameApi = craftService({ name: 'HostName', providedIn: 'manuallyProvidedAtRoot' }, (inputs) => inputs.$provided);
+export const ɵinjectHostName = hostNameApi.HOST_NAME_META_DATA.inject;
+export const ɵHostName = hostNameApi.HostName;
+export const ɵHostNameToProvide = hostNameApi.HostNameToProvide;
+export const ɵHOST_NAME_META_DATA = hostNameApi.HOST_NAME_META_DATA;
+const ɵprovideHostNameProvider = hostNameApi.provideHostName;
+export function ɵprovideHostName(name) {
+    return [
+        ɵprovideHostNameProvider(name),
+        {
+            provide: ɵHOST_TAG_LIST,
+            useFactory: () => {
+                const parentTags = inject(ɵHOST_TAG_LIST, {
+                    optional: true,
+                    skipSelf: true,
+                }) ?? [];
+                const id = (inject(COMPONENT_REGISTER, { optional: true }) ?? ɵfallbackComponentRegister).next();
+                return [...parentTags, `${name}#${id}`];
+            },
+        },
+    ];
+}
+export function ɵprovideTrackTags(tags) {
+    return [
+        {
+            provide: ɵTRACK_TAGS_LIST,
+            useFactory: () => {
+                const parentTags = inject(ɵTRACK_TAGS_LIST, {
+                    optional: true,
+                    skipSelf: true,
+                }) ?? [];
+                return [...parentTags, ...tags];
+            },
+        },
+    ];
+}
+export function ɵinjectTrackTags() {
+    return inject(ɵTRACK_TAGS_LIST);
+}
+export function* ɵHostTag() {
+    return (yield {
+        [SERVICE_YIELD_REQUEST_MARKER]: true,
+        providedIn: 'function',
+        resolve: (injector) => injector.get(ɵHOST_TAG_LIST),
+    });
+}
+export function* ɵTrackTags() {
+    return (yield {
+        [SERVICE_YIELD_REQUEST_MARKER]: true,
+        providedIn: 'function',
+        resolve: (injector) => injector.get(ɵTRACK_TAGS_LIST),
+    });
+}
+export function ɵcreateHostTaggedInjector(injector, hostName, extraProviders = [], options = {}) {
+    if (HOST_TAG_INTERNAL_SERVICE_NAMES.has(hostName)) {
+        return injector;
+    }
+    let parentDestroyRef = null;
+    try {
+        parentDestroyRef = inject(DestroyRef, { optional: true });
+    }
+    catch {
+        // not in an injection context
+    }
+    // Collect tags from the node injector chain
+    const nodeTags = injector.get(ɵHOST_TAG_LIST, []);
+    // Collect tags exclusive to the env injector chain (e.g. route-level providers
+    // that are shadowed by a parent component's node injector providing the same token)
+    let envOnlyTags = [];
+    const associatedEnvInjector = injector.get(EnvironmentInjector, null);
+    if (associatedEnvInjector) {
+        const envTags = associatedEnvInjector.get(ɵHOST_TAG_LIST, null) ?? [];
+        envOnlyTags = envTags.filter((t) => !nodeTags.includes(t));
+    }
+    // Insert env-only tags before the last element of nodeTags (the current component's tag)
+    // to preserve semantic order: parent components → route → current component → method
+    // EXPERIMENT (option A): stamp the instance ordinal that provideHostName's
+    // factory would have produced, which this useValue would otherwise discard.
+    // A host that can exist several times at once carries which one it is, the
+    // way a component tag already does. A singleton does not: a number on a host
+    // there is exactly one of reads as noise, and would change every log line and
+    // snapshot for nothing.
+    const taggedHostName = options.instanced
+        ? `${hostName}#${(injector.get(COMPONENT_REGISTER, null) ?? ɵfallbackComponentRegister).next()}`
+        : hostName;
+    const mergedTags = nodeTags.length > 0
+        ? [
+            ...nodeTags.slice(0, -1),
+            ...envOnlyTags,
+            nodeTags[nodeTags.length - 1],
+            taggedHostName,
+        ]
+        : [...envOnlyTags, taggedHostName];
+    const envInjector = createEnvironmentInjector([
+        ɵprovideHostName(hostName),
+        { provide: ɵHOST_TAG_LIST, useValue: mergedTags },
+        ...extraProviders,
+    ], injector, `HostTag(${hostName})`);
+    parentDestroyRef?.onDestroy(() => {
+        if (!envInjector.destroyed) {
+            envInjector.destroy();
+        }
+    });
+    return envInjector;
+}
+//# sourceMappingURL=craft-service.js.map