@dxos/effect 0.10.0 → 0.11.0

package/dist/lib/node-esm/index.mjs

@@ -1,849 +0,0 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  __export
-} from "./chunk-HSLMI22Q.mjs";
-
-// src/atom-kvs.ts
-import { Atom } from "@effect-atom/atom-react";
-import * as BrowserKeyValueStore from "@effect/platform-browser/BrowserKeyValueStore";
-var defaultRuntime = Atom.runtime(BrowserKeyValueStore.layerLocalStorage);
-var createKvsStore = (options) => {
-  const runtime2 = options.runtime ?? defaultRuntime;
-  return Atom.kvs({
-    runtime: runtime2,
-    key: options.key,
-    schema: options.schema,
-    defaultValue: options.defaultValue
-  }).pipe(Atom.keepAlive);
-};
-
-// src/dynamic-runtime.ts
-var dynamic_runtime_exports = {};
-__export(dynamic_runtime_exports, {
-  make: () => make
-});
-import * as Context from "effect/Context";
-import * as Effect2 from "effect/Effect";
-import * as Exit2 from "effect/Exit";
-import * as Option2 from "effect/Option";
-import * as Runtime2 from "effect/Runtime";
-
-// src/internal/errors.ts
-import * as Cause from "effect/Cause";
-import * as Chunk from "effect/Chunk";
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as GlobalValue from "effect/GlobalValue";
-import * as Option from "effect/Option";
-import * as Runtime from "effect/Runtime";
-var spanSymbol = /* @__PURE__ */ Symbol.for("effect/SpanAnnotation");
-var spanToTrace = GlobalValue.globalValue("effect/Tracer/spanToTrace", () => /* @__PURE__ */ new WeakMap());
-var locationRegex = /\((.*)\)/g;
-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;
-};
-var causeToError = (cause) => {
-  if (Cause.isEmpty(cause)) {
-    return new Error("Fiber failed without a cause");
-  } else if (Cause.isInterruptedOnly(cause)) {
-    return new Error("Fiber was interrupted");
-  } else {
-    const errors = [
-      ...Chunk.toArray(Cause.failures(cause)),
-      ...Chunk.toArray(Cause.defects(cause))
-    ];
-    const getStackFrames = () => {
-      const err = 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);
-    }
-  }
-};
-var throwCause = (cause) => {
-  throw causeToError(cause);
-};
-var unwrapExit = (exit2) => {
-  if (Exit.isSuccess(exit2)) {
-    return exit2.value;
-  }
-  return throwCause(exit2.cause);
-};
-var runAndForwardErrors = async (effect, options) => {
-  const exit2 = await Effect.runPromiseExit(effect, options);
-  return unwrapExit(exit2);
-};
-var runPromise = runAndForwardErrors;
-var runInRuntime = (...args) => {
-  if (args.length === 1) {
-    const [runtime2] = args;
-    return async (effect, options) => {
-      const exit2 = await Runtime.runPromiseExit(runtime2, effect, options);
-      return unwrapExit(exit2);
-    };
-  } else {
-    const [runtime2, effect, options] = args;
-    return (async () => {
-      const exit2 = await Runtime.runPromiseExit(runtime2, effect, options);
-      return unwrapExit(exit2);
-    })();
-  }
-};
-var promiseWithCauseCapture = (evaluate) => Effect.promise(async (signal) => {
-  try {
-    const result = await evaluate(signal);
-    return Effect.succeed(result);
-  } catch (err) {
-    return Effect.die(err);
-  }
-}).pipe(Effect.flatten);
-
-// src/dynamic-runtime.ts
-var validateTags = (context, tags) => Effect2.gen(function* () {
-  const missingTags = [];
-  for (const tag of tags) {
-    const option = Context.getOption(context, tag);
-    if (Option2.isNone(option)) {
-      missingTags.push(tag.key);
-    }
-  }
-  if (missingTags.length > 0) {
-    return yield* Effect2.die(new Error(`Missing required tags in runtime: ${missingTags.join(", ")}`));
-  }
-});
-function make(managedRuntime, tags) {
-  const managedRuntimeAny = managedRuntime;
-  let cachedRuntime;
-  let validatedRuntimePromise;
-  const getValidatedRuntimeAsync = async () => {
-    if (!validatedRuntimePromise) {
-      validatedRuntimePromise = managedRuntimeAny.runPromise(Effect2.gen(function* () {
-        const rt = yield* managedRuntimeAny.runtimeEffect;
-        yield* validateTags(rt.context, tags);
-        return rt;
-      }));
-    }
-    return validatedRuntimePromise;
-  };
-  const getValidatedRuntime = () => {
-    const validationExit = managedRuntimeAny.runSyncExit(Effect2.gen(function* () {
-      const rt = yield* managedRuntimeAny.runtimeEffect;
-      yield* validateTags(rt.context, tags);
-      return rt;
-    }));
-    return unwrapExit(validationExit);
-  };
-  return {
-    managedRuntime: managedRuntimeAny,
-    runPromise: async (effect) => {
-      const runtime2 = await getValidatedRuntimeAsync();
-      return Runtime2.runPromise(runtime2)(effect);
-    },
-    runSync: (effect) => {
-      const runtime2 = getValidatedRuntime();
-      return Runtime2.runSync(runtime2)(effect);
-    },
-    runSyncExit: (effect) => {
-      const validationExit = managedRuntimeAny.runSyncExit(Effect2.gen(function* () {
-        const rt = yield* managedRuntimeAny.runtimeEffect;
-        yield* validateTags(rt.context, tags);
-        return rt;
-      }));
-      if (Exit2.isSuccess(validationExit)) {
-        const runtime2 = validationExit.value;
-        return Runtime2.runSyncExit(runtime2)(effect);
-      }
-      return validationExit;
-    },
-    runPromiseExit: async (effect) => {
-      try {
-        const runtime2 = await getValidatedRuntimeAsync();
-        return Runtime2.runPromiseExit(runtime2)(effect);
-      } catch (error) {
-        return Exit2.die(error);
-      }
-    },
-    runFork: (effect) => {
-      const runtime2 = getValidatedRuntime();
-      return Runtime2.runFork(runtime2)(effect);
-    },
-    runtimeEffect: Effect2.gen(function* () {
-      if (cachedRuntime) {
-        return cachedRuntime;
-      }
-      const rt = yield* managedRuntimeAny.runtimeEffect;
-      yield* validateTags(rt.context, tags);
-      const runtime2 = rt;
-      cachedRuntime = runtime2;
-      return runtime2;
-    }).pipe(Effect2.catchAll(() => (
-      // This should never happen since validateTags uses Effect.die
-      Effect2.die(new Error("Unexpected error in runtimeEffect validation"))
-    ))),
-    dispose: async () => {
-      await managedRuntimeAny.dispose();
-    }
-  };
-}
-
-// src/EffectEx.ts
-var EffectEx_exports = {};
-__export(EffectEx_exports, {
-  acquireReleaseResource: () => acquireReleaseResource,
-  asyncTaskTaggingLayer: () => asyncTaskTaggingLayer,
-  causeToError: () => causeToError,
-  contextFromScope: () => contextFromScope,
-  promiseWithCauseCapture: () => promiseWithCauseCapture,
-  runAndForwardErrors: () => runAndForwardErrors,
-  runInRuntime: () => runInRuntime,
-  runPromise: () => runPromise,
-  throwCause: () => throwCause,
-  unwrapExit: () => unwrapExit
-});
-
-// src/internal/async-task-tagging.ts
-import * as Context2 from "effect/Context";
-import * as Effect3 from "effect/Effect";
-import { pipe } from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as Predicate from "effect/Predicate";
-import * as Tracer from "effect/Tracer";
-var runInTask = /* @__PURE__ */ Symbol("runInTask");
-var asyncTaskTaggingLayer = () => {
-  if (Predicate.hasProperty(console, "createTask") === false) {
-    return Layer.empty;
-  }
-  const makeTracer = Effect3.gen(function* () {
-    const oldTracer = yield* Effect3.tracer;
-    return Tracer.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 = Context2.getOption(Tracer.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);
-      }
-    });
-  });
-  return pipe(makeTracer, Effect3.map(Layer.setTracer), Layer.unwrapEffect);
-};
-
-// src/internal/context.ts
-import * as Effect4 from "effect/Effect";
-import { Context as Context3 } from "@dxos/context";
-var contextFromScope = () => Effect4.gen(function* () {
-  const ctx = new Context3();
-  yield* Effect4.addFinalizer(() => Effect4.promise(() => ctx.dispose()));
-  return ctx;
-});
-
-// src/internal/resource.ts
-import * as Effect5 from "effect/Effect";
-var acquireReleaseResource = (getResource) => Effect5.acquireRelease(Effect5.gen(function* () {
-  const resource = getResource();
-  yield* Effect5.promise(async () => {
-    await resource.open?.();
-    return void 0;
-  });
-  return resource;
-}), (resource) => Effect5.promise(async () => {
-  await resource.close?.();
-  return void 0;
-}));
-
-// src/Performance.ts
-var Performance_exports = {};
-__export(Performance_exports, {
-  addTrackEntry: () => addTrackEntry
-});
-import * as Effect6 from "effect/Effect";
-var addTrackEntry = (options) => (effect) => Effect6.gen(function* () {
-  const start = performance.now();
-  const exit2 = yield* Effect6.exit(effect);
-  const resolvedOptions = typeof options === "function" ? options(exit2) : options;
-  performance.measure(resolvedOptions.name, {
-    start,
-    detail: {
-      ...resolvedOptions.detail,
-      devtools: resolvedOptions.devtools
-    }
-  });
-  return yield* exit2;
-});
-
-// src/RuntimeProvider.ts
-var RuntimeProvider_exports = {};
-__export(RuntimeProvider_exports, {
-  currentRuntime: () => currentRuntime,
-  provide: () => provide2,
-  runPromise: () => runPromise3
-});
-import * as Effect7 from "effect/Effect";
-import * as Runtime3 from "effect/Runtime";
-var currentRuntime = () => Effect7.runtime().pipe(Effect7.map(Effect7.succeed));
-var runPromise3 = (provider) => async (effect) => {
-  const runtime2 = await runAndForwardErrors(provider);
-  return unwrapExit(await effect.pipe(Runtime3.runPromiseExit(runtime2)));
-};
-var provide2 = (runtimeProvider) => (effect) => Effect7.flatMap(runtimeProvider, (runtime2) => Effect7.provide(effect, runtime2));
-
-// src/SchemaEx.ts
-var SchemaEx_exports = {};
-__export(SchemaEx_exports, {
-  JsonPath: () => JsonPath,
-  JsonProp: () => JsonProp,
-  ParamKeyAnnotation: () => ParamKeyAnnotation,
-  UrlParser: () => UrlParser,
-  VisitResult: () => VisitResult,
-  createJsonPath: () => createJsonPath,
-  findAnnotation: () => findAnnotation,
-  findNode: () => findNode,
-  findProperty: () => findProperty,
-  fromEffectValidationPath: () => fromEffectValidationPath,
-  getAnnotation: () => getAnnotation2,
-  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: () => isTupleType2,
-  mapAst: () => mapAst,
-  setValue: () => setValue,
-  splitJsonPath: () => splitJsonPath,
-  unwrapOptional: () => unwrapOptional,
-  visit: () => visit
-});
-
-// src/internal/ast.ts
-import * as Function from "effect/Function";
-import * as Option3 from "effect/Option";
-import * as Schema from "effect/Schema";
-import * as SchemaAST from "effect/SchemaAST";
-import { invariant } from "@dxos/invariant";
-import { isNonNullable } from "@dxos/util";
-var reduceRefinements = (type, refinements = []) => {
-  if (SchemaAST.isRefinement(type)) {
-    const filter = type.filter;
-    const nextType = {
-      ...type.from,
-      annotations: {
-        ...type.from.annotations,
-        ...type.annotations
-      }
-    };
-    return reduceRefinements(nextType, [
-      ...refinements,
-      filter
-    ]);
-  }
-  return {
-    type,
-    refinements
-  };
-};
-var getBaseType = (prop) => {
-  const encoded = SchemaAST.encodedBoundAST(prop.type);
-  const unwrapped = prop.isOptional && encoded._tag === "Union" ? encoded.types[0] : encoded;
-  return reduceRefinements(unwrapped);
-};
-var getProperties = (ast) => {
-  const properties = SchemaAST.getPropertySignatures(ast);
-  return properties.map((prop) => {
-    const { type, refinements } = getBaseType(prop);
-    const mergedType = prop.annotations && Reflect.ownKeys(prop.annotations).length > 0 ? {
-      ...type,
-      annotations: {
-        ...type.annotations,
-        ...prop.annotations
-      }
-    } : type;
-    return {
-      type: mergedType,
-      refinements,
-      name: prop.name,
-      isOptional: prop.isOptional,
-      isReadonly: prop.isReadonly
-    };
-  });
-};
-var VisitResult = /* @__PURE__ */ (function(VisitResult2) {
-  VisitResult2[VisitResult2["CONTINUE"] = 0] = "CONTINUE";
-  VisitResult2[VisitResult2["SKIP"] = 1] = "SKIP";
-  VisitResult2[VisitResult2["EXIT"] = 2] = "EXIT";
-  return VisitResult2;
-})({});
-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 result2 = visitNode(prop.type, test, visitor, currentPath, depth + 1);
-      if (result2 === 2) {
-        return result2;
-      }
-    }
-  } else if (SchemaAST.isTupleType(node)) {
-    for (const [i, element] of node.elements.entries()) {
-      const currentPath = [
-        ...path,
-        i
-      ];
-      const result2 = visitNode(element.type, test, visitor, currentPath, depth);
-      if (result2 === 2) {
-        return result2;
-      }
-    }
-  } else if (SchemaAST.isUnion(node)) {
-    for (const type of node.types) {
-      const result2 = visitNode(type, test, visitor, path, depth);
-      if (result2 === 2) {
-        return result2;
-      }
-    }
-  } else if (SchemaAST.isRefinement(node)) {
-    const result2 = visitNode(node.from, test, visitor, path, depth);
-    if (result2 === 2) {
-      return result2;
-    }
-  }
-};
-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 void 0;
-    }
-    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);
-  }
-};
-var findProperty = (schema, path) => {
-  const getProp = (node, path2) => {
-    const [name, ...rest] = path2;
-    const typeNode = findNode(node, SchemaAST.isTypeLiteral);
-    invariant(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
-};
-var getAnnotation2 = (annotationId, noDefault = true) => (node) => {
-  const id = Function.pipe(SchemaAST.getIdentifierAnnotation(node), Option3.getOrUndefined);
-  const value = Function.pipe(SchemaAST.getAnnotation(annotationId)(node), Option3.getOrUndefined);
-  if (noDefault && (value === defaultAnnotations[node._tag]?.annotations[annotationId] || value === id)) {
-    return void 0;
-  }
-  return value;
-};
-var findAnnotation = (node, annotationId, noDefault = true) => {
-  const getAnnotationById = getAnnotation2(annotationId, noDefault);
-  const getBaseAnnotation = (node2) => {
-    const value = getAnnotationById(node2);
-    if (value !== void 0) {
-      return value;
-    }
-    if (SchemaAST.isUnion(node2)) {
-      if (isOption(node2)) {
-        return getAnnotationById(node2.types[0]);
-      }
-    }
-  };
-  return getBaseAnnotation(node);
-};
-var isOption = (node) => {
-  return SchemaAST.isUnion(node) && node.types.length === 2 && SchemaAST.isUndefinedKeyword(node.types[1]);
-};
-var isLiteralUnion = (node) => {
-  return SchemaAST.isUnion(node) && node.types.every(SchemaAST.isLiteral);
-};
-var getLiteralValues = (schema) => {
-  if (!isLiteralUnion(schema.ast)) {
-    return [];
-  }
-  return schema.ast.types.map((node) => node.literal);
-};
-var isArrayType = (node) => {
-  return SchemaAST.isTupleType(node) && node.elements.length === 0 && node.rest.length === 1;
-};
-var getArrayElementType = (node) => {
-  return isArrayType(node) ? node.rest.at(0)?.type : void 0;
-};
-var isTupleType2 = (node) => {
-  return SchemaAST.isTupleType(node) && node.elements.length > 0;
-};
-var isDiscriminatedUnion = (node) => {
-  return SchemaAST.isUnion(node) && !!getDiscriminatingProps(node)?.length;
-};
-var getDiscriminatingProps = (node) => {
-  invariant(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));
-  }, []);
-};
-var getDiscriminatedType = (node, value = {}) => {
-  invariant(SchemaAST.isUnion(node));
-  invariant(value);
-  const props = getDiscriminatingProps(node);
-  if (!props?.length) {
-    return;
-  }
-  for (const type of node.types) {
-    const match = SchemaAST.getPropertySignatures(type).filter((prop) => props?.includes(prop.name.toString())).every((prop) => {
-      invariant(SchemaAST.isLiteral(prop.type));
-      return prop.type.literal === value[prop.name.toString()];
-    });
-    if (match) {
-      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));
-      return literal.type.literal;
-    }).filter(isNonNullable);
-    return literals.length ? [
-      prop,
-      Schema.Literal(...literals)
-    ] : void 0;
-  }).filter(isNonNullable));
-  const schema = Schema.Struct(fields);
-  return schema.ast;
-};
-var unwrapOptional = (property) => {
-  if (!property.isOptional || !SchemaAST.isUnion(property.type) || !isOption(property.type)) {
-    return property;
-  }
-  return property.type.types[0];
-};
-var isNestedType = (node) => {
-  return SchemaAST.isDeclaration(node) || SchemaAST.isObjectKeyword(node) || SchemaAST.isTypeLiteral(node) || // TODO(wittjosiah): Tuples are actually arrays.
-  isTupleType2(node) || isDiscriminatedUnion(node);
-};
-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 (Option3.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 [];
-};
-
-// src/internal/json-path.ts
-import * as Option4 from "effect/Option";
-import * as Schema2 from "effect/Schema";
-import { JSONPath } from "jsonpath-plus";
-import { invariant as invariant2 } from "@dxos/invariant";
-import { getDeep, setDeep } from "@dxos/util";
-var PATH_REGEX = /^($|[a-zA-Z_$][\w$]*(?:\.[a-zA-Z_$][\w$]*|\[\d+\](?:\.)?)*$)/;
-var PROP_REGEX = /^\w+$/;
-var JsonPath = Schema2.String.pipe(Schema2.pattern(PATH_REGEX)).annotations({
-  title: "JSON path",
-  description: "JSON path to a property"
-});
-var JsonProp = Schema2.NonEmptyString.pipe(Schema2.pattern(PROP_REGEX, {
-  message: () => "Property name must contain only letters, numbers, and underscores"
-}));
-var isJsonPath = (value) => {
-  return Option4.isSome(Schema2.validateOption(JsonPath)(value));
-};
-var createJsonPath = (path) => {
-  const candidatePath = path.map((p, i) => {
-    if (typeof p === "number") {
-      return `[${p}]`;
-    } else {
-      return i === 0 ? p : `.${p}`;
-    }
-  }).join("");
-  invariant2(isJsonPath(candidatePath), `Invalid JsonPath: ${candidatePath}`);
-  return candidatePath;
-};
-var fromEffectValidationPath = (effectPath) => {
-  const jsonPath = effectPath.replace(/\.\[(\d+)\]/g, "[$1]");
-  invariant2(isJsonPath(jsonPath), `Invalid JsonPath: ${jsonPath}`);
-  return jsonPath;
-};
-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;
-  }) ?? [];
-};
-var getField = (object, path) => {
-  return JSONPath({
-    path,
-    json: object
-  })[0];
-};
-var getValue = (obj, path) => {
-  return getDeep(obj, splitJsonPath(path));
-};
-var setValue = (obj, path, value) => {
-  return setDeep(obj, splitJsonPath(path), value);
-};
-
-// src/internal/url.ts
-import * as Function2 from "effect/Function";
-import * as Option5 from "effect/Option";
-import * as SchemaAST2 from "effect/SchemaAST";
-import { decamelize } from "@dxos/util";
-var ParamKeyAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/ParamKey");
-var getParamKeyAnnotation = SchemaAST2.getAnnotation(ParamKeyAnnotationId);
-var ParamKeyAnnotation = (value) => (self) => self.annotations({
-  [ParamKeyAnnotationId]: value
-});
-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 (SchemaAST2.isNumberKeyword(type.ast)) {
-          params[key] = parseInt(value);
-        } else if (SchemaAST2.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 } = Function2.pipe(getParamKeyAnnotation(field.ast), Option5.getOrElse(() => ({
-            key: decamelize(key)
-          })));
-          url.searchParams.set(serializedKey, String(value));
-        }
-      }
-    });
-    return url;
-  }
-};
-export {
-  dynamic_runtime_exports as DynamicRuntime,
-  EffectEx_exports as EffectEx,
-  Performance_exports as Performance,
-  RuntimeProvider_exports as RuntimeProvider,
-  SchemaEx_exports as SchemaEx,
-  createKvsStore
-};
-//# sourceMappingURL=index.mjs.map