@logixjs/core 0.0.1

package/dist/Observability-cY4kLn0S.d.ts

@@ -0,0 +1,713 @@
+import { Effect, Context, Layer, ConfigProvider, Exit } from 'effect';
+import { a0 as SerializableErrorSummary$1, h as AnyModuleShape, k as ModuleImpl } from './module-k7m3txak.js';
+import { h as ProcessInstanceIdentity, j as ProcessTrigger, S as SerializableErrorSummary } from './protocol-g_1897M2.js';
+import { S as StaticIr } from './ir-DUOz6H-5.js';
+
+type JsonValue = null | boolean | number | string | ReadonlyArray<JsonValue> | {
+    readonly [key: string]: JsonValue;
+};
+type DowngradeReason = 'non_serializable' | 'oversized' | 'unknown';
+interface JsonValueProjectionStats {
+    readonly dropped: number;
+    readonly oversized: number;
+    readonly nonSerializable: number;
+}
+
+type ResourceSnapshotPhase = 'idle' | 'loading' | 'success' | 'error';
+type ReplayLogEvent = {
+    readonly _tag: 'ResourceSnapshot';
+    readonly resourceId: string;
+    readonly fieldPath: string;
+    readonly keyHash?: string;
+    /**
+     * Optional: source concurrency policy (e.g. "switch" / "exhaust-trailing").
+     * - Must remain slim & serializable.
+     * - Used by Devtools/replay to explain why old results are dropped / why trailing happens.
+     */
+    readonly concurrency?: string;
+    readonly phase: ResourceSnapshotPhase;
+    readonly snapshot: unknown;
+    readonly timestamp: number;
+    readonly moduleId?: string;
+    readonly instanceId?: string;
+} | {
+    readonly _tag: 'InvalidateRequest';
+    readonly timestamp: number;
+    readonly moduleId?: string;
+    readonly instanceId?: string;
+    readonly kind: 'resource' | 'query';
+    readonly target: string;
+    readonly meta?: unknown;
+};
+type ResourceSnapshotEvent = Extract<ReplayLogEvent, {
+    readonly _tag: 'ResourceSnapshot';
+}>;
+interface ReplayLogService {
+    readonly record: (event: ReplayLogEvent) => Effect.Effect<void>;
+    readonly snapshot: Effect.Effect<ReadonlyArray<ReplayLogEvent>>;
+    readonly resetCursor: Effect.Effect<void>;
+    readonly consumeNext: (predicate: (event: ReplayLogEvent) => boolean) => Effect.Effect<ReplayLogEvent | undefined>;
+    readonly consumeNextResourceSnapshot: (params: {
+        readonly resourceId: string;
+        readonly fieldPath: string;
+        readonly keyHash?: string;
+        readonly phase?: ResourceSnapshotPhase;
+    }) => Effect.Effect<ResourceSnapshotEvent | undefined>;
+}
+declare const ReplayLog_base: Context.TagClass<ReplayLog, "@logixjs/core/ReplayLog", ReplayLogService>;
+declare class ReplayLog extends ReplayLog_base {
+}
+declare const make$1: (initial?: ReadonlyArray<ReplayLogEvent>) => ReplayLogService;
+declare const layer$2: (initial?: ReadonlyArray<ReplayLogEvent>) => Layer.Layer<ReplayLog, never, never>;
+declare const record: (event: ReplayLogEvent) => Effect.Effect<void, never, ReplayLog>;
+declare const snapshot: Effect.Effect<ReadonlyArray<ReplayLogEvent>, never, ReplayLog>;
+declare const resetCursor: Effect.Effect<void, never, ReplayLog>;
+declare const consumeNextResourceSnapshot: (params: {
+    readonly resourceId: string;
+    readonly fieldPath: string;
+    readonly keyHash?: string;
+    readonly phase?: ResourceSnapshotPhase;
+}) => Effect.Effect<ResourceSnapshotEvent | undefined, never, ReplayLog>;
+
+type ReplayLog$1_ReplayLog = ReplayLog;
+declare const ReplayLog$1_ReplayLog: typeof ReplayLog;
+type ReplayLog$1_ReplayLogEvent = ReplayLogEvent;
+type ReplayLog$1_ReplayLogService = ReplayLogService;
+type ReplayLog$1_ResourceSnapshotEvent = ResourceSnapshotEvent;
+type ReplayLog$1_ResourceSnapshotPhase = ResourceSnapshotPhase;
+declare const ReplayLog$1_consumeNextResourceSnapshot: typeof consumeNextResourceSnapshot;
+declare const ReplayLog$1_record: typeof record;
+declare const ReplayLog$1_resetCursor: typeof resetCursor;
+declare const ReplayLog$1_snapshot: typeof snapshot;
+declare namespace ReplayLog$1 {
+  export { ReplayLog$1_ReplayLog as ReplayLog, type ReplayLog$1_ReplayLogEvent as ReplayLogEvent, type ReplayLog$1_ReplayLogService as ReplayLogService, type ReplayLog$1_ResourceSnapshotEvent as ResourceSnapshotEvent, type ReplayLog$1_ResourceSnapshotPhase as ResourceSnapshotPhase, ReplayLog$1_consumeNextResourceSnapshot as consumeNextResourceSnapshot, layer$2 as layer, make$1 as make, ReplayLog$1_record as record, ReplayLog$1_resetCursor as resetCursor, ReplayLog$1_snapshot as snapshot };
+}
+
+interface TriggerRef {
+    readonly kind: string;
+    readonly name?: string;
+    readonly details?: unknown;
+}
+type TraceEventType = `trace:${string}`;
+type GenericTraceEventType = Exclude<TraceEventType, 'trace:trait:converge' | 'trace:trait:check' | 'trace:trait:validate'>;
+/**
+ * ReplayEventRef：
+ * - Replay event structure referenced from Debug events.
+ * - Based on ReplayLog.Event, enriched with txn/trigger association fields for Devtools aggregation and explanation.
+ */
+type ReplayEventRef = ReplayLogEvent & {
+    readonly txnId?: string;
+    readonly trigger?: TriggerRef;
+};
+type Event = {
+    readonly type: 'module:init';
+    readonly moduleId?: string;
+    readonly instanceId?: string;
+    readonly runtimeLabel?: string;
+    readonly timestamp?: number;
+} | {
+    readonly type: 'module:destroy';
+    readonly moduleId?: string;
+    readonly instanceId?: string;
+    readonly runtimeLabel?: string;
+    readonly timestamp?: number;
+} | {
+    readonly type: 'lifecycle:phase';
+    readonly moduleId?: string;
+    readonly instanceId?: string;
+    readonly phase: 'init' | 'run' | 'destroy' | 'platform';
+    readonly name: string;
+    readonly payload?: unknown;
+    readonly runtimeLabel?: string;
+    readonly timestamp?: number;
+} | {
+    readonly type: 'action:dispatch';
+    readonly moduleId?: string;
+    readonly instanceId?: string;
+    readonly action: unknown;
+    readonly actionTag?: string;
+    readonly unknownAction?: boolean;
+    readonly txnSeq?: number;
+    readonly txnId?: string;
+    readonly runtimeLabel?: string;
+    readonly timestamp?: number;
+} | {
+    readonly type: 'state:update';
+    readonly moduleId?: string;
+    readonly instanceId?: string;
+    readonly state: unknown;
+    readonly txnSeq?: number;
+    readonly txnId?: string;
+    /**
+     * Optional: Static IR digest aligned with FieldPathId/StepId (for consumer-side reverse-mapping & alignment).
+     * - When missing or mismatched, consumers must not attempt to reverse-map rootIds -> rootPaths (avoid wrong UI).
+     * - Allowed to be omitted on near-zero-cost diagnostics=off paths.
+     */
+    readonly staticIrDigest?: string;
+    /**
+     * Optional: the affected scope aggregated by this commit (field-level dirty-set).
+     * - Populated by Runtime at commit time;
+     * - Must stay slim and serializable;
+     * - Devtools can use it to explain "why converge/validate ran / why it degraded to full".
+     */
+    readonly dirtySet?: unknown;
+    /**
+     * Optional: patch count aggregated by this commit (from StateTransaction).
+     * - Populated by Runtime only on transaction paths.
+     * - Devtools can use it as a lightweight transaction summary metric.
+     */
+    readonly patchCount?: number;
+    /**
+     * Optional: whether patch records were truncated (bounded) under full instrumentation.
+     */
+    readonly patchesTruncated?: boolean;
+    /**
+     * Optional: truncation reason code (stable enum).
+     */
+    readonly patchesTruncatedReason?: 'max_patches';
+    /**
+     * Optional: commit mode (normal/batched/low-priority, etc).
+     * - Populated by Runtime;
+     * - Default is chosen by the caller (typically "normal").
+     */
+    readonly commitMode?: string;
+    /**
+     * Optional: external visibility priority (normal/low).
+     * - Populated by Runtime.
+     * - Mainly used by React external subscription scheduling (avoid unnecessary renders).
+     */
+    readonly priority?: string;
+    /**
+     * Optional: transaction origin kind (origin.kind) that triggered this state commit:
+     * - e.g. "action" / "source-refresh" / "service-callback" / "devtools".
+     * - Populated by Runtime only on StateTransaction-based paths.
+     * - Devtools can distinguish app transactions vs devtools time-travel operations.
+     */
+    readonly originKind?: string;
+    /**
+     * Optional: transaction origin name (origin.name) that triggered this state commit:
+     * - e.g. action dispatch / fieldPath / task:success/task:failure, etc.
+     * - Populated by Runtime only on StateTransaction-based paths.
+     */
+    readonly originName?: string;
+    /**
+     * Reserved: Trait converge summary (for Devtools window-level stats / TopN costs / degrade reasons, etc.).
+     * - Phase 2: field slot only; structure is not fixed.
+     * - Later phases will align with the Trait/Replay event model into an explainable structure.
+     */
+    readonly traitSummary?: unknown;
+    /**
+     * Reserved: replay event associated with this transaction (re-emit source of truth from ReplayLog).
+     * - Phase 2: field slot only.
+     * - Later phases will align with ReplayLog.Event structure.
+     */
+    readonly replayEvent?: ReplayEventRef;
+    readonly runtimeLabel?: string;
+    readonly timestamp?: number;
+} | {
+    readonly type: 'process:start' | 'process:stop' | 'process:restart' | 'process:trigger' | 'process:dispatch' | 'process:error';
+    readonly moduleId?: string;
+    readonly instanceId?: string;
+    readonly identity: ProcessInstanceIdentity;
+    readonly severity: 'info' | 'warning' | 'error';
+    readonly eventSeq: number;
+    readonly timestampMs: number;
+    readonly trigger?: ProcessTrigger;
+    readonly dispatch?: {
+        readonly moduleId: string;
+        readonly instanceId: string;
+        readonly actionId: string;
+    };
+    readonly error?: SerializableErrorSummary;
+    readonly txnSeq?: number;
+    readonly txnId?: string;
+    readonly runtimeLabel?: string;
+    readonly timestamp?: number;
+} | {
+    readonly type: 'lifecycle:error';
+    readonly moduleId?: string;
+    readonly instanceId?: string;
+    readonly cause: unknown;
+    readonly phase?: 'init' | 'run' | 'destroy' | 'platform';
+    readonly hook?: 'initRequired' | 'start' | 'destroy' | 'suspend' | 'resume' | 'reset' | 'unknown';
+    readonly taskId?: string;
+    readonly opSeq?: number;
+    readonly origin?: string;
+    readonly txnSeq?: number;
+    readonly runtimeLabel?: string;
+    readonly timestamp?: number;
+} | {
+    readonly type: 'diagnostic';
+    readonly moduleId?: string;
+    readonly instanceId?: string;
+    readonly code: string;
+    readonly severity: 'error' | 'warning' | 'info';
+    readonly message: string;
+    readonly hint?: string;
+    readonly actionTag?: string;
+    readonly kind?: string;
+    readonly txnSeq?: number;
+    readonly txnId?: string;
+    readonly trigger?: TriggerRef;
+    readonly runtimeLabel?: string;
+    readonly timestamp?: number;
+}
+/**
+ * trace:* events:
+ * - Extension hook for runtime tracing / Playground / Alignment Lab.
+ * - Only the type prefix and moduleId are standardized; payload shape is defined by higher layers (e.g. spanId/attributes in data).
+ */
+ | {
+    readonly type: 'trace:trait:converge';
+    readonly moduleId?: string;
+    readonly instanceId?: string;
+    readonly data: JsonValue;
+    readonly txnSeq?: number;
+    readonly txnId?: string;
+    readonly runtimeLabel?: string;
+    readonly timestamp?: number;
+} | {
+    readonly type: 'trace:trait:check';
+    readonly moduleId?: string;
+    readonly instanceId?: string;
+    readonly data: JsonValue;
+    readonly txnSeq?: number;
+    readonly txnId?: string;
+    readonly runtimeLabel?: string;
+    readonly timestamp?: number;
+} | {
+    readonly type: 'trace:trait:validate';
+    readonly moduleId?: string;
+    readonly instanceId?: string;
+    readonly data: JsonValue;
+    readonly txnSeq?: number;
+    readonly txnId?: string;
+    readonly runtimeLabel?: string;
+    readonly timestamp?: number;
+} | {
+    readonly type: GenericTraceEventType;
+    readonly moduleId?: string;
+    readonly instanceId?: string;
+    readonly data?: unknown;
+    readonly txnSeq?: number;
+    readonly txnId?: string;
+    readonly runtimeLabel?: string;
+    readonly timestamp?: number;
+};
+interface Sink {
+    readonly record: (event: Event) => Effect.Effect<void>;
+}
+type DiagnosticsLevel = 'off' | 'light' | 'sampled' | 'full';
+interface TraitConvergeDiagnosticsSamplingConfig {
+    /**
+     * Sample once every N txns (deterministic, based on stable txnSeq).
+     * - 1: sample every txn (timing granularity similar to full, while keeping payload slim)
+     */
+    readonly sampleEveryN: number;
+    /**
+     * Max number of TopK hotspots to output (recommended ≤ 3).
+     */
+    readonly topK: number;
+}
+type RuntimeDebugEventKind = 'action' | 'state' | 'service' | 'process' | 'trait-computed' | 'trait-link' | 'trait-source' | 'lifecycle' | 'react-render' | 'devtools' | 'diagnostic' | (string & {});
+interface RuntimeDebugEventRef {
+    readonly eventId: string;
+    readonly eventSeq: number;
+    readonly moduleId: string;
+    readonly instanceId: string;
+    readonly runtimeLabel?: string;
+    readonly txnSeq: number;
+    readonly txnId?: string;
+    /**
+     * linkId：
+     * - Current operation chain id (shared by boundary ops in the same chain).
+     * - Created by Runtime at the boundary root and propagated via FiberRef across nested/cross-module chains.
+     */
+    readonly linkId?: string;
+    readonly timestamp: number;
+    readonly kind: RuntimeDebugEventKind;
+    readonly label: string;
+    readonly meta?: JsonValue;
+    readonly errorSummary?: SerializableErrorSummary$1;
+    readonly downgrade?: {
+        readonly reason?: 'non_serializable' | 'oversized' | 'unknown';
+    };
+}
+
+interface ObservationEnvelope$1 {
+    readonly protocolVersion: string;
+    readonly runId: string;
+    readonly seq: number;
+    readonly timestamp: number;
+    readonly type: string;
+    readonly payload: JsonValue;
+}
+interface EvidencePackageSource$1 {
+    readonly host: string;
+    readonly label?: string;
+}
+interface EvidencePackage$1 {
+    readonly protocolVersion: string;
+    readonly runId: string;
+    readonly createdAt: number;
+    readonly source: EvidencePackageSource$1;
+    readonly events: ReadonlyArray<ObservationEnvelope$1>;
+    readonly summary?: JsonValue;
+}
+
+type RunId = string;
+interface RunSessionLocalState {
+    /**
+     * once: a de-dup key set for "emit only once" behavior (must be isolated per session to avoid cross-session pollution).
+     * Returns true if it's the first occurrence, false if the key has been seen before.
+     */
+    readonly once: (key: string) => boolean;
+    /**
+     * seq: allocate monotonic sequences by key (e.g. opSeq/eventSeq), must be isolated per session.
+     */
+    readonly nextSeq: (namespace: string, key: string) => number;
+    /** Tests/reset only: clear this session's local state. */
+    readonly clear: () => void;
+}
+interface RunSession {
+    readonly runId: RunId;
+    readonly source: EvidencePackageSource$1;
+    readonly startedAt: number;
+    readonly local: RunSessionLocalState;
+}
+
+type OverrideScope = 'builtin' | 'runtime_default' | 'runtime_module' | 'provider' | 'instance';
+type RuntimeServiceOverride = {
+    readonly implId?: string;
+    readonly notes?: string;
+};
+/**
+ * RuntimeServicesOverrides: a serializable override for runtime service implementation selection.
+ *
+ * - The key is a stable serviceId.
+ * - The value may only contain serializable fields (no functions/closures) so evidence can be produced and explained.
+ */
+type RuntimeServicesOverrides = Readonly<Record<string, RuntimeServiceOverride>>;
+interface RuntimeServiceBinding {
+    readonly serviceId: string;
+    readonly implId?: string;
+    readonly implVersion?: string;
+    readonly scope: OverrideScope;
+    readonly overridden: boolean;
+    readonly notes?: string;
+}
+interface RuntimeServicesEvidence {
+    readonly moduleId?: string;
+    readonly instanceId: string;
+    readonly scope: OverrideScope;
+    readonly bindings: ReadonlyArray<RuntimeServiceBinding>;
+    readonly overridesApplied: ReadonlyArray<string>;
+}
+interface RuntimeServiceImpl<Service> {
+    readonly implId: string;
+    readonly implVersion: string;
+    readonly make: Effect.Effect<Service, never, any>;
+    readonly notes?: string;
+}
+/**
+ * RuntimeServicesRegistry：
+ * - Used to inject additional serviceId → impls (e.g. implementations provided by core-ng).
+ * - A non-serializable contract used only during assembly; selection evidence is still carried by
+ *   RuntimeServicesOverrides + RuntimeServicesEvidence.
+ */
+interface RuntimeServicesRegistry {
+    readonly implsByServiceId: Readonly<Record<string, ReadonlyArray<RuntimeServiceImpl<any>>>>;
+}
+
+interface ConstructionGuardError extends Error {
+    readonly _tag: 'ConstructionGuardError';
+    readonly kind: 'missing_service' | 'unknown_defect';
+    readonly missingService?: string;
+    readonly hint?: string;
+}
+declare const makeConstructionGuardError: (options: {
+    readonly kind: ConstructionGuardError["kind"];
+    readonly message: string;
+    readonly missingService?: string;
+    readonly hint?: string;
+}) => ConstructionGuardError;
+/**
+ * guardBuildTime：
+ * - During Build Env/Reflection, catch "missing service" defects and convert them into actionable errors.
+ * - Preserve other failures/defects as-is (do not swallow business error semantics).
+ */
+declare const guardBuildTime: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | ConstructionGuardError, R>;
+
+type ConstructionGuard_ConstructionGuardError = ConstructionGuardError;
+declare const ConstructionGuard_guardBuildTime: typeof guardBuildTime;
+declare const ConstructionGuard_makeConstructionGuardError: typeof makeConstructionGuardError;
+declare namespace ConstructionGuard {
+  export { type ConstructionGuard_ConstructionGuardError as ConstructionGuardError, ConstructionGuard_guardBuildTime as guardBuildTime, ConstructionGuard_makeConstructionGuardError as makeConstructionGuardError };
+}
+
+type RuntimeHostKind = 'node' | 'browser' | 'unknown';
+interface RuntimeHostService {
+    readonly kind: RuntimeHostKind;
+    readonly isNode: boolean;
+    readonly isBrowser: boolean;
+}
+declare const make: (kind: RuntimeHostKind) => RuntimeHostService;
+declare const RuntimeHost_base: Context.TagClass<RuntimeHost, "@logixjs/RuntimeHost", RuntimeHostService>;
+declare class RuntimeHost extends RuntimeHost_base {
+}
+declare const layer$1: (service: RuntimeHostService) => Layer.Layer<RuntimeHost, never, never>;
+declare const mock: (kind: RuntimeHostKind) => Layer.Layer<RuntimeHost, never, never>;
+declare const defaultLayer: Layer.Layer<RuntimeHost, never, never>;
+
+type RuntimeHost$1_RuntimeHost = RuntimeHost;
+declare const RuntimeHost$1_RuntimeHost: typeof RuntimeHost;
+type RuntimeHost$1_RuntimeHostKind = RuntimeHostKind;
+type RuntimeHost$1_RuntimeHostService = RuntimeHostService;
+declare const RuntimeHost$1_defaultLayer: typeof defaultLayer;
+declare const RuntimeHost$1_make: typeof make;
+declare const RuntimeHost$1_mock: typeof mock;
+declare namespace RuntimeHost$1 {
+  export { RuntimeHost$1_RuntimeHost as RuntimeHost, type RuntimeHost$1_RuntimeHostKind as RuntimeHostKind, type RuntimeHost$1_RuntimeHostService as RuntimeHostService, RuntimeHost$1_defaultLayer as defaultLayer, layer$1 as layer, RuntimeHost$1_make as make, RuntimeHost$1_mock as mock };
+}
+
+type BuildEnvConfigValue = string | number | boolean;
+interface BuildEnvOptions {
+    readonly runtimeHost?: RuntimeHostService;
+    readonly runtimeHostKind?: RuntimeHostKind;
+    /**
+     * Flat key/value config for mocking feature flags / env variables (values are coerced to string).
+     */
+    readonly config?: Record<string, BuildEnvConfigValue | undefined>;
+    /**
+     * Advanced: inject a ConfigProvider directly (higher priority than config).
+     */
+    readonly configProvider?: ConfigProvider.ConfigProvider;
+}
+declare const layer: (options?: BuildEnvOptions) => Layer.Layer<RuntimeHost, never, never>;
+declare const run: <A, E>(builder: Effect.Effect<A, E, RuntimeHost>, options?: BuildEnvOptions) => Effect.Effect<A, E | ConstructionGuardError, never>;
+
+type BuildEnv_BuildEnvConfigValue = BuildEnvConfigValue;
+type BuildEnv_BuildEnvOptions = BuildEnvOptions;
+declare const BuildEnv_layer: typeof layer;
+declare const BuildEnv_run: typeof run;
+declare namespace BuildEnv {
+  export { type BuildEnv_BuildEnvConfigValue as BuildEnvConfigValue, type BuildEnv_BuildEnvOptions as BuildEnvOptions, BuildEnv_layer as layer, BuildEnv_run as run };
+}
+
+/**
+ * Stable identifier for a kernel variant (requested kernel family).
+ *
+ * - Recommended: `[a-z0-9-]+` (lower-kebab).
+ * - Recommended reserved names: `core` (builtin semantics), `core-ng` (history/comparison).
+ */
+type KernelId = 'core' | 'core-ng' | (string & {});
+interface KernelImplementationRef {
+    /**
+     * Requested kernel family id (not a version number).
+     * Actual activation / fallback must be interpreted via RuntimeServicesEvidence.
+     */
+    readonly kernelId: KernelId;
+    /** The npm package that provides the kernel implementation. */
+    readonly packageName: string;
+    /** Optional semver for explainability (not used as a semantic anchor). */
+    readonly packageVersion?: string;
+    /** Optional build hash/id for evidence diff explainability. */
+    readonly buildId?: string;
+    /** Explainability-only labels; must not become semantic switches. */
+    readonly capabilities?: ReadonlyArray<string>;
+}
+
+declare const exportStaticIr: (module: unknown) => StaticIr | undefined;
+
+interface ManifestBudgets {
+    readonly maxBytes?: number;
+}
+interface ExtractManifestOptions {
+    readonly includeStaticIr?: boolean;
+    readonly budgets?: ManifestBudgets;
+}
+interface ModuleManifestLogicUnit {
+    readonly kind: string;
+    readonly id: string;
+    readonly derived?: boolean;
+    readonly name?: string;
+}
+interface ModuleManifestAction {
+    readonly actionTag: string;
+    readonly payload: {
+        readonly kind: 'void' | 'nonVoid' | 'unknown';
+    };
+    readonly primaryReducer?: {
+        readonly kind: 'declared' | 'registered';
+    };
+    readonly source?: {
+        readonly file: string;
+        readonly line: number;
+        readonly column: number;
+    };
+}
+interface ModuleManifestEffect {
+    readonly actionTag: string;
+    readonly sourceKey: string;
+    readonly kind: 'declared' | 'registered';
+    readonly source?: {
+        readonly file: string;
+        readonly line: number;
+        readonly column: number;
+    };
+}
+interface ModuleManifest {
+    readonly manifestVersion: string;
+    readonly moduleId: string;
+    readonly actionKeys: ReadonlyArray<string>;
+    readonly actions: ReadonlyArray<ModuleManifestAction>;
+    readonly effects?: ReadonlyArray<ModuleManifestEffect>;
+    readonly schemaKeys?: ReadonlyArray<string>;
+    readonly logicUnits?: ReadonlyArray<ModuleManifestLogicUnit>;
+    readonly source?: {
+        readonly file: string;
+        readonly line: number;
+        readonly column: number;
+    };
+    readonly meta?: Record<string, JsonValue>;
+    readonly staticIr?: ReturnType<typeof exportStaticIr>;
+    readonly digest: string;
+}
+
+type ArtifactKey = string;
+type EnvelopeBase = {
+    readonly artifactKey: ArtifactKey;
+    readonly truncated?: boolean;
+    readonly budgetBytes?: number;
+    readonly actualBytes?: number;
+    readonly digest?: string;
+    readonly notes?: JsonValue;
+};
+type ArtifactEnvelope = (EnvelopeBase & {
+    readonly ok: true;
+    readonly value: JsonValue;
+    readonly error?: never;
+}) | (EnvelopeBase & {
+    readonly ok: false;
+    readonly error: SerializableErrorSummary$1;
+    readonly value?: never;
+});
+type TrialRunArtifacts = Readonly<Record<ArtifactKey, ArtifactEnvelope>>;
+
+type RootLike<Sh extends AnyModuleShape> = ModuleImpl<any, Sh, any> | {
+    readonly impl: ModuleImpl<any, Sh, any>;
+};
+interface TrialRunReportBudgets {
+    readonly maxBytes?: number;
+}
+interface TrialRunReport {
+    readonly runId: string;
+    readonly ok: boolean;
+    readonly manifest?: ModuleManifest;
+    readonly staticIr?: ReturnType<typeof exportStaticIr>;
+    readonly artifacts?: TrialRunArtifacts;
+    readonly environment?: EnvironmentIr;
+    readonly evidence?: EvidencePackage$1;
+    readonly summary?: unknown;
+    readonly error?: SerializableErrorSummary$1;
+}
+interface EnvironmentIr {
+    readonly tagIds: ReadonlyArray<string>;
+    readonly configKeys: ReadonlyArray<string>;
+    readonly missingServices: ReadonlyArray<string>;
+    readonly missingConfigKeys: ReadonlyArray<string>;
+    readonly kernelImplementationRef?: KernelImplementationRef;
+    readonly runtimeServicesEvidence?: RuntimeServicesEvidence;
+    readonly notes?: unknown;
+}
+interface TrialRunModuleOptions {
+    readonly runId?: RunId;
+    readonly source?: EvidencePackageSource$1;
+    readonly startedAt?: number;
+    readonly diagnosticsLevel?: DiagnosticsLevel;
+    readonly maxEvents?: number;
+    readonly layer?: Layer.Layer<any, any, any>;
+    readonly buildEnv?: {
+        readonly config?: Record<string, BuildEnvConfigValue | undefined>;
+        readonly hostKind?: BuildEnvOptions['runtimeHostKind'];
+        readonly configProvider?: BuildEnvOptions['configProvider'];
+    };
+    readonly trialRunTimeoutMs?: number;
+    readonly closeScopeTimeout?: number;
+    readonly budgets?: TrialRunReportBudgets;
+}
+declare const trialRunModule: <Sh extends AnyModuleShape>(root: RootLike<Sh>, options?: TrialRunModuleOptions) => Effect.Effect<TrialRunReport, never, never>;
+
+interface TrialRunOptions {
+    readonly runId?: RunId;
+    readonly source?: EvidencePackageSource$1;
+    readonly startedAt?: number;
+    readonly diagnosticsLevel?: DiagnosticsLevel;
+    readonly maxEvents?: number;
+    readonly layer?: Layer.Layer<any, any, any>;
+    readonly runtimeServicesInstanceOverrides?: RuntimeServicesOverrides;
+}
+interface TrialRunResult<A, E> {
+    readonly session: RunSession;
+    readonly exit: Exit.Exit<A, E>;
+    readonly evidence: EvidencePackage$1;
+}
+declare const trialRun: <A, E, R>(program: Effect.Effect<A, E, R>, options?: TrialRunOptions) => Effect.Effect<TrialRunResult<A, E>, never, R>;
+
+interface TrialRunArtifactInspectionContext {
+    readonly moduleId: string;
+    readonly manifest?: ModuleManifest;
+    readonly staticIr?: ReturnType<typeof exportStaticIr>;
+    readonly environment?: EnvironmentIr;
+}
+interface TrialRunArtifactExporter {
+    readonly exporterId: string;
+    readonly artifactKey: ArtifactKey;
+    readonly export: (ctx: TrialRunArtifactInspectionContext) => JsonValue | undefined;
+}
+
+declare const registerTrialRunArtifactExporter: (tag: unknown, exporter: TrialRunArtifactExporter) => void;
+
+declare const protocolVersion = "v1";
+interface ObservationEnvelope extends ObservationEnvelope$1 {
+}
+interface EvidencePackageSource extends EvidencePackageSource$1 {
+}
+interface EvidencePackage extends EvidencePackage$1 {
+}
+declare const exportEvidencePackage: (options: {
+    readonly runId: string;
+    readonly source: EvidencePackageSource$1;
+    readonly events: ReadonlyArray<ObservationEnvelope$1>;
+    readonly createdAt?: number;
+    readonly protocolVersion?: string;
+    readonly summary?: JsonValue;
+}) => EvidencePackage$1;
+declare const importEvidencePackage: (input: unknown) => EvidencePackage$1;
+
+type Observability_ArtifactEnvelope = ArtifactEnvelope;
+type Observability_ArtifactKey = ArtifactKey;
+type Observability_EnvironmentIr = EnvironmentIr;
+type Observability_EvidencePackage = EvidencePackage;
+type Observability_EvidencePackageSource = EvidencePackageSource;
+type Observability_JsonValue = JsonValue;
+type Observability_ObservationEnvelope = ObservationEnvelope;
+type Observability_TrialRunArtifactExporter = TrialRunArtifactExporter;
+type Observability_TrialRunArtifactInspectionContext = TrialRunArtifactInspectionContext;
+type Observability_TrialRunArtifacts = TrialRunArtifacts;
+type Observability_TrialRunModuleOptions = TrialRunModuleOptions;
+type Observability_TrialRunOptions = TrialRunOptions;
+type Observability_TrialRunReport = TrialRunReport;
+type Observability_TrialRunReportBudgets = TrialRunReportBudgets;
+type Observability_TrialRunResult<A, E> = TrialRunResult<A, E>;
+declare const Observability_exportEvidencePackage: typeof exportEvidencePackage;
+declare const Observability_importEvidencePackage: typeof importEvidencePackage;
+declare const Observability_protocolVersion: typeof protocolVersion;
+declare const Observability_registerTrialRunArtifactExporter: typeof registerTrialRunArtifactExporter;
+declare const Observability_trialRun: typeof trialRun;
+declare const Observability_trialRunModule: typeof trialRunModule;
+declare namespace Observability {
+  export { type Observability_ArtifactEnvelope as ArtifactEnvelope, type Observability_ArtifactKey as ArtifactKey, type Observability_EnvironmentIr as EnvironmentIr, type Observability_EvidencePackage as EvidencePackage, type Observability_EvidencePackageSource as EvidencePackageSource, type Observability_JsonValue as JsonValue, type Observability_ObservationEnvelope as ObservationEnvelope, type Observability_TrialRunArtifactExporter as TrialRunArtifactExporter, type Observability_TrialRunArtifactInspectionContext as TrialRunArtifactInspectionContext, type Observability_TrialRunArtifacts as TrialRunArtifacts, type Observability_TrialRunModuleOptions as TrialRunModuleOptions, type Observability_TrialRunOptions as TrialRunOptions, type Observability_TrialRunReport as TrialRunReport, type Observability_TrialRunReportBudgets as TrialRunReportBudgets, type Observability_TrialRunResult as TrialRunResult, Observability_exportEvidencePackage as exportEvidencePackage, Observability_importEvidencePackage as importEvidencePackage, Observability_protocolVersion as protocolVersion, Observability_registerTrialRunArtifactExporter as registerTrialRunArtifactExporter, Observability_trialRun as trialRun, Observability_trialRunModule as trialRunModule };
+}
+
+export { type ArtifactEnvelope as A, BuildEnv as B, ConstructionGuard as C, type DiagnosticsLevel as D, type ExtractManifestOptions as E, trialRun as F, type TrialRunReportBudgets as G, type TrialRunReport as H, type EnvironmentIr as I, type JsonValue as J, type KernelImplementationRef as K, type TrialRunModuleOptions as L, type ModuleManifest as M, trialRunModule as N, Observability as O, ReplayLog$1 as R, type Sink as S, type TriggerRef as T, RuntimeHost$1 as a, type RuntimeServicesOverrides as b, type KernelId as c, type RuntimeServiceBinding as d, type RuntimeServiceOverride as e, type RuntimeServicesEvidence as f, type RuntimeServiceImpl as g, type RuntimeServicesRegistry as h, type RuntimeDebugEventRef as i, type Event as j, type TraitConvergeDiagnosticsSamplingConfig as k, type JsonValueProjectionStats as l, type DowngradeReason as m, type EvidencePackageSource as n, type EvidencePackage as o, protocolVersion as p, type ObservationEnvelope as q, exportEvidencePackage as r, importEvidencePackage as s, type ArtifactKey as t, type TrialRunArtifacts as u, type TrialRunArtifactExporter as v, type TrialRunArtifactInspectionContext as w, registerTrialRunArtifactExporter as x, type TrialRunOptions as y, type TrialRunResult as z };