injeca 0.1.8 → 0.3.0

package/dist/index.d.mts

@@ -1,2 +1,174 @@
-import { A as resolve, C as ProvidedBy, D as invoke, E as createContainer, F as createDefaultLogger, I as createLoggLogger, L as createNoopLogger, M as stop, N as Logger, O as lifecycle, P as LoggerOptions, R as Lifecycle, S as ProvideOptionWithKeys, T as ResolveDependencyDeclaration, _ as InvokeOptionWithKeys, b as ProvideOptionObject, c as injeca, d as DependencyMap, f as InferProvided, g as InvokeOptionObjectWithKeys, h as InvokeOptionObject, j as start, k as provide, l as BuildContext, m as InvokeOptionFunc, p as InvokeOption, u as Container, v as ProvideOption, w as ProvidedKey, x as ProvideOptionObjectWithKeys, y as ProvideOptionFunc } from "./global-BLY6_SI_.mjs";
-export { BuildContext, Container, DependencyMap, InferProvided, InvokeOption, InvokeOptionFunc, InvokeOptionObject, InvokeOptionObjectWithKeys, InvokeOptionWithKeys, Lifecycle, Logger, LoggerOptions, ProvideOption, ProvideOptionFunc, ProvideOptionObject, ProvideOptionObjectWithKeys, ProvideOptionWithKeys, ProvidedBy, ProvidedKey, ResolveDependencyDeclaration, createContainer, createDefaultLogger, createLoggLogger, createNoopLogger, injeca, invoke, lifecycle, provide, resolve, start, stop };
+import { $ as HookResult, A as HookContextFor, At as ServiceStatus, B as TimeoutHandler, C as ImpactChange, Ct as DependencyState, D as Disposer, Dt as ServiceExplanation, E as DependencyHookContext, Et as ServiceBlocker, F as Container, Ft as Logger, G as DecisionKind, H as DecideFor, I as ContainerOptions, It as LoggerOptions, J as DependencyHook, K as DecisionOptions, L as HookTimeouts, Lt as createDefaultLogger, M as HookHandler, Mt as StatusCause, N as InvocationContext, Nt as Clock, O as EffectSetup, Ot as ServicePhase, P as LifecycleContext, Pt as systemClock, Q as HookDecisionKind, R as PolicyOptions, Rt as createLoggLogger, S as GraphService, St as DependencySnapshot, T as BuildContext, Tt as OwnerValue, U as Decision, V as Decide, W as DecisionFor, X as FailDecision, Y as ExponentialBackoff, Z as HandledDecision, _ as RegistrationOptions, _t as ProviderInfo, a as InvocationHandle, at as ConditionalDependency, b as GraphDependency, bt as ServiceMetadata, c as InvokeOptionObject, ct as DependencyMap, d as ProvideOption, dt as KeyOptions, et as RebuildDecision, f as ProvideOptionFunc, ft as KeyReference, g as Registration, gt as ProvidedKey, h as ProvideOptionWithKeys, ht as ProvidedBy, i as TransactionReplace, it as StopDecision, j as HookDependencies, jt as SetStatusOptions, k as HookContext, kt as ServiceState, l as InvokeOptionObjectWithKeys, lt as FallbackDependency, m as ProvideOptionObjectWithKeys, mt as OptionalValue, n as Transaction, nt as RequeueOptions, o as InvokeOption, ot as DependencyDeclaration, p as ProvideOptionObject, pt as OptionalDependency, q as DecisionSource, r as TransactionProvide, rt as ServiceHook, s as InvokeOptionFunc, st as DependencyDeclarations, t as DeclareOptions, tt as RequeueDecision, u as InvokeOptionWithKeys, ut as InferProvided, v as ReplaceFunction, vt as ResolutionCondition, w as ImpactResult, wt as OwnerRecord, x as GraphResolution, xt as DependencyChange, y as Graph, yt as ResolveDependencyDeclaration, z as TimeoutContext, zt as createNoopLogger } from "./index-DXguNx2M.mjs";
+import { C as createContainer, D as ListenerEntry, E as EventKey, O as ListenerMetadata, S as invoke, T as effect, _ as stop, a as resolve$1, b as optional, c as stop$1, d as transaction, f as resolve, g as start, h as StartOptions, l as listeners, m as listen, n as invoke$1, o as setLogger, p as provide, r as provide$1, s as start$1, t as getContainer, u as graph, v as defineKey, w as dispose, x as where, y as firstAvailable } from "./global-B9Bk2EG2.mjs";
+interface ObserveRecordBase {
+  /** The key name of the service, or the name of the invocation. */
+  readonly key: string;
+  /** The owner record of the container of the service. */
+  readonly owner: OwnerRecord;
+  readonly instanceId: string | undefined;
+  readonly reason?: string;
+}
+/** A service moved to another phase. A replayed record has no `from`. */
+interface PhaseObserveRecord extends ObserveRecordBase {
+  readonly type: 'phase';
+  readonly from: ServicePhase | undefined;
+  readonly to: ServicePhase;
+  /** The decision that caused the move, when a decision caused it. */
+  readonly decision?: DecisionKind;
+}
+/** The effective status of a running instance changed. A replayed record, or the first status of an instance, has no `from`. */
+interface StatusObserveRecord extends ObserveRecordBase {
+  readonly type: 'status';
+  readonly from: ServiceStatus | undefined;
+  readonly to: ServiceStatus;
+  readonly cause?: StatusCause;
+}
+/** A hook returned a decision. `ignored` is `true` when injeca did not apply it. */
+interface DecisionObserveRecord extends ObserveRecordBase {
+  readonly type: 'decision';
+  readonly hook: ServiceHook;
+  readonly decision: DecisionKind;
+  readonly attempt: number;
+  readonly ignored: boolean;
+}
+/** A call that had no effect, for example `setStatus` after the instance was disposed. */
+interface IgnoredObserveRecord extends ObserveRecordBase {
+  readonly type: 'ignored';
+  readonly call: 'setStatus';
+}
+/** A `start` or `stop` hook did not settle before its configured timeout. The `onTimeout` decision follows as a `decision` record. */
+interface TimeoutObserveRecord extends ObserveRecordBase {
+  readonly type: 'timeout';
+  readonly hook: 'start' | 'stop';
+  readonly timeoutMs: number;
+  readonly attempt: number;
+}
+/** A second `provide` of the same key before `start()` replaced the current registration. No hook runs for it. */
+interface RegistrationReplacedObserveRecord extends ObserveRecordBase {
+  readonly type: 'registration-replaced';
+  readonly reason: string;
+}
+/** A `watch` or `observe` callback threw. The error did not stop a transition or the other callbacks. */
+interface ErrorObserveRecord extends ObserveRecordBase {
+  readonly type: 'error';
+  readonly error: unknown;
+}
+/** One record of the observe stream. */
+type ObserveRecord = PhaseObserveRecord | StatusObserveRecord | DecisionObserveRecord | IgnoredObserveRecord | TimeoutObserveRecord | RegistrationReplacedObserveRecord | ErrorObserveRecord;
+type InjecaErrorCode = 'build-after-dispose' | 'duplicate-service' | 'hook-outside-build' | 'hook-timeout' | 'invalid-argument' | 'invalid-decision' | 'reentrant-dispose' | 'replace-while-stopping' | 'stale-registration' | 'start-timeout' | 'transaction-incomplete' | 'wait-timeout';
+interface InjecaErrorOptions {
+  cause?: unknown;
+}
+/**
+ * The base class of all injeca errors. Use `code` to identify an error. The message text is not stable.
+ */
+export declare class InjecaError extends Error {
+  readonly code: InjecaErrorCode;
+  constructor(code: InjecaErrorCode, message: string, options?: InjecaErrorOptions);
+}
+/** A started container already has a current registration for the key. */
+export declare class DuplicateServiceError extends InjecaError {
+  readonly code: 'duplicate-service';
+  constructor(message: string, options?: InjecaErrorOptions);
+}
+/** A registration is no longer the current registration of its service. */
+export declare class StaleRegistrationError extends InjecaError {
+  readonly code: 'stale-registration';
+  constructor(message: string, options?: InjecaErrorOptions);
+}
+/** A hook returned a decision from another run, or a kind that the hook does not accept. */
+export declare class InvalidDecisionError extends InjecaError {
+  readonly code: 'invalid-decision';
+  constructor(message: string, options?: InjecaErrorOptions);
+}
+/** A caller used a container or an instance after its disposal started. */
+export declare class BuildAfterDisposeError extends InjecaError {
+  readonly code: 'build-after-dispose';
+  constructor(message: string, options?: InjecaErrorOptions);
+}
+/** `on` was called after `build` settled. */
+export declare class HookOutsideBuildError extends InjecaError {
+  readonly code: 'hook-outside-build';
+  constructor(message: string, options?: InjecaErrorOptions);
+}
+/** A transaction commit found a declared service without `provide`. */
+export declare class TransactionIncompleteError extends InjecaError {
+  readonly code: 'transaction-incomplete';
+  constructor(message: string, options?: InjecaErrorOptions);
+}
+/** `dispose()` was called from the cleanup chain of the same container. */
+export declare class ReentrantDisposeError extends InjecaError {
+  readonly code: 'reentrant-dispose';
+  constructor(message: string, options?: InjecaErrorOptions);
+}
+/** A `start` or `stop` hook did not settle before its configured timeout. */
+export declare class HookTimeoutError extends InjecaError {
+  readonly code: 'hook-timeout';
+  readonly hook: 'start' | 'stop';
+  readonly timeoutMs: number;
+  constructor(message: string, hook: 'start' | 'stop', timeoutMs: number, options?: InjecaErrorOptions);
+}
+/** `replace` was called on a service in `stopping`. */
+export declare class ReplaceWhileStoppingError extends InjecaError {
+  readonly code: 'replace-while-stopping';
+  constructor(message: string, options?: InjecaErrorOptions);
+}
+/** `start()` did not reach `running` for every service before its configured timeout. */
+export declare class StartTimeoutError extends InjecaError {
+  readonly code: 'start-timeout';
+  /** One entry for each service or invocation that is not `running`. */
+  readonly explanations: readonly ServiceExplanation[];
+  constructor(message: string, explanations: readonly ServiceExplanation[], options?: InjecaErrorOptions);
+}
+/** `waitFor()` did not match before its configured timeout. */
+export declare class WaitTimeoutError extends InjecaError {
+  readonly code: 'wait-timeout';
+  constructor(message: string, options?: InjecaErrorOptions);
+}
+/** A caller passed a value with the wrong shape, or reading a caller-owned property failed. */
+export declare class InvalidArgumentError extends InjecaError {
+  readonly code: 'invalid-argument';
+  constructor(message: string, options?: InjecaErrorOptions);
+}
+/**
+ * Subscribes to all transitions of the services in `container` and in its child containers.
+ *
+ * It replays the current state of each service at once, then sends each change in order.
+ * A callback error goes to the other observers as an `error` record. No call follows the disposal of the container.
+ * Returns a disposer.
+ */
+export declare function observe(container: Container, callback: (record: ObserveRecord) => void): () => void;
+/** A key name, a key from `defineKey`, or the result of `provide`. */
+type WatchKey = KeyReference;
+/**
+ * Sends the current phase and effective status of `key` at once, then each change, in order.
+ *
+ * The key resolves from `container` and its ancestors. After a withdrawal, the callback sees the old service until it is `withdrawn`, or until a new provider appears.
+ * A callback error goes to the observe stream. The container owns the subscription: no call follows its disposal. Returns a disposer.
+ */
+export declare function watch(container: Container, key: WatchKey, callback: (state: ServiceState) => void): () => void;
+interface WaitForOptions {
+  /** Waits for this effective status. Without it, `waitFor` waits until the key is available: `ready` or `degraded`. */
+  status?: ServiceStatus;
+  /** Rejects with `wait-timeout` after this many milliseconds of the container clock. There is no default. */
+  timeoutMs?: number;
+  /** Rejects with the abort reason when the signal aborts. */
+  signal?: AbortSignal;
+}
+/**
+ * Resolves with the state of `key` when it is available, or when it has `options.status`.
+ *
+ * It rejects on a timeout or an abort, and when the container is disposed. It has no built-in timeout.
+ */
+export declare function waitFor(container: Container, key: WatchKey, options?: WaitForOptions): Promise<ServiceState>;
+export declare const injeca: {
+  provide: typeof provide$1;
+  invoke: typeof invoke$1;
+  resolve: typeof resolve$1;
+  start: typeof start$1;
+  stop: typeof stop$1;
+  setLogger: typeof setLogger;
+  getContainer: typeof getContainer;
+};
+export { type BuildContext, type Clock, type ConditionalDependency, type Container, type ContainerOptions, type Decide, type DecideFor, type Decision, type DecisionFor, type DecisionKind, type DecisionObserveRecord, type DecisionOptions, type DecisionSource, type DeclareOptions, type DependencyChange, type DependencyDeclaration, type DependencyDeclarations, type DependencyHook, type DependencyHookContext, type DependencyMap, type DependencySnapshot, type DependencyState, type Disposer, type EffectSetup, type ErrorObserveRecord, type EventKey, type ExponentialBackoff, type FailDecision, type FallbackDependency, type Graph, type GraphDependency, type GraphResolution, type GraphService, type HandledDecision, type HookContext, type HookContextFor, type HookDecisionKind, type HookDependencies, type HookHandler, type HookResult, type HookTimeouts, type IgnoredObserveRecord, type ImpactChange, type ImpactResult, type InferProvided, type InjecaErrorCode, type InjecaErrorOptions, type InvocationContext, type InvocationHandle, type InvokeOption, type InvokeOptionFunc, type InvokeOptionObject, type InvokeOptionObjectWithKeys, type InvokeOptionWithKeys, type KeyOptions, type KeyReference, type LifecycleContext, type ListenerEntry, type ListenerMetadata, type Logger, type LoggerOptions, type ObserveRecord, type ObserveRecordBase, type OptionalDependency, type OptionalValue, type OwnerRecord, type OwnerValue, type PhaseObserveRecord, type PolicyOptions, type ProvideOption, type ProvideOptionFunc, type ProvideOptionObject, type ProvideOptionObjectWithKeys, type ProvideOptionWithKeys, type ProvidedBy, type ProvidedKey, type ProviderInfo, type RebuildDecision, type Registration, type RegistrationOptions, type RegistrationReplacedObserveRecord, type ReplaceFunction, type RequeueDecision, type RequeueOptions, type ResolutionCondition, type ResolveDependencyDeclaration, type ServiceBlocker, type ServiceExplanation, type ServiceHook, type ServiceMetadata, type ServicePhase, type ServiceState, type ServiceStatus, type SetStatusOptions, type StartOptions, type StatusCause, type StatusObserveRecord, type StopDecision, type TimeoutContext, type TimeoutHandler, type TimeoutObserveRecord, type Transaction, type TransactionProvide, type TransactionReplace, type WaitForOptions, type WatchKey, createContainer, createDefaultLogger, createLoggLogger, createNoopLogger, defineKey, dispose, effect, firstAvailable, graph, invoke, listen, listeners, optional, provide, resolve, start, stop, systemClock, transaction, where };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1,3 +1,211 @@
-import { a as provide, c as stop, d as createNoopLogger, i as lifecycle, l as createDefaultLogger, n as createContainer, o as resolve, r as invoke, s as start, t as injeca, u as createLoggLogger } from "./src-UXkTj4Np.mjs";
+import { a as DuplicateServiceError, c as InjecaError, d as ReentrantDisposeError, f as ReplaceWhileStoppingError, g as WaitTimeoutError, h as TransactionIncompleteError, i as BuildAfterDisposeError, l as InvalidArgumentError, m as StartTimeoutError, o as HookOutsideBuildError, p as StaleRegistrationError, s as HookTimeoutError, u as InvalidDecisionError } from "./decision-odiPb2Au.mjs";
+import { A as assertActive, C as firstAvailable, D as statusFields, E as where, F as createDefaultLogger, I as createLoggLogger, L as createNoopLogger, M as findProvider, N as untracked, O as reportCallbackError, P as withOwner, S as defineKey, T as optional, _ as invoke, a as resolve$1, b as effect, c as stop$1, d as transaction, f as resolve, g as stop, h as start, j as nodeOf, k as withoutUndefined, l as listeners, m as listen, n as invoke$1, o as setLogger, p as provide, r as provide$1, s as start$1, t as getContainer, u as graph, v as createContainer, w as normalizeName, x as systemClock, y as dispose } from "./global-C0Nk0pU8.mjs";
+import { effect as effect$1 } from "alien-signals";
+// src/queries/observe.ts
+function replayOf(service) {
+	const owner = service.container.owner;
+	const instanceId = service.signals.instance()?.id;
+	const records = [{
+		type: "phase",
+		key: service.name,
+		owner,
+		instanceId,
+		from: void 0,
+		to: service.signals.phase()
+	}];
+	const status = service.signals.effective();
+	if (status) records.push({
+		type: "status",
+		key: service.name,
+		owner,
+		instanceId,
+		from: void 0,
+		to: status.status,
+		...statusFields(status)
+	});
+	return records;
+}
+function subtree(container) {
+	return [container, ...[...container.children].flatMap(subtree)];
+}
+/**
+* Subscribes to all transitions of the services in `container` and in its child containers.
+*
+* It replays the current state of each service at once, then sends each change in order.
+* A callback error goes to the other observers as an `error` record. No call follows the disposal of the container.
+* Returns a disposer.
+*/
+function observe(container, callback) {
+	const node = nodeOf(container);
+	assertActive(node, "observe");
+	if (typeof callback !== "function") throw new InvalidArgumentError("The observe callback is not a function.");
+	const { deliveries, observers } = node.runtime;
+	const observer = {
+		container: node,
+		callback,
+		active: true
+	};
+	const replay = untracked(() => subtree(node).flatMap((current) => [...current.services]).filter((service) => service.kind !== "resolver" && service.signals.present()).flatMap(replayOf));
+	observers.add(observer);
+	const stop = () => {
+		observer.active = false;
+		observers.delete(observer);
+		node.disposedListeners.delete(stop);
+	};
+	node.disposedListeners.add(stop);
+	deliveries.deliver(replay.map((entry) => ({
+		run: () => {
+			if (observer.active) callback(Object.freeze(entry));
+		},
+		onError: (error) => reportCallbackError(node, entry.key, error, "An observe callback threw.", observer)
+	})));
+	return stop;
+}
+// src/queries/watch.ts
+const statuses = /* @__PURE__ */ new Set([
+	"ready",
+	"degraded",
+	"unavailable"
+]);
+function readKey(key, action) {
+	let name;
+	try {
+		name = normalizeName(key);
+	} catch (error) {
+		throw new InvalidArgumentError(`Cannot read the key of ${action}.`, { cause: error });
+	}
+	if (typeof name !== "string" || name.length === 0) throw new InvalidArgumentError(`The key of ${action} must be a name or a key.`);
+	return name;
+}
+function stateOf(service) {
+	if (!service) return Object.freeze({
+		phase: void 0,
+		status: void 0,
+		instanceId: void 0
+	});
+	const status = service.signals.effective();
+	return Object.freeze({
+		phase: service.signals.phase(),
+		status: status?.status,
+		instanceId: service.signals.instance()?.id,
+		...withoutUndefined({
+			reason: status?.reason,
+			cause: status?.cause
+		})
+	});
+}
+function sameState(a, b) {
+	return a.phase === b.phase && a.status === b.status && a.instanceId === b.instanceId && a.reason === b.reason && a.cause === b.cause;
+}
+/**
+* Sends the current phase and effective status of `key` at once, then each change, in order.
+*
+* The key resolves from `container` and its ancestors. After a withdrawal, the callback sees the old service until it is `withdrawn`, or until a new provider appears.
+* A callback error goes to the observe stream. The container owns the subscription: no call follows its disposal. Returns a disposer.
+*/
+function watch(container, key, callback) {
+	const node = nodeOf(container);
+	assertActive(node, "watch");
+	const name = readKey(key, "watch");
+	if (typeof callback !== "function") throw new InvalidArgumentError("The watch callback is not a function.");
+	return untracked(() => subscribe(node, name, callback));
+}
+/** The effect of one `watch` call. It tracks the provider of `name` and its state. The delivery queue calls the callback untracked. */
+function subscribe(node, name, callback) {
+	const { deliveries } = node.runtime;
+	let active = true;
+	let last;
+	let delivered;
+	const stopEffect = withOwner(node.reactiveOwner, () => effect$1(() => {
+		const current = findProvider(node, name);
+		if (current) last = current;
+		const state = stateOf(current ?? last);
+		if (delivered && sameState(delivered, state)) return;
+		delivered = state;
+		deliveries.deliver([{
+			run: () => {
+				if (active && node.state !== "disposed") callback(state);
+			},
+			onError: (error) => reportCallbackError(node, name, error, "A watch callback threw.")
+		}]);
+	}));
+	const stop = () => {
+		if (!active) return;
+		active = false;
+		stopEffect();
+		node.disposedListeners.delete(stop);
+	};
+	node.disposedListeners.add(stop);
+	return stop;
+}
+function readWaitOptions(options) {
+	let status;
+	let timeoutMs;
+	let signal;
+	try {
+		status = options?.status;
+		timeoutMs = options?.timeoutMs;
+		signal = options?.signal;
+	} catch (error) {
+		throw new InvalidArgumentError("Cannot read the waitFor options.", { cause: error });
+	}
+	if (status !== void 0 && (typeof status !== "string" || !statuses.has(status))) throw new InvalidArgumentError(`The status option of waitFor must be 'ready', 'degraded', or 'unavailable'. Got ${String(status)}.`);
+	if (timeoutMs !== void 0 && (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs < 0)) throw new InvalidArgumentError(`The timeoutMs option of waitFor must be a finite number of 0 or more. Got ${String(timeoutMs)}.`);
+	if (signal !== void 0 && !(signal instanceof AbortSignal)) throw new InvalidArgumentError("The signal option of waitFor must be an AbortSignal.");
+	return {
+		status,
+		timeoutMs,
+		signal
+	};
+}
+/**
+* Resolves with the state of `key` when it is available, or when it has `options.status`.
+*
+* It rejects on a timeout or an abort, and when the container is disposed. It has no built-in timeout.
+*/
+function waitFor(container, key, options) {
+	const node = nodeOf(container);
+	assertActive(node, "waitFor");
+	const name = readKey(key, "waitFor");
+	const { status, timeoutMs, signal } = readWaitOptions(options);
+	if (signal?.aborted) return Promise.reject(signal.reason);
+	const matches = (state) => state.phase === "running" && (status === void 0 ? state.status !== void 0 && state.status !== "unavailable" : state.status === status);
+	return new Promise((resolve, reject) => untracked(() => {
+		let done = false;
+		let stopWatch;
+		let cancelTimeout = () => {};
+		const onAbort = () => finish(() => reject(signal?.reason));
+		const onDisposed = () => finish(() => reject(new BuildAfterDisposeError(`The container was disposed before waitFor('${name}') matched.`)));
+		function finish(outcome) {
+			if (done) return;
+			done = true;
+			stopWatch?.();
+			cancelTimeout();
+			signal?.removeEventListener("abort", onAbort);
+			node.disposedListeners.delete(onDisposed);
+			outcome();
+		}
+		signal?.addEventListener("abort", onAbort, { once: true });
+		node.disposedListeners.add(onDisposed);
+		if (timeoutMs !== void 0) cancelTimeout = node.runtime.clock.setTimeout(() => {
+			finish(() => reject(new WaitTimeoutError(`waitFor('${name}') timed out after ${timeoutMs}ms.`)));
+		}, timeoutMs);
+		stopWatch = subscribe(node, name, (state) => {
+			if (matches(state)) finish(() => resolve(state));
+		});
+		if (done) stopWatch();
+	}));
+}
+// src/index.ts
+const injeca = {
+	provide: provide$1,
+	invoke: invoke$1,
+	resolve: resolve$1,
+	start: start$1,
+	stop: stop$1,
+	setLogger,
+	getContainer
+};
+export { BuildAfterDisposeError, DuplicateServiceError, HookOutsideBuildError, HookTimeoutError, InjecaError, InvalidArgumentError, InvalidDecisionError, ReentrantDisposeError, ReplaceWhileStoppingError, StaleRegistrationError, StartTimeoutError, TransactionIncompleteError, WaitTimeoutError, createContainer, createDefaultLogger, createLoggLogger, createNoopLogger, defineKey, dispose, effect, firstAvailable, graph, injeca, invoke, listen, listeners, observe, optional, provide, resolve, start, stop, systemClock, transaction, waitFor, watch, where };
 
-export { createContainer, createDefaultLogger, createLoggLogger, createNoopLogger, injeca, invoke, lifecycle, provide, resolve, start, stop };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["effect","globalProvide","globalInvoke","globalResolve","globalStart","globalStop","globalSetLogger","globalGetContainer"],"sources":["../src/queries/observe.ts","../src/queries/watch.ts","../src/index.ts"],"sourcesContent":["import type { ContainerNode, Observer, ServiceNode } from '../graph/graph'\nimport type { Container, ObserveRecord } from '../types'\n\nimport { InvalidArgumentError } from '../diagnostics/errors'\nimport { assertActive, nodeOf } from '../graph/nodes'\nimport { reportCallbackError } from '../graph/observers'\nimport { statusFields } from '../graph/status'\nimport { untracked } from '../helpers/signals'\n\nfunction replayOf(service: ServiceNode): ObserveRecord[] {\n  const owner = service.container.owner\n  const instanceId = service.signals.instance()?.id\n  const records: ObserveRecord[] = [{ type: 'phase', key: service.name, owner, instanceId, from: undefined, to: service.signals.phase() }]\n  const status = service.signals.effective()\n  if (status)\n    records.push({ type: 'status', key: service.name, owner, instanceId, from: undefined, to: status.status, ...statusFields(status) })\n\n  return records\n}\n\nfunction subtree(container: ContainerNode): ContainerNode[] {\n  return [container, ...[...container.children].flatMap(subtree)]\n}\n\n/**\n * Subscribes to all transitions of the services in `container` and in its child containers.\n *\n * It replays the current state of each service at once, then sends each change in order.\n * A callback error goes to the other observers as an `error` record. No call follows the disposal of the container.\n * Returns a disposer.\n */\nexport function observe(container: Container, callback: (record: ObserveRecord) => void): () => void {\n  const node = nodeOf(container)\n  assertActive(node, 'observe')\n  if (typeof callback !== 'function')\n    throw new InvalidArgumentError('The observe callback is not a function.')\n\n  const { deliveries, observers } = node.runtime\n  const observer: Observer = { container: node, callback, active: true }\n  const replay = untracked(() => subtree(node)\n    .flatMap(current => [...current.services])\n    .filter(service => service.kind !== 'resolver' && service.signals.present())\n    .flatMap(replayOf))\n\n  observers.add(observer)\n  const stop = (): void => {\n    observer.active = false\n    observers.delete(observer)\n    node.disposedListeners.delete(stop)\n  }\n  node.disposedListeners.add(stop)\n\n  deliveries.deliver(replay.map(entry => ({\n    run: () => {\n      if (observer.active)\n        callback(Object.freeze(entry))\n    },\n    onError: (error: unknown) => reportCallbackError(node, entry.key, error, 'An observe callback threw.', observer),\n  })))\n\n  return stop\n}\n","import type { ContainerNode, ServiceNode } from '../graph/graph'\nimport type { Container, KeyReference, ServiceState, ServiceStatus } from '../types'\n\nimport { effect } from 'alien-signals'\n\nimport { BuildAfterDisposeError, InvalidArgumentError, WaitTimeoutError } from '../diagnostics/errors'\nimport { assertActive, nodeOf } from '../graph/nodes'\nimport { reportCallbackError } from '../graph/observers'\nimport { findProvider } from '../graph/resolvers/resolvers'\nimport { untracked, withOwner } from '../helpers/signals'\nimport { withoutUndefined } from '../helpers/without-undefined'\nimport { normalizeName } from '../primitives/keys'\n\n/** A key name, a key from `defineKey`, or the result of `provide`. */\nexport type WatchKey = KeyReference\n\nconst statuses: ReadonlySet<string> = new Set<ServiceStatus>(['ready', 'degraded', 'unavailable'])\n\nfunction readKey(key: unknown, action: string): string {\n  let name: unknown\n  try {\n    name = normalizeName(key as string)\n  }\n  catch (error) {\n    throw new InvalidArgumentError(`Cannot read the key of ${action}.`, { cause: error })\n  }\n  if (typeof name !== 'string' || name.length === 0)\n    throw new InvalidArgumentError(`The key of ${action} must be a name or a key.`)\n\n  return name\n}\n\nfunction stateOf(service: ServiceNode | undefined): ServiceState {\n  if (!service)\n    return Object.freeze({ phase: undefined, status: undefined, instanceId: undefined })\n\n  const status = service.signals.effective()\n  return Object.freeze({\n    phase: service.signals.phase(),\n    status: status?.status,\n    instanceId: service.signals.instance()?.id,\n    ...withoutUndefined({ reason: status?.reason, cause: status?.cause }),\n  })\n}\n\nfunction sameState(a: ServiceState, b: ServiceState): boolean {\n  return a.phase === b.phase && a.status === b.status && a.instanceId === b.instanceId && a.reason === b.reason && a.cause === b.cause\n}\n\n/**\n * Sends the current phase and effective status of `key` at once, then each change, in order.\n *\n * The key resolves from `container` and its ancestors. After a withdrawal, the callback sees the old service until it is `withdrawn`, or until a new provider appears.\n * A callback error goes to the observe stream. The container owns the subscription: no call follows its disposal. Returns a disposer.\n */\nexport function watch(container: Container, key: WatchKey, callback: (state: ServiceState) => void): () => void {\n  const node = nodeOf(container)\n  assertActive(node, 'watch')\n  const name = readKey(key, 'watch')\n  if (typeof callback !== 'function')\n    throw new InvalidArgumentError('The watch callback is not a function.')\n\n  return untracked(() => subscribe(node, name, callback))\n}\n\n/** The effect of one `watch` call. It tracks the provider of `name` and its state. The delivery queue calls the callback untracked. */\nfunction subscribe(node: ContainerNode, name: string, callback: (state: ServiceState) => void): () => void {\n  const { deliveries } = node.runtime\n  let active = true\n  let last: ServiceNode | undefined\n  let delivered: ServiceState | undefined\n\n  const stopEffect = withOwner(node.reactiveOwner, () => effect(() => {\n    const current = findProvider(node, name)\n    if (current)\n      last = current\n    const state = stateOf(current ?? last)\n    if (delivered && sameState(delivered, state))\n      return\n\n    delivered = state\n    deliveries.deliver([{\n      run: () => {\n        if (active && node.state !== 'disposed')\n          callback(state)\n      },\n      onError: error => reportCallbackError(node, name, error, 'A watch callback threw.'),\n    }])\n  }))\n\n  const stop = (): void => {\n    if (!active)\n      return\n\n    active = false\n    stopEffect()\n    node.disposedListeners.delete(stop)\n  }\n  node.disposedListeners.add(stop)\n\n  return stop\n}\n\nexport interface WaitForOptions {\n  /** Waits for this effective status. Without it, `waitFor` waits until the key is available: `ready` or `degraded`. */\n  status?: ServiceStatus\n  /** Rejects with `wait-timeout` after this many milliseconds of the container clock. There is no default. */\n  timeoutMs?: number\n  /** Rejects with the abort reason when the signal aborts. */\n  signal?: AbortSignal\n}\n\nfunction readWaitOptions(options: WaitForOptions | undefined): WaitForOptions {\n  let status: unknown\n  let timeoutMs: unknown\n  let signal: unknown\n  try {\n    status = options?.status\n    timeoutMs = options?.timeoutMs\n    signal = options?.signal\n  }\n  catch (error) {\n    throw new InvalidArgumentError('Cannot read the waitFor options.', { cause: error })\n  }\n  if (status !== undefined && (typeof status !== 'string' || !statuses.has(status)))\n    throw new InvalidArgumentError(`The status option of waitFor must be 'ready', 'degraded', or 'unavailable'. Got ${String(status)}.`)\n  if (timeoutMs !== undefined && (typeof timeoutMs !== 'number' || !Number.isFinite(timeoutMs) || timeoutMs < 0))\n    throw new InvalidArgumentError(`The timeoutMs option of waitFor must be a finite number of 0 or more. Got ${String(timeoutMs)}.`)\n  if (signal !== undefined && !(signal instanceof AbortSignal))\n    throw new InvalidArgumentError('The signal option of waitFor must be an AbortSignal.')\n\n  return { status: status as ServiceStatus | undefined, timeoutMs: timeoutMs as number | undefined, signal: signal as AbortSignal | undefined }\n}\n\n/**\n * Resolves with the state of `key` when it is available, or when it has `options.status`.\n *\n * It rejects on a timeout or an abort, and when the container is disposed. It has no built-in timeout.\n */\nexport function waitFor(container: Container, key: WatchKey, options?: WaitForOptions): Promise<ServiceState> {\n  const node = nodeOf(container)\n  assertActive(node, 'waitFor')\n  const name = readKey(key, 'waitFor')\n  const { status, timeoutMs, signal } = readWaitOptions(options)\n  if (signal?.aborted)\n    return Promise.reject(signal.reason)\n\n  const matches = (state: ServiceState): boolean => state.phase === 'running'\n    && (status === undefined ? state.status !== undefined && state.status !== 'unavailable' : state.status === status)\n\n  return new Promise((resolve, reject) => untracked(() => {\n    let done = false\n    let stopWatch: (() => void) | undefined\n    let cancelTimeout = () => {}\n\n    const onAbort = (): void => finish(() => reject(signal?.reason))\n    const onDisposed = (): void => finish(() => reject(new BuildAfterDisposeError(`The container was disposed before waitFor('${name}') matched.`)))\n\n    function finish(outcome: () => void): void {\n      if (done)\n        return\n\n      done = true\n      stopWatch?.()\n      cancelTimeout()\n      signal?.removeEventListener('abort', onAbort)\n      node.disposedListeners.delete(onDisposed)\n      outcome()\n    }\n\n    signal?.addEventListener('abort', onAbort, { once: true })\n    node.disposedListeners.add(onDisposed)\n    if (timeoutMs !== undefined) {\n      cancelTimeout = node.runtime.clock.setTimeout(() => {\n        finish(() => reject(new WaitTimeoutError(`waitFor('${name}') timed out after ${timeoutMs}ms.`)))\n      }, timeoutMs)\n    }\n\n    stopWatch = subscribe(node, name, (state) => {\n      if (matches(state))\n        finish(() => resolve(state))\n    })\n    // The first state can match at once, before `stopWatch` was assigned.\n    if (done)\n      stopWatch()\n  }))\n}\n","import {\n  getContainer as globalGetContainer,\n  invoke as globalInvoke,\n  provide as globalProvide,\n  resolve as globalResolve,\n  setLogger as globalSetLogger,\n  start as globalStart,\n  stop as globalStop,\n} from './global'\n\nexport type { InjecaErrorCode, InjecaErrorOptions } from './diagnostics/errors'\nexport {\n  BuildAfterDisposeError,\n  DuplicateServiceError,\n  HookOutsideBuildError,\n  HookTimeoutError,\n  InjecaError,\n  InvalidArgumentError,\n  InvalidDecisionError,\n  ReentrantDisposeError,\n  ReplaceWhileStoppingError,\n  StaleRegistrationError,\n  StartTimeoutError,\n  TransactionIncompleteError,\n  WaitTimeoutError,\n} from './diagnostics/errors'\n\nexport type { Logger, LoggerOptions } from './diagnostics/logger'\n\nexport {\n  createDefaultLogger,\n  createLoggLogger,\n  createNoopLogger,\n} from './diagnostics/logger'\nexport type { Clock } from './helpers/clock'\n\nexport { systemClock } from './helpers/clock'\nexport type {\n  Decide,\n  DecideFor,\n  Decision,\n  DecisionFor,\n  DecisionKind,\n  DecisionOptions,\n  DecisionSource,\n  DependencyHook,\n  ExponentialBackoff,\n  FailDecision,\n  HandledDecision,\n  HookDecisionKind,\n  HookResult,\n  RebuildDecision,\n  RequeueDecision,\n  RequeueOptions,\n  ServiceHook,\n  StopDecision,\n} from './primitives/decision'\n\nexport { observe } from './queries/observe'\n\nexport { waitFor, watch } from './queries/watch'\nexport type { WaitForOptions, WatchKey } from './queries/watch'\n\nexport {\n  createContainer,\n  defineKey,\n  dispose,\n  effect,\n  firstAvailable,\n  graph,\n  invoke,\n  listen,\n  listeners,\n  optional,\n  provide,\n  resolve,\n  start,\n  stop,\n  transaction,\n  where,\n} from './scoped'\n\nexport type { StartOptions } from './scoped'\nexport type {\n  BuildContext,\n  ConditionalDependency,\n  Container,\n  ContainerOptions,\n  DeclareOptions,\n  DecisionObserveRecord,\n  DependencyChange,\n  DependencyDeclaration,\n  DependencyDeclarations,\n  DependencyHookContext,\n  DependencyMap,\n  DependencySnapshot,\n  DependencyState,\n  Disposer,\n  EffectSetup,\n  ErrorObserveRecord,\n  EventKey,\n  FallbackDependency,\n  Graph,\n  GraphDependency,\n  GraphResolution,\n  GraphService,\n  HookTimeouts,\n  HookContext,\n  HookContextFor,\n  HookDependencies,\n  HookHandler,\n  IgnoredObserveRecord,\n  ImpactChange,\n  ImpactResult,\n  InferProvided,\n  InvocationContext,\n  InvocationHandle,\n  InvokeOption,\n  InvokeOptionFunc,\n  InvokeOptionObject,\n  InvokeOptionObjectWithKeys,\n  InvokeOptionWithKeys,\n  KeyOptions,\n  KeyReference,\n  LifecycleContext,\n  ListenerEntry,\n  ListenerMetadata,\n  ObserveRecord,\n  ObserveRecordBase,\n  OptionalDependency,\n  OptionalValue,\n  OwnerRecord,\n  OwnerValue,\n  PhaseObserveRecord,\n  PolicyOptions,\n  ProviderInfo,\n  ProvidedBy,\n  ProvidedKey,\n  ProvideOption,\n  ProvideOptionFunc,\n  ProvideOptionObject,\n  ProvideOptionObjectWithKeys,\n  ProvideOptionWithKeys,\n  Registration,\n  RegistrationOptions,\n  RegistrationReplacedObserveRecord,\n  ReplaceFunction,\n  ResolutionCondition,\n  ResolveDependencyDeclaration,\n  ServiceBlocker,\n  ServiceExplanation,\n  ServiceMetadata,\n  ServicePhase,\n  ServiceState,\n  ServiceStatus,\n  SetStatusOptions,\n  StatusCause,\n  StatusObserveRecord,\n  TimeoutContext,\n  TimeoutHandler,\n  TimeoutObserveRecord,\n  Transaction,\n  TransactionProvide,\n  TransactionReplace,\n} from './types'\n\nexport const injeca = {\n  provide: globalProvide,\n  invoke: globalInvoke,\n  resolve: globalResolve,\n  start: globalStart,\n  stop: globalStop,\n  setLogger: globalSetLogger,\n  getContainer: globalGetContainer,\n}\n"],"mappings":"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"}

package/dist/testing.d.mts

@@ -0,0 +1,31 @@
+import { A as HookContextFor, U as Decision, j as HookDependencies, rt as ServiceHook, xt as DependencyChange } from "./index-DXguNx2M.mjs";
+export interface HookContextOptions<D = undefined> {
+  /** The service name that the decisions carry. It defaults to `'test'`. */
+  service?: string;
+  /** The instance id that the decisions carry. It defaults to `'test-instance'`. */
+  instanceId?: string;
+  /** It defaults to `1`. */
+  attempt?: number;
+  previous?: Decision;
+  /** It defaults to a signal that does not abort. */
+  signal?: AbortSignal;
+  /** The snapshot of a dependency hook. It defaults to an empty record. */
+  dependsOn?: HookDependencies<D>;
+  /** The changes of a dependency hook. It defaults to an empty list. */
+  changes?: readonly DependencyChange[];
+  /** The clock for `issuedAt`. It defaults to `Date.now`. */
+  now?: () => number;
+}
+/**
+ * Creates a hook context for a unit test of a hook handler, or of a helper that gets `decide`.
+ *
+ * Its decisions are bound to this context, as in a real run. Use `checkDecision` to check a result as injeca does.
+ */
+export declare function createHookContext<H extends ServiceHook, D = undefined>(hook: H, options?: HookContextOptions<D>): HookContextFor<H, D>;
+/**
+ * Checks the value that a handler returned for `context`, as injeca does. `undefined` gives `undefined`: the default of the hook.
+ *
+ * @throws {InvalidDecisionError} for a decision from another context, or a kind that the hook does not accept. A value that is not a decision gives `undefined`.
+ */
+export declare function checkDecision(context: object, value: unknown): Decision | undefined;
+//# sourceMappingURL=testing.d.mts.map

package/dist/testing.mjs

@@ -0,0 +1,45 @@
+import { l as InvalidArgumentError, r as validateDecision, t as createDecide } from "./decision-odiPb2Au.mjs";
+// src/testing/testing.ts
+const runs = /* @__PURE__ */ new WeakMap();
+/**
+* Creates a hook context for a unit test of a hook handler, or of a helper that gets `decide`.
+*
+* Its decisions are bound to this context, as in a real run. Use `checkDecision` to check a result as injeca does.
+*/
+function createHookContext(hook, options = {}) {
+	const attempt = options.attempt ?? 1;
+	if (!Number.isInteger(attempt) || attempt < 1) throw new InvalidArgumentError(`The attempt of a hook context must be an integer of 1 or more. Got ${String(attempt)}.`);
+	const run = {
+		service: options.service ?? "test",
+		instanceId: options.instanceId ?? "test-instance",
+		hook,
+		attempt,
+		now: options.now ?? (() => Date.now())
+	};
+	const dependencyHook = hook === "dependency-change" || hook === "dependency-status-change";
+	const context = Object.freeze({
+		decide: createDecide(run),
+		attempt,
+		previous: options.previous,
+		signal: options.signal ?? new AbortController().signal,
+		...dependencyHook ? {
+			dependsOn: Object.freeze({ ...options.dependsOn }),
+			changes: Object.freeze([...options.changes ?? []])
+		} : {}
+	});
+	runs.set(context, run);
+	return context;
+}
+/**
+* Checks the value that a handler returned for `context`, as injeca does. `undefined` gives `undefined`: the default of the hook.
+*
+* @throws {InvalidDecisionError} for a decision from another context, or a kind that the hook does not accept. A value that is not a decision gives `undefined`.
+*/
+function checkDecision(context, value) {
+	const run = runs.get(context);
+	if (!run) throw new InvalidArgumentError("The context does not come from createHookContext.");
+	return validateDecision(run, value);
+}
+export { checkDecision, createHookContext };
+
+//# sourceMappingURL=testing.mjs.map

package/dist/testing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.mjs","names":[],"sources":["../src/testing/testing.ts"],"sourcesContent":["import type { Decision, HookRun, ServiceHook } from '../primitives/decision'\nimport type { DependencyChange, HookContextFor, HookDependencies } from '../types'\n\nimport { InvalidArgumentError } from '../diagnostics/errors'\nimport { createDecide, validateDecision } from '../primitives/decision'\n\nexport interface HookContextOptions<D = undefined> {\n  /** The service name that the decisions carry. It defaults to `'test'`. */\n  service?: string\n  /** The instance id that the decisions carry. It defaults to `'test-instance'`. */\n  instanceId?: string\n  /** It defaults to `1`. */\n  attempt?: number\n  previous?: Decision\n  /** It defaults to a signal that does not abort. */\n  signal?: AbortSignal\n  /** The snapshot of a dependency hook. It defaults to an empty record. */\n  dependsOn?: HookDependencies<D>\n  /** The changes of a dependency hook. It defaults to an empty list. */\n  changes?: readonly DependencyChange[]\n  /** The clock for `issuedAt`. It defaults to `Date.now`. */\n  now?: () => number\n}\n\nconst runs = new WeakMap<object, HookRun>()\n\n/**\n * Creates a hook context for a unit test of a hook handler, or of a helper that gets `decide`.\n *\n * Its decisions are bound to this context, as in a real run. Use `checkDecision` to check a result as injeca does.\n */\nexport function createHookContext<H extends ServiceHook, D = undefined>(hook: H, options: HookContextOptions<D> = {}): HookContextFor<H, D> {\n  const attempt = options.attempt ?? 1\n  if (!Number.isInteger(attempt) || attempt < 1)\n    throw new InvalidArgumentError(`The attempt of a hook context must be an integer of 1 or more. Got ${String(attempt)}.`)\n\n  const run: HookRun = {\n    service: options.service ?? 'test',\n    instanceId: options.instanceId ?? 'test-instance',\n    hook,\n    attempt,\n    now: options.now ?? (() => Date.now()),\n  }\n  const dependencyHook = hook === 'dependency-change' || hook === 'dependency-status-change'\n  const context = Object.freeze({\n    decide: createDecide(run),\n    attempt,\n    previous: options.previous,\n    signal: options.signal ?? new AbortController().signal,\n    ...(dependencyHook ? { dependsOn: Object.freeze({ ...options.dependsOn }), changes: Object.freeze([...(options.changes ?? [])]) } : {}),\n  })\n  runs.set(context, run)\n\n  return context as unknown as HookContextFor<H, D>\n}\n\n/**\n * Checks the value that a handler returned for `context`, as injeca does. `undefined` gives `undefined`: the default of the hook.\n *\n * @throws {InvalidDecisionError} for a decision from another context, or a kind that the hook does not accept. A value that is not a decision gives `undefined`.\n */\nexport function checkDecision(context: object, value: unknown): Decision | undefined {\n  const run = runs.get(context)\n  if (!run)\n    throw new InvalidArgumentError('The context does not come from createHookContext.')\n\n  return validateDecision(run, value)\n}\n"],"mappings":";;AAwBA,MAAM,uBAAO,IAAI,QAAyB;;;;;;AAO1C,SAAgB,kBAAwD,MAAS,UAAiC,CAAC,GAAyB;CAC1I,MAAM,UAAU,QAAQ,WAAW;CACnC,IAAI,CAAC,OAAO,UAAU,OAAO,KAAK,UAAU,GAC1C,MAAM,IAAI,qBAAqB,sEAAsE,OAAO,OAAO,EAAE,EAAE;CAEzH,MAAM,MAAe;EACnB,SAAS,QAAQ,WAAW;EAC5B,YAAY,QAAQ,cAAc;EAClC;EACA;EACA,KAAK,QAAQ,cAAc,KAAK,IAAI;CACtC;CACA,MAAM,iBAAiB,SAAS,uBAAuB,SAAS;CAChE,MAAM,UAAU,OAAO,OAAO;EAC5B,QAAQ,aAAa,GAAG;EACxB;EACA,UAAU,QAAQ;EAClB,QAAQ,QAAQ,UAAU,IAAI,gBAAgB,CAAC,CAAC;EAChD,GAAI,iBAAiB;GAAE,WAAW,OAAO,OAAO,EAAE,GAAG,QAAQ,UAAU,CAAC;GAAG,SAAS,OAAO,OAAO,CAAC,GAAI,QAAQ,WAAW,CAAC,CAAE,CAAC;EAAE,IAAI,CAAC;CACvI,CAAC;CACD,KAAK,IAAI,SAAS,GAAG;CAErB,OAAO;AACT;;;;;;AAOA,SAAgB,cAAc,SAAiB,OAAsC;CACnF,MAAM,MAAM,KAAK,IAAI,OAAO;CAC5B,IAAI,CAAC,KACH,MAAM,IAAI,qBAAqB,mDAAmD;CAEpF,OAAO,iBAAiB,KAAK,KAAK;AACpC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "injeca",
   "type": "module",
-  "version": "0.1.8",
+  "version": "0.3.0",
   "description": "Pure functional programming based dependency injection library inspired by go.uber.org/fig and go.uber.org/dig.",
   "author": {
     "name": "Moeru AI Project AIRI Team",
@@ -12,7 +12,8 @@
   "homepage": "https://github.com/moeru-ai/injeca",
   "repository": {
     "type": "git",
-    "url": "https://github.com/moeru-ai/injeca.git"
+    "url": "https://github.com/moeru-ai/injeca.git",
+    "directory": "packages/injeca"
   },
   "exports": {
     ".": {
@@ -22,12 +23,17 @@
     "./global": {
       "type": "./dist/global.d.mts",
       "default": "./dist/global.mjs"
+    },
+    "./testing": {
+      "type": "./dist/testing.d.mts",
+      "default": "./dist/testing.mjs"
     }
   },
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
   "types": "./dist/index.mts",
   "files": [
+    "LICENSE",
     "README.md",
     "dist",
     "package.json"
@@ -42,31 +48,12 @@
       "optional": true
     }
   },
-  "devDependencies": {
-    "@antfu/eslint-config": "^6.7.3",
-    "@moeru/eslint-config": "^0.1.0-beta.15",
-    "@moeru/std": "^0.1.0-beta.15",
-    "@moeru/tsconfig": "^0.1.0-beta.15",
-    "@types/node": "^25.0.9",
-    "bumpp": "^10.4.0",
-    "eslint": "^9.39.2",
-    "eslint-plugin-oxlint": "^1.39.0",
-    "oxlint": "^1.39.0",
-    "publint": "^0.3.16",
-    "taze": "^19.9.2",
-    "tsdown": "^0.17.4",
-    "typescript": "^5.9.3",
-    "unplugin-unused": "^0.5.6",
-    "vite": "^7.3.1",
-    "vitest": "^4.0.17"
+  "dependencies": {
+    "alien-signals": "^3.2.1",
+    "es-toolkit": "^1.53.1"
   },
   "scripts": {
     "build": "tsdown",
-    "test": "vitest --coverage",
-    "test:run": "vitest run",
-    "lint": "eslint --cache .",
-    "lint:fix": "eslint --cache --fix .",
-    "typecheck": "tsc --noEmit",
-    "up": "taze -w -r -I -f && pnpm prune && pnpm dedupe"
+    "typecheck": "tsc --noEmit -p ../../tsconfig.json"
   }
 }

package/dist/builtin-BPDNf8Z-.mjs

@@ -1,25 +0,0 @@
-//#region src/builtin.ts
-function buildLifecycle() {
-	const onStartHooks = [];
-	const onStopHooks = [];
-	return {
-		appHooks: {
-			onStart(hook) {
-				if (hook) onStartHooks.push(hook);
-			},
-			onStop(hook) {
-				if (hook) onStopHooks.push(hook);
-			}
-		},
-		emitOnStart: async () => {
-			for (const hook of onStartHooks) await hook();
-		},
-		emitOnStop: async () => {
-			for (const hook of onStopHooks) await hook();
-		}
-	};
-}
-
-//#endregion
-export { buildLifecycle };
-//# sourceMappingURL=builtin-BPDNf8Z-.mjs.map

package/dist/builtin-BPDNf8Z-.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"builtin-BPDNf8Z-.mjs","names":["onStartHooks: (() => void | Promise<void>)[]","onStopHooks: (() => void | Promise<void>)[]"],"sources":["../src/builtin.ts"],"sourcesContent":["export interface LifecycleAppHooks {\n  onStart: (hook: () => void | Promise<void>) => void\n  onStop: (hook: () => void | Promise<void>) => void\n}\n\nexport interface Lifecycle {\n  appHooks: LifecycleAppHooks\n}\n\nexport interface LifecycleTriggerable extends Lifecycle {\n  emitOnStart: () => Promise<void>\n  emitOnStop: () => Promise<void>\n}\n\nexport function buildLifecycle(): Lifecycle {\n  const onStartHooks: (() => void | Promise<void>)[] = []\n  const onStopHooks: (() => void | Promise<void>)[] = []\n\n  const lifecycle: LifecycleTriggerable = {\n    appHooks: {\n      onStart(hook: () => void | Promise<void>) {\n        if (hook) {\n          onStartHooks.push(hook)\n        }\n      },\n      onStop(hook: () => void | Promise<void>) {\n        if (hook) {\n          onStopHooks.push(hook)\n        }\n      },\n    },\n    emitOnStart: async () => {\n      for (const hook of onStartHooks) {\n        await hook()\n      }\n    },\n    emitOnStop: async () => {\n      for (const hook of onStopHooks) {\n        await hook()\n      }\n    },\n  }\n\n  return lifecycle\n}\n"],"mappings":";AAcA,SAAgB,iBAA4B;CAC1C,MAAMA,eAA+C,EAAE;CACvD,MAAMC,cAA8C,EAAE;AA2BtD,QAzBwC;EACtC,UAAU;GACR,QAAQ,MAAkC;AACxC,QAAI,KACF,cAAa,KAAK,KAAK;;GAG3B,OAAO,MAAkC;AACvC,QAAI,KACF,aAAY,KAAK,KAAK;;GAG3B;EACD,aAAa,YAAY;AACvB,QAAK,MAAM,QAAQ,aACjB,OAAM,MAAM;;EAGhB,YAAY,YAAY;AACtB,QAAK,MAAM,QAAQ,YACjB,OAAM,MAAM;;EAGjB"}