@dxos/effect 0.8.4-main.ef1bc66f44 → 0.8.4-main.f466a3d56e

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/effect",
-  "version": "0.8.4-main.ef1bc66f44",
+  "version": "0.8.4-main.f466a3d56e",
   "description": "Effect utils.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -8,7 +8,7 @@
     "type": "git",
     "url": "https://github.com/dxos/dxos"
   },
-  "license": "MIT",
+  "license": "FSL-1.1-Apache-2.0",
   "author": "info@dxos.org",
   "type": "module",
   "exports": {
@@ -26,13 +26,6 @@
     }
   },
   "types": "dist/types/src/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "testing": [
-        "./dist/types/src/testing.d.ts"
-      ]
-    }
-  },
   "files": [
     "dist",
     "src"
@@ -40,29 +33,29 @@
   "dependencies": {
     "@effect-atom/atom-react": "^0.5.0",
     "@effect/opentelemetry": "^0.61.0",
-    "@opentelemetry/api": "^1.9.0",
-    "jsonpath-plus": "10.2.0",
-    "@dxos/invariant": "0.8.4-main.ef1bc66f44",
-    "@dxos/node-std": "0.8.4-main.ef1bc66f44",
-    "@dxos/context": "0.8.4-main.ef1bc66f44",
-    "@dxos/util": "0.8.4-main.ef1bc66f44"
+    "@opentelemetry/api": "^1.9.1",
+    "jsonpath-plus": "^10.3.0",
+    "@dxos/context": "0.8.4-main.f466a3d56e",
+    "@dxos/invariant": "0.8.4-main.f466a3d56e",
+    "@dxos/util": "0.8.4-main.f466a3d56e",
+    "@dxos/node-std": "0.8.4-main.f466a3d56e"
   },
   "devDependencies": {
     "@effect/platform": "0.94.4",
     "@effect/platform-browser": "0.74.0",
-    "@opentelemetry/api-logs": "^0.203.0",
-    "@opentelemetry/resources": "^2.1.0",
-    "@opentelemetry/sdk-logs": "^0.203.0",
-    "@opentelemetry/sdk-node": "^0.203.0",
-    "@opentelemetry/sdk-trace-node": "^2.1.0",
-    "@opentelemetry/semantic-conventions": "^1.37.0",
-    "effect": "3.19.16",
-    "@dxos/log": "0.8.4-main.ef1bc66f44"
+    "@opentelemetry/api-logs": "^0.218.0",
+    "@opentelemetry/resources": "^2.7.1",
+    "@opentelemetry/sdk-logs": "^0.218.0",
+    "@opentelemetry/sdk-node": "^0.218.0",
+    "@opentelemetry/sdk-trace-node": "^2.7.1",
+    "@opentelemetry/semantic-conventions": "^1.41.1",
+    "effect": "3.20.0",
+    "@dxos/log": "0.8.4-main.f466a3d56e"
   },
   "peerDependencies": {
     "@effect/platform": "0.94.4",
     "@effect/platform-browser": "0.74.0",
-    "effect": "3.19.16"
+    "effect": "3.20.0"
   },
   "publishConfig": {
     "access": "public"

package/src/Performance.ts

@@ -0,0 +1,45 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import type * as Exit from 'effect/Exit';
+
+export interface AddTrackEntryOptions {
+  name: string;
+  devtools?: {
+    /**
+     * @example 'track-entry'
+     */
+    dataType: string;
+    track: string;
+    trackGroup: string;
+    /**
+     * @example 'tertiary-dark'
+     */
+    color: string;
+    properties?: [string, any][];
+    tooltipText?: string;
+  };
+  detail?: Record<string, unknown>;
+}
+
+/**
+ * Puts the effect span on the performance timeline in DevTools.
+ */
+export const addTrackEntry =
+  <A, E>(options: AddTrackEntryOptions | ((exit: Exit.Exit<A, E>) => AddTrackEntryOptions)) =>
+  <R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    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: start,
+        detail: {
+          ...resolvedOptions.detail,
+          devtools: resolvedOptions.devtools,
+        },
+      });
+      return yield* exit;
+    });

package/src/ast.ts

@@ -62,12 +62,22 @@ export type SchemaProperty = Pick<SchemaAST.PropertySignature, 'name' | 'type' |
  */
 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,
-  }));
+  return properties.map((prop) => {
+    const { type, refinements } = getBaseType(prop);
+    // Merge PropertySignature-level annotations (e.g., title, description set via .annotations())
+    // onto the unwrapped base type so downstream consumers see them.
+    const mergedType =
+      prop.annotations && Reflect.ownKeys(prop.annotations).length > 0
+        ? ({ ...type, annotations: { ...type.annotations, ...prop.annotations } } as SchemaAST.AST)
+        : type;
+    return {
+      type: mergedType,
+      refinements,
+      name: prop.name,
+      isOptional: prop.isOptional,
+      isReadonly: prop.isReadonly,
+    };
+  });
 };
 
 //
@@ -254,10 +264,10 @@ export const findProperty = (
 //
 
 const defaultAnnotations: Record<string, SchemaAST.Annotated> = {
-  ['ObjectKeyword' as const]: SchemaAST.objectKeyword,
-  ['StringKeyword' as const]: SchemaAST.stringKeyword,
-  ['NumberKeyword' as const]: SchemaAST.numberKeyword,
-  ['BooleanKeyword' as const]: SchemaAST.booleanKeyword,
+  ObjectKeyword: SchemaAST.objectKeyword,
+  StringKeyword: SchemaAST.stringKeyword,
+  NumberKeyword: SchemaAST.numberKeyword,
+  BooleanKeyword: SchemaAST.booleanKeyword,
 };
 
 /**
@@ -320,6 +330,20 @@ export const isLiteralUnion = (node: SchemaAST.AST): node is SchemaAST.Union<Sch
   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.
+ */
+export const getLiteralValues = <S extends Schema.Schema<any, any, any>>(
+  schema: S,
+): ReadonlyArray<Schema.Schema.Type<S>> => {
+  if (!isLiteralUnion(schema.ast)) {
+    return [];
+  }
+  return schema.ast.types.map((node) => node.literal as Schema.Schema.Type<S>);
+};
+
 /**
  * Determines if the node is an array type.
  */

package/src/async-task-tagging.ts

@@ -0,0 +1,51 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Context from 'effect/Context';
+import * as Effect 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';
+
+const runInTask = Symbol('runInTask');
+
+/**
+ * Traces effect frames using console.createTask so that the proper stack-trace is visible in Chrome Devtools debugger.
+ */
+export const asyncTaskTaggingLayer = () => {
+  if (Predicate.hasProperty(console, 'createTask') === false) {
+    return Layer.empty;
+  }
+
+  const makeTracer = Effect.gen(function* () {
+    const oldTracer = yield* Effect.tracer;
+    return Tracer.make({
+      span: (name, ...args) => {
+        const span = oldTracer.span(name, ...args);
+        const trace = (console as any).createTask(name);
+        (span as any)[runInTask] = (f: any) => trace.run(f);
+        return span;
+      },
+      context: (f, fiber) => {
+        const maybeParentSpan = Context.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, Effect.map(Layer.setTracer), Layer.unwrapEffect);
+};

package/src/atom-kvs.ts

@@ -2,8 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as BrowserKeyValueStore from '@effect/platform-browser/BrowserKeyValueStore';
 import { Atom } from '@effect-atom/atom-react';
+import * as BrowserKeyValueStore from '@effect/platform-browser/BrowserKeyValueStore';
 import type * as Schema from 'effect/Schema';
 
 // TODO(wittjosiah): This is currently provided for convenience but maybe should be removed.

package/src/index.ts

@@ -9,5 +9,8 @@ export * as DynamicRuntime from './dynamic-runtime';
 export * from './errors';
 export * from './json-path';
 export * from './resource';
+export * from './types';
 export * from './url';
 export * as RuntimeProvider from './RuntimeProvider';
+export * as Performance from './Performance';
+export * from './async-task-tagging';

package/src/testing.ts

@@ -6,17 +6,11 @@ import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import type { TestContext } from 'vitest';
 
-// TODO(dmaretskyi): Add all different test tags here.
-export type TestTag =
-  | 'flaky' // Flaky tests.
-  | 'llm' // Tests with AI.
-  | 'sync'; // Sync with external services.
-
 export namespace TestHelpers {
   /**
    * Skip the test if the condition is false.
    *
-   * Exmaple:
+   * Example:
    * ```ts
    * it.effect(
    *   'should process an agentic loop using Claude',
@@ -41,7 +35,7 @@ export namespace TestHelpers {
   /**
    * Skip the test if the condition is true.
    *
-   * Exmaple:
+   * Example:
    * ```ts
    * it.effect(
    *   'should process an agentic loop using Claude',
@@ -63,30 +57,10 @@ export namespace TestHelpers {
         }
       });
 
-  export const tagEnabled = (tag: TestTag) => process.env.DX_TEST_TAGS?.includes(tag);
-
-  /**
-   * Skips this test if the tag is not in the list of tags to run.
-   * Tags are specified in the `DX_TEST_TAGS` environment variable.
-   *
-   * @param tag
-   * @returns
-   */
-  export const taggedTest =
-    (tag: TestTag) =>
-    <A, E, R>(effect: Effect.Effect<A, E, R>, ctx: TestContext): Effect.Effect<A, E, R> =>
-      Effect.gen(function* () {
-        if (!tagEnabled(tag)) {
-          ctx.skip();
-        } else {
-          return yield* effect;
-        }
-      });
-
   /**
    * Provide TestContext from test parameters.
    *
-   * Exmaple:
+   * Example:
    * ```ts
    * it.effect(
    *   'with context',

package/src/types.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+/**
+ * Flat intersection of up to five types. Behaves like `A & B & C & ...` but
+ * formats as a comma-separated tuple, which fits multi-line layouts more
+ * cleanly than chained `&` operators. Unused slots default to `unknown`,
+ * which is inert under intersection (`T & unknown = T`).
+ */
+export type Merge<A, B = unknown, C = unknown, D = unknown, E = unknown> = A & B & C & D & E;