@dxos/effect 0.10.0 → 0.11.0

package/dist/lib/index.mjs

@@ -0,0 +1,919 @@
+import { Atom } from "@effect-atom/atom";
+import * as BrowserKeyValueStore from "@effect/platform-browser/BrowserKeyValueStore";
+import * as Context$1 from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Option from "effect/Option";
+import * as Runtime from "effect/Runtime";
+import * as Cause from "effect/Cause";
+import * as Chunk from "effect/Chunk";
+import * as GlobalValue from "effect/GlobalValue";
+import * as Function from "effect/Function";
+import { pipe } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
+import * as Tracer$1 from "effect/Tracer";
+import { Context } from "@dxos/context";
+import * as Resource from "@effect/opentelemetry/Resource";
+import * as Tracer from "@effect/opentelemetry/Tracer";
+import { trace } from "@opentelemetry/api";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { invariant } from "@dxos/invariant";
+import { decamelize, getDeep, isNonNullable, setDeep } from "@dxos/util";
+import { JSONPath } from "jsonpath-plus";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/atom-kvs.ts
+var defaultRuntime = Atom.runtime(BrowserKeyValueStore.layerLocalStorage);
+/**
+* Creates a KVS-backed atom for structured settings using Atom.kvs.
+* The entire object is stored as a single localStorage key with JSON serialization.
+*
+* @param options.key - The localStorage key to store the value under.
+* @param options.schema - Effect Schema for the value type.
+* @param options.defaultValue - Function returning the default value.
+* @param options.runtime - Optional custom Atom runtime (defaults to localStorage).
+* @returns A writable atom that persists to localStorage.
+*
+* @idiom org.dxos.effect.kvsStore
+*   applies: Persisting a plugin's settings/config as one schema-validated localStorage blob (a global user preference set infrequently)
+*   instead-of: hand-rolled localStorage reads/writes, or scattering per-field atoms, or using this for per-context UI state
+*   uses: {@link createKvsStore}
+*   related: org.dxos.react-ui-attention.viewState
+*/
+var createKvsStore = (options) => {
+	const runtime = options.runtime ?? defaultRuntime;
+	return Atom.kvs({
+		runtime,
+		key: options.key,
+		schema: options.schema,
+		defaultValue: options.defaultValue
+	}).pipe(Atom.keepAlive);
+};
+//#endregion
+//#region src/internal/errors.ts
+var spanSymbol = Symbol.for("effect/SpanAnnotation");
+var spanToTrace = GlobalValue.globalValue("effect/Tracer/spanToTrace", () => /* @__PURE__ */ new WeakMap());
+var locationRegex = /\((.*)\)/g;
+/**
+* Adds effect spans.
+* Removes effect internal functions.
+* Unwraps error proxy.
+*/
+var prettyErrorStack = (error, appendStacks = []) => {
+	if (typeof error !== "object" || error === null) return error;
+	const span = error[spanSymbol];
+	const lines = typeof error.stack === "string" ? error.stack.split("\n") : [];
+	const out = [];
+	let atStack = false, inCore = false, passedScheduler = false;
+	for (let i = 0; i < lines.length; i++) {
+		if (!atStack && !lines[i].startsWith("    at ")) {
+			out.push(lines[i]);
+			continue;
+		}
+		atStack = true;
+		if (lines[i].includes(" at new BaseEffectError") || lines[i].includes(" at new YieldableError")) {
+			i++;
+			continue;
+		}
+		if (lines[i].includes("Generator.next")) break;
+		if (lines[i].includes("effect_internal_function")) break;
+		const filename = lines[i].match(/\/([a-zA-Z0-9_\-.]+):\d+:\d+\)$/)?.[1];
+		if (!inCore && ["core-effect.ts"].includes(filename)) inCore = true;
+		if (inCore && !passedScheduler && ["Scheduler.ts"].includes(filename)) {
+			passedScheduler = true;
+			continue;
+		}
+		if (passedScheduler && !["Scheduler.ts"].includes(filename)) inCore = false;
+		if (inCore) continue;
+		out.push(lines[i].replace(/at .*effect_instruction_i.*\((.*)\)/, "at $1").replace(/EffectPrimitive\.\w+/, "<anonymous>").replace(/at Arguments\./, "at "));
+	}
+	if (span) {
+		let current = span;
+		let i = 0;
+		while (current && current._tag === "Span" && i < 10) {
+			const stackFn = spanToTrace.get(current);
+			if (typeof stackFn === "function") {
+				const stack = stackFn();
+				if (typeof stack === "string") {
+					const locationMatchAll = stack.matchAll(locationRegex);
+					let match = false;
+					for (const [, location] of locationMatchAll) {
+						match = true;
+						out.push(`    at ${current.name} (${location})`);
+					}
+					if (!match) out.push(`    at ${current.name} (${stack.replace(/^at /, "")})`);
+				} else out.push(`    at ${current.name}`);
+			} else out.push(`    at ${current.name}`);
+			current = Option.getOrUndefined(current.parent);
+			i++;
+		}
+	}
+	out.push(...appendStacks);
+	error = Cause.originalError(error);
+	if (error.cause) error.cause = prettyErrorStack(error.cause);
+	Object.defineProperty(error, "stack", {
+		value: out.join("\n"),
+		writable: true,
+		enumerable: false,
+		configurable: true
+	});
+	return error;
+};
+/**
+* Converts a cause to an error.
+* Inserts effect spans as stack frames.
+* The error will have stack frames of where the effect was run (if stack trace limit allows).
+* Removes effect runtime internal stack frames.
+*
+* To be used in place of `Effect.runPromise`.
+*
+* @throws AggregateError if there are multiple errors.
+*/
+var causeToError = (cause) => {
+	if (Cause.isEmpty(cause)) return /* @__PURE__ */ new Error("Fiber failed without a cause");
+	else if (Cause.isInterruptedOnly(cause)) return /* @__PURE__ */ new Error("Fiber was interrupted");
+	else {
+		const errors = [...Chunk.toArray(Cause.failures(cause)), ...Chunk.toArray(Cause.defects(cause))];
+		const getStackFrames = () => {
+			const err = /* @__PURE__ */ new Error();
+			Error.captureStackTrace(err, causeToError);
+			return err.stack.split("\n").slice(1);
+		};
+		const stackFrames = getStackFrames();
+		const newErrors = errors.map((error) => prettyErrorStack(error, stackFrames));
+		if (newErrors.length === 1) return newErrors[0];
+		else return new AggregateError(newErrors);
+	}
+};
+/**
+* Throws an error based on the cause.
+* Inserts effect spans as stack frames.
+* The error will have stack frames of where the effect was run (if stack trace limit allows).
+* Removes effect runtime internal stack frames.
+*
+* To be used in place of `Effect.runPromise`.
+*
+* @throws AggregateError if there are multiple errors.
+*/
+var throwCause = (cause) => {
+	throw causeToError(cause);
+};
+var unwrapExit = (exit) => {
+	if (Exit.isSuccess(exit)) return exit.value;
+	return throwCause(exit.cause);
+};
+/**
+* Runs the embedded effect asynchronously and throws any failures and defects as errors.
+* Inserts effect spans as stack frames.
+* The error will have stack frames of where the effect was run (if stack trace limit allows).
+* Removes effect runtime internal stack frames.
+*
+* To be used in place of `Effect.runPromise`.
+*
+* @throws AggregateError if there are multiple errors.
+*/
+var runAndForwardErrors = async (effect, options) => {
+	return unwrapExit(await Effect.runPromiseExit(effect, options));
+};
+/** Alias for {@link runAndForwardErrors} — preferred name when accessed via `EffectEx.runPromise`. */
+var runPromise$1 = runAndForwardErrors;
+/**
+* Runs the embedded effect asynchronously and throws any failures and defects as errors.
+*/
+var runInRuntime = (...args) => {
+	if (args.length === 1) {
+		const [runtime] = args;
+		return async (effect, options) => {
+			return unwrapExit(await Runtime.runPromiseExit(runtime, effect, options));
+		};
+	} else {
+		const [runtime, effect, options] = args;
+		return (async () => {
+			return unwrapExit(await Runtime.runPromiseExit(runtime, effect, options));
+		})();
+	}
+};
+//#endregion
+//#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$1.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.runtimeEffect;
+			yield* validateTags(rt.context, tags);
+			return rt;
+		}));
+		return validatedRuntimePromise;
+	};
+	const getValidatedRuntime = () => {
+		return unwrapExit(managedRuntimeAny.runSyncExit(Effect.gen(function* () {
+			const rt = yield* managedRuntimeAny.runtimeEffect;
+			yield* validateTags(rt.context, tags);
+			return rt;
+		})));
+	};
+	return {
+		managedRuntime: managedRuntimeAny,
+		runPromise: async (effect) => {
+			const runtime = await getValidatedRuntimeAsync();
+			return Runtime.runPromise(runtime)(effect);
+		},
+		runSync: (effect) => {
+			const runtime = getValidatedRuntime();
+			return Runtime.runSync(runtime)(effect);
+		},
+		runSyncExit: (effect) => {
+			const validationExit = managedRuntimeAny.runSyncExit(Effect.gen(function* () {
+				const rt = yield* managedRuntimeAny.runtimeEffect;
+				yield* validateTags(rt.context, tags);
+				return rt;
+			}));
+			if (Exit.isSuccess(validationExit)) {
+				const runtime = validationExit.value;
+				return Runtime.runSyncExit(runtime)(effect);
+			}
+			return validationExit;
+		},
+		runPromiseExit: async (effect) => {
+			try {
+				const runtime = await getValidatedRuntimeAsync();
+				return Runtime.runPromiseExit(runtime)(effect);
+			} catch (error) {
+				return Exit.die(error);
+			}
+		},
+		runFork: (effect) => {
+			const runtime = getValidatedRuntime();
+			return Runtime.runFork(runtime)(effect);
+		},
+		runtimeEffect: Effect.gen(function* () {
+			if (cachedRuntime) return cachedRuntime;
+			const rt = yield* managedRuntimeAny.runtimeEffect;
+			yield* validateTags(rt.context, tags);
+			const runtime = rt;
+			cachedRuntime = runtime;
+			return runtime;
+		}).pipe(Effect.catchAll(() => Effect.die(/* @__PURE__ */ new Error("Unexpected error in runtimeEffect validation")))),
+		dispose: async () => {
+			await managedRuntimeAny.dispose();
+		}
+	};
+}
+//#endregion
+//#region src/internal/async-task-tagging.ts
+var runInTask = Symbol("runInTask");
+/**
+* Traces effect frames using console.createTask so that the proper stack-trace is visible in Chrome Devtools debugger.
+*/
+var asyncTaskTaggingLayer = () => {
+	if (Predicate.hasProperty(console, "createTask") === false) return Layer.empty;
+	return pipe(Effect.gen(function* () {
+		const oldTracer = yield* Effect.tracer;
+		return Tracer$1.make({
+			span: (name, ...args) => {
+				const span = oldTracer.span(name, ...args);
+				const trace = console.createTask(name);
+				span[runInTask] = (f) => trace.run(f);
+				return span;
+			},
+			context: (f, fiber) => {
+				const maybeParentSpan = Context$1.getOption(Tracer$1.ParentSpan)(fiber.currentContext);
+				if (maybeParentSpan._tag === "None") return oldTracer.context(f, fiber);
+				const parentSpan = maybeParentSpan.value;
+				if (parentSpan._tag === "ExternalSpan") return oldTracer.context(f, fiber);
+				const span = parentSpan;
+				if (runInTask in span && typeof span[runInTask] === "function") return span[runInTask](() => oldTracer.context(f, fiber));
+				return oldTracer.context(f, fiber);
+			}
+		});
+	}), Effect.map(Layer.setTracer), Layer.unwrapEffect);
+};
+//#endregion
+//#region src/internal/context.ts
+var __dxlog_file$2 = "/__w/dxos/dxos/packages/common/effect/src/internal/context.ts";
+var contextFromScope = () => Effect.gen(function* () {
+	const ctx = new Context(void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$2,
+		L: 13
+	});
+	yield* Effect.addFinalizer(() => Effect.promise(() => ctx.dispose()));
+	return ctx;
+});
+//#endregion
+//#region src/internal/resource.ts
+/**
+* Acquires a resource and releases it when the scope is closed.
+*/
+var acquireReleaseResource = (getResource) => Effect.acquireRelease(Effect.gen(function* () {
+	const resource = getResource();
+	yield* Effect.promise(async () => {
+		await resource.open?.();
+	});
+	return resource;
+}), (resource) => Effect.promise(async () => {
+	await resource.close?.();
+}));
+//#endregion
+//#region src/EffectEx.ts
+var EffectEx_exports = /* @__PURE__ */ __exportAll({
+	acquireReleaseResource: () => acquireReleaseResource,
+	asyncTaskTaggingLayer: () => asyncTaskTaggingLayer,
+	causeToError: () => causeToError,
+	contextFromScope: () => contextFromScope,
+	runAndForwardErrors: () => runAndForwardErrors,
+	runInRuntime: () => runInRuntime,
+	runPromise: () => runPromise$1,
+	throwCause: () => throwCause,
+	unwrapExit: () => unwrapExit
+});
+//#endregion
+//#region src/otel.ts
+var layerOtel = (evaluate) => Layer.unwrapEffect(Effect.map(Effect.isEffect(evaluate) ? evaluate : Effect.sync(evaluate), (config) => {
+	const ResourceLive = Resource.layerFromEnv(config.resource && Resource.configToAttributes(config.resource));
+	const provider = trace.getTracerProvider();
+	const TracerLive = Layer.provide(Tracer.layer, Layer.succeed(Tracer.OtelTracerProvider, provider));
+	const MetricsLive = Layer.empty;
+	const LoggerLive = Layer.empty;
+	return Layer.mergeAll(TracerLive, MetricsLive, LoggerLive).pipe(Layer.provideMerge(ResourceLive));
+}));
+//#endregion
+//#region src/Performance.ts
+var Performance_exports = /* @__PURE__ */ __exportAll({ addTrackEntry: () => addTrackEntry });
+/**
+* Puts the effect span on the performance timeline in DevTools.
+*/
+var addTrackEntry = (options) => (effect) => Effect.gen(function* () {
+	const start = performance.now();
+	const exit = yield* Effect.exit(effect);
+	const resolvedOptions = typeof options === "function" ? options(exit) : options;
+	performance.measure(resolvedOptions.name, {
+		start,
+		detail: {
+			...resolvedOptions.detail,
+			devtools: resolvedOptions.devtools
+		}
+	});
+	return yield* exit;
+});
+//#endregion
+//#region src/RuntimeProvider.ts
+var RuntimeProvider_exports = /* @__PURE__ */ __exportAll({
+	currentRuntime: () => currentRuntime,
+	provide: () => provide,
+	runPromise: () => runPromise,
+	toLayer: () => toLayer
+});
+/**
+* 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(Effect.map(provider, (runtime) => runtime.context));
+/**
+* @returns Runtime provider from the current context.
+*/
+var currentRuntime = () => Effect.runtime().pipe(Effect.map(Effect.succeed));
+/**
+* Run effect, within runitme, clean errors and fix stack-traces.
+*/
+var runPromise = (provider) => async (effect) => {
+	const runtime = await runAndForwardErrors(provider);
+	return unwrapExit(await effect.pipe(Runtime.runPromiseExit(runtime)));
+};
+/**
+* Provide services from runtime provider to effect.
+*/
+var provide = (runtimeProvider) => (effect) => Effect.flatMap(runtimeProvider, (runtime) => Effect.provide(effect, runtime));
+//#endregion
+//#region src/internal/ast.ts
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/common/effect/src/internal/ast.ts";
+/**
+* Unwraps and collects refinement filters.
+*/
+var reduceRefinements = (type, refinements = []) => {
+	if (SchemaAST.isRefinement(type)) {
+		const filter = type.filter;
+		return reduceRefinements({
+			...type.from,
+			annotations: {
+				...type.from.annotations,
+				...type.annotations
+			}
+		}, [...refinements, filter]);
+	}
+	return {
+		type,
+		refinements
+	};
+};
+/**
+* Get the base type of a property.
+*
+* Unwraps refinements and optional unions.
+*/
+var getBaseType = (prop) => {
+	const encoded = SchemaAST.encodedBoundAST(prop.type);
+	return reduceRefinements(prop.isOptional && encoded._tag === "Union" ? encoded.types[0] : encoded);
+};
+/**
+* Get the property types of an AST.
+*/
+var getProperties = (ast) => {
+	return SchemaAST.getPropertySignatures(ast).map((prop) => {
+		const { type, refinements } = getBaseType(prop);
+		return {
+			type: prop.annotations && Reflect.ownKeys(prop.annotations).length > 0 ? {
+				...type,
+				annotations: {
+					...type.annotations,
+					...prop.annotations
+				}
+			} : type,
+			refinements,
+			name: prop.name,
+			isOptional: prop.isOptional,
+			isReadonly: prop.isReadonly
+		};
+	});
+};
+var VisitResult = /* @__PURE__ */ function(VisitResult) {
+	VisitResult[VisitResult["CONTINUE"] = 0] = "CONTINUE";
+	/**
+	* Skip visiting children.
+	*/
+	VisitResult[VisitResult["SKIP"] = 1] = "SKIP";
+	/**
+	* Stop traversing immediately.
+	*/
+	VisitResult[VisitResult["EXIT"] = 2] = "EXIT";
+	return VisitResult;
+}({});
+/**
+* Visit leaf nodes.
+* Refs:
+* - https://github.com/syntax-tree/unist-util-visit?tab=readme-ov-file#visitor
+* - https://github.com/syntax-tree/unist-util-is?tab=readme-ov-file#test
+*/
+var visit = (node, testOrVisitor, visitor) => {
+	visitNode(node, testOrVisitor, visitor);
+};
+var visitNode = (node, test, visitor, path = [], depth = 0) => {
+	const $result = test?.(node, path, depth);
+	const result = $result === void 0 ? 0 : typeof $result === "boolean" ? $result ? 0 : 1 : $result;
+	if (result === 2) return result;
+	if (result !== 1) visitor(node, path, depth);
+	if (SchemaAST.isTypeLiteral(node)) for (const prop of SchemaAST.getPropertySignatures(node)) {
+		const currentPath = [...path, prop.name.toString()];
+		const result = visitNode(prop.type, test, visitor, currentPath, depth + 1);
+		if (result === 2) return result;
+	}
+	else if (SchemaAST.isTupleType(node)) for (const [i, element] of node.elements.entries()) {
+		const currentPath = [...path, i];
+		const result = visitNode(element.type, test, visitor, currentPath, depth);
+		if (result === 2) return result;
+	}
+	else if (SchemaAST.isUnion(node)) for (const type of node.types) {
+		const result = visitNode(type, test, visitor, path, depth);
+		if (result === 2) return result;
+	}
+	else if (SchemaAST.isRefinement(node)) {
+		const result = visitNode(node.from, test, visitor, path, depth);
+		if (result === 2) return result;
+	}
+};
+/**
+* Recursively descend into AST to find first node that passes the test.
+*/
+var findNode = (node, test) => {
+	if (test(node)) return node;
+	else if (SchemaAST.isTypeLiteral(node)) {
+		for (const prop of SchemaAST.getPropertySignatures(node)) {
+			const child = findNode(prop.type, test);
+			if (child) return child;
+		}
+		for (const prop of getIndexSignatures(node)) {
+			const child = findNode(prop.type, test);
+			if (child) return child;
+		}
+	} else if (SchemaAST.isTupleType(node)) for (const [_, element] of node.elements.entries()) {
+		const child = findNode(element.type, test);
+		if (child) return child;
+	}
+	else if (SchemaAST.isUnion(node)) {
+		if (isLiteralUnion(node)) return;
+		for (const type of node.types) {
+			const child = findNode(type, test);
+			if (child) return child;
+		}
+	} else if (SchemaAST.isRefinement(node)) return findNode(node.from, test);
+};
+/**
+* Get the AST node for the given property (dot-path).
+*/
+var findProperty = (schema, path) => {
+	const getProp = (node, path) => {
+		const [name, ...rest] = path;
+		const typeNode = findNode(node, SchemaAST.isTypeLiteral);
+		invariant(typeNode, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 247,
+			S: void 0,
+			A: ["typeNode", ""]
+		});
+		for (const prop of SchemaAST.getPropertySignatures(typeNode)) if (prop.name === name) if (rest.length) return getProp(prop.type, rest);
+		else return prop.type;
+	};
+	return getProp(schema.ast, path.split("."));
+};
+var defaultAnnotations = {
+	ObjectKeyword: SchemaAST.objectKeyword,
+	StringKeyword: SchemaAST.stringKeyword,
+	NumberKeyword: SchemaAST.numberKeyword,
+	BooleanKeyword: SchemaAST.booleanKeyword
+};
+/**
+* Get annotation or return undefined.
+* @param annotationId
+* @param noDefault If true, then return undefined for effect library defined values.
+*/
+var getAnnotation = (annotationId, noDefault = true) => (node) => {
+	const id = Function.pipe(SchemaAST.getIdentifierAnnotation(node), Option.getOrUndefined);
+	const value = Function.pipe(SchemaAST.getAnnotation(annotationId)(node), Option.getOrUndefined);
+	if (noDefault && (value === defaultAnnotations[node._tag]?.annotations[annotationId] || value === id)) return;
+	return value;
+};
+/**
+* Recursively descend into AST to find first matching annotations.
+* Optionally skips default annotations for basic types (e.g., 'a string').
+*/
+var findAnnotation = (node, annotationId, noDefault = true) => {
+	const getAnnotationById = getAnnotation(annotationId, noDefault);
+	const getBaseAnnotation = (node) => {
+		const value = getAnnotationById(node);
+		if (value !== void 0) return value;
+		if (SchemaAST.isUnion(node)) {
+			if (isOption(node)) return getAnnotationById(node.types[0]);
+		}
+	};
+	return getBaseAnnotation(node);
+};
+/**
+* Effect Schema.optional creates a union type with undefined as the second type.
+*/
+var isOption = (node) => {
+	return SchemaAST.isUnion(node) && node.types.length === 2 && SchemaAST.isUndefinedKeyword(node.types[1]);
+};
+/**
+* Determines if the node is a union of literal types.
+*/
+var isLiteralUnion = (node) => {
+	return SchemaAST.isUnion(node) && node.types.every(SchemaAST.isLiteral);
+};
+/**
+* Extracts the literal values from a schema that is a union of literals
+* (e.g. `Schema.Literal('a', 'b')` or `Schema.Union(Schema.Literal('a'), Schema.Literal('b'))`).
+* Returns an empty array if the schema is not a literal union.
+*/
+var getLiteralValues = (schema) => {
+	if (!isLiteralUnion(schema.ast)) return [];
+	return schema.ast.types.map((node) => node.literal);
+};
+/**
+* Determines if the node is an array type.
+*/
+var isArrayType = (node) => {
+	return SchemaAST.isTupleType(node) && node.elements.length === 0 && node.rest.length === 1;
+};
+/**
+* Get the type of the array elements.
+*/
+var getArrayElementType = (node) => {
+	return isArrayType(node) ? node.rest.at(0)?.type : void 0;
+};
+/**
+* Determines if the node is a tuple type.
+*/
+var isTupleType = (node) => {
+	return SchemaAST.isTupleType(node) && node.elements.length > 0;
+};
+/**
+* Determines if the node is a discriminated union.
+*/
+var isDiscriminatedUnion = (node) => {
+	return SchemaAST.isUnion(node) && !!getDiscriminatingProps(node)?.length;
+};
+/**
+* Get the discriminating properties for the given union type.
+*/
+var getDiscriminatingProps = (node) => {
+	invariant(SchemaAST.isUnion(node), void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$1,
+		L: 379,
+		S: void 0,
+		A: ["SchemaAST.isUnion(node)", ""]
+	});
+	if (isOption(node)) return;
+	return node.types.reduce((shared, type) => {
+		const props = SchemaAST.getPropertySignatures(type).filter((p) => SchemaAST.isLiteral(p.type)).map((p) => p.name.toString());
+		return shared.length === 0 ? props : shared.filter((prop) => props.includes(prop));
+	}, []);
+};
+/**
+* Get the discriminated type for the given value.
+*/
+var getDiscriminatedType = (node, value = {}) => {
+	invariant(SchemaAST.isUnion(node), void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$1,
+		L: 403,
+		S: void 0,
+		A: ["SchemaAST.isUnion(node)", ""]
+	});
+	invariant(value, void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$1,
+		L: 404,
+		S: void 0,
+		A: ["value", ""]
+	});
+	const props = getDiscriminatingProps(node);
+	if (!props?.length) return;
+	for (const type of node.types) if (SchemaAST.getPropertySignatures(type).filter((prop) => props?.includes(prop.name.toString())).every((prop) => {
+		invariant(SchemaAST.isLiteral(prop.type), void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 415,
+			S: void 0,
+			A: ["SchemaAST.isLiteral(prop.type)", ""]
+		});
+		return prop.type.literal === value[prop.name.toString()];
+	})) return type;
+	const fields = Object.fromEntries(props.map((prop) => {
+		const literals = node.types.map((type) => {
+			const literal = SchemaAST.getPropertySignatures(type).find((p) => p.name.toString() === prop);
+			invariant(SchemaAST.isLiteral(literal.type), void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 433,
+				S: void 0,
+				A: ["SchemaAST.isLiteral(literal.type)", ""]
+			});
+			return literal.type.literal;
+		}).filter(isNonNullable);
+		return literals.length ? [prop, Schema.Literal(...literals)] : void 0;
+	}).filter(isNonNullable));
+	return Schema.Struct(fields).ast;
+};
+/**
+* If a property signature is optional (T | undefined), returns the inner non-undefined AST node.
+* Otherwise returns the property signature unchanged, preserving its annotations.
+*/
+var unwrapOptional = (property) => {
+	if (!property.isOptional || !SchemaAST.isUnion(property.type) || !isOption(property.type)) return property;
+	return property.type.types[0];
+};
+/**
+* Determines if the node is a nested object type.
+*/
+var isNestedType = (node) => {
+	return SchemaAST.isDeclaration(node) || SchemaAST.isObjectKeyword(node) || SchemaAST.isTypeLiteral(node) || isTupleType(node) || isDiscriminatedUnion(node);
+};
+/**
+* Maps AST nodes.
+* The user is responsible for recursively calling {@link mapAst} on the SchemaAST.
+* NOTE: Will evaluate suspended ASTs.
+*/
+var mapAst = (ast, f) => {
+	switch (ast._tag) {
+		case "TypeLiteral": return new SchemaAST.TypeLiteral(ast.propertySignatures.map((prop) => new SchemaAST.PropertySignature(prop.name, f(prop.type, prop.name), prop.isOptional, prop.isReadonly, prop.annotations)), ast.indexSignatures, ast.annotations);
+		case "Union": return SchemaAST.Union.make(ast.types.map(f), ast.annotations);
+		case "TupleType": return new SchemaAST.TupleType(ast.elements.map((t, index) => new SchemaAST.OptionalType(f(t.type, index), t.isOptional, t.annotations)), ast.rest.map((t) => new SchemaAST.Type(f(t.type, void 0), t.annotations)), ast.isReadonly, ast.annotations);
+		case "Suspend": {
+			const newAst = f(ast.f(), void 0);
+			return new SchemaAST.Suspend(() => newAst, ast.annotations);
+		}
+		default: return ast;
+	}
+};
+var getIndexSignatures = (ast) => {
+	const annotation = SchemaAST.getSurrogateAnnotation(ast);
+	if (Option.isSome(annotation)) return getIndexSignatures(annotation.value);
+	switch (ast._tag) {
+		case "TypeLiteral": return ast.indexSignatures.slice();
+		case "Suspend": return getIndexSignatures(ast.f());
+		case "Refinement": return getIndexSignatures(ast.from);
+	}
+	return [];
+};
+//#endregion
+//#region src/internal/json-path.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/common/effect/src/internal/json-path.ts";
+var PATH_REGEX = /^($|[a-zA-Z_$][\w$]*(?:\.[a-zA-Z_$][\w$]*|\[\d+\](?:\.)?)*$)/;
+var PROP_REGEX = /^\w+$/;
+/**
+* https://www.ietf.org/archive/id/draft-goessner-dispatch-jsonpath-00.html
+*/
+var JsonPath = Schema.String.pipe(Schema.pattern(PATH_REGEX)).annotations({
+	title: "JSON path",
+	description: "JSON path to a property"
+});
+var JsonProp = Schema.NonEmptyString.pipe(Schema.pattern(PROP_REGEX, { message: () => "Property name must contain only letters, numbers, and underscores" }));
+var isJsonPath = (value) => {
+	return Option.isSome(Schema.validateOption(JsonPath)(value));
+};
+/**
+* Creates a JsonPath from an array of path segments.
+*
+* Currently supports:
+* - Simple property access (e.g., 'foo.bar')
+* - Array indexing with non-negative integers (e.g., 'foo[0]')
+* - Identifiers starting with letters, underscore, or $ (e.g., '$foo', '_bar')
+* - Dot notation for nested properties (e.g., 'foo.bar.baz')
+*
+* Does not support (yet?).
+* - Recursive descent (..)
+* - Wildcards (*)
+* - Array slicing
+* - Filters
+* - Negative indices
+*
+* @param path Array of string or number segments
+* @returns Valid JsonPath or undefined if invalid
+*/
+var createJsonPath = (path) => {
+	const candidatePath = path.map((p, i) => {
+		if (typeof p === "number") return `[${p}]`;
+		else return i === 0 ? p : `.${p}`;
+	}).join("");
+	invariant(isJsonPath(candidatePath), `Invalid JsonPath: ${candidatePath}`, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 69,
+		S: void 0,
+		A: ["isJsonPath(candidatePath)", "`Invalid JsonPath: ${candidatePath}`"]
+	});
+	return candidatePath;
+};
+/**
+* Converts Effect validation path format (e.g. "addresses.[0].zip")
+* to JsonPath format (e.g., "addresses[0].zip")
+*/
+var fromEffectValidationPath = (effectPath) => {
+	const jsonPath = effectPath.replace(/\.\[(\d+)\]/g, "[$1]");
+	invariant(isJsonPath(jsonPath), `Invalid JsonPath: ${jsonPath}`, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 80,
+		S: void 0,
+		A: ["isJsonPath(jsonPath)", "`Invalid JsonPath: ${jsonPath}`"]
+	});
+	return jsonPath;
+};
+/**
+* Splits a JsonPath into its constituent parts.
+* Handles property access and array indexing.
+*/
+var splitJsonPath = (path) => {
+	if (!isJsonPath(path)) return [];
+	return path.match(/[a-zA-Z_$][\w$]*|\[\d+\]/g)?.map((part) => part.replace(/[[\]]/g, "")).map((part) => {
+		const parsed = Number.parseInt(part, 10);
+		return Number.isNaN(parsed) ? part : parsed;
+	}) ?? [];
+};
+/**
+* Applies a JsonPath to an object.
+*/
+var getField = (object, path) => {
+	return JSONPath({
+		path,
+		json: object
+	})[0];
+};
+/**
+* Get value from object using JsonPath.
+*/
+var getValue = (obj, path) => {
+	return getDeep(obj, splitJsonPath(path));
+};
+/**
+* Set value on object using JsonPath.
+*/
+var setValue = (obj, path, value) => {
+	return setDeep(obj, splitJsonPath(path), value);
+};
+//#endregion
+//#region src/internal/url.ts
+var ParamKeyAnnotationId = Symbol.for("@dxos/schema/annotation/ParamKey");
+var getParamKeyAnnotation = SchemaAST.getAnnotation(ParamKeyAnnotationId);
+var ParamKeyAnnotation = (value) => (self) => self.annotations({ [ParamKeyAnnotationId]: value });
+/**
+* HTTP params parser.
+* Supports custom key serialization.
+*/
+var UrlParser = class {
+	_schema;
+	constructor(_schema) {
+		this._schema = _schema;
+	}
+	/**
+	* Parse URL params.
+	*/
+	parse(_url) {
+		const url = new URL(_url);
+		return Object.entries(this._schema.fields).reduce((params, [key, type]) => {
+			let value = url.searchParams.get(decamelize(key));
+			if (value == null) value = url.searchParams.get(key);
+			if (value != null) if (SchemaAST.isNumberKeyword(type.ast)) params[key] = parseInt(value);
+			else if (SchemaAST.isBooleanKeyword(type.ast)) params[key] = value === "true" || value === "1";
+			else params[key] = value;
+			return params;
+		}, {});
+	}
+	/**
+	* Return URL with encoded params.
+	*/
+	create(_url, params) {
+		const url = new URL(_url);
+		Object.entries(params).forEach(([key, value]) => {
+			if (value !== void 0) {
+				const field = this._schema.fields[key];
+				if (field) {
+					const { key: serializedKey } = Function.pipe(getParamKeyAnnotation(field.ast), Option.getOrElse(() => ({ key: decamelize(key) })));
+					url.searchParams.set(serializedKey, String(value));
+				}
+			}
+		});
+		return url;
+	}
+};
+//#endregion
+//#region src/SchemaEx.ts
+var SchemaEx_exports = /* @__PURE__ */ __exportAll({
+	JsonPath: () => JsonPath,
+	JsonProp: () => JsonProp,
+	ParamKeyAnnotation: () => ParamKeyAnnotation,
+	UrlParser: () => UrlParser,
+	VisitResult: () => VisitResult,
+	createJsonPath: () => createJsonPath,
+	findAnnotation: () => findAnnotation,
+	findNode: () => findNode,
+	findProperty: () => findProperty,
+	fromEffectValidationPath: () => fromEffectValidationPath,
+	getAnnotation: () => getAnnotation,
+	getArrayElementType: () => getArrayElementType,
+	getBaseType: () => getBaseType,
+	getDiscriminatedType: () => getDiscriminatedType,
+	getDiscriminatingProps: () => getDiscriminatingProps,
+	getField: () => getField,
+	getLiteralValues: () => getLiteralValues,
+	getParamKeyAnnotation: () => getParamKeyAnnotation,
+	getProperties: () => getProperties,
+	getValue: () => getValue,
+	isArrayType: () => isArrayType,
+	isDiscriminatedUnion: () => isDiscriminatedUnion,
+	isJsonPath: () => isJsonPath,
+	isLiteralUnion: () => isLiteralUnion,
+	isNestedType: () => isNestedType,
+	isOption: () => isOption,
+	isTupleType: () => isTupleType,
+	mapAst: () => mapAst,
+	setValue: () => setValue,
+	splitJsonPath: () => splitJsonPath,
+	unwrapOptional: () => unwrapOptional,
+	visit: () => visit
+});
+//#endregion
+export { dynamic_runtime_exports as DynamicRuntime, EffectEx_exports as EffectEx, Performance_exports as Performance, RuntimeProvider_exports as RuntimeProvider, SchemaEx_exports as SchemaEx, createKvsStore, layerOtel };
+
+//# sourceMappingURL=index.mjs.map