injeca 0.1.8 → 0.3.0

package/README.md

@@ -1,8 +1,8 @@
 # Injeca
 
-Pure functional programming (means no `class` and extra wrappers and containers) based dependency injection with application lifecycle management.
+Pure functional dependency injection for TypeScript, with service lifecycles, run-time changes, and status propagation. No classes, no decorators, and no extra wrappers.
 
-> Heavily inspired by [uber/fig](https://go.uber.org/fig) and [uber/dig](https://go.uber.org/dig) in Golang ecosystem.
+> Heavily inspired by [uber/fx](https://go.uber.org/fx), [uber/fig](https://go.uber.org/fig), and [uber/dig](https://go.uber.org/dig) in the Go ecosystem.
 
 [![npm version][npm-version-src]][npm-version-href]
 [![npm downloads][npm-downloads-src]][npm-downloads-href]
@@ -20,6 +20,8 @@ ni injeca
 yarn add injeca
 ```
 
+injeca works in Node.js, Electron, browsers, and workers. It has no Node-only code.
+
 ### Agent Skills
 
 Install the [injeca skill](https://skills.sh) to your AI coding agent:
@@ -30,25 +32,23 @@ npx skills add moeru-ai/injeca
 
 ## Basic usage
 
-`injeca` ships with a global singleton container exposed as `injeca`. You can register
-providers, declare their dependencies, and run invocations once everything is ready.
+`injeca` ships with a global container exposed as `injeca`. Register services, declare their dependencies, and start.
 
 ```ts
 import { createServer } from 'node:http'
 
-import { injeca, lifecycle } from 'injeca'
+import { injeca } from 'injeca'
 
-// Providers return a value once and are cached inside the container.
+// A service returns a value once. The container caches it.
 const config = injeca.provide('config', () => ({ port: 3000 }))
 
 const server = injeca.provide({
-  dependsOn: { config, lifecycle },
-  async build({ dependsOn }) {
-    const { config, lifecycle } = dependsOn
+  dependsOn: { config },
+  build({ dependsOn, on }) {
     const app = createServer()
 
-    lifecycle.appHooks.onStart(() => app.listen(config.port))
-    lifecycle.appHooks.onStop(() => app.close())
+    on('start', () => app.listen(dependsOn.config.port))
+    on('stop', () => app.close())
 
     return app
   },
@@ -56,9 +56,8 @@ const server = injeca.provide({
 
 injeca.invoke({
   dependsOn: { server },
-  async callback({ server }) {
-    // eslint-disable-next-line no-console
-    console.log('HTTP server ready:', await server.address())
+  callback({ server }) {
+    console.info('HTTP server ready:', server.address())
   },
 })
 
@@ -69,19 +68,17 @@ process.once('SIGINT', async () => {
 })
 ```
 
+- `provide` returns a typed key. Use it in `dependsOn`. injeca infers the type of each dependency.
+- `start()` builds each service when its dependencies are running, then runs its `start` hooks. It resolves when everything is running.
+- `stop()` stops dependents before their providers. The registrations stay, so a later `start()` builds them again.
+
 > [!WARNING]
 >
-> **`injeca` implements singleton / cached dependencies by default**
->
-> This means every value returned by `build` will be stored and `build` will only
-> got called once.
+> **`injeca` caches each value that `build` returns.**
 >
-> If `build` returns a function, that function is cached (not the result of calling
-> it). This is useful for lazy dependencies, "getters", or wrappers for singleton,
-> but it also means any side effects inside the returned function will run on every call.
+> `build` runs once for each instance. If `build` returns a function, injeca caches that function, not the result of a call. This is useful for lazy dependencies and getters. Side effects inside the returned function run on every call.
 >
-> If you want the returned function to be reusable (e.g. a single window), create
-> the reusable closure once inside `build`, and return a wrapper that calls it:
+> To reuse one resource, for example a single window, create it once inside `build` and return a wrapper:
 >
 > ```ts
 > const settingsWindow = injeca.provide('windows:settings', {
@@ -93,17 +90,230 @@ process.once('SIGINT', async () => {
 > })
 > ```
 
-Avoid recreating the reusable function inside the returned function, otherwise
-each call starts from a fresh cache and can create duplicate resources.
+## Lifecycle in `build`
+
+The build context gives each service its own lifecycle:
+
+| Field | Meaning |
+| --- | --- |
+| `dependsOn` | The resolved dependencies |
+| `on('start', handler)` | Runs after the service is published and its dependencies run |
+| `on('stop', handler)` | Runs before the service stops. Its dependencies are still available. |
+| `effect(setup)` | Runs `setup` at once. The disposer that it returns runs when the instance is disposed, after the `stop` hooks. |
+| `signal` | An `AbortSignal` that aborts when a newer target replaces this build, or when the container is disposed |
+| `setStatus(status, reason?)` | Sets the status of the instance. See [Status](#status). |
+
+A hook gets a hook context with a typed `decide`. A return value that is not a decision, for example the result of `app.listen()`, selects the default of the hook. Return a decision to tell injeca what to do next:
+
+```ts
+on('start', async ({ decide, attempt }) => {
+  try {
+    await app.listen(port)
+  }
+  catch (error) {
+    return decide.fail(error)
+  }
+})
+```
+
+### Retries
+
+A `start` hook can return `decide.requeue()` to try again later. The service keeps its instance, so `build` does not run again.
+
+```ts
+on('start', async ({ decide }) => {
+  try {
+    await device.connect()
+  }
+  catch (error) {
+    return decide.requeue({
+      backoff: { kind: 'exponential', initial: 500, max: 30_000, jitter: 0.2 },
+      maxAttempts: 5,
+      reason: `connect failed: ${String(error)}`,
+    })
+  }
+})
+```
+
+- During the wait, the service is `retrying`. It is not available, so its dependents stay `pending`. It still holds its dependencies.
+- `after: ms` sets a fixed delay. `backoff` doubles `initial` for each attempt, up to `max`. `jitter` is a fraction from 0 to 1 that takes a random part away from each delay.
+- The next attempt runs the `start` handler that requeued, then the handlers after it.
+- Changes during the wait merge into one attempt. A withdrawn required dependency, or `stop()`, cancels the wait and stops the service at once.
+- A dependency hook can requeue too. The service stays `running` with its current dependencies during the wait.
+- injeca has no built-in delay or limit. Without `maxAttempts`, the retries continue.
+
+`maxAttempts` limits the runs of one hook for one instance. It can come from the decision, the `provide` options, or the container options. The decision wins over the service, and the service wins over the container. A child container uses the value of its nearest ancestor.
+
+```ts
+const container = createContainer({ maxAttempts: 10, random: () => 0.5 }) // a fixed random source for deterministic tests
+injeca.provide('modules:device', { maxAttempts: 3, build: () => createDevice() })
+```
+
+When the attempts end, a running service stops first. Then it goes to `failed` with the last reason. `start()` again, `stop()` and `start()`, or `replace()` moves it out of `failed`.
+
+### Timeouts
+
+`start` and `stop` hooks wait until they settle. Set `timeouts` to limit them. A service value overrides the container value. injeca has no built-in timeout.
+
+```ts
+const container = createContainer({ timeouts: { stop: 5_000 } })
+
+provide(container, 'modules:camera', {
+  timeouts: { start: 10_000 },
+  onTimeout: (context) => {
+    if (context.hook === 'start')
+      return context.decide.requeue({ after: 1_000, maxAttempts: 3 })
+    return context.decide.fail(new Error('The camera did not close.'))
+  },
+  build: () => createCamera(),
+})
+```
+
+- The `start` timeout is for all `start` handlers of one attempt. The `stop` timeout is for all `stop` handlers and effect disposers of one instance.
+- When a timeout passes, `observe` gets a `timeout` record. Then `onTimeout` of the service, or of the container, decides. Without it, the result is `fail` with a `HookTimeoutError` (`hook-timeout`).
+- `onTimeout` runs synchronously. `context.decide` has the methods of the hook that timed out.
+- After a `stop` timeout, the remaining cleanups still run, but injeca does not wait for them. So a cleanup that awaits the disposal of its own container cannot block that disposal.
+
+## Changes at run time
+
+Services can appear and disappear after `start()`. Dependents converge automatically.
+
+```ts
+await injeca.start()
+
+// A provide after start() builds and starts when its dependencies run.
+const vision = injeca.provide('modules:vision', {
+  dependsOn: { config },
+  build: ({ dependsOn }) => createVision(dependsOn.config),
+})
+
+// Withdraw. Dependents stop first. A stale registration returns false.
+await vision.withdraw()
+```
+
+When a dependency gets a new instance, a dependent rebuilds by default. A `dependency-change` handler can move to the new instance in place:
+
+```ts
+on('dependency-change', ({ dependsOn, decide }) => {
+  speech.setTts(dependsOn.tts?.value)
+  return decide.handled()
+})
+```
 
-### Manual containers
+### Atomic replacement
 
-If you need multiple containers (for tests or per-request scopes), create them
-explicitly and pass the container reference into `provide`, `invoke`, `start`, and
-`stop`.
+A withdrawal followed by a new `provide` leaves a gap: all dependents stop. `replace()` has no gap. A hot reload tool uses it.
 
 ```ts
-import { createContainer, invoke, provide, start, stop } from 'injeca'
+const tts = injeca.provide(ttsKey, () => createTts())
+
+// The old instance keeps serving while the new one runs `build` and `start`.
+await tts.replace(() => createTtsV2())
+```
+
+- The swap is one batch. It occurs only after the new instance completes `start`. The new instance is `ready`.
+- If the new `build` or `start` fails, `replace()` rejects and the old instance does not change. This is also the usual fix for an `unavailable` provider.
+- The old instance stops after each dependent releases it. A dependent with a `dependency-change` handler moves in place. Other dependents rebuild.
+- A stale registration, or a call that a newer `replace()` or a withdrawal supersedes, resolves `false`. A service in `stopping` rejects with `ReplaceWhileStoppingError`.
+
+### Transactions
+
+A transaction publishes many services together, for example all exports of one plugin.
+
+```ts
+import { transaction } from 'injeca'
+
+const tx = transaction(container)
+tx.declare(statusKitKey, { dependsOn: { character: characterKey } })
+tx.provide(statusKitKey, { build: ({ dependsOn }) => createStatusKit(dependsOn) })
+tx.provide(characterKey, () => createCharacter())
+await tx.commit()
+```
+
+- Nothing is visible to consumers before `commit()`. Graph queries show the declared services.
+- `commit()` builds in dependency order. A service can use another service of the same transaction.
+- If all builds succeed, the services publish in one batch, then their `start` hooks run. If one build fails, nothing publishes and `commit()` rejects.
+- A service whose dependencies are not available goes to `pending`. That is not a failure.
+- A declared service without `provide` fails the commit with `TransactionIncompleteError`, unless it is declared with `optional: true`.
+- `tx.replace(key, option)` replaces a registration at the commit. `tx.abort()` and the disposal of the container drop everything.
+
+## Keys without a provider
+
+`defineKey` creates a typed key. A consumer can depend on it before any provider exists. It stays `pending` and runs no code until a provider registers.
+
+```ts
+import { defineKey, firstAvailable, injeca, optional } from 'injeca'
+
+export const llmKey = defineKey<LlmClient>('airi.llm')
+
+injeca.provide('voice:speech', {
+  dependsOn: {
+    llm: firstAvailable(remoteLlmKey, llmKey), // the first available provider
+    tts: optional(ttsKey), // `{ value, status } | undefined`
+  },
+  build: ({ dependsOn }) => createSpeech(dependsOn.llm, dependsOn.tts?.value),
+})
+
+// A plugin provides it later. The build result must match LlmClient.
+injeca.provide(llmKey, () => createLocalLlm())
+```
+
+### Exclusive keys
+
+An exclusive key can have only one provider in its resolution area: the container that has the key, with its descendants.
+
+```ts
+const whiteboardKey = defineKey<Whiteboard>('dev.airi.whiteboard', { exclusive: true })
+```
+
+If two containers in one area provide it, both go to `conflict`, in any order. They run no code, and their dependents stay `pending`. When one provider is removed, the other converges. `graph(container).explain()` lists the owner of each provider.
+
+### Resolution conditions
+
+`where(key, condition)` accepts a provider only when the condition returns `true`. The condition reads the key, the owner, and the `metadata` of the provider.
+
+```ts
+import { defineKey, optional, where } from 'injeca'
+
+const panelKey = injeca.provide('whiteboard:panel', { metadata: { version: '2.1.0' }, build: () => createPanel() })
+const themeKey = defineKey<Theme>('ui:theme')
+
+injeca.provide('whiteboard:view', {
+  dependsOn: {
+    panel: where(panelKey, ({ metadata }) => String(metadata.version).startsWith('2.')),
+    theme: optional(where(themeKey, ({ owner }) => owner.kind === 'host')),
+  },
+  build: ({ dependsOn }) => createView(dependsOn.panel, dependsOn.theme?.value),
+})
+```
+
+- A rejected required dependency keeps the dependent `pending`. A rejected optional dependency is `undefined`.
+- The condition must be pure and synchronous. A thrown error counts as `false` and goes to the observe stream.
+
+## Status
+
+A running service is `ready`, `degraded`, or `unavailable`.
+
+- `degraded` means that calls still complete, at lower quality.
+- `unavailable` means that the instance exists, but calls fail now.
+- The effective status of a service is the worst of its own status and the effective status of each required dependency. It goes down the graph.
+- A dependency that becomes `unavailable` does not stop or rebuild its dependents. They get a `dependency-status-change` call if they register a handler.
+
+```ts
+build: ({ setStatus }) => {
+  const client = connect()
+  client.on('reconnecting', () => setStatus('unavailable', { reason: 'reconnecting' }))
+  client.on('ready', () => setStatus('ready'))
+  return client
+}
+```
+
+## Containers
+
+Create containers to isolate tests, or to give each plugin its own child container.
+
+```ts
+import { createContainer, dispose, effect, invoke, provide, start, stop } from 'injeca'
 
 const container = createContainer()
 
@@ -111,14 +321,131 @@ const token = provide(container, 'token', () => crypto.randomUUID())
 
 invoke(container, {
   dependsOn: { token },
-  // eslint-disable-next-line no-console
-  callback: ({ token }) => console.log('token', token),
+  callback: ({ token }) => console.info('token', token),
 })
 
 await start(container)
 await stop(container)
 ```
 
+A child container resolves keys from its ancestors. It does not start until `start(child)` runs, so a caller can register all its services first.
+
+```ts
+const plugin = createContainer({
+  parent: injeca.getContainer(),
+  owner: { kind: 'plugin', id: 'agent-activity' },
+})
+
+provide(plugin, 'agent-activity:reaction', { dependsOn: { llm: llmKey }, build: () => createReaction() })
+effect(plugin, () => () => console.info('plugin cleaned up'))
+
+await start(plugin, { timeoutMs: 10_000 })
+await dispose(plugin)
+```
+
+- `stop()` stops. `dispose()` also withdraws the registrations and runs the container effects. A disposed container cannot be used again.
+- `start(container, { timeoutMs })` rejects with a `StartTimeoutError` that explains each service that is not running. injeca has no built-in timeout.
+- A service with a missing provider, or in a dependency cycle, stays `pending`. Use `timeoutMs` to find it.
+- A provider in a child container shadows the provider of an ancestor only while it is `running`. Until then, and after it stops, dependents use the ancestor provider. So shadowing never leaves a gap.
+- `createContainer({ isolate: [key] })` stops a key from resolving from the ancestors.
+
+### Per-consumer services
+
+`perConsumer: true` runs `build` once for each consumer container. The build context has `consumer`, the owner record of that container. The instance disposes with the consumer container.
+
+```ts
+const hostClient = injeca.provide('host:client', {
+  perConsumer: true,
+  metadata: { api: 'v1' },
+  build: ({ consumer }) => createHostClient(consumer),
+})
+```
+
+`metadata` is a frozen record on any registration. Resolution conditions and graph queries read it.
+
+## Reading state
+
+```ts
+import { observe, waitFor, watch } from 'injeca'
+
+const container = injeca.getContainer()
+
+const stopWatching = watch(container, server, ({ phase, status }) => {})
+await waitFor(container, server, { status: 'ready', timeoutMs: 5_000 })
+const stopObserving = observe(container, (record) => {})
+```
+
+- `watch` sends the current state at once, then each change, in order.
+- `observe` sends each phase change, status change, decision, and hook timeout in the container and its children.
+
+### Graph queries
+
+`graph(container)` reads the graph of the container and its children. It never changes state.
+
+```ts
+import { graph } from 'injeca'
+
+const queries = graph(container)
+
+queries.services() // all services, with the declared services of open transactions
+queries.dependencies(server) // the direct edges of a service
+queries.dependents(config) // the services that use a service now
+queries.order() // providers before their dependents
+queries.cycles() // each dependency cycle
+queries.explain(server) // why a service is not running
+queries.impact({ kind: 'withdraw', key: llmKey }) // { stopped, rebuilt, notified }
+```
+
+`impact()` runs on a copy of the graph, so a user interface can preview an action: "Disabling the plugin also stops X and Y." The change can be `withdraw`, `replace`, or `dispose`.
+
+### Listener registry
+
+injeca does not dispatch events. It stores listeners that a container owns, so that a consumer can run them by its own rules.
+
+```ts
+import { listen, listeners } from 'injeca'
+
+const gate = { id: 'airi.harness.gate' } // any object with a string id, for example an eventa definition
+
+const remove = listen(plugin, gate, handler, { priority: 10 })
+const entries = listeners(container, gate) // [{ handler, owner, metadata }]
+```
+
+`listeners()` returns the listeners of the container and its children, in registration order. `dispose(container)` removes the listeners of the container.
+
+## Migration from 0.2
+
+0.3 keeps the 0.2 call style: `provide`, `invoke`, `resolve`, `start`, `stop`, `createContainer`, and the global `injeca` object. One API changed:
+
+```ts
+// 0.2
+const server = injeca.provide({
+  dependsOn: { lifecycle },
+  build({ dependsOn }) {
+    const app = createServer()
+    dependsOn.lifecycle.appHooks.onStart(() => app.listen(3000))
+    dependsOn.lifecycle.appHooks.onStop(() => app.close())
+    return app
+  },
+})
+
+// 0.3
+const server = injeca.provide({
+  build({ on }) {
+    const app = createServer()
+    on('start', () => app.listen(3000))
+    on('stop', () => app.close())
+    return app
+  },
+})
+```
+
+Other differences:
+
+- `start()` waits for a missing provider. 0.2 threw an error. Use `start({ timeoutMs })` to fail after a time.
+- `resolve()` waits for a missing provider too. Before `start()`, it builds the services that it needs, with their `start` hooks.
+- `invoke()` returns a handle with `withdraw()`. Its callback runs again when a required dependency gets a new instance.
+
 ## License
 
 MIT

package/dist/decision-odiPb2Au.mjs

@@ -0,0 +1,194 @@
+// src/diagnostics/errors.ts
+/**
+* The base class of all injeca errors. Use `code` to identify an error. The message text is not stable.
+*/
+var InjecaError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.name = "InjecaError";
+		this.code = code;
+	}
+};
+/** A started container already has a current registration for the key. */
+var DuplicateServiceError = class extends InjecaError {
+	constructor(message, options) {
+		super("duplicate-service", message, options);
+		this.name = "DuplicateServiceError";
+	}
+};
+/** A registration is no longer the current registration of its service. */
+var StaleRegistrationError = class extends InjecaError {
+	constructor(message, options) {
+		super("stale-registration", message, options);
+		this.name = "StaleRegistrationError";
+	}
+};
+/** A hook returned a decision from another run, or a kind that the hook does not accept. */
+var InvalidDecisionError = class extends InjecaError {
+	constructor(message, options) {
+		super("invalid-decision", message, options);
+		this.name = "InvalidDecisionError";
+	}
+};
+/** A caller used a container or an instance after its disposal started. */
+var BuildAfterDisposeError = class extends InjecaError {
+	constructor(message, options) {
+		super("build-after-dispose", message, options);
+		this.name = "BuildAfterDisposeError";
+	}
+};
+/** `on` was called after `build` settled. */
+var HookOutsideBuildError = class extends InjecaError {
+	constructor(message, options) {
+		super("hook-outside-build", message, options);
+		this.name = "HookOutsideBuildError";
+	}
+};
+/** A transaction commit found a declared service without `provide`. */
+var TransactionIncompleteError = class extends InjecaError {
+	constructor(message, options) {
+		super("transaction-incomplete", message, options);
+		this.name = "TransactionIncompleteError";
+	}
+};
+/** `dispose()` was called from the cleanup chain of the same container. */
+var ReentrantDisposeError = class extends InjecaError {
+	constructor(message, options) {
+		super("reentrant-dispose", message, options);
+		this.name = "ReentrantDisposeError";
+	}
+};
+/** A `start` or `stop` hook did not settle before its configured timeout. */
+var HookTimeoutError = class extends InjecaError {
+	hook;
+	timeoutMs;
+	constructor(message, hook, timeoutMs, options) {
+		super("hook-timeout", message, options);
+		this.name = "HookTimeoutError";
+		this.hook = hook;
+		this.timeoutMs = timeoutMs;
+	}
+};
+/** `replace` was called on a service in `stopping`. */
+var ReplaceWhileStoppingError = class extends InjecaError {
+	constructor(message, options) {
+		super("replace-while-stopping", message, options);
+		this.name = "ReplaceWhileStoppingError";
+	}
+};
+/** `start()` did not reach `running` for every service before its configured timeout. */
+var StartTimeoutError = class extends InjecaError {
+	/** One entry for each service or invocation that is not `running`. */
+	explanations;
+	constructor(message, explanations, options) {
+		super("start-timeout", message, options);
+		this.name = "StartTimeoutError";
+		this.explanations = explanations;
+	}
+};
+/** `waitFor()` did not match before its configured timeout. */
+var WaitTimeoutError = class extends InjecaError {
+	constructor(message, options) {
+		super("wait-timeout", message, options);
+		this.name = "WaitTimeoutError";
+	}
+};
+/** A caller passed a value with the wrong shape, or reading a caller-owned property failed. */
+var InvalidArgumentError = class extends InjecaError {
+	constructor(message, options) {
+		super("invalid-argument", message, options);
+		this.name = "InvalidArgumentError";
+	}
+};
+// src/primitives/decision.ts
+const issued = /* @__PURE__ */ new WeakMap();
+function reasonFrom(options) {
+	return options?.reason === void 0 ? {} : { reason: options.reason };
+}
+/** Creates the `decide` object of one run. */
+function createDecide(run) {
+	function issue(fields) {
+		const decision = Object.freeze({
+			...fields,
+			service: run.service,
+			instanceId: run.instanceId,
+			hook: run.hook,
+			attempt: run.attempt,
+			issuedAt: run.now()
+		});
+		issued.set(decision, run);
+		return decision;
+	}
+	return Object.freeze({
+		handled: (options) => issue({
+			kind: "handled",
+			...reasonFrom(options)
+		}),
+		rebuild: (options) => issue({
+			kind: "rebuild",
+			...reasonFrom(options)
+		}),
+		requeue: (options) => issue({
+			kind: "requeue",
+			...reasonFrom(options),
+			...options?.after === void 0 ? {} : { after: options.after },
+			...options?.backoff === void 0 ? {} : { backoff: Object.freeze({ ...options.backoff }) },
+			...options?.maxAttempts === void 0 ? {} : { maxAttempts: options.maxAttempts }
+		}),
+		stop: (options) => issue({
+			kind: "stop",
+			...reasonFrom(options)
+		}),
+		fail: (error, options) => issue({
+			kind: "fail",
+			error,
+			...reasonFrom(options)
+		})
+	});
+}
+const validKinds = {
+	"start": /* @__PURE__ */ new Set([
+		"handled",
+		"requeue",
+		"stop",
+		"fail"
+	]),
+	"stop": /* @__PURE__ */ new Set(["handled", "fail"]),
+	"dependency-change": /* @__PURE__ */ new Set([
+		"handled",
+		"rebuild",
+		"requeue",
+		"stop",
+		"fail"
+	]),
+	"dependency-status-change": /* @__PURE__ */ new Set([
+		"handled",
+		"rebuild",
+		"requeue",
+		"stop",
+		"fail"
+	])
+};
+/** The decision for `undefined`. A `dependency-change` handler without a decision gets the default: rebuild. */
+function defaultDecision(run) {
+	const decide = createDecide(run);
+	return run.hook === "dependency-change" ? decide.rebuild() : decide.handled();
+}
+/**
+* Checks the value that a hook handler returned. It gives `undefined` for a value that `decide` did not create, so that the caller applies the default.
+* This keeps a shorthand such as `on('start', () => app.listen(port))` valid.
+*
+* @throws {InvalidDecisionError} when another run created the decision, or when the hook does not accept its kind.
+*/
+function validateDecision(run, value) {
+	const owner = typeof value === "object" && value !== null ? issued.get(value) : void 0;
+	if (!owner) return void 0;
+	if (owner !== run) throw new InvalidDecisionError(`The '${run.hook}' hook of '${run.service}' returned a decision from another run: the '${owner.hook}' hook of '${owner.service}', instance '${owner.instanceId}', attempt ${owner.attempt}.`);
+	const decision = value;
+	if (!validKinds[run.hook].has(decision.kind)) throw new InvalidDecisionError(`The '${run.hook}' hook cannot return a '${decision.kind}' decision.`);
+	return decision;
+}
+export { DuplicateServiceError as a, InjecaError as c, ReentrantDisposeError as d, ReplaceWhileStoppingError as f, WaitTimeoutError as g, TransactionIncompleteError as h, BuildAfterDisposeError as i, InvalidArgumentError as l, StartTimeoutError as m, defaultDecision as n, HookOutsideBuildError as o, StaleRegistrationError as p, validateDecision as r, HookTimeoutError as s, createDecide as t, InvalidDecisionError as u };
+
+//# sourceMappingURL=decision-odiPb2Au.mjs.map