@graphorin/core 0.5.0

package/dist/contracts/tool.d.ts

@@ -0,0 +1,264 @@
+import { Logger } from "./logger.js";
+import { Sensitivity } from "../types/sensitivity.js";
+import { MessageContent } from "../types/message.js";
+import { ModelHint, ModelSpec } from "./preferred-model.js";
+import { SecretValue } from "./secret-value.js";
+import { Tracer } from "./tracer.js";
+import { ContentChunk, InboundSanitizationPolicy, MemoryGuardTier, SandboxPolicy, SideEffectClass, ToolSource, ToolTrustClass, TruncationStrategy } from "../types/tool.js";
+import { RunContext } from "../types/run.js";
+import { ZodLikeSchema } from "../utils/validation.js";
+
+//#region src/contracts/tool.d.ts
+
+/**
+ * Pluggable function call exposed to an LLM. Concrete `Tool` instances
+ * are produced by the `tool({...})` factory in `@graphorin/tools` and
+ * by the MCP / Skills loaders. The interface lives in core because every
+ * package above the persistence layer (agent runtime, workflow engine,
+ * server, sessions, observability, …) carries `Tool[]` references on
+ * its public surface.
+ *
+ * The interface is intentionally minimal — extension fields covered by
+ * later phases (per-tool `secretsAllowed` ACL, inbound sanitization
+ * policy, result truncation strategy, streaming hint, …) are added
+ * **additively** by their owning packages so that v0.1 consumers can
+ * type their tool list against `Tool<...>` today without having to
+ * worry about future fields.
+ *
+ * @stable
+ */
+interface Tool<TInput = unknown, TOutput = unknown, TDeps = unknown> {
+  readonly name: string;
+  readonly description: string;
+  readonly inputSchema: ZodLikeSchema<TInput>;
+  readonly outputSchema?: ZodLikeSchema<TOutput>;
+  /**
+   * Either a static boolean or a predicate consulted at runtime against
+   * the realized input. `true` means the runtime suspends the run with a
+   * `tool.approval.requested` event before the tool executes.
+   */
+  readonly needsApproval?: boolean | ((input: TInput, ctx: ToolExecutionContext<TDeps>) => boolean | Promise<boolean>);
+  /**
+   * Sandbox isolation level. Defaults are picked by
+   * `@graphorin/security`. ADVISORY in the default agent build (AG-18):
+   * inline `config.tools` closures cannot be serialised out-of-process,
+   * so the resolved policy is surfaced on the `tool.execute` span /
+   * audit but the tool runs in-process. Real isolation applies to
+   * module-loadable (skill / MCP) tools.
+   */
+  readonly sandboxPolicy?: SandboxPolicy;
+  /** Free-form labels surfaced to operators and to the model. */
+  readonly tags?: ReadonlyArray<string>;
+  /**
+   * Sequential execution mode hints. Tools tagged `'sequential'` are
+   * never executed in parallel with each other; the executor serializes
+   * them inside the per-step batch.
+   *
+   * @default `'parallel'`
+   */
+  readonly executionMode?: 'parallel' | 'sequential';
+  /**
+   * Per-tool secrets ACL. Tool execution is wrapped in a scope where
+   * `ctx.secrets.require(...)` only resolves keys present here.
+   * Empty / undefined means the tool may not request any secret.
+   */
+  readonly secretsAllowed?: ReadonlyArray<string>;
+  /**
+   * Sensitivity ceiling of the tool's input + output payload. Used by
+   * the redaction validator to decide whether the result may flow to a
+   * given sink (provider / exporter).
+   */
+  readonly sensitivity?: Sensitivity;
+  /**
+   * Memory-modification guard tier (DEC-153). ACTIVE when the agent is
+   * created with `memory` wired (SDF-1): the runtime binds a scope-aware
+   * region reader over working memory and the executor snapshots/verifies
+   * the region around guarded calls. Without `memory` the guard is
+   * skipped and the agent emits a one-time WARN.
+   */
+  readonly memoryGuardTier?: MemoryGuardTier;
+  /** Inbound prompt-injection sanitization policy. */
+  readonly inboundSanitization?: InboundSanitizationPolicy;
+  /**
+   * When `true`, an inbound-sanitization hit returns `ToolError({ kind:
+   * 'inbound_sanitization_blocked' })` instead of forwarding the
+   * (sanitized) result. Intended for regulated deployments.
+   *
+   * @default `false`
+   */
+  readonly failClosed?: boolean;
+  /**
+   * Defer the tool from the per-step catalogue until the model invokes
+   * the built-in `tool_search` to look it up. Tools with deferred
+   * loading are not advertised to the model on every step, which keeps
+   * the input-token cost bounded for installations with dozens of
+   * MCP-derived tools.
+   *
+   * @default `false`
+   */
+  readonly defer_loading?: boolean;
+  /**
+   * Maximum number of tokens the assembled tool result may carry into
+   * the conversation history. `0` disables the cap (logs a one-time
+   * WARN at registration). Counted against text-shaped output and
+   * text-shaped `contentParts` entries; non-text parts pass through.
+   *
+   * @default `16384`
+   */
+  readonly maxResultTokens?: number;
+  /** Truncation strategy applied when `maxResultTokens` is exceeded. */
+  readonly truncationStrategy?: TruncationStrategy;
+  /**
+   * Worked examples shown to the model alongside the tool's
+   * description. Bounded `[1, 5]` — overflow emits a one-time WARN at
+   * registration. Each example's `input` and `output` is validated
+   * against the tool's `inputSchema` / `outputSchema`.
+   */
+  readonly examples?: ReadonlyArray<ToolExample<TInput, TOutput>>;
+  /**
+   * Render examples eagerly (every step) regardless of
+   * `defer_loading`. When undefined the runtime applies the auto-rule:
+   * `defer_loading: true` ⇒ `false`; `defer_loading: false` ⇒ `true`;
+   * neither ⇒ `undefined` (the agent runtime decides at assembly time).
+   */
+  readonly examplesEagerlyRendered?: boolean;
+  /**
+   * REQUIRED side-effect classification. v0.1 transition mode emits a
+   * one-time WARN per tool name on missing classification and applies
+   * the conservative deferred default `'side-effecting'`; v0.2 may
+   * promote the WARN to a registration error.
+   */
+  readonly sideEffectClass?: SideEffectClass;
+  /**
+   * Optional callback returning a deterministic dedup key per
+   * `(input, ctx)` tuple. REQUIRED-by-WARN for `'side-effecting'` /
+   * `'external-stateful'` tools. The framework does not validate
+   * determinism — that is the operator's contract.
+   */
+  readonly idempotencyKey?: (input: TInput, ctx: ToolExecutionContext<TDeps>) => string | Promise<string>;
+  /**
+   * Opt-in flag for streaming-tool execution. The `?: true` typing
+   * rejects `streamingHint: false` on purpose — absence is the
+   * canonical "non-streaming" signal preserving v0.1 behaviour. When
+   * `true`, `Tool.execute(...)` may call `ctx.streamContent(...)` /
+   * `ctx.reportProgress(...)` and may return `Promise<void>`.
+   */
+  readonly streamingHint?: true;
+  /**
+   * Per-tool author-time model hint. Either a cost-tier vocabulary
+   * literal (`'fast' | 'balanced' | 'smart'`) OR an explicit
+   * `ModelSpec` that always wins over the agent-side tier mapping.
+   */
+  readonly preferredModel?: ModelHint | ModelSpec;
+  /**
+   * Execute the tool. Concrete implementations may return either a raw
+   * `TOutput` or a `ToolReturn<TOutput>` envelope when extra content
+   * parts (images, files, …) need to be appended to the conversation.
+   * Streaming-hint tools may also return `void` once the per-chunk
+   * buffer has been populated.
+   */
+  execute(input: TInput, ctx: ToolExecutionContext<TDeps>): Promise<TOutput | ToolReturn<TOutput> | undefined>;
+}
+/**
+ * Worked example for a `Tool`. Type-parameterized on the same generics
+ * as `Tool`, so a `ToolExample` for `Tool<{ q: string }, { hits: T[] }>`
+ * cannot specify an `input` shape that does not match.
+ *
+ * @stable
+ */
+interface ToolExample<TInput = unknown, TOutput = unknown> {
+  readonly input: TInput;
+  readonly output: TOutput | ToolReturn<TOutput>;
+  readonly comment?: string;
+}
+/**
+ * Resolved record returned by the `ToolRegistry` getter. Carries every
+ * non-public registration-time field downstream layers consume
+ * (sanitization, audit, retrieval, side-effect classification,
+ * collision resolution, …) so consumers do not have to recompute it.
+ *
+ * @stable
+ */
+interface ResolvedTool<TInput = unknown, TOutput = unknown, TDeps = unknown> extends Tool<TInput, TOutput, TDeps> {
+  readonly __trustClass: ToolTrustClass;
+  readonly __source: ToolSource;
+  readonly __effectiveDeferLoading: boolean;
+  readonly __sideEffectClass: SideEffectClass;
+  readonly __hasIdempotencyKey: boolean;
+  readonly __streamingHint: boolean;
+  readonly __exampleCount: number;
+  readonly __preferredModel?: ModelHint | ModelSpec;
+}
+/**
+ * Optional return envelope: pairs a typed `output` (passed to the model)
+ * with extra `contentParts` that are appended verbatim to the
+ * conversation (images, files, audio, …).
+ *
+ * @stable
+ */
+interface ToolReturn<TOutput = unknown> {
+  readonly output: TOutput;
+  readonly contentParts?: ReadonlyArray<MessageContent>;
+}
+/**
+ * Per-call execution context handed to `Tool.execute(...)`. Carries the
+ * stable `toolCallId`, the parent `RunContext`, an `AbortSignal` tied to
+ * the surrounding agent run, structured tracer / logger handles, the
+ * streaming progress / content emitters, and a per-call secrets accessor
+ * scoped to the tool's `secretsAllowed` ACL.
+ *
+ * @stable
+ */
+interface ToolExecutionContext<TDeps = unknown> {
+  readonly toolCallId: string;
+  readonly runContext: RunContext<TDeps>;
+  readonly signal: AbortSignal;
+  readonly tracer: Tracer;
+  readonly logger: Logger;
+  /**
+   * Per-call secrets accessor. The accessor enforces the tool's
+   * `secretsAllowed` ACL — calling `require(...)` for a key that is
+   * not on the allowlist throws `SecretAccessDeniedError`.
+   */
+  readonly secrets: ToolSecretsAccessor;
+  /**
+   * Emit a progress event to subscribers of `agent.stream(...)`. No-op
+   * on tools without `streamingHint: true` AND on aborted streams. The
+   * counter pair `(current, total?)` is consumer-rendered as a
+   * percentage when both fields are present.
+   */
+  reportProgress(current: number, total?: number, message?: string): void;
+  /**
+   * Emit one chunk of content. Concatenated into the tool's assembled
+   * `output` per the buffer-becomes-output discipline. No-op on tools
+   * without `streamingHint: true` AND on aborted streams.
+   */
+  streamContent(chunk: ContentChunk): void;
+}
+/**
+ * Per-call secrets accessor surface. Implemented by the executor; the
+ * tool author calls `require(...)` to obtain a `SecretValue` wrapper.
+ *
+ * The accessor is intentionally narrow — the ACL enforcement happens
+ * inside `require(...)`, so the tool author never accidentally
+ * unwraps a secret outside the tool's permitted set.
+ *
+ * @stable
+ */
+interface ToolSecretsAccessor {
+  /**
+   * Resolve a secret by key. Throws `SecretAccessDeniedError` if the
+   * key is not in the tool's `secretsAllowed` allowlist; throws
+   * `SecretRequiredError` (or returns `null` when `optional: true`)
+   * if the key resolves to no value.
+   */
+  require(key: string, options?: {
+    readonly optional?: false;
+  }): Promise<SecretValue>;
+  require(key: string, options: {
+    readonly optional: true;
+  }): Promise<SecretValue | null>;
+}
+//#endregion
+export { ResolvedTool, Tool, ToolExample, ToolExecutionContext, ToolReturn, ToolSecretsAccessor };
+//# sourceMappingURL=tool.d.ts.map

package/dist/contracts/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","names":[],"sources":["../../src/contracts/tool.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;AAkCA;;;;;;;;;;;;;AAmD6B,UAnDZ,IAmDY,CAAA,SAAA,OAAA,EAAA,UAAA,OAAA,EAAA,QAAA,OAAA,CAAA,CAAA;EAEI,SAAA,IAAA,EAAA,MAAA;EA6BD,SAAA,WAAA,EAAA,MAAA;EAOgB,SAAA,WAAA,EAtFxB,aAsFwB,CAtFV,MAsFU,CAAA;EAAQ,SAAA,YAAA,CAAA,EArF9B,aAqF8B,CArFhB,OAqFgB,CAAA;EAApB;;;;;EAuB3B,SAAA,aAAA,CAAA,EAAA,OAAA,GAAA,CAAA,CAAA,KAAA,EApGM,MAoGN,EAAA,GAAA,EApGmB,oBAoGnB,CApGwC,KAoGxC,CAAA,EAAA,GAAA,OAAA,GApG6D,OAoG7D,CAAA,OAAA,CAAA,CAAA;EACO;;;;;;;;EAyBO,SAAA,aAAA,CAAA,EArHI,aAqHJ;EAAlB;EAAO,SAAA,IAAA,CAAA,EAnHM,aAmHN,CAAA,MAAA,CAAA;EAUK;;;;;;AAcjB;EACe,SAAA,aAAA,CAAA,EAAA,UAAA,GAAA,YAAA;EAAQ;;;;;EAQO,SAAA,cAAA,CAAA,EAtIF,aAsIE,CAAA,MAAA,CAAA;EAAY;;;AAU1C;;EAEwC,SAAA,WAAA,CAAA,EAlJC,WAkJD;EAAd;;AAY1B;;;;;EAKmB,SAAA,eAAA,CAAA,EArJU,eAqJV;EAMC;EAaG,SAAA,mBAAA,CAAA,EAtKU,yBAsKV;EAAY;AAanC;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAtJgC;;;;;;;sBAOV,cAAc,YAAY,QAAQ;;;;;;;;;;;;;;6BAc3B;;;;;;;oCAQlB,aACF,qBAAqB,oBACd;;;;;;;;;;;;;;4BAcY,YAAY;;;;;;;;iBAS7B,aACF,qBAAqB,SACzB,QAAQ,UAAU,WAAW;;;;;;;;;UAUjB;kBACC;mBACC,UAAU,WAAW;;;;;;;;;;;UAYvB,2EACP,KAAK,QAAQ,SAAS;yBACP;qBACJ;;8BAES;;;;8BAIA,YAAY;;;;;;;;;UAUzB;mBACE;0BACO,cAAc;;;;;;;;;;;UAYvB;;uBAEM,WAAW;mBACf;mBACA;mBACA;;;;;;oBAMC;;;;;;;;;;;;;uBAaG;;;;;;;;;;;;UAaN,mBAAA;;;;;;;;;MAUZ,QAV+B,WAAA;;;MAc/B,QAJO,WAAA"}

package/dist/contracts/tracer.d.ts

@@ -0,0 +1,84 @@
+//#region src/contracts/tracer.d.ts
+/**
+ * Discriminator union for typed observability spans.
+ *
+ * The list mirrors the span taxonomy documented for the observability
+ * layer; concrete implementations live in `@graphorin/observability`.
+ *
+ * @stable
+ */
+type SpanType = 'agent.run' | 'agent.step' | 'agent.handoff' | 'agent.suspend' | 'agent.resume' | 'provider.generate' | 'provider.stream' | 'tool.execute' | 'tool.approval' | 'memory.read.working' | 'memory.read.session' | 'memory.read.episodic' | 'memory.read.semantic' | 'memory.read.procedural' | 'memory.read.shared' | 'memory.write.working' | 'memory.write.session' | 'memory.write.episodic' | 'memory.write.semantic' | 'memory.write.procedural' | 'memory.write.shared' | 'memory.search.working' | 'memory.search.session' | 'memory.search.episodic' | 'memory.search.semantic' | 'memory.search.procedural' | 'memory.search.shared' | 'memory.consolidate.light' | 'memory.consolidate.standard' | 'memory.consolidate.deep' | 'memory.consolidate.reflect' | 'memory.search.insight' | 'memory.read.insight' | 'memory.write.insight' | 'memory.conflict' | 'memory.embed' | 'workflow.run' | 'workflow.step' | 'workflow.task' | 'workflow.checkpoint' | 'skill.activate' | 'skill.load' | 'mcp.connect' | 'mcp.call' | 'mcp.list-tools';
+/**
+ * Status of a finished span. Mirrors the OTel status convention with
+ * `'ok' | 'error'` short forms instead of the verbose tristate.
+ *
+ * @stable
+ */
+type SpanStatus = 'ok' | 'error' | 'cancelled';
+/**
+ * Free-form attributes attached to a span.
+ *
+ * @stable
+ */
+type SpanAttributes = Readonly<Record<string, SpanAttributeValue>>;
+/** @stable */
+type SpanAttributeValue = string | number | boolean | null | ReadonlyArray<string> | ReadonlyArray<number> | ReadonlyArray<boolean>;
+/**
+ * Typed span. Generic over `SpanType` so consumers can specialize a
+ * function on a particular span kind without losing the discriminator.
+ *
+ * @stable
+ */
+interface AISpan<T extends SpanType = SpanType> {
+  readonly type: T;
+  readonly id: string;
+  readonly traceId: string;
+  readonly parentId?: string;
+  /** Add or replace attributes. Repeated calls are merged (last write wins). */
+  setAttributes(attrs: SpanAttributes): void;
+  /** Append a span event (attribute-bearing time-stamped marker). */
+  addEvent(name: string, attrs?: SpanAttributes): void;
+  /** Record an exception. Multiple calls are kept in the span event log. */
+  recordException(err: unknown): void;
+  /** Set the terminal status. */
+  setStatus(status: SpanStatus, message?: string): void;
+  /** End the span. Idempotent. */
+  end(): void;
+}
+/**
+ * Span constructor parameters.
+ *
+ * @stable
+ */
+interface StartSpanOptions<T extends SpanType = SpanType> {
+  readonly type: T;
+  readonly attrs?: SpanAttributes;
+  readonly parent?: AISpan;
+}
+/**
+ * Pluggable tracer. Implementations live in `@graphorin/observability`.
+ * The interface intentionally mirrors a subset of the OTel API so that
+ * adapter code is a thin pass-through.
+ *
+ * @stable
+ */
+interface Tracer {
+  startSpan<T extends SpanType>(opts: StartSpanOptions<T>): AISpan<T>;
+  /**
+   * Convenience wrapper: start a span, run `fn` inside, and call
+   * `setStatus('ok' | 'error')` + `end()` based on the outcome.
+   */
+  span<T extends SpanType, R>(opts: StartSpanOptions<T>, fn: (span: AISpan<T>) => R | Promise<R>): Promise<R>;
+  /** Force-flush any pending spans. */
+  shutdown(): Promise<void>;
+}
+/**
+ * Minimal no-op tracer. Useful as a typed default when downstream code
+ * needs a non-null `Tracer` without taking the observability dependency.
+ *
+ * @stable
+ */
+declare const NOOP_TRACER: Tracer;
+//#endregion
+export { AISpan, NOOP_TRACER, SpanAttributeValue, SpanAttributes, SpanStatus, SpanType, StartSpanOptions, Tracer };
+//# sourceMappingURL=tracer.d.ts.map

package/dist/contracts/tracer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracer.d.ts","names":[],"sources":["../../src/contracts/tracer.ts"],"sourcesContent":[],"mappings":";;AAQA;AAqDA;AAOA;;;;;AAGY,KA/DA,QAAA,GA+DA,WAAkB,GAAA,YAAA,GAAA,eAAA,GAAA,eAAA,GAAA,cAAA,GAAA,mBAAA,GAAA,iBAAA,GAAA,cAAA,GAAA,eAAA,GAAA,qBAAA,GAAA,qBAAA,GAAA,sBAAA,GAAA,sBAAA,GAAA,wBAAA,GAAA,oBAAA,GAAA,sBAAA,GAAA,sBAAA,GAAA,uBAAA,GAAA,uBAAA,GAAA,yBAAA,GAAA,qBAAA,GAAA,uBAAA,GAAA,uBAAA,GAAA,wBAAA,GAAA,wBAAA,GAAA,0BAAA,GAAA,sBAAA,GAAA,0BAAA,GAAA,6BAAA,GAAA,yBAAA,GAAA,4BAAA,GAAA,uBAAA,GAAA,qBAAA,GAAA,sBAAA,GAAA,iBAAA,GAAA,cAAA,GAAA,cAAA,GAAA,eAAA,GAAA,eAAA,GAAA,qBAAA,GAAA,gBAAA,GAAA,YAAA,GAAA,aAAA,GAAA,UAAA,GAAA,gBAAA;;;;;AAe9B;;AAA6C,KAzBjC,UAAA,GAyBiC,IAAA,GAAA,OAAA,GAAA,WAAA;;;;;;AAsB5B,KAxCL,cAAA,GAAiB,QAwCI,CAxCK,MAwCL,CAAA,MAAA,EAxCoB,kBAwCpB,CAAA,CAAA;;AAAsB,KArC3C,kBAAA,GAqC2C,MAAA,GAAA,MAAA,GAAA,OAAA,GAAA,IAAA,GAhCnD,aAgCmD,CAAA,MAAA,CAAA,GA/BnD,aA+BmD,CAAA,MAAA,CAAA,GA9BnD,aA8BmD,CAAA,OAAA,CAAA;;;;;AAavD;;AACuD,UApCtC,MAoCsC,CAAA,UApCrB,QAoCqB,GApCV,QAoCU,CAAA,CAAA;EAAjB,SAAA,IAAA,EAnCrB,CAmCqB;EAA6B,SAAA,EAAA,EAAA,MAAA;EAAP,SAAA,OAAA,EAAA,MAAA;EAK3C,SAAA,QAAA,CAAA,EAAA,MAAA;EACU;EAAjB,aAAA,CAAA,KAAA,EApCa,cAoCb,CAAA,EAAA,IAAA;EACY;EAAP,QAAA,CAAA,IAAA,EAAA,MAAA,EAAA,KAAA,CAAA,EAnCkB,cAmClB,CAAA,EAAA,IAAA;EAAc;EAAY,eAAA,CAAA,GAAA,EAAA,OAAA,CAAA,EAAA,IAAA;EAAR;EACpB,SAAA,CAAA,MAAA,EAhCO,UAgCP,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;EAAR;EAES,GAAA,EAAA,EAAA,IAAA;;AASd;;;;;UAjCiB,2BAA2B,WAAW;iBACtC;mBACE;oBACC;;;;;;;;;UAUH,MAAA;sBACK,gBAAgB,iBAAiB,KAAK,OAAO;;;;;iBAKlD,mBACP,iBAAiB,eACZ,OAAO,OAAO,IAAI,QAAQ,KACpC,QAAQ;;cAEC;;;;;;;;cASD,aAAa"}

package/dist/contracts/tracer.js

@@ -0,0 +1,34 @@
+//#region src/contracts/tracer.ts
+/**
+* Minimal no-op tracer. Useful as a typed default when downstream code
+* needs a non-null `Tracer` without taking the observability dependency.
+*
+* @stable
+*/
+const NOOP_TRACER = {
+	startSpan(opts) {
+		return {
+			type: opts.type,
+			id: "",
+			traceId: "",
+			setAttributes() {},
+			addEvent() {},
+			recordException() {},
+			setStatus() {},
+			end() {}
+		};
+	},
+	async span(opts, fn) {
+		const span = this.startSpan(opts);
+		try {
+			return await fn(span);
+		} finally {
+			span.end();
+		}
+	},
+	async shutdown() {}
+};
+
+//#endregion
+export { NOOP_TRACER };
+//# sourceMappingURL=tracer.js.map

package/dist/contracts/tracer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracer.js","names":["NOOP_TRACER: Tracer"],"sources":["../../src/contracts/tracer.ts"],"sourcesContent":["/**\n * Discriminator union for typed observability spans.\n *\n * The list mirrors the span taxonomy documented for the observability\n * layer; concrete implementations live in `@graphorin/observability`.\n *\n * @stable\n */\nexport type SpanType =\n  | 'agent.run'\n  | 'agent.step'\n  | 'agent.handoff'\n  | 'agent.suspend'\n  | 'agent.resume'\n  | 'provider.generate'\n  | 'provider.stream'\n  | 'tool.execute'\n  | 'tool.approval'\n  | 'memory.read.working'\n  | 'memory.read.session'\n  | 'memory.read.episodic'\n  | 'memory.read.semantic'\n  | 'memory.read.procedural'\n  | 'memory.read.shared'\n  | 'memory.write.working'\n  | 'memory.write.session'\n  | 'memory.write.episodic'\n  | 'memory.write.semantic'\n  | 'memory.write.procedural'\n  | 'memory.write.shared'\n  | 'memory.search.working'\n  | 'memory.search.session'\n  | 'memory.search.episodic'\n  | 'memory.search.semantic'\n  | 'memory.search.procedural'\n  | 'memory.search.shared'\n  | 'memory.consolidate.light'\n  | 'memory.consolidate.standard'\n  | 'memory.consolidate.deep'\n  | 'memory.consolidate.reflect'\n  | 'memory.search.insight'\n  | 'memory.read.insight'\n  | 'memory.write.insight'\n  | 'memory.conflict'\n  | 'memory.embed'\n  | 'workflow.run'\n  | 'workflow.step'\n  | 'workflow.task'\n  | 'workflow.checkpoint'\n  | 'skill.activate'\n  | 'skill.load'\n  | 'mcp.connect'\n  | 'mcp.call'\n  | 'mcp.list-tools';\n\n/**\n * Status of a finished span. Mirrors the OTel status convention with\n * `'ok' | 'error'` short forms instead of the verbose tristate.\n *\n * @stable\n */\nexport type SpanStatus = 'ok' | 'error' | 'cancelled';\n\n/**\n * Free-form attributes attached to a span.\n *\n * @stable\n */\nexport type SpanAttributes = Readonly<Record<string, SpanAttributeValue>>;\n\n/** @stable */\nexport type SpanAttributeValue =\n  | string\n  | number\n  | boolean\n  | null\n  | ReadonlyArray<string>\n  | ReadonlyArray<number>\n  | ReadonlyArray<boolean>;\n\n/**\n * Typed span. Generic over `SpanType` so consumers can specialize a\n * function on a particular span kind without losing the discriminator.\n *\n * @stable\n */\nexport interface AISpan<T extends SpanType = SpanType> {\n  readonly type: T;\n  readonly id: string;\n  readonly traceId: string;\n  readonly parentId?: string;\n  /** Add or replace attributes. Repeated calls are merged (last write wins). */\n  setAttributes(attrs: SpanAttributes): void;\n  /** Append a span event (attribute-bearing time-stamped marker). */\n  addEvent(name: string, attrs?: SpanAttributes): void;\n  /** Record an exception. Multiple calls are kept in the span event log. */\n  recordException(err: unknown): void;\n  /** Set the terminal status. */\n  setStatus(status: SpanStatus, message?: string): void;\n  /** End the span. Idempotent. */\n  end(): void;\n}\n\n/**\n * Span constructor parameters.\n *\n * @stable\n */\nexport interface StartSpanOptions<T extends SpanType = SpanType> {\n  readonly type: T;\n  readonly attrs?: SpanAttributes;\n  readonly parent?: AISpan;\n}\n\n/**\n * Pluggable tracer. Implementations live in `@graphorin/observability`.\n * The interface intentionally mirrors a subset of the OTel API so that\n * adapter code is a thin pass-through.\n *\n * @stable\n */\nexport interface Tracer {\n  startSpan<T extends SpanType>(opts: StartSpanOptions<T>): AISpan<T>;\n  /**\n   * Convenience wrapper: start a span, run `fn` inside, and call\n   * `setStatus('ok' | 'error')` + `end()` based on the outcome.\n   */\n  span<T extends SpanType, R>(\n    opts: StartSpanOptions<T>,\n    fn: (span: AISpan<T>) => R | Promise<R>,\n  ): Promise<R>;\n  /** Force-flush any pending spans. */\n  shutdown(): Promise<void>;\n}\n\n/**\n * Minimal no-op tracer. Useful as a typed default when downstream code\n * needs a non-null `Tracer` without taking the observability dependency.\n *\n * @stable\n */\nexport const NOOP_TRACER: Tracer = {\n  startSpan<T extends SpanType>(opts: StartSpanOptions<T>): AISpan<T> {\n    const span: AISpan<T> = {\n      type: opts.type,\n      id: '',\n      traceId: '',\n      setAttributes(): void {},\n      addEvent(): void {},\n      recordException(): void {},\n      setStatus(): void {},\n      end(): void {},\n    };\n    return span;\n  },\n  async span<T extends SpanType, R>(\n    opts: StartSpanOptions<T>,\n    fn: (span: AISpan<T>) => R | Promise<R>,\n  ): Promise<R> {\n    const span = this.startSpan(opts);\n    try {\n      return await fn(span);\n    } finally {\n      span.end();\n    }\n  },\n  async shutdown(): Promise<void> {},\n};\n"],"mappings":";;;;;;;AA6IA,MAAaA,cAAsB;CACjC,UAA8B,MAAsC;AAWlE,SAVwB;GACtB,MAAM,KAAK;GACX,IAAI;GACJ,SAAS;GACT,gBAAsB;GACtB,WAAiB;GACjB,kBAAwB;GACxB,YAAkB;GAClB,MAAY;GACb;;CAGH,MAAM,KACJ,MACA,IACY;EACZ,MAAM,OAAO,KAAK,UAAU,KAAK;AACjC,MAAI;AACF,UAAO,MAAM,GAAG,KAAK;YACb;AACR,QAAK,KAAK;;;CAGd,MAAM,WAA0B;CACjC"}

package/dist/contracts/trigger-store.d.ts

@@ -0,0 +1,43 @@
+//#region src/contracts/trigger-store.d.ts
+/**
+ * Persisted trigger state row. Lives in the `trigger_state` table per
+ * the durable-trigger contract: library and server modes share a single
+ * code path.
+ *
+ * @stable
+ */
+interface TriggerState {
+  readonly id: string;
+  readonly kind: 'cron' | 'interval' | 'idle' | 'event';
+  readonly spec: string;
+  readonly callbackRef: string;
+  /** ISO-8601 of the next scheduled fire. */
+  readonly nextFireAt?: string;
+  /** ISO-8601 of the most recent fire. */
+  readonly lastFiredAt?: string;
+  /** Number of consecutive missed fires. */
+  readonly missedFires: number;
+  readonly disabled: boolean;
+  readonly catchupPolicy: 'none' | 'last' | 'all';
+  readonly maxCatchupRuns: number;
+  readonly catchupWindowMs: number;
+  readonly tags?: ReadonlyArray<string>;
+  readonly createdAt: string;
+  readonly updatedAt?: string;
+}
+/**
+ * Pluggable persistent storage for triggers. Default impl lives in
+ * `@graphorin/store-sqlite`.
+ *
+ * @stable
+ */
+interface TriggerStore {
+  upsert(state: TriggerState): Promise<void>;
+  get(id: string): Promise<TriggerState | null>;
+  list(): Promise<ReadonlyArray<TriggerState>>;
+  remove(id: string): Promise<void>;
+  recordFire(id: string, firedAt: string, nextFireAt?: string): Promise<void>;
+}
+//#endregion
+export { TriggerState, TriggerStore };
+//# sourceMappingURL=trigger-store.d.ts.map

package/dist/contracts/trigger-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger-store.d.ts","names":[],"sources":["../../src/contracts/trigger-store.ts"],"sourcesContent":[],"mappings":";;AAOA;AA0BA;;;;;AAGgC,UA7Bf,YAAA,CA6Be;EAAd,SAAA,EAAA,EAAA,MAAA;EAAR,SAAA,IAAA,EAAA,MAAA,GAAA,UAAA,GAAA,MAAA,GAAA,OAAA;EACY,SAAA,IAAA,EAAA,MAAA;EAC0C,SAAA,WAAA,EAAA,MAAA;EAAO;;;;;;;;;;kBAhBrD;;;;;;;;;;UAWD,YAAA;gBACD,eAAe;mBACZ,QAAQ;UACjB,QAAQ,cAAc;sBACV;gEAC0C"}

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+import { AnyValue, Barrier, Channel, ChannelKind, Ephemeral, LatestValue, ListAggregate, Reducer, Stream, anyValue, barrier, ephemeral, latestValue, listAggregate, reducer, stream } from "./channels/channels.js";
+import { Directive, DirectiveOptions } from "./channels/directive.js";
+import { Dispatch, dispatch } from "./channels/dispatch.js";
+import { PAUSE_SIGNAL_BRAND, PauseResumeScope, PauseSignal, isPauseSignal, pause, runWithPauseResume } from "./channels/pause.js";
+import { AuthTokenRecord, AuthTokenStore } from "./contracts/auth-token-store.js";
+import { Checkpoint, CheckpointId, CheckpointMetadata, CheckpointStore, CheckpointTuple, ListOptions, PendingWrite } from "./contracts/checkpoint-store.js";
+import { EmbedOptions, EmbedderProvider } from "./contracts/embedder.js";
+import { EvalSample, EvalScore, EvalScorer } from "./contracts/eval-scorer.js";
+import { LocalProviderTrust, OllamaTrust } from "./contracts/local-provider-trust.js";
+import { LogFields, LogLevel, Logger, NOOP_LOGGER } from "./contracts/logger.js";
+import { SENSITIVITY_ORDER, Sensitivity, acceptsSensitivity } from "./types/sensitivity.js";
+import { Block, EntityRole, Episode, Fact, GraphEntity, Insight, MemoryHit, MemoryKind, MemoryMetadata, MemoryProvenance, MemoryRecord, MemorySearchOptions, MemoryStatus, Rule } from "./types/memory.js";
+import { ToolCall } from "./types/tool-call.js";
+import { AssistantMessage, AudioContent, FileContent, ImageContent, Message, MessageContent, MessageRole, ReasoningContent, ReasoningContentMeta, SystemMessage, TextContent, ToolMessage, UserMessage } from "./types/message.js";
+import { SessionScope } from "./types/session-scope.js";
+import { EpisodicMemoryStore, MemoryStore, MessageRef, ProceduralMemoryStore, SemanticMemoryStore, SessionListOptions, SessionMemoryStore, SessionMessageWithMetadata, SharedMemoryStore, WorkingMemoryStore } from "./contracts/memory-store.js";
+import { OAuthServerRecord, OAuthServerStore } from "./contracts/oauth-server-store.js";
+import { MODEL_HINTS, ModelHint, ModelSpec, ProviderLike } from "./contracts/preferred-model.js";
+import { Cost, ModelUsage, Usage, UsageAccumulator, UsageSnapshot, zeroUsage } from "./types/usage.js";
+import { ReasoningContract, ReasoningRetention } from "./contracts/reasoning-retention.js";
+import { ComposeProviderMiddleware, FinishReason, OutputSpec, Provider, ProviderCapabilities, ProviderError, ProviderErrorKind, ProviderEvent, ProviderMiddleware, ProviderRequest, ProviderRequestMetadata, ProviderResponse, ResponseMetadata, ToolChoice, ToolDefinition, ToolDefinitionExample } from "./contracts/provider.js";
+import { RedactionInput, RedactionOutput, RedactionValidator } from "./contracts/redaction-validator.js";
+import { Sandbox, SandboxCode, SandboxResult, SandboxRunOptions } from "./contracts/sandbox.js";
+import { SecretRef } from "./contracts/secret-ref.js";
+import { NODEJS_INSPECT_CUSTOM, SECRET_VALUE_BRAND, SecretValue, SecretValueOptions, SecretValueStatic } from "./contracts/secret-value.js";
+import { SecretMetadata, SecretResolver, SecretResolverContext, SecretsSetOptions, SecretsStore } from "./contracts/secrets-store.js";
+import { Handoff, HandoffFilter, HandoffInputFilterDescriptor, HandoffRecord, HandoffSecretsInheritance } from "./types/handoff.js";
+import { AgentRegistryEntry, SessionAuditEntry, SessionMetadata, SessionStore, SessionStoreExt, SessionWorkflowRun } from "./contracts/session-store.js";
+import { TokenCounter } from "./contracts/token-counter.js";
+import { AISpan, NOOP_TRACER, SpanAttributeValue, SpanAttributes, SpanStatus, SpanType, StartSpanOptions, Tracer } from "./contracts/tracer.js";
+import { CompletedToolCall, ContentChunk, InboundSanitizationPolicy, MemoryGuardTier, ResultHandle, SandboxPolicy, SideEffectClass, ToolApproval, ToolError, ToolErrorKind, ToolOutcome, ToolResult, ToolSource, ToolTrustClass, TruncationStrategy } from "./types/tool.js";
+import { RunContext, RunError, RunState, RunStateUsageByModel, RunStatus, RunStep, RunTaintSummary, flattenUsageByModel } from "./types/run.js";
+import { ValidationResult, ZodLikeError, ZodLikeSafeParseResult, ZodLikeSchema, validate, validateOrThrow } from "./utils/validation.js";
+import { ResolvedTool, Tool, ToolExample, ToolExecutionContext, ToolReturn, ToolSecretsAccessor } from "./contracts/tool.js";
+import { TriggerState, TriggerStore } from "./contracts/trigger-store.js";
+import { AgentCancellingEvent, AgentEndEvent, AgentErrorEvent, AgentEvaluatorConvergedEvent, AgentEvaluatorIterationEvent, AgentEvent, AgentFanOutMergedEvent, AgentFanOutSpawnedEvent, AgentFollowUpQueuedEvent, AgentLateralLeakDetectedEvent, AgentModelFellbackEvent, AgentProgressReadEvent, AgentProgressWrittenEvent, AgentResult, AgentStartEvent, AgentSteeredEvent, ContextCompactedEvent, FanOutChildMetadata, GuardrailTrippedEvent, HandoffEvent, LateralLeakVector, ProgressArtifactRef, ReasoningDeltaEvent, StepEndEvent, StepStartEvent, TextCompleteEvent, TextDeltaEvent, ToolApprovalDeniedEvent, ToolApprovalGrantedEvent, ToolApprovalRequestedEvent, ToolCallDeltaEvent, ToolCallEndEvent, ToolCallStartEvent, ToolExecuteEndEvent, ToolExecuteErrorEvent, ToolExecutePartialEvent, ToolExecuteProgressEvent, ToolExecuteStartEvent } from "./types/agent-event.js";
+import { StopCondition, and, hasToolCall, isStepCount, isTerminal, not, or } from "./types/stop-condition.js";
+import { WorkflowChannelUpdateEvent, WorkflowCheckpointWrittenEvent, WorkflowCustomEvent, WorkflowEndEvent, WorkflowErrorEvent, WorkflowEvent, WorkflowResumedEvent, WorkflowStartEvent, WorkflowStepEndEvent, WorkflowStepStartEvent, WorkflowSuspendedEvent, WorkflowTaskEndEvent, WorkflowTaskStartEvent } from "./types/workflow-event.js";
+import { assertNever } from "./utils/assert-never.js";
+import { AsyncContext, createAsyncContext } from "./utils/async-context.js";
+import { md5, xxhash } from "./utils/hash.js";
+import { collect, filter, mapStream, merge, take, takeWhile, withSignal } from "./utils/streams.js";
+
+//#region src/index.d.ts
+/**
+ * @graphorin/core — types, contracts, and utilities for the Graphorin
+ * framework. Dependency-free root package every other `@graphorin/*`
+ * package depends on.
+ *
+ * The full documentation lives in the package `README.md` and the
+ * sub-module barrels (`./types`, `./contracts`, `./utils`, `./channels`).
+ *
+ * @packageDocumentation
+ */
+/** Canonical version constant. Mirrors the `package.json` version. */
+declare const VERSION = "0.5.0";
+//#endregion
+export { AISpan, AgentCancellingEvent, AgentEndEvent, AgentErrorEvent, AgentEvaluatorConvergedEvent, AgentEvaluatorIterationEvent, AgentEvent, AgentFanOutMergedEvent, AgentFanOutSpawnedEvent, AgentFollowUpQueuedEvent, AgentLateralLeakDetectedEvent, AgentModelFellbackEvent, AgentProgressReadEvent, AgentProgressWrittenEvent, AgentRegistryEntry, AgentResult, AgentStartEvent, AgentSteeredEvent, AnyValue, AssistantMessage, AsyncContext, AudioContent, AuthTokenRecord, AuthTokenStore, Barrier, Block, Channel, ChannelKind, Checkpoint, CheckpointId, CheckpointMetadata, CheckpointStore, CheckpointTuple, CompletedToolCall, ComposeProviderMiddleware, ContentChunk, ContextCompactedEvent, Cost, Directive, DirectiveOptions, Dispatch, EmbedOptions, EmbedderProvider, EntityRole, Ephemeral, Episode, EpisodicMemoryStore, EvalSample, EvalScore, EvalScorer, Fact, FanOutChildMetadata, FileContent, FinishReason, GraphEntity, GuardrailTrippedEvent, Handoff, HandoffEvent, HandoffFilter, HandoffInputFilterDescriptor, HandoffRecord, HandoffSecretsInheritance, ImageContent, InboundSanitizationPolicy, Insight, LateralLeakVector, LatestValue, ListAggregate, ListOptions, LocalProviderTrust, LogFields, LogLevel, Logger, MODEL_HINTS, MemoryGuardTier, MemoryHit, MemoryKind, MemoryMetadata, MemoryProvenance, MemoryRecord, MemorySearchOptions, MemoryStatus, MemoryStore, Message, MessageContent, MessageRef, MessageRole, ModelHint, ModelSpec, ModelUsage, NODEJS_INSPECT_CUSTOM, NOOP_LOGGER, NOOP_TRACER, OAuthServerRecord, OAuthServerStore, OllamaTrust, OutputSpec, PAUSE_SIGNAL_BRAND, PauseResumeScope, PauseSignal, PendingWrite, ProceduralMemoryStore, ProgressArtifactRef, Provider, ProviderCapabilities, ProviderError, ProviderErrorKind, ProviderEvent, ProviderLike, ProviderMiddleware, ProviderRequest, ProviderRequestMetadata, ProviderResponse, ReasoningContent, ReasoningContentMeta, ReasoningContract, ReasoningDeltaEvent, ReasoningRetention, RedactionInput, RedactionOutput, RedactionValidator, Reducer, ResolvedTool, ResponseMetadata, ResultHandle, Rule, RunContext, RunError, RunState, RunStateUsageByModel, RunStatus, RunStep, RunTaintSummary, SECRET_VALUE_BRAND, SENSITIVITY_ORDER, Sandbox, SandboxCode, SandboxPolicy, SandboxResult, SandboxRunOptions, SecretMetadata, SecretRef, SecretResolver, SecretResolverContext, SecretValue, SecretValueOptions, SecretValueStatic, SecretsSetOptions, SecretsStore, SemanticMemoryStore, Sensitivity, SessionAuditEntry, SessionListOptions, SessionMemoryStore, SessionMessageWithMetadata, SessionMetadata, SessionScope, SessionStore, SessionStoreExt, SessionWorkflowRun, SharedMemoryStore, SideEffectClass, SpanAttributeValue, SpanAttributes, SpanStatus, SpanType, StartSpanOptions, StepEndEvent, StepStartEvent, StopCondition, Stream, SystemMessage, TextCompleteEvent, TextContent, TextDeltaEvent, TokenCounter, Tool, ToolApproval, ToolApprovalDeniedEvent, ToolApprovalGrantedEvent, ToolApprovalRequestedEvent, ToolCall, ToolCallDeltaEvent, ToolCallEndEvent, ToolCallStartEvent, ToolChoice, ToolDefinition, ToolDefinitionExample, ToolError, ToolErrorKind, ToolExample, ToolExecuteEndEvent, ToolExecuteErrorEvent, ToolExecutePartialEvent, ToolExecuteProgressEvent, ToolExecuteStartEvent, ToolExecutionContext, ToolMessage, ToolOutcome, ToolResult, ToolReturn, ToolSecretsAccessor, ToolSource, ToolTrustClass, Tracer, TriggerState, TriggerStore, TruncationStrategy, Usage, UsageAccumulator, UsageSnapshot, UserMessage, VERSION, ValidationResult, WorkflowChannelUpdateEvent, WorkflowCheckpointWrittenEvent, WorkflowCustomEvent, WorkflowEndEvent, WorkflowErrorEvent, WorkflowEvent, WorkflowResumedEvent, WorkflowStartEvent, WorkflowStepEndEvent, WorkflowStepStartEvent, WorkflowSuspendedEvent, WorkflowTaskEndEvent, WorkflowTaskStartEvent, WorkingMemoryStore, ZodLikeError, ZodLikeSafeParseResult, ZodLikeSchema, acceptsSensitivity, and, anyValue, assertNever, barrier, collect, createAsyncContext, dispatch, ephemeral, filter, flattenUsageByModel, hasToolCall, isPauseSignal, isStepCount, isTerminal, latestValue, listAggregate, mapStream, md5, merge, not, or, pause, reducer, runWithPauseResume, stream, take, takeWhile, validate, validateOrThrow, withSignal, xxhash, zeroUsage };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAYa,OAAA"}

package/dist/index.js

@@ -0,0 +1,38 @@
+import { anyValue, barrier, ephemeral, latestValue, listAggregate, reducer, stream } from "./channels/channels.js";
+import { Directive } from "./channels/directive.js";
+import { Dispatch, dispatch } from "./channels/dispatch.js";
+import { PAUSE_SIGNAL_BRAND, PauseSignal, isPauseSignal, pause, runWithPauseResume } from "./channels/pause.js";
+import "./channels/index.js";
+import { NOOP_LOGGER } from "./contracts/logger.js";
+import { MODEL_HINTS } from "./contracts/preferred-model.js";
+import { NODEJS_INSPECT_CUSTOM, SECRET_VALUE_BRAND } from "./contracts/secret-value.js";
+import { NOOP_TRACER } from "./contracts/tracer.js";
+import "./contracts/index.js";
+import { flattenUsageByModel } from "./types/run.js";
+import { SENSITIVITY_ORDER, acceptsSensitivity } from "./types/sensitivity.js";
+import { and, hasToolCall, isStepCount, isTerminal, not, or } from "./types/stop-condition.js";
+import { zeroUsage } from "./types/usage.js";
+import { assertNever } from "./utils/assert-never.js";
+import { createAsyncContext } from "./utils/async-context.js";
+import { md5, xxhash } from "./utils/hash.js";
+import { collect, filter, mapStream, merge, take, takeWhile, withSignal } from "./utils/streams.js";
+import { validate, validateOrThrow } from "./utils/validation.js";
+import "./utils/index.js";
+
+//#region src/index.ts
+/**
+* @graphorin/core — types, contracts, and utilities for the Graphorin
+* framework. Dependency-free root package every other `@graphorin/*`
+* package depends on.
+*
+* The full documentation lives in the package `README.md` and the
+* sub-module barrels (`./types`, `./contracts`, `./utils`, `./channels`).
+*
+* @packageDocumentation
+*/
+/** Canonical version constant. Mirrors the `package.json` version. */
+const VERSION = "0.5.0";
+
+//#endregion
+export { Directive, Dispatch, MODEL_HINTS, NODEJS_INSPECT_CUSTOM, NOOP_LOGGER, NOOP_TRACER, PAUSE_SIGNAL_BRAND, PauseSignal, SECRET_VALUE_BRAND, SENSITIVITY_ORDER, VERSION, acceptsSensitivity, and, anyValue, assertNever, barrier, collect, createAsyncContext, dispatch, ephemeral, filter, flattenUsageByModel, hasToolCall, isPauseSignal, isStepCount, isTerminal, latestValue, listAggregate, mapStream, md5, merge, not, or, pause, reducer, runWithPauseResume, stream, take, takeWhile, validate, validateOrThrow, withSignal, xxhash, zeroUsage };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * @graphorin/core — types, contracts, and utilities for the Graphorin\n * framework. Dependency-free root package every other `@graphorin/*`\n * package depends on.\n *\n * The full documentation lives in the package `README.md` and the\n * sub-module barrels (`./types`, `./contracts`, `./utils`, `./channels`).\n *\n * @packageDocumentation\n */\n\n/** Canonical version constant. Mirrors the `package.json` version. */\nexport const VERSION = '0.5.0';\n\nexport * from './channels/index.js';\nexport * from './contracts/index.js';\nexport * from './types/index.js';\nexport * from './utils/index.js';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,MAAa,UAAU"}