@dxos/effect 0.8.4-main.a4bbb77 → 0.8.4-main.abd8ff62ef

package/src/errors.ts

@@ -2,11 +2,16 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Cause, Chunk, Effect, Exit, GlobalValue, Option } from 'effect';
-import type { AnySpan, Span } from 'effect/Tracer';
+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';
+import type * as Tracer from 'effect/Tracer';
 
 const spanSymbol = Symbol.for('effect/SpanAnnotation');
-const originalSymbol = Symbol.for('effect/OriginalAnnotation');
 const spanToTrace = GlobalValue.globalValue('effect/Tracer/spanToTrace', () => new WeakMap());
 const locationRegex = /\((.*)\)/g;
 
@@ -16,12 +21,19 @@ const locationRegex = /\((.*)\)/g;
  * Unwraps error proxy.
  */
 const prettyErrorStack = (error: any, appendStacks: string[] = []): any => {
+  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;
+  // Very hacky way to remove effect runtime internal stack frames.
+  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]);
@@ -39,6 +51,26 @@ const prettyErrorStack = (error: any, appendStacks: string[] = []): any => {
     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')
@@ -48,7 +80,7 @@ const prettyErrorStack = (error: any, appendStacks: string[] = []): any => {
   }
 
   if (span) {
-    let current: Span | AnySpan | undefined = span;
+    let current: Tracer.Span | Tracer.AnySpan | undefined = span;
     let i = 0;
     while (current && current._tag === 'Span' && i < 10) {
       const stackFn = spanToTrace.get(current);
@@ -77,9 +109,7 @@ const prettyErrorStack = (error: any, appendStacks: string[] = []): any => {
 
   out.push(...appendStacks);
 
-  if (error[originalSymbol]) {
-    error = error[originalSymbol];
-  }
+  error = Cause.originalError(error);
   if (error.cause) {
     error.cause = prettyErrorStack(error.cause);
   }
@@ -113,9 +143,10 @@ export const causeToError = (cause: Cause.Cause<any>): Error => {
     const errors = [...Chunk.toArray(Cause.failures(cause)), ...Chunk.toArray(Cause.defects(cause))];
 
     const getStackFrames = (): string[] => {
-      const o: { stack: string } = {} as any;
-      Error.captureStackTrace(o, getStackFrames);
-      return o.stack.split('\n').slice(1);
+      // Bun requies the target object for `captureStackTrace` to be an Error.
+      const o = new Error();
+      Error.captureStackTrace(o, causeToError);
+      return o.stack!.split('\n').slice(1);
     };
 
     const stackFrames = getStackFrames();
@@ -169,6 +200,41 @@ export const runAndForwardErrors = async <A, E>(
   return unwrapExit(exit);
 };
 
+/**
+ * Runs the embedded effect asynchronously and throws any failures and defects as errors.
+ */
+export const runInRuntime: {
+  <R>(
+    runtime: Runtime.Runtime<R>,
+  ): <A, E>(effect: Effect.Effect<A, E, R>, options?: { signal?: AbortSignal } | undefined) => Promise<A>;
+  <R, A, E>(
+    runtime: Runtime.Runtime<R>,
+    effect: Effect.Effect<A, E, R>,
+    options?: { signal?: AbortSignal } | undefined,
+  ): Promise<A>;
+} = (...args: any[]): any => {
+  if (args.length === 1) {
+    const [runtime] = args as [Runtime.Runtime<any>];
+    return async (
+      effect: Effect.Effect<any, any, any>,
+      options?: { signal?: AbortSignal } | undefined,
+    ): Promise<any> => {
+      const exit = await Runtime.runPromiseExit(runtime, effect, options);
+      return unwrapExit(exit);
+    };
+  } else {
+    const [runtime, effect, options] = args as [
+      Runtime.Runtime<any>,
+      Effect.Effect<any, any, any>,
+      { signal?: AbortSignal } | undefined,
+    ];
+    return (async () => {
+      const exit = await Runtime.runPromiseExit(runtime, effect, options);
+      return unwrapExit(exit);
+    })();
+  }
+};
+
 /**
  * Like `Effect.promise` but also caputes spans for defects.
  * Workaround for: https://github.com/Effect-TS/effect/issues/5436

package/src/index.ts

@@ -3,9 +3,14 @@
 //
 
 export * from './ast';
-export * from './jsonPath';
-export * from './url';
+export * from './atom-kvs';
 export * from './context';
+export * as DynamicRuntime from './dynamic-runtime';
 export * from './errors';
-export * from './testing';
+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/interrupt.test.ts

@@ -3,7 +3,11 @@
 //
 
 import { it } from '@effect/vitest';
-import { Cause, Effect, Fiber } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import * as Fiber from 'effect/Fiber';
+
+import { runAndForwardErrors } from './errors';
 
 const doWork = Effect.fn('doWork')(function* () {
   yield* Effect.sleep('1 minute');
@@ -16,7 +20,7 @@ it.effect.skip(
     function* (_) {
       const resultFiber = yield* doWork().pipe(Effect.fork);
       setTimeout(() => {
-        void Effect.runPromise(Fiber.interrupt(resultFiber));
+        void runAndForwardErrors(Fiber.interrupt(resultFiber));
       }, 2_000);
 
       const result = yield* resultFiber;

package/src/{jsonPath.test.ts → json-path.test.ts}

@@ -4,7 +4,7 @@
 
 import { describe, expect, test } from 'vitest';
 
-import { type JsonPath, createJsonPath, getField, isJsonPath, splitJsonPath } from './jsonPath';
+import { type JsonPath, createJsonPath, getField, getValue, isJsonPath, setValue, splitJsonPath } from './json-path';
 
 describe('createJsonPath', () => {
   test('supported path subset', () => {
@@ -32,9 +32,9 @@ describe('createJsonPath', () => {
 
   test('path splitting', () => {
     const cases = [
-      ['foo.bar[0].baz', ['foo', 'bar', '0', 'baz']],
-      ['users[1].name', ['users', '1', 'name']],
-      ['data[0][1]', ['data', '0', '1']],
+      ['foo.bar[0].baz', ['foo', 'bar', 0, 'baz']],
+      ['users[1].name', ['users', 1, 'name']],
+      ['data[0][1]', ['data', 0, 1]],
       ['simple.path', ['simple', 'path']],
       ['root', ['root']],
     ] as const;
@@ -47,15 +47,15 @@ describe('createJsonPath', () => {
   test('path splitting - extended cases', () => {
     const cases = [
       // Multiple consecutive array indices.
-      ['matrix[0][1][2]', ['matrix', '0', '1', '2']],
+      ['matrix[0][1][2]', ['matrix', 0, 1, 2]],
       // Properties with underscores and $.
       ['$_foo.bar_baz', ['$_foo', 'bar_baz']],
       // Deep nesting.
-      ['very.deep.nested[0].property.path[5]', ['very', 'deep', 'nested', '0', 'property', 'path', '5']],
+      ['very.deep.nested[0].property.path[5]', ['very', 'deep', 'nested', 0, 'property', 'path', 5]],
       // Single character properties.
-      ['a[0].b.c', ['a', '0', 'b', 'c']],
+      ['a[0].b.c', ['a', 0, 'b', 'c']],
       // Properties containing numbers.
-      ['prop123.item456[7]', ['prop123', 'item456', '7']],
+      ['prop123.item456[7]', ['prop123', 'item456', 7]],
     ] as const;
 
     cases.forEach(([input, expected]) => {
@@ -99,3 +99,42 @@ describe('createJsonPath', () => {
     expect(getField({ a: 'foo' }, 'a' as JsonPath)).toBe('foo');
   });
 });
+
+describe('Types', () => {
+  test('checks sanity', async ({ expect }) => {
+    const obj = {};
+    expect(obj).to.exist;
+  });
+});
+
+describe('get/set deep', () => {
+  test('get/set operations', ({ expect }) => {
+    const obj = {
+      name: 'test',
+      items: ['a', 'b', 'c'],
+      nested: {
+        prop: 'value',
+        arr: [1, 2, 3],
+      },
+    };
+
+    // Basic property access.
+    expect(getValue(obj, 'name' as JsonPath)).toBe('test');
+
+    // Array index access.
+    expect(getValue(obj, 'items[1]' as JsonPath)).toBe('b');
+
+    // Nested property access.
+    expect(getValue(obj, 'nested.prop' as JsonPath)).toBe('value');
+
+    // Nested array access.
+    expect(getValue(obj, 'nested.arr[2]' as JsonPath)).toBe(3);
+
+    // Setting values.
+    const updated1 = setValue(obj, 'items[1]' as JsonPath, 'x');
+    expect(updated1.items[1]).toBe('x');
+
+    const updated2 = setValue(obj, 'nested.arr[0]' as JsonPath, 99);
+    expect(updated2.nested.arr[0]).toBe(99);
+  });
+});

package/src/{jsonPath.ts → json-path.ts}

@@ -2,20 +2,26 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Option, Schema } from 'effect';
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
 import { JSONPath } from 'jsonpath-plus';
 
 import { invariant } from '@dxos/invariant';
+import { getDeep, setDeep } from '@dxos/util';
 
 export type JsonProp = string & { __JsonPath: true; __JsonProp: true };
 export type JsonPath = string & { __JsonPath: true };
 
+// TODO(burdon): Start with "$."?
+
 const PATH_REGEX = /^($|[a-zA-Z_$][\w$]*(?:\.[a-zA-Z_$][\w$]*|\[\d+\](?:\.)?)*$)/;
+
 const PROP_REGEX = /^\w+$/;
 
 /**
  * https://www.ietf.org/archive/id/draft-goessner-dispatch-jsonpath-00.html
  */
+// TODO(burdon): Keys could be arbitrary strings.
 export const JsonPath = Schema.String.pipe(Schema.pattern(PATH_REGEX)).annotations({
   title: 'JSON path',
   description: 'JSON path to a property',
@@ -49,7 +55,7 @@ export const isJsonPath = (value: unknown): value is JsonPath => {
  * @param path Array of string or number segments
  * @returns Valid JsonPath or undefined if invalid
  */
-export const createJsonPath = (path: (string | number)[]): JsonPath => {
+export const createJsonPath = (path: readonly (string | number)[]): JsonPath => {
   const candidatePath = path
     .map((p, i) => {
       if (typeof p === 'number') {
@@ -79,7 +85,7 @@ export const fromEffectValidationPath = (effectPath: string): JsonPath => {
  * Splits a JsonPath into its constituent parts.
  * Handles property access and array indexing.
  */
-export const splitJsonPath = (path: JsonPath): string[] => {
+export const splitJsonPath = (path: JsonPath): (string | number)[] => {
   if (!isJsonPath(path)) {
     return [];
   }
@@ -87,14 +93,33 @@ export const splitJsonPath = (path: JsonPath): string[] => {
   return (
     path
       .match(/[a-zA-Z_$][\w$]*|\[\d+\]/g)
-      ?.map((part) => (part.startsWith('[') ? part.replace(/[[\]]/g, '') : part)) ?? []
+      ?.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.
  */
+// TODO(burdon): Reconcile with getValue.
 export const getField = (object: any, path: JsonPath): any => {
   // By default, JSONPath returns an array of results.
   return JSONPath({ path, json: object })[0];
 };
+
+/**
+ * Get value from object using JsonPath.
+ */
+export const getValue = <T extends object>(obj: T, path: JsonPath): any => {
+  return getDeep(obj, splitJsonPath(path));
+};
+
+/**
+ * Set value on object using JsonPath.
+ */
+export const setValue = <T extends object>(obj: T, path: JsonPath, value: any): T => {
+  return setDeep(obj, splitJsonPath(path), value);
+};

package/src/layers.test.ts

@@ -3,9 +3,15 @@
 //
 
 import { it } from '@effect/vitest';
-import { Context, Duration, Effect, Layer, ManagedRuntime } from 'effect';
+import * as Context from 'effect/Context';
+import * as Duration from 'effect/Duration';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
 import { test } from 'vitest';
 
+import { runAndForwardErrors } from './errors';
+
 class ClientConfig extends Context.Tag('ClientConfig')<ClientConfig, { endpoint: string }>() {}
 
 class Client extends Context.Tag('Client')<Client, { call: () => Effect.Effect<void> }>() {
@@ -72,7 +78,7 @@ class ClientPlugin {
   async run() {
     const layer = Layer.provide(Client.layer, this._serverPlugin.clientConfigLayer);
 
-    await Effect.runPromise(
+    await runAndForwardErrors(
       Effect.gen(function* () {
         const client = yield* Client;
         yield* client.call();
@@ -85,7 +91,7 @@ test.skip('plugins', async () => {
   const serverPlugin = new ServerPlugin();
   console.log('ServerPlugin created');
 
-  await Effect.runPromise(Effect.sleep(Duration.millis(500)));
+  await runAndForwardErrors(Effect.sleep(Duration.millis(500)));
   console.log('wake up');
 
   {

package/src/otel.test.ts

@@ -15,7 +15,8 @@ import {
   ATTR_CODE_STACKTRACE,
   ATTR_SERVICE_NAME,
 } from '@opentelemetry/semantic-conventions';
-import { Duration, Effect } from 'effect';
+import * as Duration from 'effect/Duration';
+import * as Effect from 'effect/Effect';
 import { beforeEach } from 'vitest';
 
 import { LogLevel, type LogProcessor, log } from '@dxos/log';
@@ -75,6 +76,7 @@ const makeOtelLogProcessor = (logger: Logger): LogProcessor => {
     });
   };
 };
+
 log.addProcessor(makeOtelLogProcessor(logger));
 
 beforeAll(() => {

package/src/otel.ts

@@ -2,10 +2,12 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Resource, Tracer } from '@effect/opentelemetry';
+import * as Resource from '@effect/opentelemetry/Resource';
+import * as Tracer from '@effect/opentelemetry/Tracer';
 import { type Attributes, trace } from '@opentelemetry/api';
-import { Effect, Layer } from 'effect';
-import { type LazyArg } from 'effect/Function';
+import * as Effect from 'effect/Effect';
+import type * as Function from 'effect/Function';
+import * as Layer from 'effect/Layer';
 
 export interface Configuration {
   readonly resource?:
@@ -19,9 +21,11 @@ export interface Configuration {
 
 // Based on https://github.com/Effect-TS/effect/blob/main/packages/opentelemetry/src/NodeSdk.ts
 export const layerOtel: {
-  (evaluate: LazyArg<Configuration>): Layer.Layer<Resource.Resource>;
+  (evaluate: Function.LazyArg<Configuration>): Layer.Layer<Resource.Resource>;
   <R, E>(evaluate: Effect.Effect<Configuration, E, R>): Layer.Layer<Resource.Resource, E, R>;
-} = (evaluate: LazyArg<Configuration> | Effect.Effect<Configuration, any, any>): Layer.Layer<Resource.Resource> =>
+} = (
+  evaluate: Function.LazyArg<Configuration> | Effect.Effect<Configuration, any, any>,
+): Layer.Layer<Resource.Resource> =>
   Layer.unwrapEffect(
     Effect.map(
       Effect.isEffect(evaluate) ? (evaluate as Effect.Effect<Configuration>) : Effect.sync(evaluate),

package/src/resource.test.ts

@@ -3,15 +3,15 @@
 //
 
 import { it } from '@effect/vitest';
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 
-import { accuireReleaseResource } from './resource';
+import { acquireReleaseResource } from './resource';
 
 it.effect(
   'acquire-release',
   Effect.fn(function* ({ expect }) {
     const events: string[] = [];
-    const makeResource = accuireReleaseResource(() => ({
+    const makeResource = acquireReleaseResource(() => ({
       open: () => {
         events.push('open');
       },

package/src/resource.ts

@@ -2,24 +2,29 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
+import type * as Scope from 'effect/Scope';
 
 import type { Lifecycle } from '@dxos/context';
 
-// TODO(dmaretskyi): Extract to effect-utils.
-export const accuireReleaseResource = <T extends Lifecycle>(getResource: () => T) =>
+/**
+ * Acquires a resource and releases it when the scope is closed.
+ */
+export const acquireReleaseResource = <T extends Lifecycle>(
+  getResource: () => T,
+): Effect.Effect<T, never, Scope.Scope> =>
   Effect.acquireRelease(
     Effect.gen(function* () {
       const resource = getResource();
       yield* Effect.promise(async () => {
-        resource.open?.();
+        await resource.open?.();
         return undefined;
       });
       return resource;
     }),
     (resource) =>
       Effect.promise(async () => {
-        resource.close?.();
+        await resource.close?.();
         return undefined;
       }),
   );

package/src/sanity.test.ts

@@ -2,14 +2,17 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Effect, pipe } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
 import { describe, test } from 'vitest';
 
 import { log } from '@dxos/log';
 
+import { runAndForwardErrors } from './errors';
+
 describe('sanity tests', () => {
   test('function pipeline', async ({ expect }) => {
-    const result = pipe(
+    const result = Function.pipe(
       10,
       (value) => value + 3,
       (value) => value * 2,
@@ -18,36 +21,48 @@ describe('sanity tests', () => {
   });
 
   test('effect pipeline (mixing types)', async ({ expect }) => {
-    const result = await Effect.runPromise(
-      pipe(
+    const result = await runAndForwardErrors(
+      Function.pipe(
         Effect.promise(() => Promise.resolve(100)),
-        Effect.tap((value) => log('tap', { value })),
+        Effect.tap((value) => {
+          log('tap', { value });
+        }),
         Effect.map((value: number) => String(value)),
-        Effect.tap((value) => log('tap', { value })),
+        Effect.tap((value) => {
+          log('tap', { value });
+        }),
         Effect.map((value: string) => value.length),
-        Effect.tap((value) => log('tap', { value })),
+        Effect.tap((value) => {
+          log('tap', { value });
+        }),
       ),
     );
     expect(result).to.eq(3);
   });
 
   test('effect pipeline (mixing sync/async)', async ({ expect }) => {
-    const result = await Effect.runPromise(
-      pipe(
+    const result = await runAndForwardErrors(
+      Function.pipe(
         Effect.succeed(100),
-        Effect.tap((value) => log('tap', { value })),
+        Effect.tap((value) => {
+          log('tap', { value });
+        }),
         Effect.flatMap((value) => Effect.promise(() => Promise.resolve(String(value)))),
-        Effect.tap((value) => log('tap', { value })),
+        Effect.tap((value) => {
+          log('tap', { value });
+        }),
         Effect.map((value) => value.length),
-        Effect.tap((value) => log('tap', { value })),
+        Effect.tap((value) => {
+          log('tap', { value });
+        }),
       ),
     );
     expect(result).to.eq(3);
   });
 
   test('error handling', async ({ expect }) => {
-    Effect.runPromise(
-      pipe(
+    runAndForwardErrors(
+      Function.pipe(
         Effect.succeed(10),
         Effect.map((value) => value * 2),
         Effect.flatMap((value) =>
@@ -62,7 +77,7 @@ describe('sanity tests', () => {
       ),
     )
       .then(() => expect.fail())
-      .catch((error) => {
+      .catch((error: any) => {
         expect(error).to.be.instanceOf(Error);
       });
   });

package/src/testing.ts

@@ -2,20 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Effect } from 'effect';
+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',
@@ -40,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',
@@ -62,28 +57,10 @@ export namespace TestHelpers {
         }
       });
 
-  /**
-   * 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 (!process.env.DX_TEST_TAGS?.includes(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;

package/src/url.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 import { describe, expect, test } from 'vitest';
 
 import { ParamKeyAnnotation, UrlParser } from './url';