@dxos/compute 0.8.4-main.fd6878d → 0.9.0

package/dist/lib/neutral/chunk-XEVFBI6S.mjs

@@ -0,0 +1,62 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/StorageService.ts
+var StorageService_exports = {};
+__export(StorageService_exports, {
+  StorageService: () => StorageService,
+  clear: () => clear,
+  deleteKey: () => deleteKey,
+  get: () => get,
+  key: () => key,
+  list: () => list,
+  set: () => set,
+  withDefault: () => withDefault
+});
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Pipeable from "effect/Pipeable";
+var StorageService = class extends Context.Tag("@dxos/functions/StorageService")() {
+};
+var get = Effect.serviceFunctionEffect(StorageService, (_) => _.get);
+var set = Effect.serviceFunctionEffect(StorageService, (_) => _.set);
+var deleteKey = Effect.serviceFunctionEffect(StorageService, (_) => _.delete);
+var list = Effect.serviceFunctionEffect(StorageService, (_) => _.list);
+var clear = Effect.serviceFunctionEffect(StorageService, (_) => _.clear);
+var key = (schema, key2) => {
+  return {
+    key: key2,
+    get: get(schema, key2),
+    set: (value) => set(schema, key2, value),
+    delete: () => deleteKey(key2),
+    pipe(...args) {
+      return Pipeable.pipeArguments(this, arguments);
+    }
+  };
+};
+var withDefault = (getDefault) => (key2) => {
+  return {
+    key: key2.key,
+    get: key2.get.pipe(Effect.map(Option.getOrElse(() => getDefault()))),
+    set: (value) => key2.set(value),
+    delete: () => key2.delete(),
+    pipe(...args) {
+      return Pipeable.pipeArguments(this, arguments);
+    }
+  };
+};
+
+export {
+  StorageService,
+  get,
+  set,
+  deleteKey,
+  list,
+  clear,
+  key,
+  withDefault,
+  StorageService_exports
+};
+//# sourceMappingURL=chunk-XEVFBI6S.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/StorageService.ts"],
+  "sourcesContent": ["//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\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;;;;;;;;;;;AAMA,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"]
+}

package/dist/lib/neutral/chunk-Z3Y7FQGN.mjs

@@ -0,0 +1,174 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/errors.ts
+import { BaseError } from "@dxos/errors";
+var InvokerNotInitializedError = class extends BaseError.extend("InvokerNotInitializedError", "Invoker not initialized") {
+  constructor() {
+    super();
+  }
+};
+var NoHandlerError = class extends BaseError.extend("NoHandlerError", "No handler found for operation. ") {
+  constructor(operationKey) {
+    super({
+      context: {
+        operationKey
+      }
+    });
+  }
+};
+var ServiceNotAvailableError = class extends BaseError.extend("ServiceNotAvailable", "Service not available") {
+  constructor(service, options) {
+    super({
+      context: {
+        service
+      },
+      message: `Service not available: ${service}`,
+      ...options
+    });
+  }
+};
+var FunctionNotFoundError = class extends BaseError.extend("FunctionNotFound", "Function not found") {
+  constructor(functionKey, options) {
+    super({
+      context: {
+        function: functionKey
+      },
+      ...options
+    });
+  }
+};
+var FunctionError = class extends BaseError.extend("FunctionError", "Function invocation error") {
+};
+var InvalidOperationInputError = class extends BaseError.extend("InvalidOperationInput", "Operation input did not match schema") {
+};
+var InvalidOperationOutputError = class extends BaseError.extend("InvalidOperationOutput", "Operation output did not match schema") {
+};
+var TriggerStateNotFoundError = class extends BaseError.extend("TriggerStateNotFound", "Trigger state not found") {
+};
+var FunctionsAiUpstreamError = class extends BaseError.extend("FunctionsAiUpstreamError", "Upstream AI service returned an error") {
+};
+var FunctionsAiMemoizationMissError = class extends BaseError.extend("FunctionsAiMemoizationMissError", "No memoized AI conversation found for the given cache key") {
+};
+
+// src/OperationHandlerSet.ts
+var OperationHandlerSet_exports = {};
+__export(OperationHandlerSet_exports, {
+  OperationHandlerProvider: () => OperationHandlerProvider,
+  TypeId: () => TypeId,
+  async: () => async,
+  empty: () => empty,
+  getHandler: () => getHandler,
+  getHandlerByKey: () => getHandlerByKey,
+  isOperationHandlerSet: () => isOperationHandlerSet,
+  lazy: () => lazy,
+  make: () => make,
+  merge: () => merge,
+  provide: () => provide,
+  reactive: () => reactive
+});
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import { pipe } from "effect/Function";
+import * as Layer from "effect/Layer";
+import { EffectEx } from "@dxos/effect";
+import { assertArgument } from "@dxos/invariant";
+import { DXN } from "@dxos/keys";
+var TypeId = "~@dxos/operation/OperationHandlerSet";
+var isOperationHandlerSet = (value) => {
+  return typeof value === "object" && value !== null && TypeId in value;
+};
+var empty = {
+  [TypeId]: TypeId,
+  handlers: Effect.succeed([]),
+  getHandlers: () => Promise.resolve([])
+};
+var make = (...handlers) => {
+  return async(() => Promise.resolve(handlers));
+};
+var async = (getHandlers) => {
+  let promise2 = null;
+  const getHandlersCached = () => {
+    if (!promise2) {
+      promise2 = getHandlers();
+    }
+    return promise2;
+  };
+  return {
+    [TypeId]: TypeId,
+    getHandlers,
+    handlers: Effect.promise(getHandlersCached)
+  };
+};
+var reactive = (registry, atom) => {
+  let cached = null;
+  registry.subscribe(atom, () => {
+    cached = null;
+  });
+  const compute = Effect.suspend(() => pipe(
+    registry.get(atom),
+    Effect.forEach((set) => set.handlers, {
+      concurrency: "unbounded"
+    }),
+    Effect.map((groups) => groups.flat()),
+    // Reset cached on failure so a transient error doesn't permanently
+    // poison subsequent calls.
+    Effect.tapErrorCause(() => Effect.sync(() => {
+      cached = null;
+    }))
+  ));
+  const getHandlers = () => cached ??= EffectEx.runAndForwardErrors(compute);
+  return {
+    [TypeId]: TypeId,
+    getHandlers,
+    handlers: Effect.promise(getHandlers)
+  };
+};
+var merge = (...sets) => {
+  assertArgument(sets.every(isOperationHandlerSet), "sets", "sets must be an array of OperationHandlerSet");
+  return async(() => Promise.all(sets.map((set) => set.getHandlers())).then((handlers) => handlers.flat()));
+};
+var lazy = (...modules) => {
+  return async(() => Promise.all(modules.map((module) => module().then(({ default: handler }) => handler))));
+};
+var getHandler = (set, definition) => Effect.gen(function* () {
+  const handlers = yield* set.handlers;
+  const handler = handlers.find((handler2) => handler2.meta.key === definition.meta.key);
+  if (!handler) {
+    return yield* Effect.fail(new NoHandlerError(definition.meta.key));
+  }
+  return handler;
+});
+var getHandlerByKey = (set, key) => Effect.gen(function* () {
+  const handlers = yield* set.handlers;
+  const normalizeKey = (k) => DXN.isDXN(k) ? DXN.getName(k) : k;
+  const normalizedKey = normalizeKey(key);
+  const handler = handlers.find((handler2) => normalizeKey(handler2.meta.key) === normalizedKey);
+  if (!handler) {
+    return yield* Effect.fail(new NoHandlerError(key));
+  }
+  return handler;
+});
+var OperationHandlerProvider = class extends Context.Tag("@dxos/operation/OperationHandlerProvider")() {
+};
+var provide = (handlers) => Layer.succeed(OperationHandlerProvider, handlers);
+
+export {
+  InvokerNotInitializedError,
+  NoHandlerError,
+  ServiceNotAvailableError,
+  FunctionNotFoundError,
+  FunctionError,
+  InvalidOperationInputError,
+  InvalidOperationOutputError,
+  TriggerStateNotFoundError,
+  FunctionsAiUpstreamError,
+  FunctionsAiMemoizationMissError,
+  lazy,
+  getHandler,
+  getHandlerByKey,
+  OperationHandlerProvider,
+  OperationHandlerSet_exports
+};
+//# sourceMappingURL=chunk-Z3Y7FQGN.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/errors.ts", "../../../src/OperationHandlerSet.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { BaseError, type BaseErrorOptions } from '@dxos/errors';\n\n// Errors from @dxos/operation.\n\nexport class InvokerNotInitializedError extends BaseError.extend(\n  'InvokerNotInitializedError',\n  'Invoker not initialized',\n) {\n  constructor() {\n    super();\n  }\n}\n\nexport class NoHandlerError extends BaseError.extend('NoHandlerError', 'No handler found for operation. ') {\n  constructor(operationKey: string) {\n    super({ context: { operationKey } });\n  }\n}\n\n// Errors from @dxos/functions.\n\nexport class ServiceNotAvailableError extends BaseError.extend('ServiceNotAvailable', 'Service not available') {\n  constructor(service: string, options?: Omit<BaseErrorOptions, 'context'>) {\n    super({ context: { service }, message: `Service not available: ${service}`, ...options });\n  }\n}\n\nexport class FunctionNotFoundError extends BaseError.extend('FunctionNotFound', 'Function not found') {\n  constructor(functionKey: string, options?: Omit<BaseErrorOptions, 'context'>) {\n    super({ context: { function: functionKey }, ...options });\n  }\n}\n\nexport class FunctionError extends BaseError.extend('FunctionError', 'Function invocation error') {}\n\nexport class InvalidOperationInputError extends BaseError.extend(\n  'InvalidOperationInput',\n  'Operation input did not match schema',\n) {}\n\nexport class InvalidOperationOutputError extends BaseError.extend(\n  'InvalidOperationOutput',\n  'Operation output did not match schema',\n) {}\n\nexport class TriggerStateNotFoundError extends BaseError.extend('TriggerStateNotFound', 'Trigger state not found') {}\n\n/**\n * Raised when the upstream AI gateway responds with a structured JSON error envelope\n * (`{ \"type\": \"error\", \"error\": { \"type\": ..., \"message\": ... } }`). Surfaces as a typed\n * defect from `FunctionsAiHttpClient`, bypassing `@effect/ai`'s generic `HttpResponseError`\n * wrapping so callers can match on the error class directly.\n */\nexport class FunctionsAiUpstreamError extends BaseError.extend(\n  'FunctionsAiUpstreamError',\n  'Upstream AI service returned an error',\n) {}\n\n/**\n * Specialized `FunctionsAiUpstreamError` for the memoization layer: the recorded fixture for a\n * given cache key was not found and `ALLOW_LLM_GENERATION` is unset. The `cacheKey` is exposed\n * via `context.cacheKey` to make regeneration straightforward.\n */\nexport class FunctionsAiMemoizationMissError extends BaseError.extend(\n  'FunctionsAiMemoizationMissError',\n  'No memoized AI conversation found for the given cache key',\n) {}\n", "//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\nimport { type Atom, type Registry } from '@effect-atom/atom';\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport { pipe } from 'effect/Function';\nimport * as Layer from 'effect/Layer';\n\nimport { EffectEx } from '@dxos/effect';\nimport { assertArgument } from '@dxos/invariant';\nimport { DXN } from '@dxos/keys';\n\nimport { NoHandlerError } from './errors';\nimport type * as Operation from './Operation';\n\nexport const TypeId = '~@dxos/operation/OperationHandlerSet' as const;\nexport type TypeId = typeof TypeId;\n\nexport interface OperationHandlerSet {\n  [TypeId]: TypeId;\n\n  readonly handlers: Effect.Effect<Operation.WithHandler<Operation.Definition.Any>[]>;\n\n  getHandlers(): Promise<Operation.WithHandler<Operation.Definition.Any>[]>;\n}\n\nexport const isOperationHandlerSet = (value: unknown): value is OperationHandlerSet => {\n  return typeof value === 'object' && value !== null && TypeId in value;\n};\n\nexport const empty: OperationHandlerSet = {\n  [TypeId]: TypeId,\n  handlers: Effect.succeed([]),\n  getHandlers: () => Promise.resolve([]),\n};\n\n/**\n * Creates a new operation handler set from a list of handlers.\n *\n * @example\n * ```ts\n * const set = OperationHandlerSet.make(\n *   Operation.withHandler(Operation.make({ input: Schema.Void, output: Schema.Void }), (input) => Effect.succeed({})),\n *   Operation.withHandler(Operation.make({ input: Schema.Void, output: Schema.Void }), (input) => Effect.succeed({})),\n * );\n * ```\n */\nexport const make = (...handlers: Operation.WithHandler<Operation.Definition.Any>[]): OperationHandlerSet => {\n  return async(() => Promise.resolve(handlers));\n};\n\nexport const async = (\n  getHandlers: () => Promise<Operation.WithHandler<Operation.Definition.Any>[]>,\n): OperationHandlerSet => {\n  // NOTE: Re-runing async module imports has a big performance penalty in Chrome.\n  let promise: Promise<Operation.WithHandler<Operation.Definition.Any>[]> | null = null;\n  const getHandlersCached = () => {\n    if (!promise) {\n      promise = getHandlers();\n    }\n    return promise;\n  };\n  return {\n    [TypeId]: TypeId,\n    getHandlers,\n    handlers: Effect.promise(getHandlersCached),\n  };\n};\n\n/**\n * Builds a set backed by an atom of contributed sets. The merged result is\n * cached and invalidated whenever the atom changes, so most accesses are\n * cheap but newly registered handlers are picked up.\n */\nexport const reactive = (\n  registry: Registry.Registry,\n  atom: Atom.Atom<readonly OperationHandlerSet[]>,\n): OperationHandlerSet => {\n  let cached: Promise<Operation.WithHandler<Operation.Definition.Any>[]> | null = null;\n  registry.subscribe(atom, () => {\n    cached = null;\n  });\n  // `suspend` defers `registry.get(atom)` until each run, so re-evaluations\n  // after cache invalidation see the current contributed sets.\n  const compute = Effect.suspend(() =>\n    pipe(\n      registry.get(atom),\n      Effect.forEach((set) => set.handlers, { concurrency: 'unbounded' }),\n      Effect.map((groups) => groups.flat()),\n      // Reset cached on failure so a transient error doesn't permanently\n      // poison subsequent calls.\n      Effect.tapErrorCause(() =>\n        Effect.sync(() => {\n          cached = null;\n        }),\n      ),\n    ),\n  );\n  const getHandlers = () => (cached ??= EffectEx.runAndForwardErrors(compute));\n  return {\n    [TypeId]: TypeId,\n    getHandlers,\n    handlers: Effect.promise(getHandlers),\n  };\n};\n\n/**\n * Merges multiple operation handler sets into a single set.\n *\n */\nexport const merge = (...sets: OperationHandlerSet[]): OperationHandlerSet => {\n  assertArgument(sets.every(isOperationHandlerSet), 'sets', 'sets must be an array of OperationHandlerSet');\n  return async(() => Promise.all(sets.map((set) => set.getHandlers())).then((handlers) => handlers.flat()));\n};\n\n/**\n * Creates a new operation handler set from a list of lazy-loaded modules.\n *\n * @example\n * ```ts\n * const set = OperationHandlerSet.lazy(\n *   () => import('./my-handler'),\n *   () => import('./my-other-handler'),\n * );\n * ```\n */\nexport const lazy = (\n  ...modules: (() => Promise<{ default: Operation.WithHandler<Operation.Definition.Any> }>)[]\n): OperationHandlerSet => {\n  return async(() => Promise.all(modules.map((module) => module().then(({ default: handler }) => handler))));\n};\n\n/**\n * Gets a handler for an operation by definition.\n */\nexport const getHandler = <const Op extends Operation.Definition.Any>(\n  set: OperationHandlerSet,\n  definition: Op,\n): Effect.Effect<Operation.WithHandler<Op>, NoHandlerError> =>\n  Effect.gen(function* () {\n    const handlers = yield* set.handlers;\n    const handler = handlers.find((handler) => handler.meta.key === definition.meta.key);\n    if (!handler) {\n      return yield* Effect.fail(new NoHandlerError(definition.meta.key));\n    }\n    return handler as any;\n  });\n\n/**\n * Gets a handler for an operation by key.\n * Accepts either a plain NSID (`org.dxos.function.database.contextAdd`) or a\n * full DXN string (`dxn:org.dxos.function.database.contextAdd`).\n */\nexport const getHandlerByKey = (\n  set: OperationHandlerSet,\n  key: string,\n): Effect.Effect<Operation.WithHandler<Operation.Definition.Any>, NoHandlerError> =>\n  Effect.gen(function* () {\n    const handlers = yield* set.handlers;\n    // Normalize both sides to plain NSID for comparison so callers can pass\n    // either a ToolId (plain NSID) or a full DXN string.\n    const normalizeKey = (k: string) => (DXN.isDXN(k) ? DXN.getName(k) : k);\n    const normalizedKey = normalizeKey(key);\n    const handler = handlers.find((handler) => normalizeKey(handler.meta.key) === normalizedKey);\n    if (!handler) {\n      return yield* Effect.fail(new NoHandlerError(key));\n    }\n    return handler as any;\n  });\n\nexport class OperationHandlerProvider extends Context.Tag('@dxos/operation/OperationHandlerProvider')<\n  OperationHandlerProvider,\n  OperationHandlerSet\n>() {}\n\nexport const provide = (handlers: OperationHandlerSet): Layer.Layer<OperationHandlerProvider, never, never> =>\n  Layer.succeed(OperationHandlerProvider, handlers);\n"],
+  "mappings": "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",
+  "names": ["BaseError", "InvokerNotInitializedError", "extend", "NoHandlerError", "operationKey", "context", "ServiceNotAvailableError", "service", "options", "message", "FunctionNotFoundError", "functionKey", "function", "FunctionError", "InvalidOperationInputError", "InvalidOperationOutputError", "TriggerStateNotFoundError", "FunctionsAiUpstreamError", "FunctionsAiMemoizationMissError", "Context", "Effect", "pipe", "Layer", "EffectEx", "assertArgument", "DXN", "TypeId", "isOperationHandlerSet", "value", "empty", "handlers", "succeed", "getHandlers", "Promise", "resolve", "make", "async", "promise", "getHandlersCached", "reactive", "registry", "atom", "cached", "subscribe", "compute", "suspend", "pipe", "get", "forEach", "set", "concurrency", "map", "groups", "flat", "tapErrorCause", "sync", "EffectEx", "runAndForwardErrors", "merge", "sets", "assertArgument", "every", "all", "then", "lazy", "modules", "module", "default", "handler", "getHandler", "definition", "gen", "find", "meta", "key", "fail", "NoHandlerError", "getHandlerByKey", "normalizeKey", "k", "DXN", "isDXN", "getName", "normalizedKey", "OperationHandlerProvider", "Tag", "provide"]
+}

package/dist/lib/neutral/fib-HBDUGQW7.mjs

@@ -0,0 +1,10 @@
+import {
+  fib_default
+} from "./chunk-AFBNVFAY.mjs";
+import "./chunk-JAU4E4EK.mjs";
+import "./chunk-QZS4G6PE.mjs";
+import "./chunk-J5LGTIGS.mjs";
+export {
+  fib_default as default
+};
+//# sourceMappingURL=fib-HBDUGQW7.mjs.map

package/dist/lib/neutral/fib-HBDUGQW7.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}