@logixjs/core 0.0.1

package/dist/Flow-1fZT8MpX.d.cts

@@ -0,0 +1,152 @@
+import { Effect, Cause, Context } from 'effect';
+import { E as ErrorContext, l as ModuleRuntime, S as StateTransactionInstrumentation, w as StateTxnOrigin, a as StatePatchPath, P as PatchReason, C as ConcurrencyLimit, T as TraitContribution, x as ModuleTraitsSnapshot, h as AnyModuleShape, i as ModuleShape, y as Api$1, o as StateOf, p as ActionOf } from './module-B8CBqIZ_.cjs';
+import { E as Env$1 } from './Logic-DRh4sDZj.cjs';
+
+type TxnLanePolicyScope = 'provider' | 'runtime_module' | 'runtime_default' | 'builtin';
+type TxnLaneQueueMode = 'fifo' | 'lanes';
+type TxnLaneYieldStrategy = 'baseline' | 'inputPending';
+type ResolvedTxnLanePolicy = {
+    readonly enabled: boolean;
+    readonly overrideMode?: 'forced_off' | 'forced_sync';
+    readonly configScope: TxnLanePolicyScope;
+    readonly budgetMs: number;
+    readonly debounceMs: number;
+    readonly maxLagMs: number;
+    readonly allowCoalesce: boolean;
+    readonly yieldStrategy: TxnLaneYieldStrategy;
+    readonly queueMode: TxnLaneQueueMode;
+};
+
+type RuntimeInternalsEffects = {
+    readonly registerEffect: (args: {
+        readonly actionTag: string;
+        readonly handler: (payload: unknown) => Effect.Effect<void, any, any>;
+        readonly phase: 'setup' | 'run';
+        readonly logicUnit?: {
+            readonly logicUnitId: string;
+            readonly logicUnitLabel: string;
+            readonly path?: string;
+        };
+    }) => Effect.Effect<{
+        readonly sourceKey: string;
+        readonly duplicate: boolean;
+    }, never, any>;
+};
+type ImportsScope = {
+    readonly kind: 'imports-scope';
+    readonly get: (module: Context.Tag<any, ModuleRuntime<any, any>>) => ModuleRuntime<any, any> | undefined;
+};
+type RuntimeInternalsLifecycle = {
+    readonly registerInitRequired: (eff: Effect.Effect<void, never, any>, options?: {
+        readonly name?: string;
+    }) => void;
+    readonly registerStart: (eff: Effect.Effect<void, never, any>, options?: {
+        readonly name?: string;
+        readonly fatalOnFailure?: boolean;
+    }) => void;
+    readonly registerDestroy: (eff: Effect.Effect<void, never, any>, options?: {
+        readonly name?: string;
+    }) => void;
+    readonly registerOnError: (handler: (cause: Cause.Cause<unknown>, context: ErrorContext) => Effect.Effect<void, never, any>) => void;
+    readonly registerPlatformSuspend: (eff: Effect.Effect<void, never, any>, options?: {
+        readonly name?: string;
+    }) => void;
+    readonly registerPlatformResume: (eff: Effect.Effect<void, never, any>, options?: {
+        readonly name?: string;
+    }) => void;
+    readonly registerPlatformReset: (eff: Effect.Effect<void, never, any>, options?: {
+        readonly name?: string;
+    }) => void;
+};
+type RuntimeInternalsTxn = {
+    readonly instrumentation: StateTransactionInstrumentation;
+    readonly registerReducer: (tag: string, fn: (state: unknown, action: unknown) => unknown) => void;
+    readonly runWithStateTransaction: (origin: StateTxnOrigin, body: () => Effect.Effect<void, never, any>) => Effect.Effect<void, never, any>;
+    /**
+     * updateDraft：
+     * - Use only within an active transaction: update the current transaction draft state;
+     * - Does not implicitly write wildcard patches (avoid overriding already-recorded field-level patchPaths).
+     */
+    readonly updateDraft: (nextState: unknown) => void;
+    readonly recordStatePatch: (path: StatePatchPath | undefined, reason: PatchReason, from?: unknown, to?: unknown, traitNodeId?: string, stepId?: number) => void;
+    readonly recordReplayEvent: (event: unknown) => void;
+    readonly applyTransactionSnapshot: (txnId: string, mode: 'before' | 'after') => Effect.Effect<void, never, any>;
+};
+type RuntimeInternalsTraits = {
+    readonly rowIdStore: unknown;
+    readonly getListConfigs: () => ReadonlyArray<unknown>;
+    /**
+     * registerSourceRefresh：
+     * - Used only by StateTrait.install/source to mount refresh logic during the build/install phase.
+     * - The implementation must be scoped per runtime instance (must not be process-wide global).
+     */
+    readonly registerSourceRefresh: (fieldPath: string, handler: (state: unknown) => Effect.Effect<void, never, any>) => void;
+    readonly getSourceRefreshHandler: (fieldPath: string) => ((state: unknown) => Effect.Effect<void, never, any>) | undefined;
+    readonly registerStateTraitProgram: (program: unknown, registerOptions?: {
+        readonly bumpReason?: unknown;
+        readonly exportStaticIr?: boolean;
+    }) => void;
+    readonly enqueueStateTraitValidateRequest: (request: unknown) => void;
+    readonly registerModuleTraitsContribution: (contribution: TraitContribution) => void;
+    readonly freezeModuleTraits: () => void;
+    readonly getModuleTraitsContributions: () => ReadonlyArray<TraitContribution>;
+    readonly getModuleTraitsSnapshot: () => ModuleTraitsSnapshot | undefined;
+    readonly setModuleTraitsSnapshot: (snapshot: ModuleTraitsSnapshot) => void;
+};
+type RuntimeInternalsDevtools = {
+    readonly registerConvergeStaticIr: (staticIr: unknown) => void;
+};
+type ConcurrencyPolicyConfigScope = 'builtin' | 'runtime_default' | 'runtime_module' | 'provider';
+type RuntimeInternalsResolvedConcurrencyPolicy = {
+    readonly concurrencyLimit: ConcurrencyLimit;
+    readonly losslessBackpressureCapacity: number;
+    readonly allowUnbounded: boolean;
+    readonly pressureWarningThreshold: {
+        readonly backlogCount: number;
+        readonly backlogDurationMs: number;
+    };
+    readonly warningCooldownMs: number;
+    readonly configScope: ConcurrencyPolicyConfigScope;
+    readonly concurrencyLimitScope: ConcurrencyPolicyConfigScope;
+    readonly requestedConcurrencyLimit: ConcurrencyLimit;
+    readonly requestedConcurrencyLimitScope: ConcurrencyPolicyConfigScope;
+    readonly allowUnboundedScope: ConcurrencyPolicyConfigScope;
+};
+type RuntimeInternalsConcurrency = {
+    readonly resolveConcurrencyPolicy: () => Effect.Effect<RuntimeInternalsResolvedConcurrencyPolicy, never, any>;
+};
+type RuntimeInternalsTxnLanes = {
+    readonly resolveTxnLanePolicy: () => Effect.Effect<ResolvedTxnLanePolicy, never, any>;
+};
+/**
+ * RuntimeInternals（Internal Hooks Runtime Service）
+ *
+ * Goal: converge the scattered `runtime.__*` / `bound.__*` cooperation protocol into a single internal contract entrypoint,
+ * and fully ban magic fields by using Symbol + non-enumerable slots for internal capabilities.
+ */
+interface RuntimeInternals {
+    readonly moduleId?: string;
+    readonly instanceId: string;
+    readonly stateSchema?: unknown;
+    readonly lifecycle: RuntimeInternalsLifecycle;
+    readonly imports: ImportsScope;
+    readonly txn: RuntimeInternalsTxn;
+    readonly concurrency: RuntimeInternalsConcurrency;
+    readonly txnLanes: RuntimeInternalsTxnLanes;
+    readonly traits: RuntimeInternalsTraits;
+    readonly effects: RuntimeInternalsEffects;
+    readonly devtools: RuntimeInternalsDevtools;
+}
+
+type Env<Sh extends AnyModuleShape, R = unknown> = Env$1<Sh, R>;
+type Api<Sh extends ModuleShape<any, any>, R = never> = Api$1<Sh, R>;
+declare const make: <Sh extends AnyModuleShape, R = never>(runtime: ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>, runtimeInternals?: RuntimeInternals) => Api$1<Sh, R>;
+
+type Flow_Api<Sh extends ModuleShape<any, any>, R = never> = Api<Sh, R>;
+type Flow_Env<Sh extends AnyModuleShape, R = unknown> = Env<Sh, R>;
+declare const Flow_make: typeof make;
+declare namespace Flow {
+  export { type Flow_Api as Api, type Flow_Env as Env, Flow_make as make };
+}
+
+export { type Api as A, type Env as E, Flow as F, type ImportsScope as I, type RuntimeInternalsResolvedConcurrencyPolicy as R, make as m };

package/dist/Flow-BhpjE22E.d.ts

@@ -0,0 +1,152 @@
+import { Effect, Cause, Context } from 'effect';
+import { E as ErrorContext, l as ModuleRuntime, S as StateTransactionInstrumentation, w as StateTxnOrigin, a as StatePatchPath, P as PatchReason, C as ConcurrencyLimit, T as TraitContribution, x as ModuleTraitsSnapshot, h as AnyModuleShape, i as ModuleShape, y as Api$1, o as StateOf, p as ActionOf } from './module-k7m3txak.js';
+import { E as Env$1 } from './Logic-BRjEMr-W.js';
+
+type TxnLanePolicyScope = 'provider' | 'runtime_module' | 'runtime_default' | 'builtin';
+type TxnLaneQueueMode = 'fifo' | 'lanes';
+type TxnLaneYieldStrategy = 'baseline' | 'inputPending';
+type ResolvedTxnLanePolicy = {
+    readonly enabled: boolean;
+    readonly overrideMode?: 'forced_off' | 'forced_sync';
+    readonly configScope: TxnLanePolicyScope;
+    readonly budgetMs: number;
+    readonly debounceMs: number;
+    readonly maxLagMs: number;
+    readonly allowCoalesce: boolean;
+    readonly yieldStrategy: TxnLaneYieldStrategy;
+    readonly queueMode: TxnLaneQueueMode;
+};
+
+type RuntimeInternalsEffects = {
+    readonly registerEffect: (args: {
+        readonly actionTag: string;
+        readonly handler: (payload: unknown) => Effect.Effect<void, any, any>;
+        readonly phase: 'setup' | 'run';
+        readonly logicUnit?: {
+            readonly logicUnitId: string;
+            readonly logicUnitLabel: string;
+            readonly path?: string;
+        };
+    }) => Effect.Effect<{
+        readonly sourceKey: string;
+        readonly duplicate: boolean;
+    }, never, any>;
+};
+type ImportsScope = {
+    readonly kind: 'imports-scope';
+    readonly get: (module: Context.Tag<any, ModuleRuntime<any, any>>) => ModuleRuntime<any, any> | undefined;
+};
+type RuntimeInternalsLifecycle = {
+    readonly registerInitRequired: (eff: Effect.Effect<void, never, any>, options?: {
+        readonly name?: string;
+    }) => void;
+    readonly registerStart: (eff: Effect.Effect<void, never, any>, options?: {
+        readonly name?: string;
+        readonly fatalOnFailure?: boolean;
+    }) => void;
+    readonly registerDestroy: (eff: Effect.Effect<void, never, any>, options?: {
+        readonly name?: string;
+    }) => void;
+    readonly registerOnError: (handler: (cause: Cause.Cause<unknown>, context: ErrorContext) => Effect.Effect<void, never, any>) => void;
+    readonly registerPlatformSuspend: (eff: Effect.Effect<void, never, any>, options?: {
+        readonly name?: string;
+    }) => void;
+    readonly registerPlatformResume: (eff: Effect.Effect<void, never, any>, options?: {
+        readonly name?: string;
+    }) => void;
+    readonly registerPlatformReset: (eff: Effect.Effect<void, never, any>, options?: {
+        readonly name?: string;
+    }) => void;
+};
+type RuntimeInternalsTxn = {
+    readonly instrumentation: StateTransactionInstrumentation;
+    readonly registerReducer: (tag: string, fn: (state: unknown, action: unknown) => unknown) => void;
+    readonly runWithStateTransaction: (origin: StateTxnOrigin, body: () => Effect.Effect<void, never, any>) => Effect.Effect<void, never, any>;
+    /**
+     * updateDraft：
+     * - Use only within an active transaction: update the current transaction draft state;
+     * - Does not implicitly write wildcard patches (avoid overriding already-recorded field-level patchPaths).
+     */
+    readonly updateDraft: (nextState: unknown) => void;
+    readonly recordStatePatch: (path: StatePatchPath | undefined, reason: PatchReason, from?: unknown, to?: unknown, traitNodeId?: string, stepId?: number) => void;
+    readonly recordReplayEvent: (event: unknown) => void;
+    readonly applyTransactionSnapshot: (txnId: string, mode: 'before' | 'after') => Effect.Effect<void, never, any>;
+};
+type RuntimeInternalsTraits = {
+    readonly rowIdStore: unknown;
+    readonly getListConfigs: () => ReadonlyArray<unknown>;
+    /**
+     * registerSourceRefresh：
+     * - Used only by StateTrait.install/source to mount refresh logic during the build/install phase.
+     * - The implementation must be scoped per runtime instance (must not be process-wide global).
+     */
+    readonly registerSourceRefresh: (fieldPath: string, handler: (state: unknown) => Effect.Effect<void, never, any>) => void;
+    readonly getSourceRefreshHandler: (fieldPath: string) => ((state: unknown) => Effect.Effect<void, never, any>) | undefined;
+    readonly registerStateTraitProgram: (program: unknown, registerOptions?: {
+        readonly bumpReason?: unknown;
+        readonly exportStaticIr?: boolean;
+    }) => void;
+    readonly enqueueStateTraitValidateRequest: (request: unknown) => void;
+    readonly registerModuleTraitsContribution: (contribution: TraitContribution) => void;
+    readonly freezeModuleTraits: () => void;
+    readonly getModuleTraitsContributions: () => ReadonlyArray<TraitContribution>;
+    readonly getModuleTraitsSnapshot: () => ModuleTraitsSnapshot | undefined;
+    readonly setModuleTraitsSnapshot: (snapshot: ModuleTraitsSnapshot) => void;
+};
+type RuntimeInternalsDevtools = {
+    readonly registerConvergeStaticIr: (staticIr: unknown) => void;
+};
+type ConcurrencyPolicyConfigScope = 'builtin' | 'runtime_default' | 'runtime_module' | 'provider';
+type RuntimeInternalsResolvedConcurrencyPolicy = {
+    readonly concurrencyLimit: ConcurrencyLimit;
+    readonly losslessBackpressureCapacity: number;
+    readonly allowUnbounded: boolean;
+    readonly pressureWarningThreshold: {
+        readonly backlogCount: number;
+        readonly backlogDurationMs: number;
+    };
+    readonly warningCooldownMs: number;
+    readonly configScope: ConcurrencyPolicyConfigScope;
+    readonly concurrencyLimitScope: ConcurrencyPolicyConfigScope;
+    readonly requestedConcurrencyLimit: ConcurrencyLimit;
+    readonly requestedConcurrencyLimitScope: ConcurrencyPolicyConfigScope;
+    readonly allowUnboundedScope: ConcurrencyPolicyConfigScope;
+};
+type RuntimeInternalsConcurrency = {
+    readonly resolveConcurrencyPolicy: () => Effect.Effect<RuntimeInternalsResolvedConcurrencyPolicy, never, any>;
+};
+type RuntimeInternalsTxnLanes = {
+    readonly resolveTxnLanePolicy: () => Effect.Effect<ResolvedTxnLanePolicy, never, any>;
+};
+/**
+ * RuntimeInternals（Internal Hooks Runtime Service）
+ *
+ * Goal: converge the scattered `runtime.__*` / `bound.__*` cooperation protocol into a single internal contract entrypoint,
+ * and fully ban magic fields by using Symbol + non-enumerable slots for internal capabilities.
+ */
+interface RuntimeInternals {
+    readonly moduleId?: string;
+    readonly instanceId: string;
+    readonly stateSchema?: unknown;
+    readonly lifecycle: RuntimeInternalsLifecycle;
+    readonly imports: ImportsScope;
+    readonly txn: RuntimeInternalsTxn;
+    readonly concurrency: RuntimeInternalsConcurrency;
+    readonly txnLanes: RuntimeInternalsTxnLanes;
+    readonly traits: RuntimeInternalsTraits;
+    readonly effects: RuntimeInternalsEffects;
+    readonly devtools: RuntimeInternalsDevtools;
+}
+
+type Env<Sh extends AnyModuleShape, R = unknown> = Env$1<Sh, R>;
+type Api<Sh extends ModuleShape<any, any>, R = never> = Api$1<Sh, R>;
+declare const make: <Sh extends AnyModuleShape, R = never>(runtime: ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>, runtimeInternals?: RuntimeInternals) => Api$1<Sh, R>;
+
+type Flow_Api<Sh extends ModuleShape<any, any>, R = never> = Api<Sh, R>;
+type Flow_Env<Sh extends AnyModuleShape, R = unknown> = Env<Sh, R>;
+declare const Flow_make: typeof make;
+declare namespace Flow {
+  export { type Flow_Api as Api, type Flow_Env as Env, Flow_make as make };
+}
+
+export { type Api as A, type Env as E, Flow as F, type ImportsScope as I, type RuntimeInternalsResolvedConcurrencyPolicy as R, make as m };