@logixjs/core 0.0.1 → 1.0.0

package/dist/ModuleTag.d.cts

@@ -1,8 +1,8 @@
 import 'effect';
-import './Logic-DRh4sDZj.cjs';
-import './action-DiMDD_0v.cjs';
-export { p as ActionOf, q as ActionsFromMap, h as AnyModuleShape, A as AnySchema, B as BoundApi, m as ModuleHandle, G as ModuleHandleUnion, k as ModuleImpl, j as ModuleLogic, l as ModuleRuntime, i as ModuleShape, M as ModuleTag, R as ReducersFromMap, v as StateChangeWithMeta, u as StateCommitMeta, s as StateCommitMode, t as StateCommitPriority, o as StateOf } from './module-B8CBqIZ_.cjs';
-export { R as Reducer, S as Shape, m as make } from './ModuleTag-EGbgBMpZ.cjs';
-import './Platform-C49Pv956.cjs';
+import './Logic-09VQpIj3.cjs';
+import './action-BQxjPFEw.cjs';
+export { E as ActionForTag, w as ActionOf, x as ActionsFromMap, o as AnyModuleShape, A as AnySchema, B as BoundApi, J as BoundApiDispatchApi, I as BoundApiDispatchersApi, K as BoundApiLifecycleApi, Q as BoundApiReducerApi, G as BoundApiRootApi, H as BoundApiStateApi, O as BoundApiTraitsApi, N as BoundApiUseApi, z as DispatchEffect, L as LogicEffect, u as ModuleHandle, a0 as ModuleHandleUnion, r as ModuleImpl, q as ModuleLogic, s as ModuleRuntime, t as ModuleRuntimeOfShape, p as ModuleShape, M as ModuleTag, R as ReducersFromMap, U as StateChangeWithMeta, a as StateCommitMeta, T as StateCommitMode, S as StateCommitPriority, v as StateOf } from './module-Ds4tarcI.cjs';
+export { b as ActionSchemaOf, A as ActionTokenMap, a as ActionUnionOf, R as Reducer, S as Shape, c as ShapeFromActionTokenMap, m as make } from './ModuleTag-CITb8L_G.cjs';
+import './Platform-BV_0MW7g.cjs';
+import './ReadQuery-DXLzCE0E.cjs';
 import 'mutative';
-import './ReadQuery-SinbStGF.cjs';

package/dist/ModuleTag.d.ts

@@ -1,8 +1,8 @@
 import 'effect';
-import './Logic-BRjEMr-W.js';
-import './action-DiMDD_0v.js';
-export { p as ActionOf, q as ActionsFromMap, h as AnyModuleShape, A as AnySchema, B as BoundApi, m as ModuleHandle, G as ModuleHandleUnion, k as ModuleImpl, j as ModuleLogic, l as ModuleRuntime, i as ModuleShape, M as ModuleTag, R as ReducersFromMap, v as StateChangeWithMeta, u as StateCommitMeta, s as StateCommitMode, t as StateCommitPriority, o as StateOf } from './module-k7m3txak.js';
-export { R as Reducer, S as Shape, m as make } from './ModuleTag-C8FHY_sY.js';
-import './Platform-C49Pv956.js';
+import './Logic-DKg7ghGy.js';
+import './action-BQxjPFEw.js';
+export { E as ActionForTag, w as ActionOf, x as ActionsFromMap, o as AnyModuleShape, A as AnySchema, B as BoundApi, J as BoundApiDispatchApi, I as BoundApiDispatchersApi, K as BoundApiLifecycleApi, Q as BoundApiReducerApi, G as BoundApiRootApi, H as BoundApiStateApi, O as BoundApiTraitsApi, N as BoundApiUseApi, z as DispatchEffect, L as LogicEffect, u as ModuleHandle, a0 as ModuleHandleUnion, r as ModuleImpl, q as ModuleLogic, s as ModuleRuntime, t as ModuleRuntimeOfShape, p as ModuleShape, M as ModuleTag, R as ReducersFromMap, U as StateChangeWithMeta, a as StateCommitMeta, T as StateCommitMode, S as StateCommitPriority, v as StateOf } from './module-Zd1Gn-Nj.js';
+export { b as ActionSchemaOf, A as ActionTokenMap, a as ActionUnionOf, R as Reducer, S as Shape, c as ShapeFromActionTokenMap, m as make } from './ModuleTag-CGho_InD.js';
+import './Platform-BV_0MW7g.js';
+import './ReadQuery-DXLzCE0E.js';
 import 'mutative';
-import './ReadQuery-SinbStGF.js';

package/dist/ModuleTag.js

@@ -1,36 +1,42 @@
 import {
   Reducer,
   make
-} from "./chunk-76WT3HOR.js";
-import "./chunk-KIXAU3GM.js";
-import "./chunk-JCXGZRMU.js";
-import "./chunk-JGIWG6SR.js";
-import "./chunk-PYOE4VSI.js";
-import "./chunk-BABLDP24.js";
-import "./chunk-NZJKFF45.js";
-import "./chunk-KP7MUZNX.js";
-import "./chunk-PAYXCY6A.js";
-import "./chunk-ZGDVUPTM.js";
+} from "./chunk-6YZOXFPQ.js";
+import "./chunk-GWSM4KLB.js";
+import "./chunk-AO4JEOKD.js";
+import "./chunk-SNPNHU3H.js";
+import "./chunk-IVXSVHO4.js";
+import "./chunk-EPQFNJU3.js";
+import "./chunk-NUDBM4MM.js";
+import "./chunk-MYB2B5WX.js";
+import "./chunk-VJLWD47W.js";
+import "./chunk-EKCDHWRK.js";
+import "./chunk-RLXO27MW.js";
+import "./chunk-IOZ3VKPK.js";
 import "./chunk-LEU6UA5J.js";
-import "./chunk-BE3HW4FY.js";
-import "./chunk-ZFLHVFUC.js";
-import "./chunk-KL5ACTCT.js";
-import "./chunk-AUIR5O6W.js";
-import "./chunk-BZ2SHDN2.js";
-import "./chunk-YS3AZQ2G.js";
-import "./chunk-66ALHVEX.js";
-import "./chunk-ZFY7U2FR.js";
-import "./chunk-M3BFQ7HK.js";
-import "./chunk-IHVBV5C2.js";
-import "./chunk-3RMKLXHX.js";
-import "./chunk-3QMIVH35.js";
-import "./chunk-NQZ2OSGR.js";
-import "./chunk-CW6T36TN.js";
-import "./chunk-DMBALCE2.js";
-import "./chunk-GMPEOUP2.js";
-import "./chunk-OFADUJWJ.js";
-import "./chunk-M7IYCTJV.js";
-import "./chunk-JWOYLO27.js";
+import "./chunk-ZBBMZMA6.js";
+import "./chunk-UEFFTVPY.js";
+import "./chunk-AFSB6NKM.js";
+import "./chunk-YZDJMAKL.js";
+import "./chunk-SGTRAXXX.js";
+import "./chunk-6HFAW2MH.js";
+import "./chunk-EB46EYI7.js";
+import "./chunk-HJM5Y5NU.js";
+import "./chunk-RHJIGDUE.js";
+import "./chunk-J3CWXIPV.js";
+import "./chunk-SOOBFXRR.js";
+import "./chunk-63ZQ5RIN.js";
+import "./chunk-S4S5N4BJ.js";
+import "./chunk-NZMWWDAY.js";
+import "./chunk-MYKNINNN.js";
+import "./chunk-FBYW3QDI.js";
+import "./chunk-K6JQW266.js";
+import "./chunk-CYYSQMLO.js";
+import "./chunk-R4LFQGP3.js";
+import "./chunk-V2SBGVDO.js";
+import "./chunk-LPPZDFTD.js";
+import "./chunk-PBD7BJUN.js";
+import "./chunk-4MZ7BT3R.js";
 import "./chunk-PZ5AY32C.js";
 export {
   Reducer,

package/dist/Observability-Bdhnx2Dv.d.ts

@@ -0,0 +1,385 @@
+import { J as JsonValue, v as SerializableErrorSummary, m as DiagnosticsLevel } from './ReadQuery-DXLzCE0E.js';
+import { Effect, ServiceMap, Layer, ConfigProvider, Exit } from 'effect';
+import { o as AnyModuleShape, r as ModuleImpl } from './module-Zd1Gn-Nj.js';
+import { S as StaticIr } from './ir-D-uqwL_4.js';
+
+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: ServiceMap.ServiceClass<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;
+    readonly value?: never;
+});
+type TrialRunArtifacts = Readonly<Record<ArtifactKey, ArtifactEnvelope>>;
+
+interface TrialRunReportBudgets$1 {
+    readonly maxBytes?: number;
+}
+
+type RootLike<Sh extends AnyModuleShape> = ModuleImpl<any, Sh, any> | {
+    readonly impl: ModuleImpl<any, Sh, any>;
+};
+interface TrialRunReportBudgets extends TrialRunReportBudgets$1 {
+}
+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;
+}
+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;
+declare const Observability_JsonValue: typeof 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, 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 ExtractManifestOptions as E, type KernelImplementationRef as K, type ModuleManifest as M, Observability as O, RuntimeHost$1 as R, type TrialRunArtifacts as T, type RuntimeServicesOverrides as a, type KernelId as b, type RuntimeServiceBinding as c, type RuntimeServiceOverride as d, type RuntimeServicesEvidence as e, type RuntimeServiceImpl as f, type RuntimeServicesRegistry as g, type EvidencePackageSource as h, type EvidencePackage as i, type ObservationEnvelope as j, exportEvidencePackage as k, importEvidencePackage as l, type ArtifactKey as m, type TrialRunArtifactExporter as n, type TrialRunArtifactInspectionContext as o, protocolVersion as p, type TrialRunOptions as q, registerTrialRunArtifactExporter as r, type TrialRunResult as s, trialRun as t, type TrialRunReportBudgets as u, type TrialRunReport as v, type EnvironmentIr as w, type TrialRunModuleOptions as x, trialRunModule as y };