@dxos/compute 0.8.4-main.cb12b3f963 → 0.8.4-main.dfabb4ec29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/compute",
-  "version": "0.8.4-main.cb12b3f963",
+  "version": "0.8.4-main.dfabb4ec29",
   "description": "Umbrella package for AI-aware DXOS compute primitives.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -36,15 +36,15 @@
   ],
   "dependencies": {
     "@effect-atom/atom": "^0.5.1",
-    "handlebars": "4.7.8",
-    "@dxos/ai": "0.8.4-main.cb12b3f963",
-    "@dxos/echo": "0.8.4-main.cb12b3f963",
-    "@dxos/errors": "0.8.4-main.cb12b3f963",
-    "@dxos/invariant": "0.8.4-main.cb12b3f963",
-    "@dxos/log": "0.8.4-main.cb12b3f963",
-    "@dxos/keys": "0.8.4-main.cb12b3f963",
-    "@dxos/protocols": "0.8.4-main.cb12b3f963",
-    "@dxos/schema": "0.8.4-main.cb12b3f963"
+    "@dxos/errors": "0.8.4-main.dfabb4ec29",
+    "@dxos/ai": "0.8.4-main.dfabb4ec29",
+    "@dxos/echo": "0.8.4-main.dfabb4ec29",
+    "@dxos/invariant": "0.8.4-main.dfabb4ec29",
+    "@dxos/keys": "0.8.4-main.dfabb4ec29",
+    "@dxos/log": "0.8.4-main.dfabb4ec29",
+    "@dxos/protocols": "0.8.4-main.dfabb4ec29",
+    "@dxos/schema": "0.8.4-main.dfabb4ec29",
+    "@dxos/vendor-kbn-handlebars": "0.8.4-main.dfabb4ec29"
   },
   "devDependencies": {
     "effect": "3.20.0",

package/src/Blueprint.ts

@@ -2,6 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
+// @import-as-namespace
+
 import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
@@ -11,31 +13,16 @@ import { Annotation, Database, Filter, Obj, Type } from '@dxos/echo';
 import { BaseError } from '@dxos/errors';
 import { log } from '@dxos/log';
 
+import * as McpServer from './McpServer';
 import * as Operation from './Operation';
 import * as Template from './Template';
 
-/**
- * MCP server definition.
- */
-export const McpServer = Schema.Struct({
-  /**
-   * URL of the MCP server.
-   */
-  url: Schema.String.annotations({
-    description: 'URL of the MCP server',
-  }),
-
-  protocol: Schema.Union(Schema.Literal('sse'), Schema.Literal('http')).annotations({
-    description: 'Protocol of the MCP server',
-  }),
-});
-export interface McpServer extends Schema.Schema.Type<typeof McpServer> {}
-
 /**
  * Blueprint schema defines the structure for AI assistant blueprints.
  * Blueprints contain instructions, tools, and artifacts that guide the AI's behavior.
  * Blueprints may use tools to create and read artifacts, which are managed by the assistant.
  */
+// TODO(burdon): Rename Skill?
 export const Blueprint = Schema.Struct({
   /**
    * Global registry ID.
@@ -85,10 +72,9 @@ export const Blueprint = Schema.Struct({
   /**
    * Array of MCP servers that the AI assistant can use when this blueprint is active.
    */
-  mcpServers: Schema.optional(Schema.Array(McpServer)),
+  mcpServers: Schema.optional(Schema.Array(McpServer.McpServer)),
 }).pipe(
   Type.object({
-    // TODO(burdon): Is this a DXN? Need to create a Format type for these IDs.
     typename: 'org.dxos.type.blueprint',
     version: '0.1.0',
   }),

package/src/Credential.ts

@@ -2,6 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
+// @import-as-namespace
+
 import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Redacted from 'effect/Redacted';

package/src/McpServer.ts

@@ -0,0 +1,44 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Schema from 'effect/Schema';
+
+/**
+ * MCP server connection spec — the minimal fields needed to dial an MCP server.
+ *
+ * Used as a value type embedded in blueprints and passed to runtime session connect logic.
+ * The user-facing ECHO object (`@dxos/assistant-toolkit` `McpServer`) composes this struct
+ * and adds instance-level fields (`name`, `enabled`) and ECHO annotations.
+ */
+export const McpServer = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional).annotations({
+    description: 'Human-readable name of the MCP server',
+  }),
+
+  url: Schema.String.annotations({
+    description: 'URL of the MCP server',
+  }),
+
+  /**
+   * Transport protocol. Prefer `'http'` (Streamable HTTP) for new servers; `'sse'` is
+   * kept for compatibility with servers that haven't migrated and is deprecated per
+   * the MCP SDK. Clients support both during the migration period.
+   */
+  protocol: Schema.Union(Schema.Literal('http'), Schema.Literal('sse')).annotations({
+    description: 'Transport protocol of the MCP server (prefer "http"; "sse" deprecated)',
+  }),
+
+  /**
+   * Optional API key sent with requests.
+   * Persisted in plaintext when stored on a space-replicated ECHO object — see the
+   * `@dxos/assistant-toolkit` `McpServer` type for security implications.
+   */
+  apiKey: Schema.optional(Schema.String).annotations({
+    description: 'Optional API key sent with requests',
+  }),
+});
+
+export interface McpServer extends Schema.Schema.Type<typeof McpServer> {}

package/src/Operation.ts

@@ -2,6 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
+// @import-as-namespace
+
 import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
@@ -14,8 +16,6 @@ import { Annotation, JsonSchema, Obj, Ref, Type, type DXN, type Key } from '@dxo
 import type { NoHandlerError } from './errors';
 import type { Operation } from './index';
 
-// @import-as-namespace
-
 /**
  * Schema type that accepts any Encoded form but requires no Context.
  * This allows ECHO object schemas where Type !== Encoded due to [KindId] symbol.
@@ -166,6 +166,21 @@ export const make = <const P extends Types.NoExcessProperties<Props<any, any>, P
   } as any;
 };
 
+/**
+ * Marks an operation as intrinsic — provided directly by the DXOS platform runtime rather than
+ * deployed as a user function. The `intrinsic:<key>` deployedId routes invocations to the
+ * built-in implementation registered with the runtime.
+ */
+export const intrinsic = <const O extends Operation.Definition.Any>(op: O): O => {
+  return {
+    ...op,
+    meta: {
+      ...op.meta,
+      deployedId: `intrinsic:${op.meta.key}`,
+    },
+  };
+};
+
 /**
  * Attaches a handler to an Operation definition.
  * The handler may use any services declared in the operation, plus Operation.Service (always available).
@@ -330,11 +345,16 @@ export const PersistentOperation = Schema$.Struct({
 );
 export interface PersistentOperation extends Schema$.Schema.Type<typeof PersistentOperation> {}
 
+const FUNCTION_META_KEY = 'org.dxos.service.function';
+
 /**
  * Serialize an operation definition to a persistent operation record.
  */
 export const serialize = (operation: Definition.Any): PersistentOperation => {
   return Obj.make(PersistentOperation, {
+    [Obj.Meta]: {
+      keys: operation.meta.deployedId ? [{ source: FUNCTION_META_KEY, id: operation.meta.deployedId }] : [],
+    },
     key: operation.meta.key,
     name: operation.meta.name ?? '',
     version: operation.meta.version ?? '0.0.0',
@@ -352,7 +372,7 @@ export const serialize = (operation: Definition.Any): PersistentOperation => {
  */
 export const deserialize = (record: PersistentOperation): Definition.Any => {
   // Extract deployed function ID from ECHO meta keys (matches FUNCTIONS_META_KEY in @dxos/functions).
-  const deployedId = Obj.getMeta(record).keys.find((key) => key.source === 'org.dxos.service.function')?.id;
+  const deployedId = Obj.getMeta(record).keys.find((key) => key.source === FUNCTION_META_KEY)?.id;
   return make({
     input: record.inputSchema ? JsonSchema.toEffectSchema(record.inputSchema) : Schema$.Unknown,
     output: record.outputSchema ? JsonSchema.toEffectSchema(record.outputSchema) : Schema$.Unknown,

package/src/OperationHandlerSet.ts

@@ -2,6 +2,8 @@
 // Copyright 2026 DXOS.org
 //
 
+// @import-as-namespace
+
 import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';

package/src/OperationRegistry.ts

@@ -2,6 +2,8 @@
 // Copyright 2026 DXOS.org
 //
 
+// @import-as-namespace
+
 import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';

package/src/Routine.ts

@@ -2,6 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
+// @import-as-namespace
+
 import * as Schema from 'effect/Schema';
 
 import { Annotation, JsonSchema, Obj, Ref, Type } from '@dxos/echo';
@@ -13,6 +15,7 @@ import * as Template from './Template';
  * Executable instructions, which may use Blueprints.
  * May reference additional context.
  */
+// TODO(burdon): Name?
 export const Routine = Schema.Struct({
   /**
    * Name of the routine.
@@ -39,6 +42,7 @@ export const Routine = Schema.Struct({
    * Natural language instructions for the routine.
    * These should provide concrete course of action for the AI to follow.
    */
+  // TODO(burdon): Form editor.
   instructions: Template.Template.pipe(Annotation.FormInputAnnotation.set(false)),
 
   /**

package/src/Script.ts

@@ -2,6 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
+// @import-as-namespace
+
 import * as Schema from 'effect/Schema';
 
 import { Annotation, Obj, Ref, Type } from '@dxos/echo';

package/src/StorageService.ts

@@ -2,6 +2,8 @@
 // Copyright 2026 DXOS.org
 //
 
+// @import-as-namespace
+
 import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Option from 'effect/Option';

package/src/Template.test.ts

@@ -0,0 +1,151 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
+import { describe, expect, test } from 'vitest';
+
+import { FunctionNotFoundError } from './errors';
+import * as Operation from './Operation';
+import * as OperationRegistry from './OperationRegistry';
+import * as Template from './Template';
+
+describe('Template', () => {
+  describe('make', () => {
+    test('creates a template with defaults', () => {
+      const template = Template.make();
+      expect(template.source).toBeDefined();
+      expect(template.inputs).toEqual([]);
+    });
+
+    test('wraps the source string as a Text ref', () => {
+      const template = Template.make({ source: 'Hello {{name}}.' });
+      expect(template.source.target?.content).toBe('Hello {{name}}.');
+    });
+
+    test('preserves inputs', () => {
+      const template = Template.make({
+        source: 'Hello {{name}}.',
+        inputs: [{ name: 'name', kind: 'value', default: 'world' }],
+      });
+      expect(template.inputs).toHaveLength(1);
+      expect(template.inputs?.[0]).toMatchObject({ name: 'name', kind: 'value', default: 'world' });
+    });
+  });
+
+  describe('schema', () => {
+    test('Template is a Schema', () => {
+      expect(Schema.isSchema(Template.Template)).toBe(true);
+    });
+
+    test('Input is a Schema', () => {
+      expect(Schema.isSchema(Template.Input)).toBe(true);
+    });
+
+    test('InputKind accepts all documented kinds', () => {
+      const decode = Schema.decodeSync(Template.InputKind);
+      for (const kind of ['value', 'operation']) {
+        expect(decode(kind as any)).toBe(kind);
+      }
+    });
+
+    test('InputKind rejects unknown kinds', () => {
+      expect(() => Schema.decodeSync(Template.InputKind)('nonsense' as any)).toThrow();
+    });
+  });
+
+  describe('process', () => {
+    test('substitutes simple variables', () => {
+      expect(Template.process('Hello {{name}}.', { name: 'world' })).toBe('Hello world.');
+    });
+
+    test('renders an empty variables object as empty placeholders', () => {
+      expect(Template.process('Hello {{name}}.')).toBe('Hello .');
+    });
+
+    test('trims leading and trailing whitespace', () => {
+      expect(Template.process('   \n\nHello.\n\n   ')).toBe('Hello.');
+    });
+
+    test('collapses runs of 3+ blank lines down to one blank line', () => {
+      const input = 'a\n\n\n\n\nb';
+      expect(Template.process(input)).toBe('a\n\nb');
+    });
+
+    test('preserves double newlines', () => {
+      expect(Template.process('a\n\nb')).toBe('a\n\nb');
+    });
+
+    test('{{section}} helper increments on each call', () => {
+      expect(Template.process('{{section}} / {{section}} / {{section}}')).toBe('1 / 2 / 3');
+    });
+  });
+
+  describe('processTemplate', () => {
+    const greet = Operation.withHandler(
+      Operation.make({
+        input: Schema.Void,
+        output: Schema.String,
+        meta: { key: 'test.greet' },
+      }),
+      () => Effect.succeed('Alice'),
+    );
+
+    const stubRegistry = (operations: Record<string, Operation.Definition.Any>) =>
+      Effect.provideService(OperationRegistry.Service, {
+        resolve: (key) => Effect.succeed(Option.fromNullable(operations[key])),
+      });
+
+    const stubInvoker = Effect.provideService(Operation.Service, {
+      invoke: (op, input) => (op as any).handler(input),
+      schedule: () => Effect.succeed(undefined),
+      invokePromise: () => Promise.resolve({}),
+    } as Operation.OperationService);
+
+    test('resolves a value-kind input from its default', async () => {
+      const template = Template.make({
+        source: 'Hello {{name}}!',
+        inputs: [{ name: 'name', kind: 'value', default: 'world' }],
+      });
+
+      const result = await Template.processTemplate(template).pipe(stubRegistry({}), stubInvoker, Effect.runPromise);
+      expect(result).toBe('Hello world!');
+    });
+
+    test('resolves an operation-kind input and substitutes the result', async () => {
+      const template = Template.make({
+        source: 'Hello {{name}}.',
+        inputs: [{ name: 'name', kind: 'operation', operation: 'test.greet' }],
+      });
+
+      const result = await Template.processTemplate(template).pipe(
+        stubRegistry({ 'test.greet': greet }),
+        stubInvoker,
+        Effect.runPromise,
+      );
+
+      expect(result).toBe('Hello Alice.');
+    });
+
+    test('fails with FunctionNotFoundError when the function key cannot be resolved', async () => {
+      const template = Template.make({
+        source: 'Hello {{name}}.',
+        inputs: [{ name: 'name', kind: 'operation', operation: 'test.missing' }],
+      });
+
+      const result = await Template.processTemplate(template).pipe(
+        stubRegistry({}),
+        stubInvoker,
+        Effect.either,
+        Effect.runPromise,
+      );
+
+      expect(result._tag).toBe('Left');
+      if (result._tag === 'Left') {
+        expect(result.left).toBeInstanceOf(FunctionNotFoundError);
+      }
+    });
+  });
+});

package/src/Template.ts

@@ -2,16 +2,17 @@
 // Copyright 2024 DXOS.org
 //
 
+// @import-as-namespace
+
 import * as Effect from 'effect/Effect';
-import * as Record from 'effect/Record';
 import * as Schema from 'effect/Schema';
-import handlebars from 'handlebars';
 
 import { Database, Ref } from '@dxos/echo';
 import type { ObjectNotFoundError } from '@dxos/echo/Err';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import { Text } from '@dxos/schema';
+import Handlebars from '@dxos/vendor-kbn-handlebars';
 
 import { FunctionNotFoundError } from './errors';
 import * as Operation from './Operation';
@@ -22,13 +23,13 @@ import * as OperationRegistry from './OperationRegistry';
  */
 export const InputKind = Schema.Literal(
   'value', // Literal value.
-  'pass-through',
-  'retriever',
-  'function',
-  'query',
-  'resolver',
-  'context',
-  'schema',
+  'operation',
+  // 'pass-through',
+  // 'retriever',
+  // 'query',
+  // 'resolver',
+  // 'context',
+  // 'schema',
 );
 
 export type InputKind = Schema.Schema.Type<typeof InputKind>;
@@ -39,13 +40,13 @@ export type InputKind = Schema.Schema.Type<typeof InputKind>;
  */
 export const Input = Schema.Struct({
   name: Schema.String,
-  kind: Schema.optional(InputKind),
+  kind: InputKind,
   default: Schema.optional(Schema.Any),
-
   /**
-   * Function to call if the kind is 'function'.
+   * Operation key invoked when `kind === 'operation'`. The referenced operation must accept void input —
+   * template inputs have no mechanism for passing arguments.
    */
-  function: Schema.optional(Schema.String),
+  operation: Schema.optional(Schema.String),
 });
 
 export type Input = Schema.Schema.Type<typeof Input>;
@@ -54,17 +55,19 @@ export type Input = Schema.Schema.Type<typeof Input>;
  * Template type.
  */
 export const Template = Schema.Struct({
-  source: Ref.Ref(Text.Text).annotations({ description: 'Handlebars template source' }),
+  source: Ref.Ref(Text.Text).annotations({ description: 'Markdown + Handlebars template.' }),
+
+  /**
+   * NOTE: We use an array rather than map so that updating variable names in the template doesn't disconnect existing inputs.
+   */
   inputs: Schema.optional(Schema.Array(Input)),
 });
 
 export interface Template extends Schema.Schema.Type<typeof Template> {}
 
-export const make = ({
-  id,
-  source,
-  inputs = [],
-}: { id?: string; source?: string; inputs?: Input[] } = {}): Template => ({
+export type MakeProps = Partial<{ id: string; source: string; inputs: Input[] }>;
+
+export const make = ({ id, source, inputs = [] }: MakeProps = {}): Template => ({
   source: Ref.make(Text.make({ id, content: source })),
   inputs,
 });
@@ -75,8 +78,9 @@ export const make = ({
 export const process = <Options extends {}>(source: string, variables: Partial<Options> = {}): string => {
   invariant(typeof source === 'string');
   let section = 0;
+  const handlebars = Handlebars.create();
   handlebars.registerHelper('section', () => String(++section));
-  const template = handlebars.compile(source.trim());
+  const template = handlebars.compileAST(source.trim());
   const output = template(variables);
   return output.trim().replace(/(\n\s*){3,}/g, '\n\n');
 };
@@ -85,20 +89,33 @@ export const processTemplate = (
   template: Template,
 ): Effect.Effect<string, ObjectNotFoundError | FunctionNotFoundError, OperationRegistry.Service | Operation.Service> =>
   Effect.gen(function* () {
-    const variables = yield* Effect.forEach(template.inputs ?? [], (input) =>
+    const entries = yield* Effect.forEach(template.inputs ?? [], (input) =>
       Effect.gen(function* () {
-        if (input.kind === 'function') {
-          const fn = yield* OperationRegistry.resolve(input.function!).pipe(
-            Effect.flatten,
-            Effect.catchTag('NoSuchElementException', () => Effect.fail(new FunctionNotFoundError(input.function!))),
-          );
-          const result = yield* Operation.invoke(fn, {} as any).pipe(Effect.orDie);
-          return [input.name, result] as const;
-        } else {
-          return yield* Effect.dieMessage(`Unsupported input kind: ${input.kind}`);
+        switch (input.kind) {
+          case 'value': {
+            return [input.name, input.default] as const;
+          }
+
+          case 'operation': {
+            invariant(input.operation);
+            const fn = yield* OperationRegistry.resolve(input.operation).pipe(
+              Effect.flatten,
+              Effect.catchTag('NoSuchElementException', () => Effect.fail(new FunctionNotFoundError(input.operation!))),
+            );
+
+            // NOTE: Operations referenced by template inputs must accept void input — see `Input.operation`.
+            const result = yield* Operation.invoke(fn, undefined as any).pipe(Effect.orDie);
+            return [input.name, result] as const;
+          }
+
+          default: {
+            return yield* Effect.dieMessage(`Unsupported input kind: ${input.kind}`);
+          }
         }
       }),
-    ).pipe(Effect.map(Record.fromEntries));
+    );
+
+    const variables = Object.fromEntries(entries);
 
     log('processTemplate', { variables });
     return process((yield* Database.load(template.source)).content, variables);

package/src/Trigger.ts

@@ -2,6 +2,8 @@
 // Copyright 2023 DXOS.org
 //
 
+// @import-as-namespace
+
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 

package/src/TriggerEvent.ts

@@ -2,6 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
+// @import-as-namespace
+
 import * as Schema from 'effect/Schema';
 
 import { DXN, Obj, Ref } from '@dxos/echo';

package/src/errors.ts

@@ -48,3 +48,24 @@ export class InvalidOperationOutputError extends BaseError.extend(
 ) {}
 
 export class TriggerStateNotFoundError extends BaseError.extend('TriggerStateNotFound', 'Trigger state not found') {}
+
+/**
+ * Raised when the upstream AI gateway responds with a structured JSON error envelope
+ * (`{ "type": "error", "error": { "type": ..., "message": ... } }`). Surfaces as a typed
+ * defect from `FunctionsAiHttpClient`, bypassing `@effect/ai`'s generic `HttpResponseError`
+ * wrapping so callers can match on the error class directly.
+ */
+export class FunctionsAiUpstreamError extends BaseError.extend(
+  'FunctionsAiUpstreamError',
+  'Upstream AI service returned an error',
+) {}
+
+/**
+ * Specialized `FunctionsAiUpstreamError` for the memoization layer: the recorded fixture for a
+ * given cache key was not found and `ALLOW_LLM_GENERATION` is unset. The `cacheKey` is exposed
+ * via `context.cacheKey` to make regeneration straightforward.
+ */
+export class FunctionsAiMemoizationMissError extends BaseError.extend(
+  'FunctionsAiMemoizationMissError',
+  'No memoized AI conversation found for the given cache key',
+) {}

package/src/index.ts

@@ -2,9 +2,11 @@
 // Copyright 2026 DXOS.org
 //
 
+export * from './errors';
+
 export * as Blueprint from './Blueprint';
 export * as Credential from './Credential';
-export * from './errors';
+export * as McpServer from './McpServer';
 export * as Operation from './Operation';
 export * as OperationHandlerSet from './OperationHandlerSet';
 export * as OperationRegistry from './OperationRegistry';

package/src/testing/definitions.ts

@@ -21,7 +21,7 @@ export const Fibonacci = Operation.make({
   output: Schema.Struct({
     result: Schema.String,
   }),
-});
+}).pipe(Operation.intrinsic);
 
 export const Reply = Operation.make({
   meta: {
@@ -31,7 +31,7 @@ export const Reply = Operation.make({
   },
   input: Schema.Any,
   output: Schema.Any,
-});
+}).pipe(Operation.intrinsic);
 
 export const Sleep = Operation.make({
   meta: {
@@ -46,4 +46,4 @@ export const Sleep = Operation.make({
     }),
   }),
   output: Schema.Void,
-});
+}).pipe(Operation.intrinsic);

package/dist/lib/neutral/chunk-DDEBBRCI.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/StorageService.ts"],
-  "sourcesContent": ["//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Option from 'effect/Option';\nimport * as Pipeable from 'effect/Pipeable';\nimport * as Schema from 'effect/Schema';\n\nexport interface Service {\n  /** Read a value by key. Returns `None` if key does not exist. */\n  get<S extends Schema.Schema<any, string, any>>(\n    schema: S,\n    key: string,\n  ): Effect.Effect<Option.Option<Schema.Schema.Type<S>>, never, Schema.Schema.Context<S>>;\n\n  /** Write a value for the given key. */\n  set<S extends Schema.Schema<any, string, any>>(\n    schema: S,\n    key: string,\n    value: Schema.Schema.Type<S>,\n  ): Effect.Effect<void, never, Schema.Schema.Context<S>>;\n\n  /** Remove a key. */\n  delete(key: string): Effect.Effect<void>;\n\n  /** List all keys, optionally filtered by prefix. */\n  list(prefix?: string): Effect.Effect<readonly string[]>;\n\n  /** Remove all keys managed by this scoped store. */\n  clear(): Effect.Effect<void>;\n}\n\n/**\n * Scoped key-value storage service for processes.\n * Each process receives its own namespaced instance via the process manager.\n * Construct a live implementation with `StorageService.layer` from `@dxos/functions-runtime`.\n */\nexport class StorageService extends Context.Tag('@dxos/functions/StorageService')<StorageService, Service>() {}\n\nexport const get = Effect.serviceFunctionEffect(StorageService, (_) => _.get);\nexport const set = Effect.serviceFunctionEffect(StorageService, (_) => _.set);\nexport const deleteKey = Effect.serviceFunctionEffect(StorageService, (_) => _.delete);\nexport const list = Effect.serviceFunctionEffect(StorageService, (_) => _.list);\nexport const clear = Effect.serviceFunctionEffect(StorageService, (_) => _.clear);\n\n/**\n * Typed key in a storage service.\n */\nexport interface Key<T> extends Pipeable.Pipeable {\n  readonly key: string;\n\n  get: Effect.Effect<Option.Option<T>, never, StorageService>;\n  set(value: T): Effect.Effect<void, never, StorageService>;\n  delete(): Effect.Effect<void, never, StorageService>;\n}\n\n/**\n * Create a typed key in a storage service.\n */\nexport const key = <S extends Schema.Schema<any, string, any>>(schema: S, key: string): Key<Schema.Schema.Type<S>> => {\n  return {\n    key,\n    get: get(schema, key),\n    set: (value: Schema.Schema.Type<S>) => set(schema, key, value),\n    delete: () => deleteKey(key),\n    pipe(...args: any) {\n      return Pipeable.pipeArguments(this, arguments);\n    },\n  };\n};\n\n/**\n * Typed key in a storage service with a default value.\n */\nexport interface KeyWithDefault<T, U> extends Pipeable.Pipeable {\n  readonly key: string;\n  get: Effect.Effect<T | U, never, StorageService>;\n  set(value: U): Effect.Effect<void, never, StorageService>;\n  delete(): Effect.Effect<void, never, StorageService>;\n}\n\n/**\n * Assign a default value to a key if it is not present.\n */\nexport const withDefault =\n  <T>(getDefault: () => NoInfer<T>) =>\n  (key: Key<T>): KeyWithDefault<T, T> => {\n    return {\n      key: key.key,\n      get: key.get.pipe(Effect.map(Option.getOrElse(() => getDefault()))),\n      set: (value) => key.set(value),\n      delete: () => key.delete(),\n      pipe(...args: any) {\n        return Pipeable.pipeArguments(this, arguments);\n      },\n    };\n  };\n"],
-  "mappings": ";;;;;AAAA;;;;;;;;;;;AAIA,YAAYA,aAAa;AACzB,YAAYC,YAAY;AACxB,YAAYC,YAAY;AACxB,YAAYC,cAAc;AAgCnB,IAAMC,iBAAN,cAAqCC,YAAI,gCAAA,EAAA,EAAA;AAA8D;AAEvG,IAAMC,MAAaC,6BAAsBH,gBAAgB,CAACI,MAAMA,EAAEF,GAAG;AACrE,IAAMG,MAAaF,6BAAsBH,gBAAgB,CAACI,MAAMA,EAAEC,GAAG;AACrE,IAAMC,YAAmBH,6BAAsBH,gBAAgB,CAACI,MAAMA,EAAEG,MAAM;AAC9E,IAAMC,OAAcL,6BAAsBH,gBAAgB,CAACI,MAAMA,EAAEI,IAAI;AACvE,IAAMC,QAAeN,6BAAsBH,gBAAgB,CAACI,MAAMA,EAAEK,KAAK;AAgBzE,IAAMC,MAAM,CAA4CC,QAAWD,SAAAA;AACxE,SAAO;IACLA,KAAAA;IACAR,KAAKA,IAAIS,QAAQD,IAAAA;IACjBL,KAAK,CAACO,UAAiCP,IAAIM,QAAQD,MAAKE,KAAAA;IACxDL,QAAQ,MAAMD,UAAUI,IAAAA;IACxBG,QAAQC,MAAS;AACf,aAAgBC,uBAAc,MAAMC,SAAAA;IACtC;EACF;AACF;AAeO,IAAMC,cACX,CAAIC,eACJ,CAACR,SAAAA;AACC,SAAO;IACLA,KAAKA,KAAIA;IACTR,KAAKQ,KAAIR,IAAIW,KAAYM,WAAWC,iBAAU,MAAMF,WAAAA,CAAAA,CAAAA,CAAAA;IACpDb,KAAK,CAACO,UAAUF,KAAIL,IAAIO,KAAAA;IACxBL,QAAQ,MAAMG,KAAIH,OAAM;IACxBM,QAAQC,MAAS;AACf,aAAgBC,uBAAc,MAAMC,SAAAA;IACtC;EACF;AACF;",
-  "names": ["Context", "Effect", "Option", "Pipeable", "StorageService", "Tag", "get", "serviceFunctionEffect", "_", "set", "deleteKey", "delete", "list", "clear", "key", "schema", "value", "pipe", "args", "pipeArguments", "arguments", "withDefault", "getDefault", "map", "getOrElse"]
-}