@dxos/compute 0.8.4-main.e8ec1fe → 0.8.4-main.f466a3d56e

package/src/index.ts

@@ -1,9 +1,22 @@
 //
-// Copyright 2024 DXOS.org
+// Copyright 2026 DXOS.org
 //
 
-export * from './compute-graph';
-export * from './compute-graph-registry';
-export * from './compute-node';
-export * from './functions';
-export * from './types';
+export * from './errors';
+
+export * as Blueprint from './Blueprint';
+export * as Credential from './Credential';
+export * as McpServer from './McpServer';
+export * as LayerSpec from './LayerSpec';
+export * as Operation from './Operation';
+export * as OperationHandlerSet from './OperationHandlerSet';
+export * as OperationRegistry from './OperationRegistry';
+export * as Process from './Process';
+export * as Routine from './Routine';
+export * as Script from './Script';
+export * as ServiceResolver from './ServiceResolver';
+export * as StorageService from './StorageService';
+export * as Template from './Template';
+export * as Trace from './Trace';
+export * as Trigger from './Trigger';
+export * as TriggerEvent from './TriggerEvent';

package/src/testing/definitions.ts

@@ -0,0 +1,49 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import * as Operation from '../Operation';
+
+export const Fibonacci = Operation.make({
+  meta: {
+    key: 'org.example.function.fib',
+    name: 'Fibonacci',
+    description: 'Function that calculates a Fibonacci number',
+  },
+  input: Schema.Struct({
+    iterations: Schema.optional(Schema.Number).annotations({
+      description: 'Number of iterations',
+      default: 100_000,
+    }),
+  }),
+  output: Schema.Struct({
+    result: Schema.String,
+  }),
+}).pipe(Operation.intrinsic);
+
+export const Reply = Operation.make({
+  meta: {
+    key: 'org.example.function.reply',
+    name: 'Reply',
+    description: 'Function that echoes the input',
+  },
+  input: Schema.Any,
+  output: Schema.Any,
+}).pipe(Operation.intrinsic);
+
+export const Sleep = Operation.make({
+  meta: {
+    key: 'org.example.function.sleep',
+    name: 'Sleep',
+    description: 'Function that sleeps for a given amount of time',
+  },
+  input: Schema.Struct({
+    duration: Schema.optional(Schema.Number).annotations({
+      description: 'Milliseconds to sleep',
+      default: 100_000,
+    }),
+  }),
+  output: Schema.Void,
+}).pipe(Operation.intrinsic);

package/src/testing/fib.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import * as Operation from '../Operation';
+import { Fibonacci } from './definitions';
+
+export default Fibonacci.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ iterations = 100_000 }) {
+      let a = 0n;
+      let b = 1n;
+      for (let i = 0; i < iterations; i++) {
+        a += b;
+        b = a - b;
+      }
+      return { result: a.toString() };
+    }),
+  ),
+);

package/src/testing/index.ts

@@ -1,8 +1,16 @@
 //
-// Copyright 2024 DXOS.org
+// Copyright 2025 DXOS.org
 //
 
-export * from './test-builder';
-export * from './test-plugin';
-export * from './util';
-export * from './test-runtime';
+import * as OperationHandlerSet from '../OperationHandlerSet';
+
+export { Fibonacci, Reply, Sleep } from './definitions';
+export { default as FibonacciHandler } from './fib';
+export { default as ReplyHandler } from './reply';
+export { default as SleepHandler } from './sleep';
+
+export const ExampleHandlers = OperationHandlerSet.lazy(
+  () => import('./fib'),
+  () => import('./reply'),
+  () => import('./sleep'),
+);

package/src/testing/reply.ts

@@ -0,0 +1,18 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+
+import * as Operation from '../Operation';
+import { Reply } from './definitions';
+
+export default Reply.pipe(
+  Operation.withHandler(
+    Effect.fn(function* (input) {
+      yield* Console.log('reply', { input });
+      return input;
+    }),
+  ),
+);

package/src/testing/sleep.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import * as Operation from '../Operation';
+import { Sleep } from './definitions';
+
+export default Sleep.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ duration = 100_000 }) {
+      yield* Effect.sleep(duration);
+    }),
+  ),
+);

package/src/umbrella.test.ts

@@ -0,0 +1,51 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import {
+  Blueprint,
+  Credential,
+  FunctionNotFoundError,
+  Operation,
+  OperationHandlerSet,
+  OperationRegistry,
+  Process,
+  Routine,
+  Script,
+  ServiceResolver,
+  StorageService,
+  Template,
+  Trace,
+  Trigger,
+  TriggerEvent,
+} from './index';
+
+describe('umbrella re-exports', () => {
+  test('top-level re-exports preserve source-package namespace nesting', ({ expect }) => {
+    // Operation primitives.
+    expect(Operation).toBeDefined();
+    expect(OperationHandlerSet).toBeDefined();
+    expect(OperationRegistry).toBeDefined();
+
+    // Blueprint primitives.
+    expect(Blueprint).toBeDefined();
+    expect(Blueprint.make).toBeTypeOf('function');
+    expect(Routine).toBeDefined();
+    expect(Template).toBeDefined();
+
+    // Function primitives.
+    expect(Process).toBeDefined();
+    expect(Trigger).toBeDefined();
+    expect(TriggerEvent).toBeDefined();
+    expect(Script).toBeDefined();
+    expect(Trace).toBeDefined();
+    expect(ServiceResolver).toBeDefined();
+    expect(StorageService).toBeDefined();
+    expect(Credential).toBeDefined();
+
+    // Error classes exported top-level.
+    expect(FunctionNotFoundError).toBeDefined();
+  });
+});