@craft-ts/core 0.7.0-beta.13

package/src/lib/async-process.js

@@ -0,0 +1,702 @@
+import { assertInInjectionContext, computed, batch as craftBatch, DestroyRef, inject, Injector, isSignal, runInInjectionContext, signal, untracked, } from './host/craft-compat';
+import { executeGeneratorCompatibleFactory, isGeneratorFunction, } from './craft-generator-runtime';
+import { executeGeneratorCompatibleFactoryAsync } from './craft-program-runtime';
+import { attachCraftSettledValue, createYieldableSettledValue, CraftNotSettled, } from './craft-settled';
+import { toCraftStatus, } from './util/craft-resource-status';
+import { resourceById } from './resource-by-id';
+import { isSource } from './util/util';
+import { methodParamsWrapperEqual, unwrapMethodParams, wrapMethodParams, } from './util/method-trigger-nonce';
+import { craftResource } from './craft-resource';
+import { preservedResource } from './preserved-resource';
+import { isCraftException, } from './craft-exception';
+import { CORRELATION_ID_SERVICE } from './correlation-id';
+import { createNamedPrimitiveGen, } from './craft-primitive-gen';
+import { takeUntilDestroyed } from './host/craft-compat';
+import { createSchemaValidationRuntime, useSchemaValidationPolicy, } from './schema-validation';
+import { APP_SNAPSHOT_REGISTRY, INSERTION_SNAPSHOT_REGISTRY, InsertionSnapshotRegistry, TAKE_APP_SNAPSHOT, triggerAndCollectInsertions, } from './take-app-snapshot';
+import { createResourceExceptionsRuntime, enrichResourceException, } from './resource-exception';
+import { ɵcreateHostTaggedInjector, ɵHOST_TAG_LIST } from './craft-service';
+import { injectFnWrapper } from './fn-wrapper';
+import { ɵprovidePrimitiveMethodRuntimeContext } from './primitive-method-runtime-context';
+import { ɵcreatePrimitiveResourceByIdRuntimeContext, ɵcreatePrimitiveResourceRuntimeContext, ɵobservePrimitiveResourceRuntimeContext, } from './primitive-resource-runtime-context';
+import { createYieldableInsertionMethod, isNonYieldableInsertionMethod, yieldableInvocation, } from './yieldable';
+import { createYieldableReactiveFacade, deepYieldable, hasDeepYieldableInsertion, isYieldableReactiveValue, nameInsertedReactiveValue, } from './reactive-read';
+import { craftUse } from './craft-use';
+const ASYNC_PROCESS_INVALID_YIELD_ERROR_MESSAGE = 'asyncProcess generators can only yield craftService dependencies or exposed dependency helpers.';
+const ASYNC_PROCESS_APP_START_ERROR_MESSAGE = 'asyncProcess generators do not support onAppStart(...).';
+export function asyncProcess(name, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+AsyncProcessConfig, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+...insertions
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    return createNamedPrimitiveGen(name, createAsyncProcessRef(name, AsyncProcessConfig, ...insertions));
+}
+function createAsyncProcessRef(name, AsyncProcessConfig, ...insertions) {
+    const insertionSnapshotRegistry = new InsertionSnapshotRegistry();
+    const asyncExtraProviders = [
+        {
+            provide: INSERTION_SNAPSHOT_REGISTRY,
+            useValue: insertionSnapshotRegistry,
+        },
+        ...(AsyncProcessConfig.providers ?? []),
+    ];
+    let injector;
+    if ([
+        'params' in AsyncProcessConfig ? AsyncProcessConfig.params : undefined,
+        'method' in AsyncProcessConfig ? AsyncProcessConfig.method : undefined,
+        'loader' in AsyncProcessConfig ? AsyncProcessConfig.loader : undefined,
+        'stream' in AsyncProcessConfig ? AsyncProcessConfig.stream : undefined,
+        ...insertions,
+    ].some((value) => isGeneratorFunction(value))) {
+        assertInInjectionContext(asyncProcess);
+        injector = ɵcreateHostTaggedInjector(inject(Injector), `asyncProcess:${name}`, asyncExtraProviders);
+    }
+    const getInjector = () => {
+        if (!injector) {
+            assertInInjectionContext(asyncProcess);
+            injector = ɵcreateHostTaggedInjector(inject(Injector), `asyncProcess:${name}`, asyncExtraProviders);
+        }
+        return injector;
+    };
+    const AsyncProcessResourceParamsFnSignal = signal(undefined);
+    // Incremented on every explicit method call so the resource request always
+    // changes, forcing the loader to re-run even when the method returns the same
+    // value or `undefined`. Starts at 0 = "never called" to preserve idle.
+    const methodTriggerSeq = signal(0);
+    const hasParamsFn = 'params' in AsyncProcessConfig &&
+        typeof AsyncProcessConfig.params === 'function';
+    const isConnectedToSource = !hasParamsFn && isSource(AsyncProcessConfig.method);
+    const hasMethodFn = !hasParamsFn &&
+        typeof AsyncProcessConfig.method === 'function' &&
+        !isSignal(AsyncProcessConfig.method);
+    const isUsingIdentifier = 'identifier' in AsyncProcessConfig;
+    const methodParamsException = signal(undefined);
+    const schemaParseExceptions = signal({});
+    const configuredSchemas = {
+        method: AsyncProcessConfig.methodSchema,
+        params: AsyncProcessConfig.paramsSchema,
+        loader: AsyncProcessConfig.loaderSchema,
+    };
+    const hasConfiguredSchema = Object.values(configuredSchemas).some(Boolean);
+    const setSchemaException = (stage, exception) => {
+        untracked(() => {
+            schemaParseExceptions.update((current) => {
+                const next = { ...current };
+                if (exception)
+                    next[stage] = exception;
+                else
+                    delete next[stage];
+                return next;
+            });
+        });
+    };
+    const schemaPolicy = useSchemaValidationPolicy(getInjector(), AsyncProcessConfig.schemaValidationPolicy);
+    const schemaValidation = {
+        method: createSchemaValidationRuntime({
+            schema: configuredSchemas.method,
+            primitive: 'asyncProcess',
+            name,
+            policy: schemaPolicy,
+            setException: setSchemaException,
+        }),
+        params: createSchemaValidationRuntime({
+            schema: configuredSchemas.params,
+            primitive: 'asyncProcess',
+            name,
+            policy: schemaPolicy,
+            setException: setSchemaException,
+        }),
+        loader: createSchemaValidationRuntime({
+            schema: configuredSchemas.loader,
+            primitive: 'asyncProcess',
+            name,
+            policy: schemaPolicy,
+            setException: setSchemaException,
+        }),
+    };
+    const schemaParse = computed(() => {
+        const values = schemaParseExceptions();
+        return {
+            ...(values['method'] ? { method: values['method'] } : {}),
+            ...(values['params'] ? { params: values['params'] } : {}),
+            ...(values['loader'] ? { loader: values['loader'] } : {}),
+        };
+    });
+    const getIdentifierFromParams = (params) => {
+        if (!isUsingIdentifier || !('identifier' in AsyncProcessConfig)) {
+            return undefined;
+        }
+        if (params === undefined || params === null) {
+            return undefined;
+        }
+        return AsyncProcessConfig.identifier?.(params);
+    };
+    const sanitizeParamsResult = (value) => {
+        if (isCraftException(value)) {
+            return undefined;
+        }
+        return value;
+    };
+    const reactiveParamsException = computed(() => {
+        if (hasMethodFn) {
+            return undefined;
+        }
+        const schemaParamsException = schemaParseExceptions()['params'];
+        if (schemaParamsException) {
+            return enrichResourceException(schemaParamsException, {
+                scope: 'params',
+            });
+        }
+        if (hasParamsFn) {
+            const paramsValue = executeGeneratorCompatibleFactory({
+                factory: AsyncProcessConfig
+                    .params,
+                thisArg: undefined,
+                getInjector,
+                args: [],
+                invalidYieldErrorMessage: ASYNC_PROCESS_INVALID_YIELD_ERROR_MESSAGE,
+                multipleAppStartErrorMessage: ASYNC_PROCESS_APP_START_ERROR_MESSAGE,
+                onAppStartNotSupportedErrorMessage: ASYNC_PROCESS_APP_START_ERROR_MESSAGE,
+            });
+            return isCraftException(paramsValue)
+                ? enrichResourceException(paramsValue, { scope: 'params' })
+                : undefined;
+        }
+        if (isConnectedToSource) {
+            const sourceValue = AsyncProcessConfig.method();
+            return isCraftException(sourceValue)
+                ? enrichResourceException(sourceValue, { scope: 'params' })
+                : undefined;
+        }
+        return undefined;
+    });
+    const paramsException = computed(() => {
+        return hasMethodFn ? methodParamsException() : reactiveParamsException();
+    });
+    const { setLoaderException, exceptions, hasException, createSelectExceptions, createSelectHasException, } = createResourceExceptionsRuntime({
+        isUsingIdentifier,
+        paramsException,
+    });
+    const wrappedSourceParams = isConnectedToSource
+        ? (() => {
+            const value = sanitizeParamsResult(AsyncProcessConfig.method());
+            if (!configuredSchemas.params || isCraftException(value))
+                return value;
+            const parsed = schemaValidation.params.parseSync(value, 'params', 'source');
+            return parsed.accepted ? parsed.value : undefined;
+        })
+        : undefined;
+    const wrappedParamsFn = hasParamsFn
+        ? (() => {
+            const value = executeGeneratorCompatibleFactory({
+                factory: AsyncProcessConfig.params,
+                thisArg: undefined,
+                getInjector,
+                args: [],
+                invalidYieldErrorMessage: ASYNC_PROCESS_INVALID_YIELD_ERROR_MESSAGE,
+                multipleAppStartErrorMessage: ASYNC_PROCESS_APP_START_ERROR_MESSAGE,
+                onAppStartNotSupportedErrorMessage: ASYNC_PROCESS_APP_START_ERROR_MESSAGE,
+            });
+            if (!configuredSchemas.params || isCraftException(value)) {
+                return sanitizeParamsResult(value);
+            }
+            const parsed = schemaValidation.params.parseSync(value, 'params', 'params');
+            return parsed.accepted ? parsed.value : undefined;
+        })
+        : undefined;
+    const wrappedLoader = 'loader' in AsyncProcessConfig && AsyncProcessConfig.loader
+        ? (async (param) => {
+            const injector = getInjector();
+            const correlationSvc = injector.get(CORRELATION_ID_SERVICE, null);
+            const operationId = correlationSvc?.lastCorrelationId() ?? null;
+            if (operationId)
+                correlationSvc?.startOperation(operationId);
+            // Unwrap the method-trigger nonce so the user loader and identifier logic
+            // only ever see plain params (no-op for source / params-fn / byId modes).
+            const rawParams = unwrapMethodParams(param.params);
+            const loaderParam = { ...param, params: rawParams };
+            try {
+                const step = await executeGeneratorCompatibleFactoryAsync({
+                    factory: AsyncProcessConfig.loader,
+                    thisArg: undefined,
+                    getInjector,
+                    args: [loaderParam],
+                    invalidYieldErrorMessage: ASYNC_PROCESS_INVALID_YIELD_ERROR_MESSAGE,
+                    appStartNotSupportedErrorMessage: ASYNC_PROCESS_APP_START_ERROR_MESSAGE,
+                });
+                if (step.kind === 'shortCircuit') {
+                    const exceptionId = getIdentifierFromParams(rawParams);
+                    setLoaderException(enrichResourceException(step.exception, {
+                        scope: 'loader',
+                        identifier: exceptionId,
+                    }), exceptionId);
+                    return undefined;
+                }
+                const result = step.value;
+                if (isCraftException(result)) {
+                    const exceptionId = getIdentifierFromParams(rawParams);
+                    setLoaderException(enrichResourceException(result, {
+                        scope: 'loader',
+                        identifier: exceptionId,
+                    }), exceptionId);
+                    return undefined;
+                }
+                let validatedResult = result;
+                if (configuredSchemas.loader) {
+                    const parsed = await schemaValidation.loader.parseAsync(result, 'loader', 'loader', getIdentifierFromParams(rawParams));
+                    if (!parsed.accepted) {
+                        const exceptionId = getIdentifierFromParams(rawParams);
+                        setLoaderException(enrichResourceException(parsed.exception, {
+                            scope: 'loader',
+                            identifier: exceptionId,
+                        }), exceptionId);
+                        return undefined;
+                    }
+                    validatedResult = parsed.value;
+                }
+                const successId = getIdentifierFromParams(rawParams);
+                setLoaderException(undefined, successId);
+                return validatedResult;
+            }
+            catch (error) {
+                if (!isCraftException(error)) {
+                    injector.get(TAKE_APP_SNAPSHOT, null)?.();
+                }
+                throw error;
+            }
+            finally {
+                if (operationId)
+                    correlationSvc?.endOperation(operationId);
+            }
+        })
+        : undefined;
+    const wrappedStream = 'stream' in AsyncProcessConfig && AsyncProcessConfig.stream
+        ? ((...args) => {
+            const result = executeGeneratorCompatibleFactory({
+                factory: AsyncProcessConfig.stream,
+                thisArg: undefined,
+                getInjector,
+                args,
+                invalidYieldErrorMessage: ASYNC_PROCESS_INVALID_YIELD_ERROR_MESSAGE,
+                multipleAppStartErrorMessage: ASYNC_PROCESS_APP_START_ERROR_MESSAGE,
+                onAppStartNotSupportedErrorMessage: ASYNC_PROCESS_APP_START_ERROR_MESSAGE,
+            });
+            const wrapStreamSignal = (streamSignal) => {
+                if (!configuredSchemas.loader || !isSignal(streamSignal)) {
+                    return streamSignal;
+                }
+                let lastValue;
+                return computed(() => {
+                    const streamItem = streamSignal();
+                    if (streamItem &&
+                        typeof streamItem === 'object' &&
+                        'error' in streamItem) {
+                        return streamItem;
+                    }
+                    const rawValue = streamItem &&
+                        typeof streamItem === 'object' &&
+                        'value' in streamItem
+                        ? streamItem.value
+                        : streamItem;
+                    const parsed = schemaValidation.loader.parseSync(rawValue, 'loader', 'stream');
+                    if (!parsed.accepted) {
+                        return lastValue === undefined
+                            ? undefined
+                            : { value: lastValue };
+                    }
+                    lastValue = parsed.value;
+                    return { value: lastValue };
+                });
+            };
+            if (result &&
+                typeof result.then === 'function') {
+                return Promise.resolve(result).then(wrapStreamSignal);
+            }
+            return wrapStreamSignal(result);
+        })
+        : undefined;
+    const resourceParamsSrc = isConnectedToSource
+        ? wrappedSourceParams
+        : hasParamsFn
+            ? wrappedParamsFn
+            : AsyncProcessResourceParamsFnSignal;
+    // Method-based, non-grouped: feed the resource a nonce-tagged request so every
+    // explicit call re-runs the loader (even for identical / `undefined` params),
+    // while `resourceParamsSrc` stays the raw signal for all public consumers.
+    const usesMethodParamsSignal = !isConnectedToSource && !hasParamsFn;
+    const methodTaggedParams = computed(() => {
+        const seq = methodTriggerSeq();
+        if (seq === 0)
+            return undefined; // idle until the first call
+        return wrapMethodParams(AsyncProcessResourceParamsFnSignal(), seq);
+    });
+    const asyncProcessResourceOptions = {
+        ...AsyncProcessConfig,
+        params: usesMethodParamsSignal
+            ? methodTaggedParams
+            : resourceParamsSrc,
+        equal: usesMethodParamsSignal
+            ? methodParamsWrapperEqual(AsyncProcessConfig.equal)
+            : AsyncProcessConfig.equal,
+        loader: wrappedLoader,
+        stream: wrappedStream,
+    };
+    const resourceTarget = isUsingIdentifier
+        ? resourceById({
+            ...AsyncProcessConfig,
+            params: resourceParamsSrc,
+            loader: wrappedLoader,
+            stream: wrappedStream,
+            identifier: AsyncProcessConfig.identifier,
+        })
+        : AsyncProcessConfig.preservePreviousValue?.()
+            ? preservedResource(asyncProcessResourceOptions)
+            : craftResource(asyncProcessResourceOptions);
+    if (configuredSchemas.loader) {
+        const target = resourceTarget;
+        const originalResourceSet = target.set.bind(target);
+        const originalResourceUpdate = target.update.bind(target);
+        target.set = (value) => {
+            const parsed = schemaValidation.loader.parseSync(value, 'loader', 'set');
+            if (parsed.accepted)
+                originalResourceSet(parsed.value);
+        };
+        target.update = (updateFn) => originalResourceUpdate((current) => {
+            const parsed = schemaValidation.loader.parseSync(updateFn(current), 'loader', 'update');
+            return parsed.accepted ? parsed.value : current;
+        });
+    }
+    runInInjectionContext(getInjector(), () => ɵobservePrimitiveResourceRuntimeContext(isUsingIdentifier
+        ? ɵcreatePrimitiveResourceByIdRuntimeContext('asyncProcess', resourceTarget)
+        : ɵcreatePrimitiveResourceRuntimeContext('asyncProcess', resourceTarget), name));
+    // Capture the raw Angular status BEFORE `Object.assign` overrides
+    // `resourceTarget.status` with the craft computed (avoids a computation cycle).
+    const rawResourceStatus = resourceTarget.status;
+    const publicExceptions = hasConfiguredSchema
+        ? computed(() => ({ ...exceptions(), parse: schemaParse() }))
+        : exceptions;
+    const asyncOutput = Object.assign(resourceTarget, 
+    // byId is used to helps TS to correctly infer the resourceByGroup
+    isUsingIdentifier
+        ? {
+            /**
+             * Only added to help TS inference (TS cannot infer ResourceByIdHandler without erasing the signal getter, () => ResourceByIdRef<...>) )
+             */
+            _resourceById: resourceTarget,
+            select: (id) => {
+                const selectExceptions = createSelectExceptions(id);
+                const selectHasException = createSelectHasException(id);
+                return computed(() => {
+                    const list = resourceTarget();
+                    //@ts-expect-error GroupIdentifier & string is not recognized correctly
+                    const resource = list[id];
+                    if (!resource) {
+                        return undefined;
+                    }
+                    const rawSelectStatus = resource.status;
+                    const result = Object.assign(resource, {
+                        status: computed(() => toCraftStatus(rawSelectStatus(), selectHasException())),
+                        exception: computed(() => selectExceptions().list[0]),
+                        hasException: selectHasException,
+                        hasSchema: signal(hasConfiguredSchema),
+                        exceptions: hasConfiguredSchema
+                            ? computed(() => ({
+                                ...selectExceptions(),
+                                parse: schemaParse(),
+                            }))
+                            : selectExceptions,
+                    });
+                    attachCraftSettledValue(name, result);
+                    return result;
+                })();
+            },
+            selectOrCreate: (id) => {
+                const selected = resourceTarget.addById(id);
+                const selectExceptions = createSelectExceptions(id);
+                const selectHasException = createSelectHasException(id);
+                const rawSelectStatus = selected.status;
+                const result = Object.assign(selected, {
+                    status: computed(() => toCraftStatus(rawSelectStatus(), selectHasException())),
+                    exception: computed(() => selectExceptions().list[0]),
+                    hasException: selectHasException,
+                    hasSchema: signal(hasConfiguredSchema),
+                    exceptions: hasConfiguredSchema
+                        ? computed(() => ({
+                            ...selectExceptions(),
+                            parse: schemaParse(),
+                        }))
+                        : selectExceptions,
+                });
+                attachCraftSettledValue(name, result);
+                return result;
+            },
+        }
+        : {}, {
+        ...(isUsingIdentifier
+            ? {}
+            : {
+                status: computed(() => toCraftStatus(rawResourceStatus(), hasException())),
+                exception: computed(() => exceptions().list[0]),
+            }),
+        hasException,
+        hasSchema: signal(hasConfiguredSchema),
+        exceptions: publicExceptions,
+        ...(hasParamsFn
+            ? { resourceParamsSrc }
+            : {
+                method: isSignal(AsyncProcessConfig.method)
+                    ? undefined
+                    : (arg) => {
+                        let methodArg = arg;
+                        if (configuredSchemas.method) {
+                            const parsedMethod = schemaValidation.method.parseSync(arg, 'method', 'method');
+                            if (!parsedMethod.accepted) {
+                                methodParamsException.set(enrichResourceException(parsedMethod.exception, {
+                                    scope: 'params',
+                                }));
+                                return yieldableInvocation(parsedMethod.exception);
+                            }
+                            methodArg = parsedMethod.value;
+                        }
+                        const result = executeGeneratorCompatibleFactory({
+                            factory: AsyncProcessConfig.method,
+                            thisArg: undefined,
+                            getInjector,
+                            args: [methodArg],
+                            invalidYieldErrorMessage: ASYNC_PROCESS_INVALID_YIELD_ERROR_MESSAGE,
+                            multipleAppStartErrorMessage: ASYNC_PROCESS_APP_START_ERROR_MESSAGE,
+                            onAppStartNotSupportedErrorMessage: ASYNC_PROCESS_APP_START_ERROR_MESSAGE,
+                        });
+                        if (isCraftException(result)) {
+                            methodParamsException.set(enrichResourceException(result, { scope: 'params' }));
+                            return yieldableInvocation(result);
+                        }
+                        let paramsResult = result;
+                        if (configuredSchemas.params) {
+                            const parsedParams = schemaValidation.params.parseSync(result, 'params', 'method');
+                            if (!parsedParams.accepted) {
+                                methodParamsException.set(enrichResourceException(parsedParams.exception, {
+                                    scope: 'params',
+                                }));
+                                return yieldableInvocation(parsedParams.exception);
+                            }
+                            paramsResult = parsedParams.value;
+                        }
+                        if (methodParamsException()) {
+                            methodParamsException.set(undefined);
+                        }
+                        if (isUsingIdentifier) {
+                            const id = AsyncProcessConfig.identifier?.(arg);
+                            resourceTarget.addById(id);
+                        }
+                        // These two signals form one method request. Publish them as
+                        // one batch so the resource watch cannot start the loader
+                        // once for the nonce and once again for the params.
+                        craftBatch(() => {
+                            methodTriggerSeq.update((n) => n + 1);
+                            AsyncProcessResourceParamsFnSignal.set(paramsResult);
+                        });
+                        return yieldableInvocation(paramsResult);
+                    },
+            }),
+    });
+    if (!isUsingIdentifier) {
+        attachCraftSettledValue(name, asyncOutput);
+    }
+    const publicAsyncContext = createYieldableReactiveFacade(asyncOutput, {
+        name,
+        primitive: 'asyncProcess',
+        path: name,
+    });
+    const insertionSettledState = isUsingIdentifier
+        ? createYieldableSettledValue(computed(() => {
+            const params = craftUse(publicAsyncContext.resourceParamsSrc());
+            if (params == null)
+                throw new CraftNotSettled(name);
+            const id = AsyncProcessConfig.identifier?.(params);
+            if (id == null)
+                throw new CraftNotSettled(name);
+            const selected = publicAsyncContext.select(id);
+            if (!selected)
+                throw new CraftNotSettled(name);
+            return craftUse(selected.settledValue());
+        }), {
+            primitive: 'asyncProcess',
+            insertion: 'settledState',
+            path: `${name}.settledState`,
+        })
+        : createYieldableSettledValue(computed(() => craftUse(publicAsyncContext.settledValue())), {
+            primitive: 'asyncProcess',
+            insertion: 'settledState',
+            path: `${name}.settledState`,
+        });
+    const insertionsResult = insertions?.reduce((acc, insert) => {
+        const rawResult = executeGeneratorCompatibleFactory({
+            factory: insert,
+            thisArg: undefined,
+            getInjector,
+            args: [
+                {
+                    ...(isUsingIdentifier
+                        ? {
+                            resourceById: createYieldableReactiveFacade(resourceTarget, {
+                                name: 'resourceById',
+                                primitive: 'asyncProcess',
+                                path: `${name}.resourceById`,
+                            }),
+                        }
+                        : { resource: publicAsyncContext }),
+                    resourceParamsSrc: createYieldableReactiveFacade(resourceParamsSrc, {
+                        name: 'resourceParamsSrc',
+                        primitive: 'asyncProcess',
+                        path: `${name}.resourceParamsSrc`,
+                    }),
+                    hasException: publicAsyncContext.hasException,
+                    exceptions: publicAsyncContext.exceptions,
+                    insertions: acc,
+                    state: createYieldableReactiveFacade(resourceTarget.state, {
+                        name: 'state',
+                        primitive: 'asyncProcess',
+                        path: `${name}.state`,
+                    }),
+                    settledState: insertionSettledState,
+                    set: (nextState) => yieldableInvocation(resourceTarget.set(nextState)),
+                    update: (updateFn) => yieldableInvocation(resourceTarget.update(updateFn)),
+                    patch: (patchFn) => yieldableInvocation(resourceTarget.update((current) => ({
+                        ...current,
+                        ...patchFn(current),
+                    }))),
+                    __primitiveKind: 'asyncProcess',
+                },
+            ],
+            invalidYieldErrorMessage: ASYNC_PROCESS_INVALID_YIELD_ERROR_MESSAGE,
+            multipleAppStartErrorMessage: ASYNC_PROCESS_APP_START_ERROR_MESSAGE,
+            onAppStartNotSupportedErrorMessage: ASYNC_PROCESS_APP_START_ERROR_MESSAGE,
+        });
+        const wrappedResult = Object.entries(rawResult).reduce((wrappedAcc, [key, value]) => {
+            if (typeof value === 'function' &&
+                !isSignal(value) &&
+                !isYieldableReactiveValue(value) &&
+                !isNonYieldableInsertionMethod(value)) {
+                const injector = getInjector();
+                const methodInjector = ɵcreateHostTaggedInjector(injector, `method:${key}`, [
+                    ɵprovidePrimitiveMethodRuntimeContext('asyncProcess', {
+                        state: resourceTarget.state,
+                        set: resourceTarget.set,
+                        update: resourceTarget.update,
+                        patch: (patchFn) => resourceTarget.update((current) => ({
+                            ...current,
+                            ...patchFn(current),
+                        })),
+                    }, value),
+                ]);
+                const wrappedFn = runInInjectionContext(methodInjector, () => injectFnWrapper()(value));
+                wrappedAcc[key] = createYieldableInsertionMethod(wrappedFn, {
+                    injector: methodInjector,
+                    invalidYieldErrorMessage: ASYNC_PROCESS_INVALID_YIELD_ERROR_MESSAGE,
+                    multipleAppStartErrorMessage: ASYNC_PROCESS_APP_START_ERROR_MESSAGE,
+                    onAppStartNotSupportedErrorMessage: ASYNC_PROCESS_APP_START_ERROR_MESSAGE,
+                });
+            }
+            else {
+                const namedValue = nameInsertedReactiveValue(value, key, 'asyncProcess', `${name}.${key}`);
+                wrappedAcc[key] = createYieldableReactiveFacade(namedValue, {
+                    name: key,
+                    primitive: 'asyncProcess',
+                    insertion: key,
+                    path: `${name}.${key}`,
+                });
+            }
+            return wrappedAcc;
+        }, {});
+        return { ...acc, ...wrappedResult };
+    }, {});
+    Object.assign(asyncOutput, insertionsResult);
+    const snapshotRegistry = injector
+        ? injector.get(APP_SNAPSHOT_REGISTRY, null)
+        : (() => {
+            try {
+                return inject(APP_SNAPSHOT_REGISTRY, { optional: true });
+            }
+            catch {
+                return null;
+            }
+        })();
+    const hostTagList = injector
+        ? (injector.get(ɵHOST_TAG_LIST, null) ?? [])
+        : (() => {
+            try {
+                return inject(ɵHOST_TAG_LIST, { optional: true }) ?? [];
+            }
+            catch {
+                return [];
+            }
+        })();
+    const destroyRefAsync = injector
+        ? injector.get(DestroyRef, null)
+        : (() => {
+            try {
+                return inject(DestroyRef, { optional: true });
+            }
+            catch {
+                return null;
+            }
+        })();
+    if (snapshotRegistry && destroyRefAsync) {
+        snapshotRegistry.triggerSnapshot$
+            .pipe(takeUntilDestroyed(destroyRefAsync))
+            .subscribe(() => {
+            const insertionSnapshots = triggerAndCollectInsertions(insertionSnapshotRegistry);
+            let stateSnapshot;
+            try {
+                if (isUsingIdentifier) {
+                    const byId = resourceTarget();
+                    stateSnapshot = {
+                        params: AsyncProcessResourceParamsFnSignal(),
+                        resources: Object.entries(byId ?? {}).reduce((acc, [id, res]) => {
+                            acc[id] = res?.state?.();
+                            return acc;
+                        }, {}),
+                        ...(insertionSnapshots ? { insertions: insertionSnapshots } : {}),
+                    };
+                }
+                else {
+                    const resourceState = asyncOutput.state();
+                    stateSnapshot = {
+                        params: AsyncProcessResourceParamsFnSignal(),
+                        ...resourceState,
+                        ...(insertionSnapshots ? { insertions: insertionSnapshots } : {}),
+                    };
+                }
+            }
+            catch (error) {
+                stateSnapshot = {
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+            snapshotRegistry.allSnapShot$.next({
+                source: 'asyncProcess',
+                from: hostTagList,
+                state: stateSnapshot,
+            });
+        });
+    }
+    if (!('resource' in asyncOutput)) {
+        Object.defineProperty(asyncOutput, 'resource', {
+            value: asyncOutput,
+            enumerable: false,
+            configurable: true,
+        });
+    }
+    const publicAsyncProcess = createYieldableReactiveFacade(asyncOutput, {
+        name,
+        primitive: 'asyncProcess',
+        path: name,
+    });
+    return (hasDeepYieldableInsertion(insertions)
+        ? deepYieldable(publicAsyncProcess)
+        : publicAsyncProcess);
+}
+//# sourceMappingURL=async-process.js.map