@logixjs/core 0.0.1 → 1.0.0

package/dist/ReadQuery-DXLzCE0E.d.ts

@@ -0,0 +1,614 @@
+import { Effect, ServiceMap, Layer } from 'effect';
+
+interface SerializableErrorSummary$1 {
+    readonly message: string;
+    readonly name?: string;
+    readonly code?: string;
+    readonly hint?: string;
+}
+
+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: ServiceMap.ServiceClass<ReplayLog, "@logixjs/core/ReplayLog", ReplayLogService>;
+declare class ReplayLog extends ReplayLog_base {
+}
+declare const make: (initial?: ReadonlyArray<ReplayLogEvent>) => ReplayLogService;
+declare const layer: (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_layer: typeof layer;
+declare const ReplayLog$1_make: typeof make;
+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, ReplayLog$1_layer as layer, ReplayLog$1_make as make, ReplayLog$1_record as record, ReplayLog$1_resetCursor as resetCursor, ReplayLog$1_snapshot as snapshot };
+}
+
+declare const DIAGNOSTICS_BUDGET_CONTRACT_V1: "diagnostics_budget.v1";
+type RunBudgetDomain = 'process' | 'workflow' | 'flow';
+type RunBudgetEnvelopeV1 = {
+    readonly contract: typeof DIAGNOSTICS_BUDGET_CONTRACT_V1;
+    readonly domain: RunBudgetDomain;
+    readonly runId: string;
+    readonly limits?: {
+        readonly maxEvents?: number;
+        readonly maxBytes?: number;
+    };
+    readonly usage?: {
+        readonly emitted?: number;
+        readonly dropped?: number;
+        readonly downgraded?: number;
+    };
+};
+type RunDegradeReasonV1 = 'budget_exceeded' | 'payload_oversized' | 'payload_non_serializable' | 'observer_disabled' | 'sampled_out' | 'unknown';
+type RunDegradeMarkerV1 = {
+    readonly contract: typeof DIAGNOSTICS_BUDGET_CONTRACT_V1;
+    readonly degraded: boolean;
+    readonly reason?: RunDegradeReasonV1;
+};
+
+type DiagnosticsLevel$1 = 'off' | 'light' | 'full';
+type ProcessScope = {
+    readonly type: 'app';
+    readonly appId: string;
+} | {
+    readonly type: 'moduleInstance';
+    readonly moduleId: string;
+    readonly instanceId: string;
+} | {
+    readonly type: 'uiSubtree';
+    readonly subtreeId: string;
+};
+interface ProcessIdentity {
+    readonly processId: string;
+    readonly scope: ProcessScope;
+}
+interface ProcessInstanceIdentity {
+    readonly identity: ProcessIdentity;
+    readonly runSeq: number;
+}
+type ProcessTriggerSpec = {
+    readonly kind: 'moduleAction';
+    readonly name?: string;
+    readonly moduleId: string;
+    readonly actionId: string;
+} | {
+    readonly kind: 'moduleStateChange';
+    readonly name?: string;
+    readonly moduleId: string;
+    readonly path: string;
+} | {
+    readonly kind: 'platformEvent';
+    readonly name?: string;
+    readonly platformEvent: string;
+} | {
+    readonly kind: 'timer';
+    readonly name?: string;
+    readonly timerId: string;
+};
+type ProcessTrigger = {
+    readonly kind: 'moduleAction';
+    readonly name?: string;
+    readonly moduleId: string;
+    readonly instanceId: string;
+    readonly actionId: string;
+    readonly txnSeq: number;
+    readonly triggerSeq?: number;
+} | {
+    readonly kind: 'moduleStateChange';
+    readonly name?: string;
+    readonly moduleId: string;
+    readonly instanceId: string;
+    readonly path: string;
+    readonly txnSeq: number;
+    readonly triggerSeq?: number;
+} | {
+    readonly kind: 'platformEvent';
+    readonly name?: string;
+    readonly platformEvent: string;
+    readonly triggerSeq?: number;
+} | {
+    readonly kind: 'timer';
+    readonly name?: string;
+    readonly timerId: string;
+    readonly triggerSeq?: number;
+};
+interface ProcessConcurrencyPolicy {
+    readonly mode: 'latest' | 'serial' | 'drop' | 'parallel';
+    readonly maxParallel?: number;
+    readonly maxQueue?: number;
+}
+interface ProcessErrorPolicy {
+    readonly mode: 'failStop' | 'supervise';
+    readonly maxRestarts?: number;
+    readonly windowMs?: number;
+}
+interface ProcessDefinition {
+    readonly processId: string;
+    readonly name?: string;
+    readonly description?: string;
+    readonly requires?: ReadonlyArray<string>;
+    readonly triggers: ReadonlyArray<ProcessTriggerSpec>;
+    readonly concurrency: ProcessConcurrencyPolicy;
+    readonly errorPolicy: ProcessErrorPolicy;
+    readonly diagnosticsLevel?: DiagnosticsLevel$1;
+}
+interface ProcessInstallation {
+    readonly identity: ProcessIdentity;
+    readonly enabled: boolean;
+    readonly installedAt?: string;
+}
+interface SerializableErrorSummary {
+    readonly name?: string;
+    readonly message: string;
+    readonly code?: string;
+    readonly hint?: string;
+}
+type ProcessInstanceStatus = {
+    readonly identity: ProcessInstanceIdentity;
+    readonly status: 'starting' | 'running' | 'stopping' | 'stopped' | 'failed';
+    readonly stoppedReason?: 'scopeDisposed' | 'manualStop' | 'failed' | 'unknown';
+    readonly lastError?: SerializableErrorSummary;
+};
+type ProcessEvent = {
+    readonly type: 'process:start' | 'process:stop' | 'process:restart' | 'process:trigger' | 'process:dispatch' | 'process:error';
+    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;
+    /**
+     * Run 级诊断预算 envelope（统一口径，兼容 workflow/flow）。
+     * - 旧消费端可继续读取 error.hint；
+     * - 新消费端应优先读取该结构化字段。
+     */
+    readonly budgetEnvelope?: RunBudgetEnvelopeV1;
+    /**
+     * Run 级降级标记（统一口径，兼容 workflow/flow）。
+     */
+    readonly degrade?: RunDegradeMarkerV1;
+};
+interface ProcessControlRequest {
+    readonly action: 'start' | 'stop' | 'restart';
+    readonly reason?: string;
+}
+interface ProcessPlatformEvent {
+    readonly eventName: string;
+    readonly payload?: Record<string, unknown>;
+}
+
+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 budgetEnvelope?: ProcessEvent['budgetEnvelope'];
+    readonly degrade?: ProcessEvent['degrade'];
+    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 opSeq?: number;
+    readonly trigger?: TriggerRef;
+    readonly runtimeLabel?: string;
+    readonly timestamp?: number;
+} | {
+    readonly type: 'warn:priority-inversion';
+    readonly moduleId?: string;
+    readonly instanceId?: string;
+    readonly tickSeq: number;
+    readonly reason: 'deferredBacklog' | 'subscribedNonUrgent';
+    readonly selectorId?: string;
+    readonly runtimeLabel?: string;
+    readonly timestamp?: number;
+} | {
+    readonly type: 'warn:microtask-starvation';
+    readonly moduleId?: string;
+    readonly instanceId?: string;
+    readonly tickSeq: number;
+    readonly microtaskChainDepth?: number;
+    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';
+type DiagnosticsMaterialization = 'eager' | 'lazy';
+type TraceMode = 'off' | 'on';
+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' | 'budget_exceeded' | 'unknown';
+    };
+}
+
+type ReadLane = 'static' | 'dynamic';
+type ReadProducer = 'aot' | 'jit' | 'manual' | 'dynamic';
+type ReadQueryFallbackReason = 'missingDeps' | 'unsupportedSyntax' | 'unstableSelectorId' | 'missingBuildGrade';
+type EqualsKind = 'objectIs' | 'shallowStruct' | 'custom';
+type ReadQueryStrictGateRule = 'denyFallbackReason' | 'requireStatic:global' | 'requireStatic:selectorId' | 'requireStatic:module';
+type ReadQueryQualitySource = 'build' | 'runtime_jit' | 'runtime_dynamic_fallback';
+interface ReadQueryStrictGateGrade {
+    readonly evaluatedAt: 'build' | 'runtime';
+    readonly verdict: 'PASS' | 'WARN' | 'FAIL';
+    readonly rule?: ReadQueryStrictGateRule;
+    readonly fallbackReason?: ReadQueryFallbackReason;
+}
+interface ReadQueryQualityMeta {
+    readonly source: ReadQueryQualitySource;
+    readonly strictGate?: ReadQueryStrictGateGrade;
+    readonly reportId?: string;
+    readonly missingBuildGrade?: boolean;
+}
+interface ReadsDigest {
+    readonly count: number;
+    readonly hash: number;
+}
+interface ReadQueryStaticIr {
+    readonly selectorId: string;
+    readonly debugKey?: string;
+    readonly lane: ReadLane;
+    readonly producer: ReadProducer;
+    readonly reads?: ReadonlyArray<string | number>;
+    readonly readsDigest?: ReadsDigest;
+    readonly fallbackReason?: ReadQueryFallbackReason;
+    readonly equalsKind: EqualsKind;
+}
+interface ReadQuery<S, V> {
+    readonly selectorId: string;
+    readonly debugKey?: string;
+    readonly reads: ReadonlyArray<string | number>;
+    readonly select: (state: S) => V;
+    readonly equalsKind: EqualsKind;
+    readonly equals?: (previous: V, next: V) => boolean;
+}
+interface ReadQueryCompiled<S, V> extends ReadQuery<S, V> {
+    readonly lane: ReadLane;
+    readonly producer: ReadProducer;
+    readonly readsDigest?: ReadsDigest;
+    readonly fallbackReason?: ReadQueryFallbackReason;
+    readonly staticIr: ReadQueryStaticIr;
+    readonly quality?: ReadQueryQualityMeta;
+}
+type ReadQueryInput<S, V> = ((state: S) => V) | ReadQuery<S, V>;
+declare function isReadQuery<S, V>(input: ReadQueryInput<S, V>): input is ReadQuery<S, V>;
+declare function isReadQuery(input: unknown): input is ReadQuery<any, any>;
+declare function isReadQueryCompiled<S, V>(input: ReadQueryInput<S, V> | ReadQueryCompiled<S, V>): input is ReadQueryCompiled<S, V>;
+declare function isReadQueryCompiled(input: unknown): input is ReadQueryCompiled<any, any>;
+interface ReadQueryStrictGateConfig {
+    readonly mode: 'off' | 'warn' | 'error';
+    readonly requireStatic?: {
+        readonly selectorIds?: ReadonlyArray<string>;
+        readonly modules?: ReadonlyArray<string>;
+    };
+    readonly denyFallbackReasons?: ReadonlyArray<ReadQueryFallbackReason>;
+}
+interface ReadQueryStrictGateViolationDetails {
+    readonly moduleId: string;
+    readonly instanceId: string;
+    readonly txnSeq: number;
+    readonly selectorId: string;
+    readonly debugKey?: string;
+    readonly fallbackReason: ReadQueryFallbackReason;
+    readonly rule: ReadQueryStrictGateRule;
+}
+interface ReadQueryStrictGateError extends Error {
+    readonly _tag: 'ReadQueryStrictGateError';
+    readonly details: ReadQueryStrictGateViolationDetails;
+}
+type ReadQueryStrictGateDiagnosticEvent = Extract<Event, {
+    readonly type: 'diagnostic';
+}>;
+type ReadQueryStrictGateDecision = {
+    readonly verdict: 'PASS';
+} | {
+    readonly verdict: 'WARN';
+    readonly diagnostic: ReadQueryStrictGateDiagnosticEvent;
+    readonly details: ReadQueryStrictGateViolationDetails;
+} | {
+    readonly verdict: 'FAIL';
+    readonly diagnostic: ReadQueryStrictGateDiagnosticEvent;
+    readonly error: ReadQueryStrictGateError;
+    readonly details: ReadQueryStrictGateViolationDetails;
+};
+
+export { type ReadLane as A, type ReadProducer as B, type EqualsKind as C, type DiagnosticsLevel$1 as D, type Event as E, type ReadsDigest as F, type ReadQueryQualityMeta as G, type ReadQueryStrictGateGrade as H, type ReadQueryStaticIr as I, type JsonValue as J, type ReadQuery as K, type ReadQueryStrictGateConfig as L, isReadQuery as M, isReadQueryCompiled as N, type ProcessScope as P, ReplayLog$1 as R, type SerializableErrorSummary as S, type TriggerRef as T, type ProcessInstallation as a, type ProcessInstanceStatus as b, type ProcessControlRequest as c, type ProcessPlatformEvent as d, type ProcessEvent as e, type ProcessDefinition as f, type ProcessIdentity as g, type ProcessInstanceIdentity as h, type ProcessTriggerSpec as i, type ProcessTrigger as j, type ProcessConcurrencyPolicy as k, type ProcessErrorPolicy as l, type DiagnosticsLevel as m, type ReadQueryFallbackReason as n, type RuntimeDebugEventRef as o, type Sink as p, type DiagnosticsMaterialization as q, type TraceMode as r, type TraitConvergeDiagnosticsSamplingConfig as s, type JsonValueProjectionStats as t, type DowngradeReason as u, type SerializableErrorSummary$1 as v, type ReadQueryCompiled as w, type ReadQueryStrictGateRule as x, type ReadQueryStrictGateDecision as y, type ReadQueryInput as z };