@dxos/effect 0.8.4-main.548089c → 0.8.4-main.59c2e9b

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@dxos/effect",
-  "version": "0.8.4-main.548089c",
+  "version": "0.8.4-main.59c2e9b",
   "description": "Effect utils.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
   "license": "MIT",
   "author": "info@dxos.org",
   "type": "module",
@@ -13,24 +17,36 @@
       "types": "./dist/types/src/index.d.ts",
       "browser": "./dist/lib/browser/index.mjs",
       "node": "./dist/lib/node-esm/index.mjs"
+    },
+    "./testing": {
+      "source": "./src/testing.ts",
+      "types": "./dist/types/src/testing.d.ts",
+      "browser": "./dist/lib/browser/testing.mjs",
+      "node": "./dist/lib/node-esm/testing.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
   "typesVersions": {
-    "*": {}
+    "*": {
+      "testing": [
+        "./dist/types/src/testing.d.ts"
+      ]
+    }
   },
   "files": [
     "dist",
     "src"
   ],
   "dependencies": {
-    "@effect/opentelemetry": "^0.58.0",
+    "@effect-atom/atom-react": "^0.4.6",
+    "@effect/opentelemetry": "^0.59.2",
+    "@effect/platform-browser": "0.73.0",
     "@opentelemetry/api": "^1.9.0",
     "jsonpath-plus": "10.2.0",
-    "@dxos/invariant": "0.8.4-main.548089c",
-    "@dxos/context": "0.8.4-main.548089c",
-    "@dxos/util": "0.8.4-main.548089c",
-    "@dxos/node-std": "0.8.4-main.548089c"
+    "@dxos/context": "0.8.4-main.59c2e9b",
+    "@dxos/invariant": "0.8.4-main.59c2e9b",
+    "@dxos/node-std": "0.8.4-main.59c2e9b",
+    "@dxos/util": "0.8.4-main.59c2e9b"
   },
   "devDependencies": {
     "@opentelemetry/api-logs": "^0.203.0",
@@ -39,11 +55,11 @@
     "@opentelemetry/sdk-node": "^0.203.0",
     "@opentelemetry/sdk-trace-node": "^2.1.0",
     "@opentelemetry/semantic-conventions": "^1.37.0",
-    "effect": "3.18.3",
-    "@dxos/log": "0.8.4-main.548089c"
+    "effect": "3.19.11",
+    "@dxos/log": "0.8.4-main.59c2e9b"
   },
   "peerDependencies": {
-    "effect": "^3.13.3"
+    "effect": "3.19.11"
   },
   "publishConfig": {
     "access": "public"

package/src/RuntimeProvider.ts

@@ -0,0 +1,35 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Runtime from 'effect/Runtime';
+
+import { runAndForwardErrors, unwrapExit } from './errors';
+
+/**
+ * Provides effect runtime with services to run effects.
+ */
+export type RuntimeProvider<R> = Effect.Effect<Runtime.Runtime<R>>;
+
+/**
+ * @returns Runtime provider from the current context.
+ */
+export const currentRuntime = <R = never>() => Effect.runtime<R>().pipe(Effect.map(Effect.succeed));
+
+/**
+ * Run effect, within runitme, clean errors and fix stack-traces.
+ */
+export const runPromise =
+  <R>(provider: RuntimeProvider<R>) =>
+  async <A>(effect: Effect.Effect<A, any, R>): Promise<A> => {
+    const runtime = await runAndForwardErrors(provider);
+    return unwrapExit(await effect.pipe(Runtime.runPromiseExit(runtime)));
+  };
+
+/**
+ * Provide services from runtime provider to effect.
+ */
+export const provide: {
+  <R2>(runtime: RuntimeProvider<R2>): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, R2>>;
+} = (runtimeProvider) => (effect) => Effect.flatMap(runtimeProvider, (runtime) => Effect.provide(effect, runtime));

package/src/ast.test.ts

@@ -15,13 +15,12 @@ import {
   getAnnotation,
   getDiscriminatedType,
   getDiscriminatingProps,
-  getSimpleType,
   isArrayType,
+  isDiscriminatedUnion,
   isOption,
-  isSimpleType,
   visit,
 } from './ast';
-import { type JsonPath, type JsonProp } from './jsonPath';
+import { type JsonPath, type JsonProp } from './json-path';
 
 const ZipCode = Schema.String.pipe(
   Schema.pattern(/^\d{5}$/, {
@@ -65,10 +64,9 @@ describe('AST', () => {
 
     const prop = findProperty(TestSchema, 'name' as JsonProp);
     invariant(prop);
-    const node = findNode(prop, isSimpleType);
+    const node = findNode(prop, (node) => node._tag === 'StringKeyword');
     invariant(node);
-    const type = getSimpleType(node);
-    expect(type).to.eq('string');
+    expect(node._tag).to.eq('StringKeyword');
   });
 
   test('findProperty', ({ expect }) => {
@@ -137,7 +135,11 @@ describe('AST', () => {
     });
 
     const props: string[] = [];
-    visit(TestSchema.ast, (_, path) => props.push(path.join('.')));
+    visit(
+      TestSchema.ast,
+      (_, path) => props.push(path.join('.')),
+      (node, path, depth) => depth < 3,
+    );
   });
 
   test('discriminated unions', ({ expect }) => {
@@ -152,7 +154,7 @@ describe('AST', () => {
       expect(isOption(TestUnionSchema.ast)).to.be.false;
       expect(getDiscriminatingProps(TestUnionSchema.ast)).to.deep.eq(['kind']);
 
-      const node = findNode(TestUnionSchema.ast, isSimpleType);
+      const node = findNode(TestUnionSchema.ast, isDiscriminatedUnion);
       expect(node).to.eq(TestUnionSchema.ast);
     }
 

package/src/ast.ts

@@ -10,7 +10,7 @@ import * as SchemaAST from 'effect/SchemaAST';
 import { invariant } from '@dxos/invariant';
 import { isNonNullable } from '@dxos/util';
 
-import { type JsonPath, type JsonProp } from './jsonPath';
+import { type JsonPath, type JsonProp } from './json-path';
 
 //
 // Refs
@@ -19,75 +19,54 @@ import { type JsonPath, type JsonProp } from './jsonPath';
 // https://effect-ts.github.io/effect/schema/SchemaAST.ts.html
 //
 
-// TODO(wittjosiah): What is a "simple type"?
-export type SimpleType = 'object' | 'string' | 'number' | 'boolean' | 'enum' | 'literal';
-
-const isTupleType = (node: SchemaAST.AST): boolean => {
-  // NOTE: Arrays are represented as tuples with no elements and a rest part.
-  return SchemaAST.isTupleType(node) && node.elements.length > 0;
-};
-
 /**
- * Get the base type; e.g., traverse through refinements.
+ * Unwraps and collects refinement filters.
  */
-export const getSimpleType = (node: SchemaAST.AST): SimpleType | undefined => {
-  if (
-    SchemaAST.isDeclaration(node) ||
-    SchemaAST.isObjectKeyword(node) ||
-    SchemaAST.isTypeLiteral(node) ||
-    // TODO(wittjosiah): Tuples are actually arrays.
-    isTupleType(node) ||
-    isDiscriminatedUnion(node)
-  ) {
-    return 'object';
-  }
-
-  if (SchemaAST.isStringKeyword(node)) {
-    return 'string';
-  }
-  if (SchemaAST.isNumberKeyword(node)) {
-    return 'number';
-  }
-  if (SchemaAST.isBooleanKeyword(node)) {
-    return 'boolean';
+const reduceRefinements = (
+  type: SchemaAST.AST,
+  refinements: SchemaAST.Refinement['filter'][] = [],
+): { type: SchemaAST.AST; refinements: SchemaAST.Refinement['filter'][] } => {
+  if (SchemaAST.isRefinement(type)) {
+    const annotations = type.annotations;
+    const filter = type.filter;
+    const nextType = { ...type.from, annotations: { ...type.annotations, ...annotations } } as SchemaAST.AST;
+    return reduceRefinements(nextType, [...refinements, filter]);
   }
 
-  if (SchemaAST.isEnums(node)) {
-    return 'enum';
-  }
+  return { type, refinements };
+};
 
-  if (SchemaAST.isLiteral(node)) {
-    return 'literal';
-  }
+/**
+ * Get the base type of a property.
+ *
+ * Unwraps refinements and optional unions.
+ */
+export const getBaseType = (
+  prop: SchemaAST.PropertySignature | SchemaProperty,
+): { type: SchemaAST.AST; refinements: SchemaAST.Refinement['filter'][] } => {
+  const encoded = SchemaAST.encodedBoundAST(prop.type);
+  // Extract property ast from optional union.
+  const unwrapped = prop.isOptional && encoded._tag === 'Union' ? encoded.types[0] : encoded;
+  return reduceRefinements(unwrapped);
 };
 
-export const isSimpleType = (node: SchemaAST.AST): boolean => !!getSimpleType(node);
+export type SchemaProperty = Pick<SchemaAST.PropertySignature, 'name' | 'type' | 'isOptional' | 'isReadonly'> & {
+  /** Can be used to validate the property to the spec of the initial AST. */
+  refinements: SchemaAST.Refinement['filter'][];
+};
 
-export namespace SimpleType {
-  /**
-   * Returns the default empty value for a given SimpleType.
-   * Used for initializing new array values etc.
-   */
-  export const getDefaultValue = (type: SimpleType): any => {
-    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}`);
-      }
-    }
-  };
-}
+/**
+ * Get the property types of an AST.
+ */
+export const getProperties = (ast: SchemaAST.AST): SchemaProperty[] => {
+  const properties = SchemaAST.getPropertySignatures(ast);
+  return properties.map((prop) => ({
+    ...getBaseType(prop),
+    name: prop.name,
+    isOptional: prop.isOptional,
+    isReadonly: prop.isReadonly,
+  }));
+};
 
 //
 // Branded types
@@ -111,23 +90,14 @@ export type TestFn = (node: SchemaAST.AST, path: Path, depth: number) => VisitRe
 
 export type VisitorFn = (node: SchemaAST.AST, path: Path, depth: number) => void;
 
-const defaultTest: TestFn = isSimpleType;
-
 /**
  * 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
  */
-export const visit: {
-  (node: SchemaAST.AST, visitor: VisitorFn): void;
-  (node: SchemaAST.AST, test: TestFn, visitor: VisitorFn): void;
-} = (node: SchemaAST.AST, testOrVisitor: TestFn | VisitorFn, visitor?: VisitorFn): void => {
-  if (!visitor) {
-    visitNode(node, defaultTest, testOrVisitor);
-  } else {
-    visitNode(node, testOrVisitor as TestFn, visitor);
-  }
+export const visit = (node: SchemaAST.AST, testOrVisitor: TestFn | VisitorFn, visitor: VisitorFn): void => {
+  visitNode(node, testOrVisitor as TestFn, visitor);
 };
 
 const visitNode = (
@@ -344,10 +314,31 @@ export const isOption = (node: SchemaAST.AST): boolean => {
 /**
  * Determines if the node is a union of literal types.
  */
-export const isLiteralUnion = (node: SchemaAST.AST): boolean => {
+export const isLiteralUnion = (node: SchemaAST.AST): node is SchemaAST.Union<SchemaAST.Literal> => {
   return SchemaAST.isUnion(node) && node.types.every(SchemaAST.isLiteral);
 };
 
+/**
+ * Determines if the node is an array type.
+ */
+export const isArrayType = (node: SchemaAST.AST): node is SchemaAST.TupleType => {
+  return SchemaAST.isTupleType(node) && node.elements.length === 0 && node.rest.length === 1;
+};
+
+/**
+ * Get the type of the array elements.
+ */
+export const getArrayElementType = (node: SchemaAST.AST): SchemaAST.AST | undefined => {
+  return isArrayType(node) ? node.rest.at(0)?.type : undefined;
+};
+
+/**
+ * Determines if the node is a tuple type.
+ */
+export const isTupleType = (node: SchemaAST.AST): boolean => {
+  return SchemaAST.isTupleType(node) && node.elements.length > 0;
+};
+
 /**
  * Determines if the node is a discriminated union.
  */
@@ -427,6 +418,20 @@ export const getDiscriminatedType = (
   return schema.ast;
 };
 
+/**
+ * Determines if the node is a nested object type.
+ */
+export const isNestedType = (node: SchemaAST.AST): boolean => {
+  return (
+    SchemaAST.isDeclaration(node) ||
+    SchemaAST.isObjectKeyword(node) ||
+    SchemaAST.isTypeLiteral(node) ||
+    // TODO(wittjosiah): Tuples are actually arrays.
+    isTupleType(node) ||
+    isDiscriminatedUnion(node)
+  );
+};
+
 /**
  * Maps AST nodes.
  * The user is responsible for recursively calling {@link mapAst} on the SchemaAST.
@@ -475,19 +480,6 @@ export const mapAst = (
   }
 };
 
-/**
- * @returns true if AST is for Array(T) or optional(Array(T)).
- */
-export const isArrayType = (node: SchemaAST.AST): boolean => {
-  return (
-    SchemaAST.isTupleType(node) ||
-    (SchemaAST.isUnion(node) &&
-      node.types.some(isArrayType) &&
-      node.types.some(SchemaAST.isUndefinedKeyword) &&
-      node.types.length === 2)
-  );
-};
-
 const getIndexSignatures = (ast: SchemaAST.AST): Array<SchemaAST.IndexSignature> => {
   const annotation = SchemaAST.getSurrogateAnnotation(ast);
   if (Option.isSome(annotation)) {

package/src/atom-kvs.ts

@@ -0,0 +1,35 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as BrowserKeyValueStore from '@effect/platform-browser/BrowserKeyValueStore';
+import { Atom } from '@effect-atom/atom-react';
+import type * as Schema from 'effect/Schema';
+
+// TODO(wittjosiah): This is currently provided for convenience but maybe should be removed.
+const 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.
+ */
+export const createKvsStore = <T extends Record<string, any>>(options: {
+  key: string;
+  schema: Schema.Schema<T>;
+  defaultValue: () => T;
+  runtime?: ReturnType<typeof Atom.runtime>;
+}): Atom.Writable<T> => {
+  const runtime = options.runtime ?? defaultRuntime;
+  return Atom.kvs({
+    runtime,
+    key: options.key,
+    schema: options.schema,
+    defaultValue: options.defaultValue,
+  }).pipe(Atom.keepAlive);
+};