@dxos/effect 0.12.0-next-73daef452f1464b62efdbca75fb0067c1066f264 → 0.13.0

package/dist/lib/AtomEx.mjs

@@ -0,0 +1,44 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import * as Duration from "effect/Duration";
+import * as Registry from "effect/reactivity/AtomRegistry";
+import { assertArgument } from "@dxos/invariant";
+//#region src/AtomEx.ts
+var AtomEx_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_IDLE_TTL: () => DEFAULT_IDLE_TTL,
+	OwnerId: () => OwnerId,
+	makeOwned: () => makeOwned,
+	makeRegistry: () => makeRegistry
+});
+/**
+* Default grace period before an atom with no subscribers is removed from a registry.
+*/
+var DEFAULT_IDLE_TTL = Duration.seconds(5);
+/**
+* An atom registry with the default idle grace period. Use it for any registry that hosts ECHO atoms,
+* which carry no `keepAlive` of their own.
+*/
+var makeRegistry = ({ idleTTL = DEFAULT_IDLE_TTL, ...options } = {}) => {
+	const millis = Duration.toMillis(idleTTL);
+	assertArgument(Number.isFinite(millis), "idleTTL", "Must be finite; use Atom.keepAlive to retain an atom");
+	return Registry.make({
+		...options,
+		defaultIdleTTL: millis > 0 ? millis : void 0
+	});
+};
+/**
+* Key under which an {@link Owner} exposes what its atoms are mounted with.
+*/
+var OwnerId = Symbol.for("@dxos/effect/AtomEx/Owner");
+/**
+* Keeps `atom` mounted until `owner` is collected. Unlike `Atom.keepAlive`, it does not outlive the
+* owner. Neither the atom nor its value may reference `owner`, or the registry keeps `owner` alive.
+*/
+var makeOwned = (owner, atom) => {
+	const { registry, finalizer } = owner[OwnerId];
+	finalizer.register(owner, registry.mount(atom));
+	return atom;
+};
+//#endregion
+export { DEFAULT_IDLE_TTL, OwnerId, makeOwned, makeRegistry, AtomEx_exports as t };
+
+//# sourceMappingURL=AtomEx.mjs.map

package/dist/lib/AtomEx.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AtomEx.mjs","names":[],"sources":["../../src/AtomEx.ts"],"sourcesContent":["//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Duration from 'effect/Duration';\nimport type * as Atom from 'effect/reactivity/Atom';\nimport * as Registry from 'effect/reactivity/AtomRegistry';\n\nimport { assertArgument } from '@dxos/invariant';\n\n// @import-as-namespace\n\n/**\n * Default grace period before an atom with no subscribers is removed from a registry.\n */\nexport const DEFAULT_IDLE_TTL = Duration.seconds(5);\n\nexport type RegistryOptions = Omit<NonNullable<Parameters<typeof Registry.make>[0]>, 'defaultIdleTTL'> & {\n  /** Must be finite; use `Atom.keepAlive` to retain an atom indefinitely. Zero removes on the next task. */\n  idleTTL?: Duration.Input;\n};\n\n/**\n * An atom registry with the default idle grace period. Use it for any registry that hosts ECHO atoms,\n * which carry no `keepAlive` of their own.\n */\nexport const makeRegistry = ({ idleTTL = DEFAULT_IDLE_TTL, ...options }: RegistryOptions = {}) => {\n  const millis = Duration.toMillis(idleTTL);\n  // An infinite TTL makes the registry's bucket arithmetic NaN, which removes nodes at once.\n  assertArgument(Number.isFinite(millis), 'idleTTL', 'Must be finite; use Atom.keepAlive to retain an atom');\n  return Registry.make({ ...options, defaultIdleTTL: millis > 0 ? millis : undefined });\n};\n\n/**\n * Key under which an {@link Owner} exposes what its atoms are mounted with.\n */\nexport const OwnerId = Symbol.for('@dxos/effect/AtomEx/Owner');\n\n/**\n * An object whose atoms live as long as it does; see {@link makeOwned}.\n */\nexport interface Owner {\n  readonly [OwnerId]: {\n    /** The registry the owner's atoms are mounted in. */\n    readonly registry: Registry.AtomRegistry;\n    /**\n     * Unmounts a collected owner's atoms. One per class, held in a static field: a registry the\n     * instance created would be collected with it and never run.\n     */\n    readonly finalizer: FinalizationRegistry<() => void>;\n  };\n}\n\n/**\n * Keeps `atom` mounted until `owner` is collected. Unlike `Atom.keepAlive`, it does not outlive the\n * owner. Neither the atom nor its value may reference `owner`, or the registry keeps `owner` alive.\n */\nexport const makeOwned = <A extends Atom.Atom<unknown>>(owner: Owner, atom: A): A => {\n  const { registry, finalizer } = owner[OwnerId];\n  finalizer.register(owner, registry.mount(atom));\n  return atom;\n};\n"],"mappings":";;;;;;;;;;;;;;AAeA,IAAa,mBAAmB,SAAS,QAAQ,CAAC;;;;;AAWlD,IAAa,gBAAgB,EAAE,UAAU,kBAAkB,GAAG,YAA6B,CAAC,MAAM;CAChG,MAAM,SAAS,SAAS,SAAS,OAAO;CAExC,eAAe,OAAO,SAAS,MAAM,GAAG,WAAW,sDAAsD;CACzG,OAAO,SAAS,KAAK;EAAE,GAAG;EAAS,gBAAgB,SAAS,IAAI,SAAS,KAAA;CAAU,CAAC;AACtF;;;;AAKA,IAAa,UAAU,OAAO,IAAI,2BAA2B;;;;;AAqB7D,IAAa,aAA2C,OAAc,SAAe;CACnF,MAAM,EAAE,UAAU,cAAc,MAAM;CACtC,UAAU,SAAS,OAAO,SAAS,MAAM,IAAI,CAAC;CAC9C,OAAO;AACT"}

package/dist/lib/DynamicRuntime.mjs

@@ -0,0 +1,93 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { n as runAndForwardErrors, s as unwrapExit } from "./chunk-errors.mjs";
+import * as Effect from "effect/Effect";
+import * as Context from "effect/Context";
+import * as Exit from "effect/Exit";
+import * as Option from "effect/Option";
+//#region src/dynamic-runtime.ts
+var dynamic_runtime_exports = /* @__PURE__ */ __exportAll({ make: () => make });
+/**
+* Validate that all required tags are present in the runtime context.
+*/
+var validateTags = (context, tags) => Effect.gen(function* () {
+	const missingTags = [];
+	for (const tag of tags) {
+		const option = Context.getOption(context, tag);
+		if (Option.isNone(option)) missingTags.push(tag.key);
+	}
+	if (missingTags.length > 0) return yield* Effect.die(/* @__PURE__ */ new Error(`Missing required tags in runtime: ${missingTags.join(", ")}`));
+});
+/**
+* Create a dynamic runtime from a managed runtime and validate required tags.
+*/
+function make(managedRuntime, tags) {
+	const managedRuntimeAny = managedRuntime;
+	let cachedRuntime;
+	let validatedRuntimePromise;
+	const getValidatedRuntimeAsync = async () => {
+		if (!validatedRuntimePromise) validatedRuntimePromise = managedRuntimeAny.runPromise(Effect.gen(function* () {
+			const rt = yield* managedRuntimeAny.contextEffect;
+			yield* validateTags(rt, tags);
+			return rt;
+		}));
+		return validatedRuntimePromise;
+	};
+	const getValidatedRuntime = () => {
+		const validationExit = managedRuntimeAny.runSyncExit(Effect.gen(function* () {
+			const rt = yield* managedRuntimeAny.contextEffect;
+			yield* validateTags(rt, tags);
+			return rt;
+		}));
+		return unwrapExit(validationExit);
+	};
+	return {
+		managedRuntime: managedRuntimeAny,
+		runPromise: async (effect) => {
+			const runtime = await getValidatedRuntimeAsync();
+			return runAndForwardErrors(Effect.provideContext(effect, runtime));
+		},
+		runSync: (effect) => {
+			const runtime = getValidatedRuntime();
+			return Effect.runSync(Effect.provideContext(effect, runtime));
+		},
+		runSyncExit: (effect) => {
+			const validationExit = managedRuntimeAny.runSyncExit(Effect.gen(function* () {
+				const rt = yield* managedRuntimeAny.contextEffect;
+				yield* validateTags(rt, tags);
+				return rt;
+			}));
+			if (Exit.isSuccess(validationExit)) {
+				const runtime = validationExit.value;
+				return Effect.runSyncExit(Effect.provideContext(effect, runtime));
+			}
+			return validationExit;
+		},
+		runPromiseExit: async (effect) => {
+			try {
+				const runtime = await getValidatedRuntimeAsync();
+				return Effect.runPromiseExit(Effect.provideContext(effect, runtime));
+			} catch (error) {
+				return Exit.die(error);
+			}
+		},
+		runFork: (effect) => {
+			const runtime = getValidatedRuntime();
+			return Effect.runFork(Effect.provideContext(effect, runtime));
+		},
+		contextEffect: Effect.gen(function* () {
+			if (cachedRuntime) return cachedRuntime;
+			const rt = yield* managedRuntimeAny.contextEffect;
+			yield* validateTags(rt, tags);
+			const runtime = rt;
+			cachedRuntime = runtime;
+			return runtime;
+		}).pipe(Effect.catch(() => Effect.die(/* @__PURE__ */ new Error("Unexpected error in contextEffect validation")))),
+		dispose: async () => {
+			await managedRuntimeAny.dispose();
+		}
+	};
+}
+//#endregion
+export { make, dynamic_runtime_exports as t };
+
+//# sourceMappingURL=DynamicRuntime.mjs.map

package/dist/lib/DynamicRuntime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DynamicRuntime.mjs","names":[],"sources":["../../src/dynamic-runtime.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Exit from 'effect/Exit';\nimport type * as Fiber from 'effect/Fiber';\nimport type * as ManagedRuntime from 'effect/ManagedRuntime';\nimport * as Option from 'effect/Option';\n\nimport { runAndForwardErrors, unwrapExit } from './internal/errors.ts';\n\n/**\n * Helper type to construct a union of tag identifiers from an array of tags.\n */\nexport type TagsToContext<Tags extends ReadonlyArray<Context.Key<any, any>>> = Tags extends readonly [\n  infer Head,\n  ...infer Tail,\n]\n  ? Head extends Context.Key<infer Id, any>\n    ? Tail extends ReadonlyArray<Context.Key<any, any>>\n      ? Id | TagsToContext<Tail>\n      : Id\n    : never\n  : never;\n\n/**\n * A runtime wrapper that validates required tags are available at runtime\n * while providing type-level guarantees that effects require those tags.\n */\nexport interface DynamicRuntime<Tags extends ReadonlyArray<Context.Key<any, any>>> {\n  /**\n   * Run an effect as a promise that requires the specified tags.\n   */\n  readonly runPromise: <A, E>(effect: Effect.Effect<A, E, TagsToContext<Tags>>) => Promise<A>;\n\n  /**\n   * Run an effect synchronously that requires the specified tags.\n   */\n  readonly runSync: <A, E>(effect: Effect.Effect<A, E, TagsToContext<Tags>>) => A;\n\n  /**\n   * Run an effect synchronously returning exit that requires the specified tags.\n   */\n  readonly runSyncExit: <A, E>(effect: Effect.Effect<A, E, TagsToContext<Tags>>) => Exit.Exit<A, E>;\n\n  /**\n   * Run an effect as a promise returning exit that requires the specified tags.\n   */\n  readonly runPromiseExit: <A, E>(effect: Effect.Effect<A, E, TagsToContext<Tags>>) => Promise<Exit.Exit<A, E>>;\n\n  /**\n   * Fork an effect that requires the specified tags.\n   */\n  readonly runFork: <A, E>(effect: Effect.Effect<A, E, TagsToContext<Tags>>) => Fiber.Fiber<A, E>;\n\n  /**\n   * Get the runtime as an effect that requires the specified tags.\n   */\n  readonly contextEffect: Effect.Effect<Context.Context<TagsToContext<Tags>>, never, never>;\n\n  /**\n   * Dispose the underlying managed runtime.\n   */\n  readonly dispose: () => Promise<void>;\n\n  /**\n   * Get the underlying managed runtime.\n   */\n  readonly managedRuntime: ManagedRuntime.ManagedRuntime<any, any>;\n}\n\n/**\n * Validate that all required tags are present in the runtime context.\n */\nconst validateTags = <Tags extends ReadonlyArray<Context.Key<any, any>>>(\n  context: Context.Context<any>,\n  tags: Tags,\n): Effect.Effect<void> =>\n  Effect.gen(function* () {\n    const missingTags: string[] = [];\n    for (const tag of tags) {\n      const option = Context.getOption(context, tag);\n      if (Option.isNone(option)) {\n        missingTags.push(tag.key);\n      }\n    }\n\n    if (missingTags.length > 0) {\n      return yield* Effect.die(new Error(`Missing required tags in runtime: ${missingTags.join(', ')}`));\n    }\n  });\n\n/**\n * Create a dynamic runtime from a managed runtime and validate required tags.\n */\nexport function make<const Tags extends ReadonlyArray<Context.Key<any, any>>>(\n  managedRuntime: ManagedRuntime.ManagedRuntime<any, any> | ManagedRuntime.ManagedRuntime<never, never>,\n  tags: Tags,\n): DynamicRuntime<Tags> {\n  type RequiredContext = TagsToContext<Tags>;\n  const managedRuntimeAny = managedRuntime as ManagedRuntime.ManagedRuntime<any, any>;\n\n  // Cache for the validated runtime - once resolved, can be used synchronously.\n  let cachedRuntime: Context.Context<RequiredContext> | undefined;\n\n  // Cache validated runtime for async operations.\n  let validatedRuntimePromise: Promise<Context.Context<RequiredContext>> | undefined;\n\n  const getValidatedRuntimeAsync = async (): Promise<Context.Context<RequiredContext>> => {\n    if (!validatedRuntimePromise) {\n      validatedRuntimePromise = managedRuntimeAny.runPromise(\n        Effect.gen(function* () {\n          const rt = yield* managedRuntimeAny.contextEffect;\n          yield* validateTags(rt, tags);\n          return rt as Context.Context<RequiredContext>;\n        }),\n      );\n    }\n    return validatedRuntimePromise;\n  };\n\n  // Get validated runtime for sync operations.\n  const getValidatedRuntime = (): Context.Context<RequiredContext> => {\n    const validationExit = managedRuntimeAny.runSyncExit(\n      Effect.gen(function* () {\n        const rt = yield* managedRuntimeAny.contextEffect;\n        yield* validateTags(rt, tags);\n        return rt as Context.Context<RequiredContext>;\n      }),\n    );\n    return unwrapExit(validationExit);\n  };\n\n  return {\n    managedRuntime: managedRuntimeAny,\n    runPromise: async <A, E>(effect: Effect.Effect<A, E, RequiredContext>): Promise<A> => {\n      const runtime = await getValidatedRuntimeAsync();\n      return runAndForwardErrors(Effect.provideContext(effect, runtime));\n    },\n    runSync: <A, E>(effect: Effect.Effect<A, E, RequiredContext>): A => {\n      const runtime = getValidatedRuntime();\n      return Effect.runSync(Effect.provideContext(effect, runtime));\n    },\n    runSyncExit: <A, E>(effect: Effect.Effect<A, E, RequiredContext>): Exit.Exit<A, E> => {\n      const validationExit = managedRuntimeAny.runSyncExit(\n        Effect.gen(function* () {\n          const rt = yield* managedRuntimeAny.contextEffect;\n          yield* validateTags(rt, tags);\n          return rt as Context.Context<RequiredContext>;\n        }),\n      );\n      if (Exit.isSuccess(validationExit)) {\n        const runtime = validationExit.value;\n        return Effect.runSyncExit(Effect.provideContext(effect, runtime));\n      }\n      return validationExit as Exit.Exit<A, E>;\n    },\n    runPromiseExit: async <A, E>(effect: Effect.Effect<A, E, RequiredContext>): Promise<Exit.Exit<A, E>> => {\n      try {\n        const runtime = await getValidatedRuntimeAsync();\n        return Effect.runPromiseExit(Effect.provideContext(effect, runtime));\n      } catch (error) {\n        // If validation failed, return a failure exit\n        return Exit.die(error);\n      }\n    },\n    runFork: <A, E>(effect: Effect.Effect<A, E, RequiredContext>): Fiber.Fiber<A, E> => {\n      const runtime = getValidatedRuntime();\n      return Effect.runFork(Effect.provideContext(effect, runtime));\n    },\n    contextEffect: Effect.gen(function* () {\n      // Return cached runtime if available.\n      if (cachedRuntime) {\n        return cachedRuntime;\n      }\n      const rt = yield* managedRuntimeAny.contextEffect;\n      yield* validateTags(rt, tags);\n      const runtime = rt as Context.Context<RequiredContext>;\n      // Cache for future sync calls.\n      cachedRuntime = runtime;\n      return runtime;\n    }).pipe(\n      Effect.catch(() =>\n        // This should never happen since validateTags uses Effect.die\n        Effect.die(new Error('Unexpected error in contextEffect validation')),\n      ),\n    ),\n    dispose: async (): Promise<void> => {\n      await managedRuntimeAny.dispose();\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;AA4EA,IAAM,gBACJ,SACA,SAEA,OAAO,IAAI,aAAa;CACtB,MAAM,cAAwB,CAAC;CAC/B,KAAK,MAAM,OAAO,MAAM;EACtB,MAAM,SAAS,QAAQ,UAAU,SAAS,GAAG;EAC7C,IAAI,OAAO,OAAO,MAAM,GACtB,YAAY,KAAK,IAAI,GAAG;CAE5B;CAEA,IAAI,YAAY,SAAS,GACvB,OAAO,OAAO,OAAO,oBAAI,IAAI,MAAM,qCAAqC,YAAY,KAAK,IAAI,GAAG,CAAC;AAErG,CAAC;;;;AAKH,SAAgB,KACd,gBACA,MACsB;CAEtB,MAAM,oBAAoB;CAG1B,IAAI;CAGJ,IAAI;CAEJ,MAAM,2BAA2B,YAAuD;EACtF,IAAI,CAAC,yBACH,0BAA0B,kBAAkB,WAC1C,OAAO,IAAI,aAAa;GACtB,MAAM,KAAK,OAAO,kBAAkB;GACpC,OAAO,aAAa,IAAI,IAAI;GAC5B,OAAO;EACT,CAAC,CACH;EAEF,OAAO;CACT;CAGA,MAAM,4BAA8D;EAClE,MAAM,iBAAiB,kBAAkB,YACvC,OAAO,IAAI,aAAa;GACtB,MAAM,KAAK,OAAO,kBAAkB;GACpC,OAAO,aAAa,IAAI,IAAI;GAC5B,OAAO;EACT,CAAC,CACH;EACA,OAAO,WAAW,cAAc;CAClC;CAEA,OAAO;EACL,gBAAgB;EAChB,YAAY,OAAa,WAA6D;GACpF,MAAM,UAAU,MAAM,yBAAyB;GAC/C,OAAO,oBAAoB,OAAO,eAAe,QAAQ,OAAO,CAAC;EACnE;EACA,UAAgB,WAAoD;GAClE,MAAM,UAAU,oBAAoB;GACpC,OAAO,OAAO,QAAQ,OAAO,eAAe,QAAQ,OAAO,CAAC;EAC9D;EACA,cAAoB,WAAkE;GACpF,MAAM,iBAAiB,kBAAkB,YACvC,OAAO,IAAI,aAAa;IACtB,MAAM,KAAK,OAAO,kBAAkB;IACpC,OAAO,aAAa,IAAI,IAAI;IAC5B,OAAO;GACT,CAAC,CACH;GACA,IAAI,KAAK,UAAU,cAAc,GAAG;IAClC,MAAM,UAAU,eAAe;IAC/B,OAAO,OAAO,YAAY,OAAO,eAAe,QAAQ,OAAO,CAAC;GAClE;GACA,OAAO;EACT;EACA,gBAAgB,OAAa,WAA2E;GACtG,IAAI;IACF,MAAM,UAAU,MAAM,yBAAyB;IAC/C,OAAO,OAAO,eAAe,OAAO,eAAe,QAAQ,OAAO,CAAC;GACrE,SAAS,OAAO;IAEd,OAAO,KAAK,IAAI,KAAK;GACvB;EACF;EACA,UAAgB,WAAoE;GAClF,MAAM,UAAU,oBAAoB;GACpC,OAAO,OAAO,QAAQ,OAAO,eAAe,QAAQ,OAAO,CAAC;EAC9D;EACA,eAAe,OAAO,IAAI,aAAa;GAErC,IAAI,eACF,OAAO;GAET,MAAM,KAAK,OAAO,kBAAkB;GACpC,OAAO,aAAa,IAAI,IAAI;GAC5B,MAAM,UAAU;GAEhB,gBAAgB;GAChB,OAAO;EACT,CAAC,CAAC,CAAC,KACD,OAAO,YAEL,OAAO,oBAAI,IAAI,MAAM,8CAA8C,CAAC,CACtE,CACF;EACA,SAAS,YAA2B;GAClC,MAAM,kBAAkB,QAAQ;EAClC;CACF;AACF"}

package/dist/lib/EffectEx.mjs

@@ -0,0 +1,3 @@
+import { a as runPromise, i as runInRuntime, n as runAndForwardErrors, o as throwCause, r as runDetached, s as unwrapExit, t as causeToError } from "./chunk-errors.mjs";
+import { a as contextWithoutParentSpan, i as contextFromScope, n as streamFromEmitter, o as withContext, r as acquireReleaseResource, s as asyncTaskTaggingLayer } from "./chunk-EffectEx.mjs";
+export { acquireReleaseResource, asyncTaskTaggingLayer, causeToError, contextFromScope, contextWithoutParentSpan, runAndForwardErrors, runDetached, runInRuntime, runPromise, streamFromEmitter, throwCause, unwrapExit, withContext };

package/dist/lib/GlobalValue.mjs

@@ -0,0 +1,22 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+//#region src/internal/GlobalValue.ts
+var GlobalValue_exports = /* @__PURE__ */ __exportAll({ globalValue: () => globalValue });
+var REGISTRY = Symbol.for("@dxos/effect/globalValue");
+var registry = () => {
+	const global = globalThis;
+	return global[REGISTRY] ??= /* @__PURE__ */ new Map();
+};
+/**
+* Returns the value stored for `id`, computing and storing it on first use.
+*
+* @param id Stable identity for the value; equal ids share one instance process-wide.
+*/
+var globalValue = (id, compute) => {
+	const map = registry();
+	if (!map.has(id)) map.set(id, compute());
+	return map.get(id);
+};
+//#endregion
+export { globalValue, GlobalValue_exports as t };
+
+//# sourceMappingURL=GlobalValue.mjs.map

package/dist/lib/GlobalValue.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlobalValue.mjs","names":[],"sources":["../../src/internal/GlobalValue.ts"],"sourcesContent":["//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\n// Effect 4 removed `effect/GlobalValue`. This is a like-for-like replacement: a value memoised\n// against a registry on `globalThis`, so duplicate copies of a module -- bundler chunk splitting,\n// a dependency pulled in twice, a worker realm -- still share one instance.\n\nconst REGISTRY = Symbol.for('@dxos/effect/globalValue');\n\ntype Registry = Map<unknown, unknown>;\n\nconst registry = (): Registry => {\n  const global = globalThis as Record<symbol, unknown>;\n  return (global[REGISTRY] ??= new Map()) as Registry;\n};\n\n/**\n * Returns the value stored for `id`, computing and storing it on first use.\n *\n * @param id Stable identity for the value; equal ids share one instance process-wide.\n */\nexport const globalValue = <T>(id: unknown, compute: () => T): T => {\n  const map = registry();\n  if (!map.has(id)) {\n    map.set(id, compute());\n  }\n  return map.get(id) as T;\n};\n"],"mappings":";;;AAUA,IAAM,WAAW,OAAO,IAAI,0BAA0B;AAItD,IAAM,iBAA2B;CAC/B,MAAM,SAAS;CACf,OAAQ,OAAO,8BAAc,IAAI,IAAI;AACvC;;;;;;AAOA,IAAa,eAAkB,IAAa,YAAwB;CAClE,MAAM,MAAM,SAAS;CACrB,IAAI,CAAC,IAAI,IAAI,EAAE,GACb,IAAI,IAAI,IAAI,QAAQ,CAAC;CAEvB,OAAO,IAAI,IAAI,EAAE;AACnB"}

package/dist/lib/Hook.mjs

@@ -0,0 +1,107 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { invariant } from "@dxos/invariant";
+import * as Context from "effect/Context";
+import * as Function from "effect/Function";
+import * as Pipeable from "effect/Pipeable";
+import * as Scope from "effect/Scope";
+//#region src/Hook.ts
+var Hook_exports = /* @__PURE__ */ __exportAll({
+	Controller: () => Controller,
+	TypeId: () => TypeId,
+	controllerLayer: () => controllerLayer,
+	emit: () => emit,
+	handler: () => handler,
+	make: () => make,
+	makeController: () => makeController,
+	on: () => on,
+	subscribe: () => subscribe
+});
+var __dxlog_file = "/__w/dxos/dxos/packages/common/effect/src/Hook.ts";
+var TypeId = "~@dxos/effect/Hook";
+/**
+* Pairs a hook with the function that runs on it, ready to pass to `subscribe`. Dual: called with
+* one argument it returns the pipeable form, so `handler(fn)` composes onto the hook.
+*
+* @param hook The hook to bind to.
+* @param handler Runs per emit, receiving the hook's payload.
+* @returns The pairing `subscribe` registers.
+*/
+var handler = Function.dual(2, (hook, handler) => ({
+	hook,
+	handler
+}));
+/**
+* Declares a hook. Curried so the payload type is given explicitly while the id stays inferred:
+* `make<Payload>()('my/id')`.
+*
+* @param id Identifies the hook across package and bundle boundaries, so it must be unique.
+* @param options.strategy How subscribers are dispatched; `parallel` by default.
+* @returns The hook to emit and subscribe to.
+*/
+var make = () => (id, options) => ({
+	...Pipeable.Prototype,
+	[TypeId]: { _Data: void 0 },
+	id,
+	strategy: options?.strategy ?? "parallel"
+});
+var Controller = class extends Context.Service()("@dxos/effect/Hook.Controller") {};
+/**
+* Registers the handler until the current scope closes; unsubscription is a plain removal.
+*/
+var subscribe = (handler) => Controller.pipe(Effect.flatMap((controller) => controller.subscribe(handler)));
+/**
+* Subscribes `fn` to `hook` for the current scope: `handler` and `subscribe` in one call.
+*/
+var on = (hook, fn) => subscribe(handler(hook, fn));
+/**
+* Dispatches to every subscriber and completes once all of them have — including the hooks those
+* handlers emit in turn — so an emit doubles as a barrier for the work the hook triggers. A
+* handler that fails fails the emitter as a defect, so this is not a fire-and-forget notification.
+*/
+var emit = (hook, payload) => Controller.pipe(Effect.flatMap((controller) => controller.emit(hook, payload)));
+var makeController = () => {
+	const subscribers = /* @__PURE__ */ new Map();
+	const controller = {
+		subscribe: (handler) => Effect.gen(function* () {
+			const scope = yield* Effect.scope;
+			const entry = subscribers.get(handler.hook.id) ?? {
+				hook: handler.hook,
+				handlers: /* @__PURE__ */ new Set()
+			};
+			invariant(entry.hook.strategy === handler.hook.strategy, `Hook id collision: ${handler.hook.id} is declared with two dispatch strategies`, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 132,
+				S: this,
+				A: ["entry.hook.strategy === handler.hook.strategy", "`Hook id collision: ${handler.hook.id} is declared with two dispatch strategies`"]
+			});
+			subscribers.set(handler.hook.id, entry);
+			entry.handlers.add(handler);
+			yield* Scope.addFinalizer(scope, Effect.sync(() => {
+				entry.handlers.delete(handler);
+				if (entry.handlers.size === 0) subscribers.delete(handler.hook.id);
+			}));
+		}),
+		emit: (hook, payload) => Effect.gen(function* () {
+			const handlers = subscribers.get(hook.id)?.handlers;
+			if (handlers === void 0) return;
+			const dispatch = Array.from(handlers, (entry) => entry.handler(payload));
+			if (hook.strategy === "serial") yield* Effect.forEach(dispatch, (effect) => effect, { discard: true });
+			else yield* Effect.all(dispatch, {
+				concurrency: "unbounded",
+				discard: true
+			});
+		}).pipe(Effect.provideService(Controller, controller))
+	};
+	return controller;
+};
+/**
+* One controller per layer build, so separate runtimes never share subscribers.
+*/
+var controllerLayer = Layer.sync(Controller, makeController);
+//#endregion
+export { Controller, TypeId, controllerLayer, emit, handler, make, makeController, on, subscribe, Hook_exports as t };
+
+//# sourceMappingURL=Hook.mjs.map

package/dist/lib/Hook.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Hook.mjs","names":[],"sources":["../../src/Hook.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Function from 'effect/Function';\nimport * as Layer from 'effect/Layer';\nimport * as Pipeable from 'effect/Pipeable';\nimport * as Scope from 'effect/Scope';\n\nimport { invariant } from '@dxos/invariant';\n\n// @import-as-namespace\n\n/**\n * How the handlers of one hook are dispatched: `parallel` runs them concurrently and is the\n * default; `serial` runs them one after another in subscription order.\n */\nexport type Strategy = 'serial' | 'parallel';\n\nexport const TypeId = '~@dxos/effect/Hook';\nexport type TypeId = typeof TypeId;\n\nexport interface Hook<Id extends string, T> extends Pipeable.Pipeable {\n  readonly [TypeId]: {\n    _Data: T;\n  };\n  readonly id: Id;\n  readonly strategy: Strategy;\n}\n\nexport type Any = {\n  readonly [TypeId]: {\n    _Data: any;\n  };\n  readonly id: string;\n  readonly strategy: Strategy;\n};\n\nexport type Payload<E extends Any> = E[TypeId]['_Data'];\n\n/**\n * Handlers run in the subscriber's controller so they can emit further hooks; failures are defects\n * since a hook cannot enumerate the errors of every subscriber.\n */\nexport type HandlerFn<E extends Any> = (payload: Payload<E>) => Effect.Effect<void, never, Controller>;\n\nexport interface Handler<E extends Any> {\n  readonly hook: E;\n  readonly handler: HandlerFn<E>;\n}\n\n/**\n * Pairs a hook with the function that runs on it, ready to pass to `subscribe`. Dual: called with\n * one argument it returns the pipeable form, so `handler(fn)` composes onto the hook.\n *\n * @param hook The hook to bind to.\n * @param handler Runs per emit, receiving the hook's payload.\n * @returns The pairing `subscribe` registers.\n */\nexport const handler: {\n  <E extends Any>(hook: E, handler: HandlerFn<E>): Handler<E>;\n  <E extends Any>(handler: HandlerFn<E>): (hook: E) => Handler<E>;\n} = Function.dual(2, <E extends Any>(hook: E, handler: HandlerFn<E>): Handler<E> => ({ hook, handler }));\n\n/**\n * Declares a hook. Curried so the payload type is given explicitly while the id stays inferred:\n * `make<Payload>()('my/id')`.\n *\n * @param id Identifies the hook across package and bundle boundaries, so it must be unique.\n * @param options.strategy How subscribers are dispatched; `parallel` by default.\n * @returns The hook to emit and subscribe to.\n */\nexport const make =\n  <const T>() =>\n  <const Id extends string>(id: Id, options?: { strategy?: Strategy }): Hook<Id, T> => ({\n    ...Pipeable.Prototype,\n    [TypeId]: { _Data: undefined as any },\n    id,\n    strategy: options?.strategy ?? 'parallel',\n  });\n\nexport interface ControllerService {\n  subscribe<E extends Any>(handler: Handler<E>): Effect.Effect<void, never, Scope.Scope>;\n  emit<E extends Any>(hook: E, payload: Payload<E>): Effect.Effect<void>;\n}\n\nexport class Controller extends Context.Service<Controller, ControllerService>()('@dxos/effect/Hook.Controller') {}\n\n/**\n * Registers the handler until the current scope closes; unsubscription is a plain removal.\n */\nexport const subscribe = <E extends Any>(handler: Handler<E>): Effect.Effect<void, never, Controller | Scope.Scope> =>\n  Controller.pipe(Effect.flatMap((controller) => controller.subscribe(handler)));\n\n/**\n * Subscribes `fn` to `hook` for the current scope: `handler` and `subscribe` in one call.\n */\nexport const on = <E extends Any>(hook: E, fn: HandlerFn<E>): Effect.Effect<void, never, Controller | Scope.Scope> =>\n  subscribe(handler(hook, fn));\n\n/**\n * Dispatches to every subscriber and completes once all of them have — including the hooks those\n * handlers emit in turn — so an emit doubles as a barrier for the work the hook triggers. A\n * handler that fails fails the emitter as a defect, so this is not a fire-and-forget notification.\n */\nexport const emit = <E extends Any>(hook: E, payload: Payload<E>): Effect.Effect<void, never, Controller> =>\n  Controller.pipe(Effect.flatMap((controller) => controller.emit(hook, payload)));\n\n// Erases the payload type so handlers for different hooks can share one registry.\ntype AnyHandler = {\n  readonly hook: Any;\n  readonly handler: (payload: any) => Effect.Effect<void, never, Controller>;\n};\n\nexport const makeController = (): ControllerService => {\n  // Keyed by id, not by the hook object: these hooks cross package and bundle boundaries, and a\n  // module instantiated twice (dual resolution, a dep-optimizer re-bundle, HMR) would otherwise give\n  // publisher and subscriber different objects for the same hook and turn the cascade into a silent\n  // no-op. The registry holds the hook it first saw, so a genuine id collision is loud instead.\n  const subscribers = new Map<string, { readonly hook: Any; readonly handlers: Set<AnyHandler> }>();\n\n  const controller: ControllerService = {\n    subscribe: (handler) =>\n      Effect.gen(function* () {\n        const scope = yield* Effect.scope;\n        const entry = subscribers.get(handler.hook.id) ?? { hook: handler.hook, handlers: new Set<AnyHandler>() };\n        // A duplicated module and a genuine id collision both present as two objects with one id, so\n        // identity cannot separate them; a differing strategy is the one inconsistency that can only\n        // be a collision, and it is worth failing on rather than dispatching two contracts as one.\n        invariant(\n          entry.hook.strategy === handler.hook.strategy,\n          `Hook id collision: ${handler.hook.id} is declared with two dispatch strategies`,\n        );\n        subscribers.set(handler.hook.id, entry);\n        entry.handlers.add(handler);\n        yield* Scope.addFinalizer(\n          scope,\n          Effect.sync(() => {\n            entry.handlers.delete(handler);\n            if (entry.handlers.size === 0) {\n              subscribers.delete(handler.hook.id);\n            }\n          }),\n        );\n      }),\n    emit: (hook, payload) =>\n      Effect.gen(function* () {\n        const handlers = subscribers.get(hook.id)?.handlers;\n        if (handlers === undefined) {\n          return;\n        }\n        const dispatch = Array.from(handlers, (entry) => entry.handler(payload));\n        if (hook.strategy === 'serial') {\n          yield* Effect.forEach(dispatch, (effect) => effect, { discard: true });\n        } else {\n          yield* Effect.all(dispatch, { concurrency: 'unbounded', discard: true });\n        }\n      }).pipe(Effect.provideService(Controller, controller)),\n  };\n\n  return controller;\n};\n\n/**\n * One controller per layer build, so separate runtimes never share subscribers.\n */\nexport const controllerLayer: Layer.Layer<Controller> = Layer.sync(Controller, makeController);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,IAAa,SAAS;;;;;;;;;AAwCtB,IAAa,UAGT,SAAS,KAAK,IAAmB,MAAS,aAAuC;CAAE;CAAM;AAAQ,EAAE;;;;;;;;;AAUvG,IAAa,cAEe,IAAQ,aAAoD;CACpF,GAAG,SAAS;EACX,SAAS,EAAE,OAAO,KAAA,EAAiB;CACpC;CACA,UAAU,SAAS,YAAY;AACjC;AAOF,IAAa,aAAb,cAAgC,QAAQ,QAAuC,CAAC,CAAC,8BAA8B,CAAC,CAAC,CAAC;;;;AAKlH,IAAa,aAA4B,YACvC,WAAW,KAAK,OAAO,SAAS,eAAe,WAAW,UAAU,OAAO,CAAC,CAAC;;;;AAK/E,IAAa,MAAqB,MAAS,OACzC,UAAU,QAAQ,MAAM,EAAE,CAAC;;;;;;AAO7B,IAAa,QAAuB,MAAS,YAC3C,WAAW,KAAK,OAAO,SAAS,eAAe,WAAW,KAAK,MAAM,OAAO,CAAC,CAAC;AAQhF,IAAa,uBAA0C;CAKrD,MAAM,8BAAc,IAAI,IAAwE;CAEhG,MAAM,aAAgC;EACpC,YAAY,YACV,OAAO,IAAI,aAAa;GACtB,MAAM,QAAQ,OAAO,OAAO;GAC5B,MAAM,QAAQ,YAAY,IAAI,QAAQ,KAAK,EAAE,KAAK;IAAE,MAAM,QAAQ;IAAM,0BAAU,IAAI,IAAgB;GAAE;GAIxG,UACE,MAAM,KAAK,aAAa,QAAQ,KAAK,UACrC,sBAAsB,QAAQ,KAAK,GAAG,4CACzC;IAAA,YAAA;IAAA,GAAA;IAAA,GAAA;IAAA,GAAA;IAAA,GAAA,CAAA,iDAAA,kFAAA;GAAA,CAAC;GACA,YAAY,IAAI,QAAQ,KAAK,IAAI,KAAK;GACtC,MAAM,SAAS,IAAI,OAAO;GAC1B,OAAO,MAAM,aACX,OACA,OAAO,WAAW;IAChB,MAAM,SAAS,OAAO,OAAO;IAC7B,IAAI,MAAM,SAAS,SAAS,GAC1B,YAAY,OAAO,QAAQ,KAAK,EAAE;GAEtC,CAAC,CACH;EACF,CAAC;EACH,OAAO,MAAM,YACX,OAAO,IAAI,aAAa;GACtB,MAAM,WAAW,YAAY,IAAI,KAAK,EAAE,CAAC,EAAE;GAC3C,IAAI,aAAa,KAAA,GACf;GAEF,MAAM,WAAW,MAAM,KAAK,WAAW,UAAU,MAAM,QAAQ,OAAO,CAAC;GACvE,IAAI,KAAK,aAAa,UACpB,OAAO,OAAO,QAAQ,WAAW,WAAW,QAAQ,EAAE,SAAS,KAAK,CAAC;QAErE,OAAO,OAAO,IAAI,UAAU;IAAE,aAAa;IAAa,SAAS;GAAK,CAAC;EAE3E,CAAC,CAAC,CAAC,KAAK,OAAO,eAAe,YAAY,UAAU,CAAC;CACzD;CAEA,OAAO;AACT;;;;AAKA,IAAa,kBAA2C,MAAM,KAAK,YAAY,cAAc"}

package/dist/lib/Performance.mjs

@@ -0,0 +1,80 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import * as Effect from "effect/Effect";
+//#region src/Performance.ts
+var Performance_exports = /* @__PURE__ */ __exportAll({
+	TRACK_ENTRIES_ENABLED: () => TRACK_ENTRIES_ENABLED,
+	addTrackEntry: () => addTrackEntry,
+	summarizeDetail: () => summarizeDetail,
+	trackEntry: () => trackEntry
+});
+/**
+* Whether track entries reach the performance timeline: on under the dev server, off in a production
+* build unless it was made with `VITE_PERF_TRACK_ENTRIES=true`. The bundler folds the constant, so a
+* gated call site costs nothing in a build that has it off.
+*
+* Entries are not free. `performance.measure` structured-clones `detail` on every call and keeps every
+* entry for the life of the realm, so a per-query entry carrying bound parameters was the largest
+* allocating mechanism in a Composer tab once the log store's sweep was fixed.
+*/
+var TRACK_ENTRIES_ENABLED = Boolean(false) || false;
+/** Longer strings are cut in the entry, since the clone would otherwise copy them whole. */
+var MAX_STRING_LENGTH = 256;
+var MAX_ARRAY_LENGTH = 64;
+var MAX_DEPTH = 3;
+var summarize = (value, depth) => {
+	if (typeof value === "string") return value.length > MAX_STRING_LENGTH ? `${value.slice(0, MAX_STRING_LENGTH)}…(${value.length} chars)` : value;
+	if (value instanceof Uint8Array) return `<Uint8Array ${value.length} bytes>`;
+	if (value instanceof ArrayBuffer) return `<ArrayBuffer ${value.byteLength} bytes>`;
+	if (Array.isArray(value)) {
+		if (value.length > MAX_ARRAY_LENGTH) return `<Array ${value.length} items>`;
+		return depth >= MAX_DEPTH ? `<Array ${value.length} items>` : value.map((item) => summarize(item, depth + 1));
+	}
+	if (value !== null && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+		if (depth >= MAX_DEPTH) return `<Object ${Object.keys(value).length} keys>`;
+		return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, summarize(item, depth + 1)]));
+	}
+	return value;
+};
+/**
+* Bounds a value before it goes into an entry's `detail`: a blob or long string becomes a type-and-size
+* marker, a large array a count, and nesting stops at a fixed depth. Anything with a prototype other than
+* `Object` (class instances, ECHO objects) passes through untouched, as the clone would fail on it anyway.
+*/
+var summarizeDetail = (value) => summarize(value, 0);
+/**
+* Puts one entry on the performance timeline, with `detail` and `devtools.properties` bounded by
+* {@link summarizeDetail}. A no-op unless {@link TRACK_ENTRIES_ENABLED}.
+*/
+var trackEntry = (options) => {
+	if (!TRACK_ENTRIES_ENABLED) return;
+	performance.measure(options.name, {
+		start: options.start,
+		end: options.end ?? performance.now(),
+		detail: {
+			...options.detail && summarizeDetail(options.detail),
+			devtools: options.devtools && {
+				...options.devtools,
+				properties: options.devtools.properties?.map(([key, value]) => [key, summarizeDetail(value)])
+			}
+		}
+	});
+};
+/**
+* Puts the effect span on the performance timeline in DevTools. See {@link trackEntry}.
+*/
+var addTrackEntry = (options) => (effect) => {
+	if (!TRACK_ENTRIES_ENABLED) return effect;
+	return Effect.gen(function* () {
+		const start = performance.now();
+		const exit = yield* Effect.exit(effect);
+		trackEntry({
+			start,
+			...typeof options === "function" ? options(exit) : options
+		});
+		return yield* exit;
+	});
+};
+//#endregion
+export { TRACK_ENTRIES_ENABLED, addTrackEntry, summarizeDetail, Performance_exports as t, trackEntry };
+
+//# sourceMappingURL=Performance.mjs.map

package/dist/lib/Performance.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Performance.mjs","names":[],"sources":["../../src/Performance.ts"],"sourcesContent":["//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\nimport type * as Exit from 'effect/Exit';\n\n/**\n * Whether track entries reach the performance timeline: on under the dev server, off in a production\n * build unless it was made with `VITE_PERF_TRACK_ENTRIES=true`. The bundler folds the constant, so a\n * gated call site costs nothing in a build that has it off.\n *\n * Entries are not free. `performance.measure` structured-clones `detail` on every call and keeps every\n * entry for the life of the realm, so a per-query entry carrying bound parameters was the largest\n * allocating mechanism in a Composer tab once the log store's sweep was fixed.\n */\nexport const TRACK_ENTRIES_ENABLED: boolean =\n  Boolean(import.meta.env?.DEV) || import.meta.env?.VITE_PERF_TRACK_ENTRIES === 'true';\n\n/** Longer strings are cut in the entry, since the clone would otherwise copy them whole. */\nconst MAX_STRING_LENGTH = 256;\nconst MAX_ARRAY_LENGTH = 64;\nconst MAX_DEPTH = 3;\n\nconst summarize = (value: unknown, depth: number): unknown => {\n  if (typeof value === 'string') {\n    return value.length > MAX_STRING_LENGTH ? `${value.slice(0, MAX_STRING_LENGTH)}…(${value.length} chars)` : value;\n  }\n  if (value instanceof Uint8Array) {\n    return `<Uint8Array ${value.length} bytes>`;\n  }\n  if (value instanceof ArrayBuffer) {\n    return `<ArrayBuffer ${value.byteLength} bytes>`;\n  }\n  if (Array.isArray(value)) {\n    if (value.length > MAX_ARRAY_LENGTH) {\n      return `<Array ${value.length} items>`;\n    }\n    return depth >= MAX_DEPTH ? `<Array ${value.length} items>` : value.map((item) => summarize(item, depth + 1));\n  }\n  if (value !== null && typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype) {\n    if (depth >= MAX_DEPTH) {\n      return `<Object ${Object.keys(value).length} keys>`;\n    }\n    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, summarize(item, depth + 1)]));\n  }\n  return value;\n};\n\n/**\n * Bounds a value before it goes into an entry's `detail`: a blob or long string becomes a type-and-size\n * marker, a large array a count, and nesting stops at a fixed depth. Anything with a prototype other than\n * `Object` (class instances, ECHO objects) passes through untouched, as the clone would fail on it anyway.\n */\nexport const summarizeDetail = (value: unknown): unknown => summarize(value, 0);\n\nexport interface DevtoolsOptions {\n  /**\n   * @example 'track-entry'\n   */\n  dataType: string;\n  track: string;\n  trackGroup: string;\n  /**\n   * @example 'tertiary-dark'\n   */\n  color: string;\n  properties?: [string, any][];\n  tooltipText?: string;\n}\n\nexport interface TrackEntryOptions {\n  name: string;\n  start: number;\n  /** Defaults to now. */\n  end?: number;\n  devtools?: DevtoolsOptions;\n  detail?: Record<string, unknown>;\n}\n\nexport interface AddTrackEntryOptions {\n  name: string;\n  devtools?: DevtoolsOptions;\n  detail?: Record<string, unknown>;\n}\n\n/**\n * Puts one entry on the performance timeline, with `detail` and `devtools.properties` bounded by\n * {@link summarizeDetail}. A no-op unless {@link TRACK_ENTRIES_ENABLED}.\n */\nexport const trackEntry = (options: TrackEntryOptions): void => {\n  if (!TRACK_ENTRIES_ENABLED) {\n    return;\n  }\n  performance.measure(options.name, {\n    start: options.start,\n    end: options.end ?? performance.now(),\n    detail: {\n      ...(options.detail && (summarizeDetail(options.detail) as Record<string, unknown>)),\n      devtools: options.devtools && {\n        ...options.devtools,\n        properties: options.devtools.properties?.map(([key, value]) => [key, summarizeDetail(value)]),\n      },\n    },\n  });\n};\n\n/**\n * Puts the effect span on the performance timeline in DevTools. See {@link trackEntry}.\n */\nexport const addTrackEntry =\n  <A, E>(options: AddTrackEntryOptions | ((exit: Exit.Exit<A, E>) => AddTrackEntryOptions)) =>\n  <R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => {\n    if (!TRACK_ENTRIES_ENABLED) {\n      return effect;\n    }\n    return Effect.gen(function* () {\n      const start = performance.now();\n      const exit = yield* Effect.exit(effect);\n      trackEntry({ start, ...(typeof options === 'function' ? options(exit) : options) });\n      return yield* exit;\n    });\n  };\n"],"mappings":";;;;;;;;;;;;;;;;;;AAgBA,IAAa,wBACX,QAAA,KAA4B,KAAK;;AAGnC,IAAM,oBAAoB;AAC1B,IAAM,mBAAmB;AACzB,IAAM,YAAY;AAElB,IAAM,aAAa,OAAgB,UAA2B;CAC5D,IAAI,OAAO,UAAU,UACnB,OAAO,MAAM,SAAS,oBAAoB,GAAG,MAAM,MAAM,GAAG,iBAAiB,EAAE,IAAI,MAAM,OAAO,WAAW;CAE7G,IAAI,iBAAiB,YACnB,OAAO,eAAe,MAAM,OAAO;CAErC,IAAI,iBAAiB,aACnB,OAAO,gBAAgB,MAAM,WAAW;CAE1C,IAAI,MAAM,QAAQ,KAAK,GAAG;EACxB,IAAI,MAAM,SAAS,kBACjB,OAAO,UAAU,MAAM,OAAO;EAEhC,OAAO,SAAS,YAAY,UAAU,MAAM,OAAO,WAAW,MAAM,KAAK,SAAS,UAAU,MAAM,QAAQ,CAAC,CAAC;CAC9G;CACA,IAAI,UAAU,QAAQ,OAAO,UAAU,YAAY,OAAO,eAAe,KAAK,MAAM,OAAO,WAAW;EACpG,IAAI,SAAS,WACX,OAAO,WAAW,OAAO,KAAK,KAAK,CAAC,CAAC,OAAO;EAE9C,OAAO,OAAO,YAAY,OAAO,QAAQ,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,UAAU,CAAC,KAAK,UAAU,MAAM,QAAQ,CAAC,CAAC,CAAC,CAAC;CACzG;CACA,OAAO;AACT;;;;;;AAOA,IAAa,mBAAmB,UAA4B,UAAU,OAAO,CAAC;;;;;AAoC9E,IAAa,cAAc,YAAqC;CAC9D,IAAI,CAAC,uBACH;CAEF,YAAY,QAAQ,QAAQ,MAAM;EAChC,OAAO,QAAQ;EACf,KAAK,QAAQ,OAAO,YAAY,IAAI;EACpC,QAAQ;GACN,GAAI,QAAQ,UAAW,gBAAgB,QAAQ,MAAM;GACrD,UAAU,QAAQ,YAAY;IAC5B,GAAG,QAAQ;IACX,YAAY,QAAQ,SAAS,YAAY,KAAK,CAAC,KAAK,WAAW,CAAC,KAAK,gBAAgB,KAAK,CAAC,CAAC;GAC9F;EACF;CACF,CAAC;AACH;;;;AAKA,IAAa,iBACJ,aACH,WAA2D;CAC7D,IAAI,CAAC,uBACH,OAAO;CAET,OAAO,OAAO,IAAI,aAAa;EAC7B,MAAM,QAAQ,YAAY,IAAI;EAC9B,MAAM,OAAO,OAAO,OAAO,KAAK,MAAM;EACtC,WAAW;GAAE;GAAO,GAAI,OAAO,YAAY,aAAa,QAAQ,IAAI,IAAI;EAAS,CAAC;EAClF,OAAO,OAAO;CAChB,CAAC;AACH"}

package/dist/lib/RuntimeProvider.mjs

@@ -0,0 +1,43 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { n as makeGlobalTracer } from "./chunk-otel.mjs";
+import { n as runAndForwardErrors, s as unwrapExit } from "./chunk-errors.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Context from "effect/Context";
+import * as Tracer from "effect/Tracer";
+//#region src/RuntimeProvider.ts
+var RuntimeProvider_exports = /* @__PURE__ */ __exportAll({
+	currentRuntime: () => currentRuntime,
+	provide: () => provide,
+	runPromise: () => runPromise,
+	toLayer: () => toLayer
+});
+var defaultTracer;
+var withDefaultTracer = (context) => {
+	defaultTracer ??= Context.make(Tracer.Tracer, makeGlobalTracer("@dxos/effect/RuntimeProvider"));
+	return Context.merge(defaultTracer, context);
+};
+/**
+* Bridges a runtime provider into a {@link Layer} exposing its services, so a stack that resolves
+* dependencies via `RuntimeProvider.currentRuntime` can be provided from an existing runtime.
+*/
+var toLayer = (provider) => Layer.effectContext(provider);
+/**
+* @returns Runtime provider from the current context.
+*/
+var currentRuntime = () => Effect.context().pipe(Effect.map(Effect.succeed));
+/**
+* Run effect, within runtime, clean errors and fix stack-traces.
+*/
+var runPromise = (provider) => async (effect) => {
+	const context = await runAndForwardErrors(provider);
+	return unwrapExit(await Effect.runPromiseExit(Effect.provideContext(effect, withDefaultTracer(context))));
+};
+/**
+* Provide services from runtime provider to effect.
+*/
+var provide = (runtimeProvider) => (effect) => Effect.flatMap(runtimeProvider, (context) => Effect.provideContext(effect, withDefaultTracer(context)));
+//#endregion
+export { currentRuntime, provide, runPromise, RuntimeProvider_exports as t, toLayer };
+
+//# sourceMappingURL=RuntimeProvider.mjs.map

package/dist/lib/RuntimeProvider.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeProvider.mjs","names":[],"sources":["../../src/RuntimeProvider.ts"],"sourcesContent":["//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport * as Tracer from 'effect/Tracer';\n\nimport { runAndForwardErrors, unwrapExit } from './internal/errors.ts';\nimport { makeGlobalTracer } from './otel.ts';\n\nlet defaultTracer: Context.Context<never> | undefined;\n\nconst withDefaultTracer = <R>(context: Context.Context<R>): Context.Context<R> => {\n  defaultTracer ??= Context.make(Tracer.Tracer, makeGlobalTracer('@dxos/effect/RuntimeProvider'));\n  return Context.merge(defaultTracer, context);\n};\n\n/**\n * Provides effect runtime with services to run effects.\n *\n * Effect 4 removed the `Runtime<R>` value this used to carry -- its `Runtime` module is now only\n * about `runMain` -- so the provider yields the service context directly. That is what every\n * consumer actually used the runtime for, and it drops a layer of indirection.\n */\nexport type RuntimeProvider<R> = Effect.Effect<Context.Context<R>>;\n\n/**\n * Bridges a runtime provider into a {@link Layer} exposing its services, so a stack that resolves\n * dependencies via `RuntimeProvider.currentRuntime` can be provided from an existing runtime.\n */\nexport const toLayer = <R>(provider: RuntimeProvider<R>): Layer.Layer<R> => Layer.effectContext(provider);\n\n/**\n * @returns Runtime provider from the current context.\n */\nexport const currentRuntime = <R = never>(): Effect.Effect<RuntimeProvider<R>, never, R> =>\n  Effect.context<R>().pipe(Effect.map(Effect.succeed));\n\n/**\n * Run effect, within runtime, clean errors and fix stack-traces.\n */\nexport const runPromise =\n  <R>(provider: RuntimeProvider<R>) =>\n  async <A>(effect: Effect.Effect<A, any, R>): Promise<A> => {\n    const context = await runAndForwardErrors(provider);\n    return unwrapExit(await Effect.runPromiseExit(Effect.provideContext(effect, withDefaultTracer(context))));\n  };\n\n/**\n * Provide services from runtime provider to effect.\n */\nexport const provide: {\n  <R2>(runtime: RuntimeProvider<R2>): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, R2>>;\n} = (runtimeProvider) => (effect) =>\n  Effect.flatMap(runtimeProvider, (context) => Effect.provideContext(effect, withDefaultTracer(context)));\n"],"mappings":";;;;;;;;;;;;;;AAYA,IAAI;AAEJ,IAAM,qBAAwB,YAAoD;CAChF,kBAAkB,QAAQ,KAAK,OAAO,QAAQ,iBAAiB,8BAA8B,CAAC;CAC9F,OAAO,QAAQ,MAAM,eAAe,OAAO;AAC7C;;;;;AAeA,IAAa,WAAc,aAAiD,MAAM,cAAc,QAAQ;;;;AAKxG,IAAa,uBACX,OAAO,QAAW,CAAC,CAAC,KAAK,OAAO,IAAI,OAAO,OAAO,CAAC;;;;AAKrD,IAAa,cACP,aACJ,OAAU,WAAiD;CACzD,MAAM,UAAU,MAAM,oBAAoB,QAAQ;CAClD,OAAO,WAAW,MAAM,OAAO,eAAe,OAAO,eAAe,QAAQ,kBAAkB,OAAO,CAAC,CAAC,CAAC;AAC1G;;;;AAKF,IAAa,WAER,qBAAqB,WACxB,OAAO,QAAQ,kBAAkB,YAAY,OAAO,eAAe,QAAQ,kBAAkB,OAAO,CAAC,CAAC"}