@dxos/effect 0.8.4-main.b97322e → 0.8.4-main.bc2380dfbc

package/dist/lib/browser/index.mjs

@@ -1,70 +1,72 @@
 import "@dxos/node-std/globals";
+import {
+  __export
+} from "./chunk-CGS2ULMK.mjs";
 
 // src/ast.ts
-import { Option, pipe, SchemaAST, Schema } from "effect";
-import { isUndefinedKeyword } from "effect/SchemaAST";
+import * as Function from "effect/Function";
+import * as Option 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 __dxlog_file = "/__w/dxos/dxos/packages/common/effect/src/ast.ts";
-var getSimpleType = (node) => {
-  if (SchemaAST.isDeclaration(node) || SchemaAST.isObjectKeyword(node) || SchemaAST.isTypeLiteral(node) || isDiscriminatedUnion(node)) {
-    return "object";
-  }
-  if (SchemaAST.isStringKeyword(node)) {
-    return "string";
-  }
-  if (SchemaAST.isNumberKeyword(node)) {
-    return "number";
-  }
-  if (SchemaAST.isBooleanKeyword(node)) {
-    return "boolean";
-  }
-  if (SchemaAST.isEnums(node)) {
-    return "enum";
-  }
-  if (SchemaAST.isLiteral(node)) {
-    return "literal";
+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 isSimpleType = (node) => !!getSimpleType(node);
-(function(SimpleType2) {
-  SimpleType2.getDefaultValue = (type) => {
-    switch (type) {
-      case "string": {
-        return "";
-      }
-      case "number": {
-        return 0;
-      }
-      case "boolean": {
-        return false;
-      }
-      case "object": {
-        return {};
-      }
-      default: {
-        throw new Error(`Unsupported type for default value: ${type}`);
+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
       }
-    }
-  };
-})(SimpleType || (SimpleType = {}));
-var VisitResult = /* @__PURE__ */ function(VisitResult2) {
+    } : 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 defaultTest = isSimpleType;
+})({});
 var visit = (node, testOrVisitor, visitor) => {
-  if (!visitor) {
-    visitNode(node, defaultTest, testOrVisitor);
-  } else {
-    visitNode(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;
+  const $result = test?.(node, path, depth);
+  const result = $result === void 0 ? 0 : typeof $result === "boolean" ? $result ? 0 : 1 : $result;
   if (result === 2) {
     return result;
   }
@@ -117,6 +119,12 @@ var findNode = (node, test) => {
         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);
@@ -125,12 +133,13 @@ var findNode = (node, test) => {
       }
     }
   } else if (SchemaAST.isUnion(node)) {
-    if (isOption(node)) {
-      for (const type of node.types) {
-        const child = findNode(type, test);
-        if (child) {
-          return child;
-        }
+    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)) {
@@ -141,15 +150,7 @@ var findProperty = (schema, path) => {
   const getProp = (node, path2) => {
     const [name, ...rest] = path2;
     const typeNode = findNode(node, SchemaAST.isTypeLiteral);
-    invariant(typeNode, void 0, {
-      F: __dxlog_file,
-      L: 247,
-      S: void 0,
-      A: [
-        "typeNode",
-        ""
-      ]
-    });
+    invariant(typeNode);
     for (const prop of SchemaAST.getPropertySignatures(typeNode)) {
       if (prop.name === name) {
         if (rest.length) {
@@ -163,21 +164,21 @@ var findProperty = (schema, path) => {
   return getProp(schema.ast, path.split("."));
 };
 var defaultAnnotations = {
-  ["ObjectKeyword"]: SchemaAST.objectKeyword,
-  ["StringKeyword"]: SchemaAST.stringKeyword,
-  ["NumberKeyword"]: SchemaAST.numberKeyword,
-  ["BooleanKeyword"]: SchemaAST.booleanKeyword
-};
-var getAnnotation = (annotationId, noDefault = true) => (node) => {
-  const id = pipe(SchemaAST.getIdentifierAnnotation(node), Option.getOrUndefined);
-  const value = pipe(SchemaAST.getAnnotation(annotationId)(node), Option.getOrUndefined);
+  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), Option.getOrUndefined);
+  const value = Function.pipe(SchemaAST.getAnnotation(annotationId)(node), Option.getOrUndefined);
   if (noDefault && (value === defaultAnnotations[node._tag]?.annotations[annotationId] || value === id)) {
     return void 0;
   }
   return value;
 };
 var findAnnotation = (node, annotationId, noDefault = true) => {
-  const getAnnotationById = getAnnotation(annotationId, noDefault);
+  const getAnnotationById = getAnnotation2(annotationId, noDefault);
   const getBaseAnnotation = (node2) => {
     const value = getAnnotationById(node2);
     if (value !== void 0) {
@@ -197,19 +198,26 @@ var isOption = (node) => {
 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), void 0, {
-    F: __dxlog_file,
-    L: 344,
-    S: void 0,
-    A: [
-      "SchemaAST.isUnion(node)",
-      ""
-    ]
-  });
+  invariant(SchemaAST.isUnion(node));
   if (isOption(node)) {
     return;
   }
@@ -219,39 +227,15 @@ var getDiscriminatingProps = (node) => {
   }, []);
 };
 var getDiscriminatedType = (node, value = {}) => {
-  invariant(SchemaAST.isUnion(node), void 0, {
-    F: __dxlog_file,
-    L: 368,
-    S: void 0,
-    A: [
-      "SchemaAST.isUnion(node)",
-      ""
-    ]
-  });
-  invariant(value, void 0, {
-    F: __dxlog_file,
-    L: 369,
-    S: void 0,
-    A: [
-      "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), void 0, {
-        F: __dxlog_file,
-        L: 380,
-        S: void 0,
-        A: [
-          "SchemaAST.isLiteral(prop.type)",
-          ""
-        ]
-      });
+      invariant(SchemaAST.isLiteral(prop.type));
       return prop.type.literal === value[prop.name.toString()];
     });
     if (match) {
@@ -261,15 +245,7 @@ var getDiscriminatedType = (node, value = {}) => {
   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, {
-        F: __dxlog_file,
-        L: 398,
-        S: void 0,
-        A: [
-          "SchemaAST.isLiteral(literal.type)",
-          ""
-        ]
-      });
+      invariant(SchemaAST.isLiteral(literal.type));
       return literal.type.literal;
     }).filter(isNonNullable);
     return literals.length ? [
@@ -280,10 +256,14 @@ var getDiscriminatedType = (node, value = {}) => {
   const schema = Schema.Struct(fields);
   return schema.ast;
 };
+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);
+      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);
@@ -300,151 +280,75 @@ var mapAst = (ast, f) => {
     }
   }
 };
-var isArrayType = (node) => {
-  return SchemaAST.isTupleType(node) || SchemaAST.isUnion(node) && node.types.some(isArrayType) && node.types.some(isUndefinedKeyword) && node.types.length === 2;
-};
-var SimpleType;
-
-// src/jsonPath.ts
-import { Schema as Schema2, Option as Option2 } from "effect";
-import { JSONPath } from "jsonpath-plus";
-import { invariant as invariant2 } from "@dxos/invariant";
-var __dxlog_file2 = "/__w/dxos/dxos/packages/common/effect/src/jsonPath.ts";
-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 Option2.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}`, {
-    F: __dxlog_file2,
-    L: 63,
-    S: void 0,
-    A: [
-      "isJsonPath(candidatePath)",
-      "`Invalid JsonPath: ${candidatePath}`"
-    ]
-  });
-  return candidatePath;
-};
-var fromEffectValidationPath = (effectPath) => {
-  const jsonPath = effectPath.replace(/\.\[(\d+)\]/g, "[$1]");
-  invariant2(isJsonPath(jsonPath), `Invalid JsonPath: ${jsonPath}`, {
-    F: __dxlog_file2,
-    L: 74,
-    S: void 0,
-    A: [
-      "isJsonPath(jsonPath)",
-      "`Invalid JsonPath: ${jsonPath}`"
-    ]
-  });
-  return jsonPath;
-};
-var splitJsonPath = (path) => {
-  if (!isJsonPath(path)) {
-    return [];
+var getIndexSignatures = (ast) => {
+  const annotation = SchemaAST.getSurrogateAnnotation(ast);
+  if (Option.isSome(annotation)) {
+    return getIndexSignatures(annotation.value);
   }
-  return path.match(/[a-zA-Z_$][\w$]*|\[\d+\]/g)?.map((part) => part.startsWith("[") ? part.replace(/[[\]]/g, "") : part) ?? [];
-};
-var getField = (object, path) => {
-  return JSONPath({
-    path,
-    json: object
-  })[0];
+  switch (ast._tag) {
+    case "TypeLiteral":
+      return ast.indexSignatures.slice();
+    case "Suspend":
+      return getIndexSignatures(ast.f());
+    case "Refinement":
+      return getIndexSignatures(ast.from);
+  }
+  return [];
 };
 
-// src/url.ts
-import { SchemaAST as SchemaAST2, Option as Option3, pipe as pipe2 } from "effect";
-import { decamelize } from "@dxos/util";
-var ParamKeyAnnotationId = Symbol.for("@dxos/schema/annotation/ParamKey");
-var getParamKeyAnnotation = SchemaAST2.getAnnotation(ParamKeyAnnotationId);
-var ParamKeyAnnotation = (value) => (self) => self.annotations({
-  [ParamKeyAnnotationId]: value
-});
-var UrlParser = class {
-  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 } = pipe2(getParamKeyAnnotation(field.ast), Option3.getOrElse(() => ({
-            key: decamelize(key)
-          })));
-          url.searchParams.set(serializedKey, String(value));
-        }
-      }
-    });
-    return url;
-  }
+// 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/context.ts
-import { Effect } from "effect";
+import * as Effect from "effect/Effect";
 import { Context } from "@dxos/context";
-var __dxlog_file3 = "/__w/dxos/dxos/packages/common/effect/src/context.ts";
 var contextFromScope = () => Effect.gen(function* () {
-  const ctx = new Context(void 0, {
-    F: __dxlog_file3,
-    L: 12
-  });
+  const ctx = new Context();
   yield* Effect.addFinalizer(() => Effect.promise(() => ctx.dispose()));
   return ctx;
 });
 
+// src/dynamic-runtime.ts
+var dynamic_runtime_exports = {};
+__export(dynamic_runtime_exports, {
+  make: () => make
+});
+import * as Context2 from "effect/Context";
+import * as Effect3 from "effect/Effect";
+import * as Exit2 from "effect/Exit";
+import * as Option3 from "effect/Option";
+import * as Runtime2 from "effect/Runtime";
+
 // src/errors.ts
-import { Cause, Chunk, Effect as Effect2, Exit, GlobalValue, Option as Option4 } from "effect";
-var spanSymbol = Symbol.for("effect/SpanAnnotation");
-var originalSymbol = Symbol.for("effect/OriginalAnnotation");
+import * as Cause from "effect/Cause";
+import * as Chunk from "effect/Chunk";
+import * as Effect2 from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as GlobalValue from "effect/GlobalValue";
+import * as Option2 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;
+  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]);
@@ -461,6 +365,26 @@ var prettyErrorStack = (error, appendStacks = []) => {
     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) {
@@ -486,14 +410,12 @@ var prettyErrorStack = (error, appendStacks = []) => {
       } else {
         out.push(`    at ${current.name}`);
       }
-      current = Option4.getOrUndefined(current.parent);
+      current = Option2.getOrUndefined(current.parent);
       i++;
     }
   }
   out.push(...appendStacks);
-  if (error[originalSymbol]) {
-    error = error[originalSymbol];
-  }
+  error = Cause.originalError(error);
   if (error.cause) {
     error.cause = prettyErrorStack(error.cause);
   }
@@ -505,98 +427,402 @@ var prettyErrorStack = (error, appendStacks = []) => {
   });
   return error;
 };
-var runAndForwardErrors = async (effect, options) => {
-  const exit = await Effect2.runPromiseExit(effect, options);
-  if (Exit.isSuccess(exit)) {
-    return exit.value;
-  }
-  if (Cause.isEmpty(exit.cause)) {
-    throw new Error("Fiber failed without a cause");
-  } else if (Cause.isInterrupted(exit.cause)) {
-    throw new Error("Fiber was interrupted");
+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(exit.cause)),
-      ...Chunk.toArray(Cause.defects(exit.cause))
+      ...Chunk.toArray(Cause.failures(cause)),
+      ...Chunk.toArray(Cause.defects(cause))
     ];
     const getStackFrames = () => {
-      const o = {};
-      Error.captureStackTrace(o, getStackFrames);
+      const o = new Error();
+      Error.captureStackTrace(o, causeToError);
       return o.stack.split("\n").slice(1);
     };
     const stackFrames = getStackFrames();
     const newErrors = errors.map((error) => prettyErrorStack(error, stackFrames));
     if (newErrors.length === 1) {
-      throw newErrors[0];
+      return newErrors[0];
     } else {
-      throw new AggregateError(newErrors);
+      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 Effect2.runPromiseExit(effect, options);
+  return unwrapExit(exit2);
+};
+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) => Effect2.promise(async (signal) => {
+  try {
+    const result = await evaluate(signal);
+    return Effect2.succeed(result);
+  } catch (err) {
+    return Effect2.die(err);
+  }
+}).pipe(Effect2.flatten);
 
-// src/testing.ts
-import { Effect as Effect3 } from "effect";
-(function(TestHelpers2) {
-  TestHelpers2.runIf = (condition) => (effect, ctx) => Effect3.gen(function* () {
-    if (!condition) {
-      ctx.skip();
-    } else {
-      return yield* effect;
+// src/dynamic-runtime.ts
+var validateTags = (context, tags) => Effect3.gen(function* () {
+  const missingTags = [];
+  for (const tag of tags) {
+    const option = Context2.getOption(context, tag);
+    if (Option3.isNone(option)) {
+      missingTags.push(tag.key);
     }
-  });
-  TestHelpers2.skipIf = (condition) => (effect, ctx) => Effect3.gen(function* () {
-    if (condition) {
-      ctx.skip();
+  }
+  if (missingTags.length > 0) {
+    return yield* Effect3.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(Effect3.gen(function* () {
+        const rt = yield* managedRuntimeAny.runtimeEffect;
+        yield* validateTags(rt.context, tags);
+        return rt;
+      }));
+    }
+    return validatedRuntimePromise;
+  };
+  const getValidatedRuntime = () => {
+    const validationExit = managedRuntimeAny.runSyncExit(Effect3.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(Effect3.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: Effect3.gen(function* () {
+      if (cachedRuntime) {
+        return cachedRuntime;
+      }
+      const rt = yield* managedRuntimeAny.runtimeEffect;
+      yield* validateTags(rt.context, tags);
+      const runtime2 = rt;
+      cachedRuntime = runtime2;
+      return runtime2;
+    }).pipe(Effect3.catchAll(() => (
+      // This should never happen since validateTags uses Effect.die
+      Effect3.die(new Error("Unexpected error in runtimeEffect validation"))
+    ))),
+    dispose: async () => {
+      await managedRuntimeAny.dispose();
+    }
+  };
+}
+
+// src/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 yield* effect;
+      return i === 0 ? p : `.${p}`;
     }
-  });
-})(TestHelpers || (TestHelpers = {}));
-var TestHelpers;
+  }).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/resource.ts
-import { Effect as Effect4 } from "effect";
-var accuireReleaseResource = (getResource) => Effect4.acquireRelease(Effect4.gen(function* () {
+import * as Effect4 from "effect/Effect";
+var acquireReleaseResource = (getResource) => Effect4.acquireRelease(Effect4.gen(function* () {
   const resource = getResource();
   yield* Effect4.promise(async () => {
-    resource.open?.();
+    await resource.open?.();
     return void 0;
   });
   return resource;
 }), (resource) => Effect4.promise(async () => {
-  resource.close?.();
+  await resource.close?.();
   return void 0;
 }));
+
+// src/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;
+  }
+};
+
+// src/RuntimeProvider.ts
+var RuntimeProvider_exports = {};
+__export(RuntimeProvider_exports, {
+  currentRuntime: () => currentRuntime,
+  provide: () => provide2,
+  runPromise: () => runPromise2
+});
+import * as Effect5 from "effect/Effect";
+import * as Runtime3 from "effect/Runtime";
+var currentRuntime = () => Effect5.runtime().pipe(Effect5.map(Effect5.succeed));
+var runPromise2 = (provider) => async (effect) => {
+  const runtime2 = await runAndForwardErrors(provider);
+  return unwrapExit(await effect.pipe(Runtime3.runPromiseExit(runtime2)));
+};
+var provide2 = (runtimeProvider) => (effect) => Effect5.flatMap(runtimeProvider, (runtime2) => Effect5.provide(effect, runtime2));
+
+// 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/async-task-tagging.ts
+import * as Context3 from "effect/Context";
+import * as Effect7 from "effect/Effect";
+import { pipe as pipe3 } 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 = Effect7.gen(function* () {
+    const oldTracer = yield* Effect7.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 = Context3.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 pipe3(makeTracer, Effect7.map(Layer.setTracer), Layer.unwrapEffect);
+};
 export {
+  dynamic_runtime_exports as DynamicRuntime,
   JsonPath,
   JsonProp,
   ParamKeyAnnotation,
-  SimpleType,
-  TestHelpers,
+  Performance_exports as Performance,
+  RuntimeProvider_exports as RuntimeProvider,
   UrlParser,
   VisitResult,
-  accuireReleaseResource,
+  acquireReleaseResource,
+  asyncTaskTaggingLayer,
+  causeToError,
   contextFromScope,
   createJsonPath,
+  createKvsStore,
   findAnnotation,
   findNode,
   findProperty,
   fromEffectValidationPath,
-  getAnnotation,
+  getAnnotation2 as getAnnotation,
+  getArrayElementType,
+  getBaseType,
   getDiscriminatedType,
   getDiscriminatingProps,
   getField,
+  getLiteralValues,
   getParamKeyAnnotation,
-  getSimpleType,
+  getProperties,
+  getValue,
   isArrayType,
   isDiscriminatedUnion,
   isJsonPath,
   isLiteralUnion,
+  isNestedType,
   isOption,
-  isSimpleType,
+  isTupleType2 as isTupleType,
   mapAst,
+  promiseWithCauseCapture,
   runAndForwardErrors,
+  runInRuntime,
+  setValue,
   splitJsonPath,
+  throwCause,
+  unwrapExit,
   visit
 };
 //# sourceMappingURL=index.mjs.map