@ontrails/core 1.0.0-beta.15 → 1.0.0-beta.16

package/src/tracing.ts

@@ -0,0 +1,345 @@
+/**
+ * Intrinsic tracing primitives.
+ *
+ * This module is the home for the trace record type, the sink interface,
+ * the sink registry, and the helpers `executeTrail` uses to create root
+ * trace records and child spans. Core keeps this minimal contract public so
+ * `@ontrails/observe`, `@ontrails/tracing`, adapters, and tests share the
+ * same intrinsic execution record shape.
+ *
+ * Tracing is intrinsic: every `executeTrail` call automatically produces a
+ * root `TraceRecord`, `ctx.trace(label, fn)` creates nested child spans, and
+ * the signal runtime records lifecycle points underneath the active producer
+ * trace. A default no-op sink is installed at module load so core never
+ * crashes when no real sink has been registered.
+ */
+
+/** Signal lifecycle records emitted by the typed signal runtime. */
+export type SignalTraceRecordName =
+  | 'signal.fired'
+  | 'signal.handler.completed'
+  | 'signal.handler.failed'
+  | 'signal.handler.invoked'
+  | 'signal.handler.predicate_failed'
+  | 'signal.handler.predicate_matched'
+  | 'signal.handler.predicate_skipped'
+  | 'signal.invalid';
+
+/** Activation boundary records emitted by runtime materializers. */
+export type ActivationTraceRecordName =
+  | 'activation.cycle_detected'
+  | 'activation.scheduled'
+  | 'activation.webhook'
+  | 'activation.webhook.invalid';
+
+/** Evidence of a single trail execution, manual span, activation boundary, or signal lifecycle point. */
+export interface TraceRecord {
+  readonly id: string;
+  readonly traceId: string;
+  readonly rootId: string;
+  readonly parentId?: string | undefined;
+  readonly kind: 'activation' | 'signal' | 'span' | 'trail';
+  readonly name: string;
+  readonly trailId?: string | undefined;
+  readonly surface?: 'cli' | 'mcp' | 'http' | 'ws' | undefined;
+  readonly intent?: 'read' | 'write' | 'destroy' | undefined;
+  readonly startedAt: number;
+  readonly endedAt?: number | undefined;
+  readonly status: 'ok' | 'err' | 'cancelled';
+  readonly errorCategory?: string | undefined;
+  readonly sampled?: boolean | undefined;
+  readonly permit?:
+    | { readonly id: string; readonly tenantId?: string }
+    | undefined;
+  readonly attrs: Readonly<Record<string, unknown>>;
+}
+
+/**
+ * Minimal shape a tracing sink must satisfy.
+ *
+ * Kept intentionally tiny so adapters in `@ontrails/tracing`,
+ * `@ontrails/observe`, and user code can all satisfy it without
+ * additional dependencies.
+ */
+export interface TraceSink {
+  readonly write: (record: TraceRecord) => void | Promise<void>;
+}
+
+/** Trace context carried through trail execution via `ctx.extensions`. */
+export interface TraceContext {
+  readonly traceId: string;
+  readonly spanId: string;
+  readonly rootId: string;
+  readonly sampled: boolean;
+}
+
+/** Key used to store trace context in `ctx.extensions`. */
+export const TRACE_CONTEXT_KEY = '__trace_context';
+
+/** Read trace context from trail context extensions. */
+export const getTraceContext = (ctx: {
+  readonly extensions?: Readonly<Record<string, unknown>> | undefined;
+}): TraceContext | undefined =>
+  ctx.extensions?.[TRACE_CONTEXT_KEY] as TraceContext | undefined;
+
+// ---------------------------------------------------------------------------
+// Default no-op sink + sink registry
+// ---------------------------------------------------------------------------
+
+/** No-op sink installed by default so core never crashes without configuration. */
+export const NOOP_SINK: TraceSink = {
+  // oxlint-disable-next-line no-empty-function -- intentional no-op
+  write: () => {},
+};
+
+// oxlint-disable-next-line eslint-plugin-jest/require-hook -- module-level sink registry, not test setup
+let currentSink: TraceSink = NOOP_SINK;
+
+/**
+ * Register a trace sink globally.
+ *
+ * All trails executed via `executeTrail` will write their completed trace
+ * records to this sink, as will every `ctx.trace(label, fn)` child span.
+ * Registering `undefined` or calling {@link clearTraceSink} resets back to
+ * the default no-op sink.
+ */
+export const registerTraceSink = (sink: TraceSink | undefined): void => {
+  currentSink = sink ?? NOOP_SINK;
+};
+
+/** Retrieve the currently registered sink (never undefined). */
+export const getTraceSink = (): TraceSink => currentSink;
+
+/** True when tracing is effectively disabled and executeTrail should skip allocation. */
+export const isTracingDisabled = (sink: TraceSink = currentSink): boolean =>
+  sink === NOOP_SINK;
+
+/** Reset the sink registry back to the default no-op sink. */
+export const clearTraceSink = (): void => {
+  currentSink = NOOP_SINK;
+};
+
+// ---------------------------------------------------------------------------
+// Record + span helpers
+// ---------------------------------------------------------------------------
+
+/** Options for creating a trail-scoped {@link TraceRecord}. */
+interface CreateTraceRecordOptions {
+  readonly trailId: string;
+  readonly traceId?: string | undefined;
+  readonly parentId?: string | undefined;
+  readonly rootId?: string | undefined;
+  readonly surface?: TraceRecord['surface'];
+  readonly intent?: TraceRecord['intent'];
+  readonly sampled?: boolean | undefined;
+  readonly permit?:
+    | { readonly id: string; readonly tenantId?: string }
+    | undefined;
+}
+
+interface CreateActivationTraceRecordOptions {
+  readonly attrs?: Readonly<Record<string, unknown>> | undefined;
+  readonly parentId?: string | undefined;
+  readonly rootId?: string | undefined;
+  readonly traceId?: string | undefined;
+  readonly sampled?: boolean | undefined;
+}
+
+/** Create a fresh trail-kind {@link TraceRecord}. */
+export const createTraceRecord = (
+  options: CreateTraceRecordOptions
+): TraceRecord => {
+  const id = Bun.randomUUIDv7();
+  const traceId = options.traceId ?? Bun.randomUUIDv7();
+
+  return {
+    attrs: {},
+    endedAt: undefined,
+    id,
+    intent: options.intent,
+    kind: 'trail',
+    name: options.trailId,
+    parentId: options.parentId,
+    permit: options.permit,
+    rootId: options.rootId ?? id,
+    sampled: options.sampled,
+    startedAt: Date.now(),
+    status: 'ok',
+    surface: options.surface,
+    traceId,
+    trailId: options.trailId,
+  };
+};
+
+/** Create an activation-kind {@link TraceRecord}. */
+export const createActivationTraceRecord = (
+  name: ActivationTraceRecordName,
+  options: CreateActivationTraceRecordOptions = {}
+): TraceRecord => {
+  const id = Bun.randomUUIDv7();
+  const traceId = options.traceId ?? Bun.randomUUIDv7();
+
+  return {
+    attrs: options.attrs ?? {},
+    endedAt: undefined,
+    errorCategory: undefined,
+    id,
+    intent: undefined,
+    kind: 'activation',
+    name,
+    parentId: options.parentId,
+    permit: undefined,
+    rootId: options.rootId ?? id,
+    sampled: options.sampled,
+    startedAt: Date.now(),
+    status: 'ok',
+    surface: undefined,
+    traceId,
+    trailId: undefined,
+  };
+};
+
+/** Build a span record from a parent trace context. */
+export const createSpanRecord = (
+  parent: TraceContext,
+  label: string
+): TraceRecord => ({
+  attrs: {},
+  endedAt: undefined,
+  errorCategory: undefined,
+  id: Bun.randomUUIDv7(),
+  intent: undefined,
+  kind: 'span',
+  name: label,
+  parentId: parent.spanId,
+  rootId: parent.rootId,
+  sampled: parent.sampled,
+  startedAt: Date.now(),
+  status: 'ok',
+  surface: undefined,
+  traceId: parent.traceId,
+  trailId: undefined,
+});
+
+/** Build a signal lifecycle record from a parent trace context. */
+export const createSignalTraceRecord = (
+  parent: TraceContext,
+  name: SignalTraceRecordName,
+  attrs: Readonly<Record<string, unknown>> = {}
+): TraceRecord => ({
+  attrs,
+  endedAt: undefined,
+  errorCategory: undefined,
+  id: Bun.randomUUIDv7(),
+  intent: undefined,
+  kind: 'signal',
+  name,
+  parentId: parent.spanId,
+  rootId: parent.rootId,
+  sampled: parent.sampled,
+  startedAt: Date.now(),
+  status: 'ok',
+  surface: undefined,
+  traceId: parent.traceId,
+  trailId: undefined,
+});
+
+/** Use a completed record as the current trace parent for subsequent trail execution. */
+export const traceContextFromRecord = (record: TraceRecord): TraceContext => ({
+  rootId: record.rootId,
+  sampled: record.sampled ?? true,
+  spanId: record.id,
+  traceId: record.traceId,
+});
+
+/** Mark a record as completed with timing and status. */
+export const completeRecord = (
+  record: TraceRecord,
+  status: TraceRecord['status'],
+  errorCategory?: string | undefined
+): TraceRecord => ({
+  ...record,
+  endedAt: Date.now(),
+  errorCategory,
+  status,
+});
+
+/**
+ * Best-effort sink write that never throws.
+ *
+ * Returns `true` when the sink accepted the record, `false` when the write
+ * threw. Most callers can ignore the return value -- it exists so that
+ * callers that hand the written record back as a parent trace context
+ * (e.g. {@link writeActivationTraceRecord}) can refuse to do so when the
+ * record never actually made it to storage.
+ */
+export const writeToSink = async (
+  sink: TraceSink,
+  record: TraceRecord
+): Promise<boolean> => {
+  try {
+    await Promise.resolve(sink.write(record));
+    return true;
+  } catch {
+    // Sink failures must never affect trail result delivery.
+    return false;
+  }
+};
+
+/** Best-effort write for signal lifecycle records, no-op when tracing is disabled. */
+export const writeSignalTraceRecord = async (
+  ctx: { readonly extensions?: Readonly<Record<string, unknown>> | undefined },
+  name: SignalTraceRecordName,
+  attrs: Readonly<Record<string, unknown>>,
+  status: TraceRecord['status'] = 'ok',
+  errorCategory?: string | undefined,
+  sink: TraceSink = getTraceSink()
+): Promise<void> => {
+  const parent = getTraceContext(ctx);
+  if (parent === undefined || isTracingDisabled(sink)) {
+    return;
+  }
+  await writeToSink(
+    sink,
+    completeRecord(
+      createSignalTraceRecord(parent, name, attrs),
+      status,
+      errorCategory
+    )
+  );
+};
+
+/** Best-effort write for activation boundary records, no-op when tracing is disabled. */
+export const writeActivationTraceRecord = async (
+  name: ActivationTraceRecordName,
+  attrs: Readonly<Record<string, unknown>>,
+  status: TraceRecord['status'] = 'ok',
+  errorCategory?: string | undefined,
+  parent?: TraceContext | undefined,
+  sink: TraceSink = getTraceSink()
+): Promise<TraceRecord | undefined> => {
+  if (isTracingDisabled(sink)) {
+    return undefined;
+  }
+  const record = completeRecord(
+    createActivationTraceRecord(name, {
+      attrs,
+      parentId: parent?.spanId,
+      rootId: parent?.rootId,
+      // Parentless activations are the root span of their trace tree. Default
+      // sampled to true so the activation boundary stays consistent with
+      // child trail records, which default sampled=true via
+      // traceContextFromRecord. Inconsistent sampled flags within a trace
+      // break filters/exporters that gate on the activation boundary.
+      sampled: parent?.sampled ?? true,
+      traceId: parent?.traceId,
+    }),
+    status,
+    errorCategory
+  );
+  const written = await writeToSink(sink, record);
+  // When the sink dropped the record we must not hand it back to callers as
+  // a parent trace context -- subsequent child writes would reference an
+  // activation span that never reached storage, producing broken lineage.
+  return written ? record : undefined;
+};

package/src/trail.ts

@@ -1,14 +1,25 @@
 import type { z } from 'zod';
 
+import type {
+  ActivationEntry,
+  ActivationEntrySpec,
+  ActivationSource,
+  ActivationSourceRef,
+} from './activation-source.js';
+import {
+  isActivationEntrySpec,
+  isActivationSource,
+} from './activation-source.js';
 import type { AnyContour } from './contour.js';
 import type { FieldOverride } from './derive.js';
+import type { Layer } from './layer.js';
 import type { Result } from './result.js';
 import type { AnyResource } from './resource.js';
 import type { AnySignal } from './signal.js';
 import {
   createLateBoundSignalMarker,
   getLateBoundSignalRef,
-} from './internal/signal-ref.js';
+} from './signal-ref.js';
 import type { TrailsError } from './errors.js';
 import type {
   Detour,
@@ -21,6 +32,17 @@ import type {
 // Trail example
 // ---------------------------------------------------------------------------
 
+export interface TrailExampleSignalAssertion {
+  /** Signal contract object or stable signal ID expected during the example. */
+  readonly signal: AnySignal | string;
+  /** Exact payload assertion for the fired signal. */
+  readonly payload?: unknown | undefined;
+  /** Partial payload assertion; declared fields must match, extras ignored. */
+  readonly payloadMatch?: unknown | undefined;
+  /** Number of matching fired signals expected. Defaults to one. */
+  readonly times?: number | undefined;
+}
+
 /**
  * A named example for documentation and testing.
  *
@@ -41,6 +63,8 @@ export interface TrailExample<I, O> {
   readonly expectedMatch?: Partial<O> | undefined;
   /** Error class name for error-path examples */
   readonly error?: string | undefined;
+  /** Signal fires expected while executing this example. */
+  readonly signals?: readonly TrailExampleSignalAssertion[] | undefined;
 }
 
 // ---------------------------------------------------------------------------
@@ -79,12 +103,33 @@ export interface TrailSpec<I, O, CI = never> {
   readonly intent?: 'read' | 'write' | 'destroy' | undefined;
   /** Trail is idempotent (safe to retry) */
   readonly idempotent?: boolean | undefined;
-  /** Whether trailheads expose this trail by default. */
+  /**
+   * Trail explicitly supports dry-run execution semantics.
+   *
+   * This is a declaration for governance, derivation, and surface tooling. It
+   * does not change runtime behavior by itself; the active invocation signal is
+   * `TrailContext.dryRun`.
+   */
+  readonly dryRun?: boolean | undefined;
+  /** Whether surfaces expose this trail by default. */
   readonly visibility?: TrailVisibility | undefined;
   /** Arbitrary meta for tooling and filtering */
   readonly meta?: Readonly<Record<string, unknown>> | undefined;
   /** Recovery paths activated when blaze fails with a matching error class. */
   readonly detours?: readonly Detour<I, O, TrailsError>[] | undefined;
+  /**
+   * Typed layers attached at trail scope.
+   *
+   * Layers declared here wrap this trail's implementation on every execution,
+   * regardless of which surface invokes it. The execution pipeline composes
+   * trail-scope layers innermost — closer to the blaze than surface-scope
+   * or topo-scope layers — so the final order is
+   * `topo → surface → trail → blaze` (outermost-first).
+   *
+   * Layers are typed and inspectable. Omit `input` for surface-invisible
+   * wrappers that do not project any fields.
+   */
+  readonly layers?: readonly Layer[] | undefined;
   /** Per-field overrides for deriveFields() (labels, hints, options) */
   readonly fields?: Readonly<Record<string, FieldOverride>> | undefined;
   /** Contours this trail operates on. */
@@ -93,7 +138,7 @@ export interface TrailSpec<I, O, CI = never> {
   readonly crosses?: readonly (string | AnyTrail)[] | undefined;
   /**
    * Composition-only input schema — merged with `input` for `ctx.cross()` calls,
-   * invisible to public trailheads (CLI, MCP, HTTP).
+   * invisible to public surfaces (CLI, MCP, HTTP).
    *
    * Fields here are available in the blaze but are not derived into CLI flags,
    * MCP tool parameters, or HTTP request bodies. Use for data that only makes
@@ -103,7 +148,7 @@ export interface TrailSpec<I, O, CI = never> {
   /** Resources this trail may access via resource.from(ctx) */
   readonly resources?: readonly AnyResource[] | undefined;
   /**
-   * Signals this trail emits via `ctx.fire()`.
+   * Signals this trail fires via `ctx.fire()`.
    *
    * Accepts either a string id or a `Signal` value. Both forms are
    * normalized to the signal's id at trail definition time, so
@@ -114,12 +159,14 @@ export interface TrailSpec<I, O, CI = never> {
    */
   readonly fires?: readonly (string | AnySignal)[] | undefined;
   /**
-   * Signals that activate this trail (framework auto-subscribes).
+   * Activation sources that can invoke this trail.
    *
-   * Accepts either a string id or a `Signal` value. Both forms are
-   * normalized to the signal's id at trail definition time.
+   * Bare strings and `Signal` values are signal-source shorthand. Object form
+   * preserves the source kind and per-source metadata for the activation graph.
    */
-  readonly on?: readonly (string | AnySignal)[] | undefined;
+  readonly on?:
+    | readonly (ActivationEntrySpec | ActivationSourceRef)[]
+    | undefined;
   /** Auth requirement: scopes object, 'public', or omitted (undeclared) */
   readonly permit?: PermitRequirement | undefined;
   /** Primary input fields and their order. CLI projects as positional args. */
@@ -130,10 +177,16 @@ export interface TrailSpec<I, O, CI = never> {
 // Trail (the frozen runtime object)
 // ---------------------------------------------------------------------------
 
-/** Intent describes what a trail does to the world */
-export type Intent = 'read' | 'write' | 'destroy';
+/** Intent describes what a trail does to the world. */
+export const intentValues = Object.freeze([
+  'read',
+  'write',
+  'destroy',
+] as const);
 
-/** Whether trailheads expose a trail by default. */
+export type Intent = (typeof intentValues)[number];
+
+/** Whether surfaces expose a trail by default. */
 export type TrailVisibility = 'public' | 'internal';
 
 /** A fully-defined trail — the unit of work in the Trails system */
@@ -147,6 +200,7 @@ export interface Trail<I, O, CI = never> extends Omit<
   | 'detours'
   | 'fires'
   | 'intent'
+  | 'layers'
   | 'on'
   | 'resources'
 > {
@@ -161,15 +215,27 @@ export interface Trail<I, O, CI = never> extends Omit<
   readonly crossInput?: z.ZodType<CI> | undefined;
   /** Recovery paths activated when blaze fails with a matching error (always present, default []). */
   readonly detours: readonly Detour<I, O, TrailsError>[];
+  /**
+   * Typed layers attached at trail scope (always present, default []).
+   *
+   * Composed innermost in the layer chain — closest to the blaze. The final
+   * composition order is `topo → surface → trail → blaze` (outermost-first).
+   */
+  readonly layers: readonly Layer[];
   /** Resources this trail may access via resource.from(ctx) (always present, default []) */
   readonly resources: readonly AnyResource[];
-  /** IDs of signals this trail emits via ctx.fire() (always present, default []) */
+  /** IDs of signals this trail fires via ctx.fire() (always present, default []) */
   readonly fires: readonly string[];
-  /** IDs of signals that activate this trail (always present, default []) */
+  /**
+   * IDs of signal sources that activate this trail (always present, default []).
+   * Non-signal activation sources live in `activationSources`.
+   */
   readonly on: readonly string[];
+  /** Normalized activation source entries declared through `on` (always present, default []). */
+  readonly activationSources: readonly ActivationEntry[];
   /** What this trail does to the world (always present, default 'write') */
   readonly intent: Intent;
-  /** Whether trailheads expose this trail by default (always present, default 'public'). */
+  /** Whether surfaces expose this trail by default (always present, default 'public'). */
   readonly visibility: TrailVisibility;
   /** Primary input fields and their order (always present, default undefined) */
   readonly args?: readonly string[] | false | undefined;
@@ -220,6 +286,78 @@ const normalizeSignalRef = (entry: string | AnySignal): string => {
   return createLateBoundSignalMarker(ref, entry.id);
 };
 
+const freezeActivationSource = (source: ActivationSource): ActivationSource =>
+  Object.freeze({
+    ...source,
+    ...(source.meta === undefined
+      ? {}
+      : { meta: Object.freeze({ ...source.meta }) }),
+  });
+
+const shouldPreserveSignalSource = (source: ActivationSource): boolean =>
+  source.kind === 'signal' &&
+  (!('payload' in source) ||
+    'input' in source ||
+    'parse' in source ||
+    'cron' in source ||
+    'timezone' in source);
+
+const normalizeActivationSource = (
+  source: ActivationSourceRef
+): ActivationSource => {
+  if (typeof source === 'string') {
+    return freezeActivationSource({ id: source, kind: 'signal' });
+  }
+
+  if (isActivationSource(source) && shouldPreserveSignalSource(source)) {
+    return freezeActivationSource({
+      ...source,
+      id: normalizeSignalRef(source.id),
+      kind: 'signal',
+    });
+  }
+
+  if (isActivationSource(source) && source.kind !== 'signal') {
+    return freezeActivationSource(source);
+  }
+
+  return freezeActivationSource({
+    id: normalizeSignalRef(source as string | AnySignal),
+    kind: 'signal',
+  });
+};
+
+const normalizeActivationEntry = (
+  entry: ActivationEntrySpec | ActivationSourceRef
+): ActivationEntry => {
+  const source = isActivationEntrySpec(entry) ? entry.source : entry;
+  const normalized: ActivationEntry = {
+    source: normalizeActivationSource(source),
+    ...(isActivationEntrySpec(entry) && entry.meta !== undefined
+      ? { meta: Object.freeze({ ...entry.meta }) }
+      : {}),
+    ...(isActivationEntrySpec(entry) && entry.where !== undefined
+      ? { where: entry.where }
+      : {}),
+  };
+
+  return Object.freeze(normalized);
+};
+
+const normalizeActivationSources = (
+  entries: readonly (ActivationEntrySpec | ActivationSourceRef)[]
+): readonly ActivationEntry[] =>
+  Object.freeze(entries.map((entry) => normalizeActivationEntry(entry)));
+
+const extractSignalActivationIds = (
+  activations: readonly ActivationEntry[]
+): readonly string[] =>
+  Object.freeze(
+    activations
+      .filter((entry) => entry.source.kind === 'signal')
+      .map((entry) => entry.source.id)
+  );
+
 /** Normalize a crosses entry — trail objects are reduced to their id. */
 const normalizeCrossRef = (entry: string | AnyTrail): string =>
   typeof entry === 'string' ? entry : entry.id;
@@ -229,19 +367,26 @@ const normalizeCollections = <I, O, CI>(
   spec: TrailSpec<I, O, CI>
 ): {
   readonly args: readonly string[] | false | undefined;
+  readonly activationSources: readonly ActivationEntry[];
   readonly contours: readonly AnyContour[];
   readonly detours: readonly Detour<I, O, TrailsError>[];
   readonly fires: readonly string[];
+  readonly layers: readonly Layer[];
   readonly on: readonly string[];
   readonly resources: readonly AnyResource[];
-} => ({
-  args: Array.isArray(spec.args) ? Object.freeze([...spec.args]) : spec.args,
-  contours: Object.freeze([...(spec.contours ?? [])]),
-  detours: Object.freeze([...(spec.detours ?? [])]),
-  fires: Object.freeze((spec.fires ?? []).map(normalizeSignalRef)),
-  on: Object.freeze((spec.on ?? []).map(normalizeSignalRef)),
-  resources: Object.freeze([...(spec.resources ?? [])]),
-});
+} => {
+  const activationSources = normalizeActivationSources(spec.on ?? []);
+  return {
+    activationSources,
+    args: Array.isArray(spec.args) ? Object.freeze([...spec.args]) : spec.args,
+    contours: Object.freeze([...(spec.contours ?? [])]),
+    detours: Object.freeze([...(spec.detours ?? [])]),
+    fires: Object.freeze((spec.fires ?? []).map(normalizeSignalRef)),
+    layers: Object.freeze([...(spec.layers ?? [])]),
+    on: extractSignalActivationIds(activationSources),
+    resources: Object.freeze([...(spec.resources ?? [])]),
+  };
+};
 
 /**
  * Create a trail definition.
@@ -296,6 +441,7 @@ export function trail<I, O, CI = never>(
     contours: _c,
     detours: _d,
     fires: _f,
+    layers: _l,
     on: _o,
     resources: _r,
     ...spec

package/src/trails/derive-trail.ts

@@ -7,7 +7,7 @@ import {
   isTrailsError,
   NotFoundError,
 } from '../errors.js';
-import { stripDefaultsFromShape } from '../internal/zod-wrappers.js';
+import { stripDefaultsFromShape } from '../zod-wrappers.js';
 import type { AnyResource } from '../resource.js';
 import { Result } from '../result.js';
 import type { StoreAccessorProtocol } from '../store/accessor-protocol.js';