@statedelta-axiom/runtime 0.1.0

package/dist/index.cjs

@@ -0,0 +1 @@
+'use strict';var compiler=require('@statedelta-axiom/compiler'),sandbox=require('@statedelta-axiom/sandbox'),contracts=require('@statedelta-axiom/contracts');var C=Object.freeze([]);function h(s){if(!s)return {append:()=>{},drain:()=>C,clear:()=>{}};let u=[];return {append(m){u.push(m);},drain(){if(u.length===0)return C;let m=u;return u=[],m},clear(){u=[];}}}function k(s={}){let u=s.id??"main",m=s.capabilities?.deterministic!==false,S=m&&s.buffer?.enabled!==false,d=s.environment?.compilation??compiler.createCompilationService(s.compiler??{}),E=h(S),c="live",f=[],y=[],g=S?{append(e){c!=="recovery"&&E.append(e);},replayCursor(){return c!=="recovery"?null:f.shift()??null},isRecoveryMode(){return c==="recovery"},reportRecoveryError(e){y.push(e);}}:void 0,P={...s.environment,compilation:d,...g!==void 0&&{providerBuffer:g}},I=sandbox.createSandboxManager({environment:P}),A=s.persist?{persist:s.persist}:void 0,r=I.createSandbox({id:u,mode:s.mainMode??"closed",capabilities:s.capabilities,physics:A}),v=false,R,a;function n(e){if(v)throw new Error(`Runtime "${u}" is disposed; "${e}" rejected.`)}function p(e){if(!r.system)throw new Error(`NOT_GOVERNED: "${e}" requires mainMode="governed"; main is closed`)}function D(e){if(e?.provides!==void 0&&c==="live")throw new Error(`${contracts.PROVIDER_ERROR_CODES.LIVE_MODE_PROVIDES_FORBIDDEN}: provides input is only valid in recovery mode`);if(e?.effects){let t=r.app.getTick()+1,o=Date.now();for(let i of e.effects)c==="live"&&E.append({type:"effect",tick:t,id:i.id,data:i.data,ts:o}),r.app.applyEffect(i.id,i.data);}e?.provides&&e.provides.length>0&&f.push(...e.provides);}function B(){if(c==="recovery"){if(y.length>0){let e=y;throw y=[],f=[],new Error(`Recovery failed: ${e.join("; ")}`)}if(f.length>0){let e=f.length;throw f=[],new Error(`${contracts.PROVIDER_ERROR_CODES.REPLAY_OVERFLOW}: ${e} provide entries left in queue after step`)}}}return {id:u,boot(e,t){n("boot");let{artifact:o,sourceKey:i}=d.compile(e);return d.retain(i),a!==void 0&&d.release(a),a=i,R=e,r.boot(o,{...t,bootSourceKey:i})},bootCompiled(e,t){return n("bootCompiled"),s.persist?.definitions===true?{success:false,registered:{states:[],actions:[],rules:[],events:[],views:[],sandboxes:[]},errors:[{resource:"physics",code:"DEFINITIONS_REQUIRE_DSL",message:"bootCompiled rejected: physics.persist.definitions=true requires boot(dsl) \u2014 DSL is the source of truth for Definitions",data:{hint:"use runtime.boot(dsl) instead, or unset physics.persist.definitions for tests / service mode"}}],warnings:[]}:(R=void 0,a!==void 0&&(d.release(a),a=void 0),r.boot(e,t))},bootSource(){return R},dispose(){return v?{ok:false,error:{code:"RUNTIME_DISPOSED"}}:(v=true,E.clear(),f=[],a!==void 0&&(d.release(a),a=void 0),I.dispose(u))},isDisposed(){return v},step(e){n("step"),D(e);let t=r.app.step();return B(),t},async stepAsync(e){n("stepAsync"),D(e);let t=await r.app.stepAsync();return B(),t},getMode(){return c},setMode(e){if(n("setMode"),e!==c){if(e==="recovery"&&!m)throw new Error(`${contracts.PROVIDER_ERROR_CODES.RECOVERY_REQUIRES_DETERMINISM}: recovery mode requires capabilities.deterministic !== false`);f=[],y=[],c=e;}},collectDelta(){return v?[]:E.drain()},getCapabilities(){let e=s.environment?.providers??{},t=!!s.environment?.async,o=[];for(let i of Object.keys(e)){let l=e[i],_=l.mode==="async"&&!t;o.push({id:i,...l.description!==void 0&&{description:l.description},mode:l.mode,persistence:l.persistence,available:!_,..._&&{reason:"Requires async runtime (current runtime is sync)"}});}return {async:t,persistDefinitions:s.persist?.definitions===true,providers:o}},snapshot(){return n("snapshot"),r.app.snapshot()},recover(e){if(n("recover"),e.persistence===void 0)return r.app.restore(e);let t=e.persistence.bootSourceKey,o=d.getSource(t);if(o===void 0)return {ok:false,error:{code:"RECOVER_SOURCE_UNAVAILABLE",message:`Source for bootSourceKey "${t}" not found in CompilationService \u2014 it was evicted or never registered. Share the same service between the snapshotting and recovering Runtimes, or boot(dsl) first to register it.`,data:{bootSourceKey:t}}};if(r.getPhase()==="created"){let{artifact:i}=d.compile(o);d.retain(t),a!==void 0&&d.release(a),a=t,R=o;let l=r.boot(i,{bootSourceKey:t});if(!l.success)return {ok:false,error:{code:"RECOVER_BOOT_FAILED",message:"Recover via service failed during boot of recompiled artifact",data:{errors:l.errors}}}}return r.app.restore(e)},state:{get(e,t){return n("state.get"),r.app.get(e,t)},hasState(e){return n("state.hasState"),r.app.hasState(e)},getStateIds(){return n("state.getStateIds"),r.app.getStateIds()}},getTick(){return n("getTick"),r.app.getTick()},getPhase(){return n("getPhase"),r.getPhase()},isIdle(){return n("isIdle"),r.app.isIdle()},getPhysics(){return n("getPhysics"),r.app.getPhysics()},invoke(e,t){return n("invoke"),p("invoke"),r.system.invoke(e,t)},invokeAsync(e,t){return n("invokeAsync"),p("invokeAsync"),r.system.invokeAsync(e,t)},dispatch(e,t,o){return n("dispatch"),p("dispatch"),r.system.dispatch(e,t,o)},emit(e,t){n("emit"),p("emit"),r.system.emit(e,t);},processEvents(){return n("processEvents"),p("processEvents"),r.system.processEvents()},hasAction(e){return n("hasAction"),p("hasAction"),r.system.hasAction(e)},getActionIds(){return n("getActionIds"),p("getActionIds"),r.system.getActionIds()},hasRule(e){return n("hasRule"),p("hasRule"),r.system.hasRule(e)},getRuleCount(){return n("getRuleCount"),p("getRuleCount"),r.system.getRuleCount()},watch(e){return n("watch"),r.app.watch(e)},on(e,t){return n("on"),r.app.on(e,o=>{c==="recovery"&&e!=="error"||t(o);})}}}exports.createDeltaBuffer=h;exports.createRuntime=k;

package/dist/index.d.cts

@@ -0,0 +1,348 @@
+import { BootDSL, BootResult, BootDefinitions, ProvideBufferEntry, BufferEntry, RuntimeCapabilities } from '@statedelta-axiom/contracts';
+export { BufferEntry, EffectBufferEntry, ProvideBufferEntry } from '@statedelta-axiom/contracts';
+import { Scope, HandlersMap, CompilerMode } from '@statedelta-axiom/compiler';
+import { PersistConfigInput, RealmCtx, StepResult, SystemPhase, RealmPhysics, SystemEvents } from '@statedelta-axiom/realm-system';
+import { SandboxEnvironment, SandboxCapabilities, SandboxMode, SandboxOpResult, SandboxSnapshot, ISandbox, SandboxChange } from '@statedelta-axiom/sandbox';
+import { DirectiveResult } from '@statedelta-actions/sdk/core';
+import { EventProcessingResult } from '@statedelta-actions/sdk/events';
+
+/**
+ * Tipos públicos do Runtime (ADR-R001 — lib TOP do ecossistema).
+ *
+ * Runtime é a camada que a Aplicação JS instancia diretamente. Define
+ * environment compartilhado, instancia Sandbox main (face JS via
+ * `runtime.main`), expõe primitivos de persistência (snapshot/recover,
+ * applyEffect/recoverEffect, collectDelta).
+ *
+ * Esta versão cobre: lifecycle, tick unificado com `step(input)`
+ * (ADR-R021), modo live/recovery (ADR-R021), buffer (ADR-R012),
+ * snapshot/recover, system events, **compiler integrado** (`boot(dsl)` —
+ * ADR-R003/ADR-S4) e **Sandbox main via SandboxManager** (children
+ * declaráveis via `BootDSL.sandboxes` / directive `sandbox create`). Watch
+ * streaming, plugin validator, modal `open` external, `goto`, UX wrapper
+ * ficam pra fases posteriores.
+ */
+
+type DispatchResult = ReturnType<NonNullable<ISandbox["system"]>["dispatch"]>;
+/**
+ * Config do Runtime. Defaults orientados pro modo determinístico
+ * (ADR-R011) — Aplicação JS típica é business async com replay.
+ */
+interface RuntimeConfig {
+    /**
+     * Identificador da Sandbox main. Default: `"main"`.
+     * Usado em snapshots e cross-realm path syntax (ADR-041).
+     */
+    readonly id?: string;
+    /**
+     * Environment compartilhado do ecossistema (ADR-R002 — categoria A,
+     * ambient). Propagado por referência pra Sandbox main; quando há
+     * children declaradas via DSL, mesmo environment é compartilhado.
+     */
+    readonly environment?: SandboxEnvironment;
+    /**
+     * Capabilities da main — cascade restritiva pros children
+     * (ADR-067 RS, ADR-030 Sandbox). Default da policy depende do `mode`
+     * abaixo.
+     */
+    readonly capabilities?: SandboxCapabilities;
+    /**
+     * Mode da Sandbox main:
+     * - `"closed"` (default determinístico) — só AppPort, sem
+     *   imperativas externas
+     * - `"governed"` (modo serviço — ADR-R011) — SystemPort exposto;
+     *   consumer aciona invoke/dispatch/emit direto
+     */
+    readonly mainMode?: SandboxMode;
+    /**
+     * Buffer de effects (ADR-R012). Quando enabled, `applyEffect` registra
+     * na trilha consumível via `collectDelta()`. Lib superior persiste
+     * no formato dela (StateDoc/DeltaDoc/etc).
+     *
+     * Default: `{ enabled: true }` (modo determinístico). Modo serviço
+     * (ADR-R011) tipicamente desliga (`{ enabled: false }`).
+     */
+    readonly buffer?: {
+        readonly enabled?: boolean;
+    };
+    /**
+     * Config do compiler interno (ADR-R003/ADR-S4) — usado quando o Runtime cria
+     * o `CompilationService` interno (`environment.compilation` ausente).
+     * Quando um `CompilationService` é injetado, esta config é ignorada.
+     *
+     * `scope` são funções puras extras pra `$fn` (somam-se aos
+     * `@statedelta-libs/operators` que já vêm no scope-base); `handlers` são
+     * services com contexto pra `$fn "ns:method"`; `mode` é `"jit"` (default)
+     * ou `"closures"` (CSP-safe).
+     */
+    readonly compiler?: {
+        readonly scope?: Scope;
+        readonly handlers?: HandlersMap;
+        readonly mode?: CompilerMode;
+    };
+    /**
+     * **Persistência v2 — `physics.persist` (ADR-030 raiz)** — declara
+     * capacidade de persistência do realm da main. Repassado pra Sandbox main
+     * via `physics.persist`. Cascade restritivo é aplicado pelas children
+     * (ADR-031 raiz).
+     *
+     * - `definitions: true` → snapshot completo (Store + DSL), `register`
+     *   dinâmico habilitado. Exige `environment.compilation` (handshake — ADR-037).
+     * - `effects: true` → buffer de effects pra replay determinístico.
+     *
+     * Default: `undefined` (sem persistência declarada — comportamento legado).
+     */
+    readonly persist?: PersistConfigInput;
+}
+
+/**
+ * Modo de operação do Runtime.
+ *
+ * - `"live"` (default) — operação normal. `step({ effects? })` registra
+ *   inputs no buffer; handlers chamam hooks via env; signals/notify ON.
+ * - `"recovery"` — reconstrução determinística a partir de um buffer
+ *   gravado. `step({ effects?, provides? })` consome a fila injetada;
+ *   buffer NÃO registra; signals/notify silenciados. Exige
+ *   `capabilities.deterministic !== false`. Toggle via `setMode()`.
+ */
+type RuntimeMode = "live" | "recovery";
+/**
+ * Input por tick — payload único do `step(input?)`.
+ *
+ * - `effects`  — lista de inputs `{ id, data }` aplicados antes do tick.
+ *                Equivalente a múltiplos `applyEffect` + um step.
+ * - `provides` — fila FIFO consumida pelo handler `provide` durante o tick.
+ *                **Só permitido em modo `"recovery"`**. Em live, presença
+ *                desta key lança `LIVE_MODE_PROVIDES_FORBIDDEN`.
+ */
+interface StepInput {
+    readonly effects?: ReadonlyArray<{
+        readonly id: string;
+        readonly data: unknown;
+    }>;
+    readonly provides?: readonly ProvideBufferEntry[];
+}
+/**
+ * Acesso de leitura ao state do realm — namespace agrupado pra todas as
+ * queries de state (intra-main + cross-sandbox via path syntax).
+ *
+ * Cascade restritiva quando `mainMode === "closed"`:
+ * - Reads só são permitidos pra states declarados em `exports`. States
+ *   internos retornam `undefined` (`get`), `false` (`hasState`), ou são
+ *   omitidos do array (`getStateIds`). ADR-031 — implementado em
+ *   `@statedelta-axiom/sandbox/src/ports.ts`.
+ *
+ * Em `governed` (open) → todos os states são visíveis.
+ *
+ * Cross-sandbox: aceita path syntax `"child-id/state-id"` (ADR-041). A
+ * child filtra leitura via seu próprio `exports`.
+ */
+interface RuntimeStateAccess {
+    /**
+     * Lê um state (intra-main) ou state de child (`"child/state"`). Em
+     * closed, retorna `undefined` pra states não-exportados.
+     *
+     * - 1 arg sem `:` → state inteiro
+     * - 1 arg com `:` → split em `stateId:field`
+     * - 2 args → intra-realm direto, sem split
+     */
+    get(path: string, field?: string): unknown;
+    /**
+     * `true` se o state existe E está visível pelo modo atual. Em closed
+     * com exports declarado, só retorna `true` pra states exportados.
+     */
+    hasState(path: string): boolean;
+    /**
+     * Lista state IDs visíveis pelo modo atual. Em closed com exports,
+     * só lista os exportados.
+     */
+    getStateIds(): string[];
+}
+/**
+ * Interface pública do Runtime — única lib que a Aplicação JS instancia
+ * diretamente (ADR-R001). Sandbox main é exposta via `main` pra acesso
+ * JS direto à face JS (ADR-R005).
+ */
+interface IRuntime {
+    /** ID do Runtime (declarado no config ou default `"main"`). */
+    readonly id: string;
+    /**
+     * Boot canônico — `BootDSL` (JSON) → `compiler.compileBoot(dsl)` → boot da
+     * Sandbox main. Guarda `dsl` como source (`bootSource()`). `compileBoot`
+     * lança em DSL malformado (erro de programador); falhas de registro/
+     * validação vêm no `BootResult.errors` (são dados — ADR-063 RS).
+     */
+    boot(dsl: BootDSL, options?: {
+        env?: Record<string, unknown>;
+    }): BootResult;
+    /**
+     * Boot escape hatch — `BootDefinitions` JS já compiladas. Delega direto
+     * pra Sandbox main. Sem source (`bootSource()` fica `undefined`).
+     *
+     * Casos típicos: testes unitários, debug, modo serviço sem replay,
+     * apps JS-only que opt-out de DSL.
+     */
+    bootCompiled(definitions: BootDefinitions<RealmCtx>, options?: {
+        env?: Record<string, unknown>;
+    }): BootResult;
+    /**
+     * O `BootDSL` passado pro último `boot(dsl)` — ou `undefined` se ainda não
+     * bootou, ou se bootou via `bootCompiled` (escape hatch, sem source). Útil
+     * pra a lib superior persistir o source e recriar via recompilação.
+     */
+    bootSource(): BootDSL | undefined;
+    /**
+     * Encerra o Runtime — dispose da Sandbox main + cleanup de buffer/
+     * listeners. Idempotente.
+     */
+    dispose(): SandboxOpResult;
+    /** True após `dispose()`. Reads pós-dispose lançam (semântica Sandbox). */
+    isDisposed(): boolean;
+    /**
+     * Tick síncrono — aplica `input.effects` (se houver), carrega
+     * `input.provides` na fila (recovery only), avança o realm um tick.
+     *
+     * Comportamento por modo:
+     * - `"live"` — `provides` no input lança `LIVE_MODE_PROVIDES_FORBIDDEN`.
+     *   Effects são depositados e registrados no buffer (se enabled).
+     *   Handlers `provide` resolvem via env hook (registram automaticamente).
+     * - `"recovery"` — consome `input.provides` em FIFO. Buffer NÃO registra
+     *   nada. Signals/notify silenciados. Erros hard em divergência:
+     *   `REPLAY_UNDERFLOW` (fila vazia mid-step),
+     *   `REPLAY_OVERFLOW` (fila sobrou ao fim do step),
+     *   `REPLAY_PROVIDER_MISMATCH`, `REPLAY_PARAMS_MISMATCH`.
+     *
+     * Lança em ecosystem async (use `stepAsync`).
+     */
+    step(input?: StepInput): StepResult;
+    /** Tick async — mesma semântica de `step`, await-able. */
+    stepAsync(input?: StepInput): Promise<StepResult>;
+    /** Modo corrente: `"live"` (default) ou `"recovery"`. */
+    getMode(): RuntimeMode;
+    /**
+     * Alterna modo. Transição `"live" → "recovery"` exige
+     * `capabilities.deterministic !== false`; senão lança
+     * `RECOVERY_REQUIRES_DETERMINISM`. Idempotente — setar o mesmo modo
+     * é no-op.
+     */
+    setMode(mode: RuntimeMode): void;
+    /**
+     * Drena o buffer pendente — retorna entries (`effect` | `provide`)
+     * aplicados desde a última coleta e marca como coletados. Lib superior
+     * empilha no formato dela (StateDoc/DeltaDoc/log).
+     *
+     * Buffer disabled (modo serviço OU `physics.deterministic: false`) →
+     * array vazio sempre.
+     */
+    collectDelta(): readonly BufferEntry[];
+    /**
+     * Inventário do runtime: flags + providers registrados. Customer chama
+     * tipicamente antes do boot pra adaptar a infra (ex: descobrir se um
+     * provider `async` está disponível antes de planejar `stepAsync`).
+     */
+    getCapabilities(): RuntimeCapabilities;
+    /** Captura snapshot do state inteiro — delega Sandbox main. */
+    snapshot(): SandboxOpResult<SandboxSnapshot>;
+    /** Restaura state a partir de snapshot — delega Sandbox main. */
+    recover(snap: SandboxSnapshot): SandboxOpResult;
+    /**
+     * Namespace de leitura do state. Closed filtra por `exports`; governed
+     * vê tudo. Path syntax aceita cross-sandbox (`"child/state"`).
+     */
+    readonly state: RuntimeStateAccess;
+    /** Tick atual (cumulativo desde boot; incrementa em cada step executado). */
+    getTick(): number;
+    /** Fase do system: `"created" | "booted" | "running" | "finished" | ...` */
+    getPhase(): SystemPhase;
+    /** Engine está parado (sem trabalho pendente)? */
+    isIdle(): boolean;
+    /** Leis imutáveis do realm (determinismo, persistence, async). */
+    getPhysics(): Readonly<RealmPhysics>;
+    /**
+     * Invoca action por ID (síncrono). Em `mainMode: "closed"` lança
+     * `NOT_GOVERNED` — closed protege o interior do realm.
+     */
+    invoke(id: string, params?: Record<string, unknown>): DirectiveResult;
+    /** Versão async de `invoke`. Closed throws `NOT_GOVERNED`. */
+    invokeAsync(id: string, params?: Record<string, unknown>): Promise<DirectiveResult>;
+    /**
+     * Dispatch direto numa op de state. Aceita path syntax (`"child/state"`).
+     * Closed throws `NOT_GOVERNED`.
+     */
+    dispatch(statePath: string, op: string, params?: Record<string, unknown>): DispatchResult;
+    /** Emit de evento. Closed throws `NOT_GOVERNED`. */
+    emit(event: string, data?: unknown): void;
+    /** Processa eventos pendentes manualmente. Closed throws `NOT_GOVERNED`. */
+    processEvents(): EventProcessingResult;
+    /** Action com este ID existe? Closed throws `NOT_GOVERNED`. */
+    hasAction(id: string): boolean;
+    /** Lista IDs de actions registradas. Closed throws `NOT_GOVERNED`. */
+    getActionIds(): string[];
+    /** Rule com este ID existe? Closed throws `NOT_GOVERNED`. */
+    hasRule(id: string): boolean;
+    /** Contagem total de rules. Closed throws `NOT_GOVERNED`. */
+    getRuleCount(): number;
+    /**
+     * Observa mudanças efetivas do realm por tick — canal de persistência
+     * observacional (effects aplicados, lifecycle, error, notify, requests).
+     * Lazy subscribe; retorna unsubscribe idempotente.
+     */
+    watch(listener: (change: SandboxChange) => void): () => void;
+    /** Inscreve listener em system events do RS interno. */
+    on<K extends keyof SystemEvents & string>(event: K, listener: (data: SystemEvents[K]) => void): () => void;
+}
+
+/**
+ * Runtime — factory `createRuntime` (ADR-R001).
+ *
+ * Camada TOP do ecossistema. É o **único** lugar com compiler (ADR-S1/ADR-002/
+ * ADR-003 Sandbox): `boot(dsl)` compila a árvore estática inteira top-down →
+ * `BootDefinitions` (sandboxes aninhadas e o `boot` embutido em diretivas
+ * `sandbox create` inclusos) e boota a main. O **SandboxManager** + as Sandboxes
+ * + o RS são interpretadores puros — só recebem JS. Cria a Sandbox **main** via
+ * `manager.createSandbox(...)` (a main é gerenciada → pode ter children declaradas
+ * via `BootDSL.sandboxes` / directive `sandbox create`).
+ * Monta o buffer de inputs externos (ADR-R012 + ADR-039 raiz). Expõe a API pública
+ * pra Aplicação JS.
+ *
+ * Cobre: createRuntime + lifecycle (boot/bootCompiled/dispose), tick unificado
+ * (`step(input?)` / `stepAsync(input?)` — ADR-R021), modo live/recovery
+ * (ADR-R021), buffer + collectDelta (ADR-R012), snapshot/recover (delega
+ * Sandbox main), system events com silêncio em recovery, **`boot(dsl)` via
+ * compiler** (ADR-R003/ADR-S4). Watch streaming, plugin validator, modal `open`
+ * external, `goto`, UX wrapper ficam pra fases posteriores.
+ */
+
+/**
+ * Cria um Runtime com compiler + SandboxManager + Sandbox main configurados.
+ * Defaults orientados pro modo determinístico (ADR-R011) — `mainMode: "closed"`,
+ * buffer enabled, mode `"live"`. Modo serviço opt-in via `mainMode: "governed"` +
+ * `buffer: { enabled: false }`.
+ */
+declare function createRuntime(config?: RuntimeConfig): IRuntime;
+
+/**
+ * Buffer de inputs externos (ADR-R012 + ADR-039 raiz) — log linear de
+ * `effect` (customer push) e `provide` (system synthesize), em ordem
+ * temporal global.
+ *
+ * Lib superior consome via `collectDelta()` e empilha no formato dela
+ * (StateDoc/DeltaDoc/log/etc). Buffer é desligável (modo serviço, FPS
+ * sem replay) — append vira no-op, drain retorna vazio (zero overhead).
+ *
+ * Anti-determinismo: buffer só faz sentido com determinismo declarado
+ * (`physics.deterministic: true` — ADR-R011). Sem isso, replay é
+ * impossível e persistir entries é desperdício.
+ */
+
+interface DeltaBuffer {
+    /** Appenda um entry (effect ou provide). No-op quando desligado. */
+    append(entry: BufferEntry): void;
+    /** Drena tudo acumulado. No-op quando desligado (retorna vazio). */
+    drain(): readonly BufferEntry[];
+    /** Limpa sem retornar — usado em dispose. */
+    clear(): void;
+}
+declare function createDeltaBuffer(enabled: boolean): DeltaBuffer;
+
+export { type DeltaBuffer, type IRuntime, type RuntimeConfig, type RuntimeMode, type StepInput, createDeltaBuffer, createRuntime };

package/dist/index.d.ts

@@ -0,0 +1,348 @@
+import { BootDSL, BootResult, BootDefinitions, ProvideBufferEntry, BufferEntry, RuntimeCapabilities } from '@statedelta-axiom/contracts';
+export { BufferEntry, EffectBufferEntry, ProvideBufferEntry } from '@statedelta-axiom/contracts';
+import { Scope, HandlersMap, CompilerMode } from '@statedelta-axiom/compiler';
+import { PersistConfigInput, RealmCtx, StepResult, SystemPhase, RealmPhysics, SystemEvents } from '@statedelta-axiom/realm-system';
+import { SandboxEnvironment, SandboxCapabilities, SandboxMode, SandboxOpResult, SandboxSnapshot, ISandbox, SandboxChange } from '@statedelta-axiom/sandbox';
+import { DirectiveResult } from '@statedelta-actions/sdk/core';
+import { EventProcessingResult } from '@statedelta-actions/sdk/events';
+
+/**
+ * Tipos públicos do Runtime (ADR-R001 — lib TOP do ecossistema).
+ *
+ * Runtime é a camada que a Aplicação JS instancia diretamente. Define
+ * environment compartilhado, instancia Sandbox main (face JS via
+ * `runtime.main`), expõe primitivos de persistência (snapshot/recover,
+ * applyEffect/recoverEffect, collectDelta).
+ *
+ * Esta versão cobre: lifecycle, tick unificado com `step(input)`
+ * (ADR-R021), modo live/recovery (ADR-R021), buffer (ADR-R012),
+ * snapshot/recover, system events, **compiler integrado** (`boot(dsl)` —
+ * ADR-R003/ADR-S4) e **Sandbox main via SandboxManager** (children
+ * declaráveis via `BootDSL.sandboxes` / directive `sandbox create`). Watch
+ * streaming, plugin validator, modal `open` external, `goto`, UX wrapper
+ * ficam pra fases posteriores.
+ */
+
+type DispatchResult = ReturnType<NonNullable<ISandbox["system"]>["dispatch"]>;
+/**
+ * Config do Runtime. Defaults orientados pro modo determinístico
+ * (ADR-R011) — Aplicação JS típica é business async com replay.
+ */
+interface RuntimeConfig {
+    /**
+     * Identificador da Sandbox main. Default: `"main"`.
+     * Usado em snapshots e cross-realm path syntax (ADR-041).
+     */
+    readonly id?: string;
+    /**
+     * Environment compartilhado do ecossistema (ADR-R002 — categoria A,
+     * ambient). Propagado por referência pra Sandbox main; quando há
+     * children declaradas via DSL, mesmo environment é compartilhado.
+     */
+    readonly environment?: SandboxEnvironment;
+    /**
+     * Capabilities da main — cascade restritiva pros children
+     * (ADR-067 RS, ADR-030 Sandbox). Default da policy depende do `mode`
+     * abaixo.
+     */
+    readonly capabilities?: SandboxCapabilities;
+    /**
+     * Mode da Sandbox main:
+     * - `"closed"` (default determinístico) — só AppPort, sem
+     *   imperativas externas
+     * - `"governed"` (modo serviço — ADR-R011) — SystemPort exposto;
+     *   consumer aciona invoke/dispatch/emit direto
+     */
+    readonly mainMode?: SandboxMode;
+    /**
+     * Buffer de effects (ADR-R012). Quando enabled, `applyEffect` registra
+     * na trilha consumível via `collectDelta()`. Lib superior persiste
+     * no formato dela (StateDoc/DeltaDoc/etc).
+     *
+     * Default: `{ enabled: true }` (modo determinístico). Modo serviço
+     * (ADR-R011) tipicamente desliga (`{ enabled: false }`).
+     */
+    readonly buffer?: {
+        readonly enabled?: boolean;
+    };
+    /**
+     * Config do compiler interno (ADR-R003/ADR-S4) — usado quando o Runtime cria
+     * o `CompilationService` interno (`environment.compilation` ausente).
+     * Quando um `CompilationService` é injetado, esta config é ignorada.
+     *
+     * `scope` são funções puras extras pra `$fn` (somam-se aos
+     * `@statedelta-libs/operators` que já vêm no scope-base); `handlers` são
+     * services com contexto pra `$fn "ns:method"`; `mode` é `"jit"` (default)
+     * ou `"closures"` (CSP-safe).
+     */
+    readonly compiler?: {
+        readonly scope?: Scope;
+        readonly handlers?: HandlersMap;
+        readonly mode?: CompilerMode;
+    };
+    /**
+     * **Persistência v2 — `physics.persist` (ADR-030 raiz)** — declara
+     * capacidade de persistência do realm da main. Repassado pra Sandbox main
+     * via `physics.persist`. Cascade restritivo é aplicado pelas children
+     * (ADR-031 raiz).
+     *
+     * - `definitions: true` → snapshot completo (Store + DSL), `register`
+     *   dinâmico habilitado. Exige `environment.compilation` (handshake — ADR-037).
+     * - `effects: true` → buffer de effects pra replay determinístico.
+     *
+     * Default: `undefined` (sem persistência declarada — comportamento legado).
+     */
+    readonly persist?: PersistConfigInput;
+}
+
+/**
+ * Modo de operação do Runtime.
+ *
+ * - `"live"` (default) — operação normal. `step({ effects? })` registra
+ *   inputs no buffer; handlers chamam hooks via env; signals/notify ON.
+ * - `"recovery"` — reconstrução determinística a partir de um buffer
+ *   gravado. `step({ effects?, provides? })` consome a fila injetada;
+ *   buffer NÃO registra; signals/notify silenciados. Exige
+ *   `capabilities.deterministic !== false`. Toggle via `setMode()`.
+ */
+type RuntimeMode = "live" | "recovery";
+/**
+ * Input por tick — payload único do `step(input?)`.
+ *
+ * - `effects`  — lista de inputs `{ id, data }` aplicados antes do tick.
+ *                Equivalente a múltiplos `applyEffect` + um step.
+ * - `provides` — fila FIFO consumida pelo handler `provide` durante o tick.
+ *                **Só permitido em modo `"recovery"`**. Em live, presença
+ *                desta key lança `LIVE_MODE_PROVIDES_FORBIDDEN`.
+ */
+interface StepInput {
+    readonly effects?: ReadonlyArray<{
+        readonly id: string;
+        readonly data: unknown;
+    }>;
+    readonly provides?: readonly ProvideBufferEntry[];
+}
+/**
+ * Acesso de leitura ao state do realm — namespace agrupado pra todas as
+ * queries de state (intra-main + cross-sandbox via path syntax).
+ *
+ * Cascade restritiva quando `mainMode === "closed"`:
+ * - Reads só são permitidos pra states declarados em `exports`. States
+ *   internos retornam `undefined` (`get`), `false` (`hasState`), ou são
+ *   omitidos do array (`getStateIds`). ADR-031 — implementado em
+ *   `@statedelta-axiom/sandbox/src/ports.ts`.
+ *
+ * Em `governed` (open) → todos os states são visíveis.
+ *
+ * Cross-sandbox: aceita path syntax `"child-id/state-id"` (ADR-041). A
+ * child filtra leitura via seu próprio `exports`.
+ */
+interface RuntimeStateAccess {
+    /**
+     * Lê um state (intra-main) ou state de child (`"child/state"`). Em
+     * closed, retorna `undefined` pra states não-exportados.
+     *
+     * - 1 arg sem `:` → state inteiro
+     * - 1 arg com `:` → split em `stateId:field`
+     * - 2 args → intra-realm direto, sem split
+     */
+    get(path: string, field?: string): unknown;
+    /**
+     * `true` se o state existe E está visível pelo modo atual. Em closed
+     * com exports declarado, só retorna `true` pra states exportados.
+     */
+    hasState(path: string): boolean;
+    /**
+     * Lista state IDs visíveis pelo modo atual. Em closed com exports,
+     * só lista os exportados.
+     */
+    getStateIds(): string[];
+}
+/**
+ * Interface pública do Runtime — única lib que a Aplicação JS instancia
+ * diretamente (ADR-R001). Sandbox main é exposta via `main` pra acesso
+ * JS direto à face JS (ADR-R005).
+ */
+interface IRuntime {
+    /** ID do Runtime (declarado no config ou default `"main"`). */
+    readonly id: string;
+    /**
+     * Boot canônico — `BootDSL` (JSON) → `compiler.compileBoot(dsl)` → boot da
+     * Sandbox main. Guarda `dsl` como source (`bootSource()`). `compileBoot`
+     * lança em DSL malformado (erro de programador); falhas de registro/
+     * validação vêm no `BootResult.errors` (são dados — ADR-063 RS).
+     */
+    boot(dsl: BootDSL, options?: {
+        env?: Record<string, unknown>;
+    }): BootResult;
+    /**
+     * Boot escape hatch — `BootDefinitions` JS já compiladas. Delega direto
+     * pra Sandbox main. Sem source (`bootSource()` fica `undefined`).
+     *
+     * Casos típicos: testes unitários, debug, modo serviço sem replay,
+     * apps JS-only que opt-out de DSL.
+     */
+    bootCompiled(definitions: BootDefinitions<RealmCtx>, options?: {
+        env?: Record<string, unknown>;
+    }): BootResult;
+    /**
+     * O `BootDSL` passado pro último `boot(dsl)` — ou `undefined` se ainda não
+     * bootou, ou se bootou via `bootCompiled` (escape hatch, sem source). Útil
+     * pra a lib superior persistir o source e recriar via recompilação.
+     */
+    bootSource(): BootDSL | undefined;
+    /**
+     * Encerra o Runtime — dispose da Sandbox main + cleanup de buffer/
+     * listeners. Idempotente.
+     */
+    dispose(): SandboxOpResult;
+    /** True após `dispose()`. Reads pós-dispose lançam (semântica Sandbox). */
+    isDisposed(): boolean;
+    /**
+     * Tick síncrono — aplica `input.effects` (se houver), carrega
+     * `input.provides` na fila (recovery only), avança o realm um tick.
+     *
+     * Comportamento por modo:
+     * - `"live"` — `provides` no input lança `LIVE_MODE_PROVIDES_FORBIDDEN`.
+     *   Effects são depositados e registrados no buffer (se enabled).
+     *   Handlers `provide` resolvem via env hook (registram automaticamente).
+     * - `"recovery"` — consome `input.provides` em FIFO. Buffer NÃO registra
+     *   nada. Signals/notify silenciados. Erros hard em divergência:
+     *   `REPLAY_UNDERFLOW` (fila vazia mid-step),
+     *   `REPLAY_OVERFLOW` (fila sobrou ao fim do step),
+     *   `REPLAY_PROVIDER_MISMATCH`, `REPLAY_PARAMS_MISMATCH`.
+     *
+     * Lança em ecosystem async (use `stepAsync`).
+     */
+    step(input?: StepInput): StepResult;
+    /** Tick async — mesma semântica de `step`, await-able. */
+    stepAsync(input?: StepInput): Promise<StepResult>;
+    /** Modo corrente: `"live"` (default) ou `"recovery"`. */
+    getMode(): RuntimeMode;
+    /**
+     * Alterna modo. Transição `"live" → "recovery"` exige
+     * `capabilities.deterministic !== false`; senão lança
+     * `RECOVERY_REQUIRES_DETERMINISM`. Idempotente — setar o mesmo modo
+     * é no-op.
+     */
+    setMode(mode: RuntimeMode): void;
+    /**
+     * Drena o buffer pendente — retorna entries (`effect` | `provide`)
+     * aplicados desde a última coleta e marca como coletados. Lib superior
+     * empilha no formato dela (StateDoc/DeltaDoc/log).
+     *
+     * Buffer disabled (modo serviço OU `physics.deterministic: false`) →
+     * array vazio sempre.
+     */
+    collectDelta(): readonly BufferEntry[];
+    /**
+     * Inventário do runtime: flags + providers registrados. Customer chama
+     * tipicamente antes do boot pra adaptar a infra (ex: descobrir se um
+     * provider `async` está disponível antes de planejar `stepAsync`).
+     */
+    getCapabilities(): RuntimeCapabilities;
+    /** Captura snapshot do state inteiro — delega Sandbox main. */
+    snapshot(): SandboxOpResult<SandboxSnapshot>;
+    /** Restaura state a partir de snapshot — delega Sandbox main. */
+    recover(snap: SandboxSnapshot): SandboxOpResult;
+    /**
+     * Namespace de leitura do state. Closed filtra por `exports`; governed
+     * vê tudo. Path syntax aceita cross-sandbox (`"child/state"`).
+     */
+    readonly state: RuntimeStateAccess;
+    /** Tick atual (cumulativo desde boot; incrementa em cada step executado). */
+    getTick(): number;
+    /** Fase do system: `"created" | "booted" | "running" | "finished" | ...` */
+    getPhase(): SystemPhase;
+    /** Engine está parado (sem trabalho pendente)? */
+    isIdle(): boolean;
+    /** Leis imutáveis do realm (determinismo, persistence, async). */
+    getPhysics(): Readonly<RealmPhysics>;
+    /**
+     * Invoca action por ID (síncrono). Em `mainMode: "closed"` lança
+     * `NOT_GOVERNED` — closed protege o interior do realm.
+     */
+    invoke(id: string, params?: Record<string, unknown>): DirectiveResult;
+    /** Versão async de `invoke`. Closed throws `NOT_GOVERNED`. */
+    invokeAsync(id: string, params?: Record<string, unknown>): Promise<DirectiveResult>;
+    /**
+     * Dispatch direto numa op de state. Aceita path syntax (`"child/state"`).
+     * Closed throws `NOT_GOVERNED`.
+     */
+    dispatch(statePath: string, op: string, params?: Record<string, unknown>): DispatchResult;
+    /** Emit de evento. Closed throws `NOT_GOVERNED`. */
+    emit(event: string, data?: unknown): void;
+    /** Processa eventos pendentes manualmente. Closed throws `NOT_GOVERNED`. */
+    processEvents(): EventProcessingResult;
+    /** Action com este ID existe? Closed throws `NOT_GOVERNED`. */
+    hasAction(id: string): boolean;
+    /** Lista IDs de actions registradas. Closed throws `NOT_GOVERNED`. */
+    getActionIds(): string[];
+    /** Rule com este ID existe? Closed throws `NOT_GOVERNED`. */
+    hasRule(id: string): boolean;
+    /** Contagem total de rules. Closed throws `NOT_GOVERNED`. */
+    getRuleCount(): number;
+    /**
+     * Observa mudanças efetivas do realm por tick — canal de persistência
+     * observacional (effects aplicados, lifecycle, error, notify, requests).
+     * Lazy subscribe; retorna unsubscribe idempotente.
+     */
+    watch(listener: (change: SandboxChange) => void): () => void;
+    /** Inscreve listener em system events do RS interno. */
+    on<K extends keyof SystemEvents & string>(event: K, listener: (data: SystemEvents[K]) => void): () => void;
+}
+
+/**
+ * Runtime — factory `createRuntime` (ADR-R001).
+ *
+ * Camada TOP do ecossistema. É o **único** lugar com compiler (ADR-S1/ADR-002/
+ * ADR-003 Sandbox): `boot(dsl)` compila a árvore estática inteira top-down →
+ * `BootDefinitions` (sandboxes aninhadas e o `boot` embutido em diretivas
+ * `sandbox create` inclusos) e boota a main. O **SandboxManager** + as Sandboxes
+ * + o RS são interpretadores puros — só recebem JS. Cria a Sandbox **main** via
+ * `manager.createSandbox(...)` (a main é gerenciada → pode ter children declaradas
+ * via `BootDSL.sandboxes` / directive `sandbox create`).
+ * Monta o buffer de inputs externos (ADR-R012 + ADR-039 raiz). Expõe a API pública
+ * pra Aplicação JS.
+ *
+ * Cobre: createRuntime + lifecycle (boot/bootCompiled/dispose), tick unificado
+ * (`step(input?)` / `stepAsync(input?)` — ADR-R021), modo live/recovery
+ * (ADR-R021), buffer + collectDelta (ADR-R012), snapshot/recover (delega
+ * Sandbox main), system events com silêncio em recovery, **`boot(dsl)` via
+ * compiler** (ADR-R003/ADR-S4). Watch streaming, plugin validator, modal `open`
+ * external, `goto`, UX wrapper ficam pra fases posteriores.
+ */
+
+/**
+ * Cria um Runtime com compiler + SandboxManager + Sandbox main configurados.
+ * Defaults orientados pro modo determinístico (ADR-R011) — `mainMode: "closed"`,
+ * buffer enabled, mode `"live"`. Modo serviço opt-in via `mainMode: "governed"` +
+ * `buffer: { enabled: false }`.
+ */
+declare function createRuntime(config?: RuntimeConfig): IRuntime;
+
+/**
+ * Buffer de inputs externos (ADR-R012 + ADR-039 raiz) — log linear de
+ * `effect` (customer push) e `provide` (system synthesize), em ordem
+ * temporal global.
+ *
+ * Lib superior consome via `collectDelta()` e empilha no formato dela
+ * (StateDoc/DeltaDoc/log/etc). Buffer é desligável (modo serviço, FPS
+ * sem replay) — append vira no-op, drain retorna vazio (zero overhead).
+ *
+ * Anti-determinismo: buffer só faz sentido com determinismo declarado
+ * (`physics.deterministic: true` — ADR-R011). Sem isso, replay é
+ * impossível e persistir entries é desperdício.
+ */
+
+interface DeltaBuffer {
+    /** Appenda um entry (effect ou provide). No-op quando desligado. */
+    append(entry: BufferEntry): void;
+    /** Drena tudo acumulado. No-op quando desligado (retorna vazio). */
+    drain(): readonly BufferEntry[];
+    /** Limpa sem retornar — usado em dispose. */
+    clear(): void;
+}
+declare function createDeltaBuffer(enabled: boolean): DeltaBuffer;
+
+export { type DeltaBuffer, type IRuntime, type RuntimeConfig, type RuntimeMode, type StepInput, createDeltaBuffer, createRuntime };

package/dist/index.js

@@ -0,0 +1 @@
+import {createCompilationService}from'@statedelta-axiom/compiler';import {createSandboxManager}from'@statedelta-axiom/sandbox';import {PROVIDER_ERROR_CODES}from'@statedelta-axiom/contracts';var C=Object.freeze([]);function h(s){if(!s)return {append:()=>{},drain:()=>C,clear:()=>{}};let u=[];return {append(m){u.push(m);},drain(){if(u.length===0)return C;let m=u;return u=[],m},clear(){u=[];}}}function k(s={}){let u=s.id??"main",m=s.capabilities?.deterministic!==false,S=m&&s.buffer?.enabled!==false,d=s.environment?.compilation??createCompilationService(s.compiler??{}),E=h(S),c="live",f=[],y=[],g=S?{append(e){c!=="recovery"&&E.append(e);},replayCursor(){return c!=="recovery"?null:f.shift()??null},isRecoveryMode(){return c==="recovery"},reportRecoveryError(e){y.push(e);}}:void 0,P={...s.environment,compilation:d,...g!==void 0&&{providerBuffer:g}},I=createSandboxManager({environment:P}),A=s.persist?{persist:s.persist}:void 0,r=I.createSandbox({id:u,mode:s.mainMode??"closed",capabilities:s.capabilities,physics:A}),v=false,R,a;function n(e){if(v)throw new Error(`Runtime "${u}" is disposed; "${e}" rejected.`)}function p(e){if(!r.system)throw new Error(`NOT_GOVERNED: "${e}" requires mainMode="governed"; main is closed`)}function D(e){if(e?.provides!==void 0&&c==="live")throw new Error(`${PROVIDER_ERROR_CODES.LIVE_MODE_PROVIDES_FORBIDDEN}: provides input is only valid in recovery mode`);if(e?.effects){let t=r.app.getTick()+1,o=Date.now();for(let i of e.effects)c==="live"&&E.append({type:"effect",tick:t,id:i.id,data:i.data,ts:o}),r.app.applyEffect(i.id,i.data);}e?.provides&&e.provides.length>0&&f.push(...e.provides);}function B(){if(c==="recovery"){if(y.length>0){let e=y;throw y=[],f=[],new Error(`Recovery failed: ${e.join("; ")}`)}if(f.length>0){let e=f.length;throw f=[],new Error(`${PROVIDER_ERROR_CODES.REPLAY_OVERFLOW}: ${e} provide entries left in queue after step`)}}}return {id:u,boot(e,t){n("boot");let{artifact:o,sourceKey:i}=d.compile(e);return d.retain(i),a!==void 0&&d.release(a),a=i,R=e,r.boot(o,{...t,bootSourceKey:i})},bootCompiled(e,t){return n("bootCompiled"),s.persist?.definitions===true?{success:false,registered:{states:[],actions:[],rules:[],events:[],views:[],sandboxes:[]},errors:[{resource:"physics",code:"DEFINITIONS_REQUIRE_DSL",message:"bootCompiled rejected: physics.persist.definitions=true requires boot(dsl) \u2014 DSL is the source of truth for Definitions",data:{hint:"use runtime.boot(dsl) instead, or unset physics.persist.definitions for tests / service mode"}}],warnings:[]}:(R=void 0,a!==void 0&&(d.release(a),a=void 0),r.boot(e,t))},bootSource(){return R},dispose(){return v?{ok:false,error:{code:"RUNTIME_DISPOSED"}}:(v=true,E.clear(),f=[],a!==void 0&&(d.release(a),a=void 0),I.dispose(u))},isDisposed(){return v},step(e){n("step"),D(e);let t=r.app.step();return B(),t},async stepAsync(e){n("stepAsync"),D(e);let t=await r.app.stepAsync();return B(),t},getMode(){return c},setMode(e){if(n("setMode"),e!==c){if(e==="recovery"&&!m)throw new Error(`${PROVIDER_ERROR_CODES.RECOVERY_REQUIRES_DETERMINISM}: recovery mode requires capabilities.deterministic !== false`);f=[],y=[],c=e;}},collectDelta(){return v?[]:E.drain()},getCapabilities(){let e=s.environment?.providers??{},t=!!s.environment?.async,o=[];for(let i of Object.keys(e)){let l=e[i],_=l.mode==="async"&&!t;o.push({id:i,...l.description!==void 0&&{description:l.description},mode:l.mode,persistence:l.persistence,available:!_,..._&&{reason:"Requires async runtime (current runtime is sync)"}});}return {async:t,persistDefinitions:s.persist?.definitions===true,providers:o}},snapshot(){return n("snapshot"),r.app.snapshot()},recover(e){if(n("recover"),e.persistence===void 0)return r.app.restore(e);let t=e.persistence.bootSourceKey,o=d.getSource(t);if(o===void 0)return {ok:false,error:{code:"RECOVER_SOURCE_UNAVAILABLE",message:`Source for bootSourceKey "${t}" not found in CompilationService \u2014 it was evicted or never registered. Share the same service between the snapshotting and recovering Runtimes, or boot(dsl) first to register it.`,data:{bootSourceKey:t}}};if(r.getPhase()==="created"){let{artifact:i}=d.compile(o);d.retain(t),a!==void 0&&d.release(a),a=t,R=o;let l=r.boot(i,{bootSourceKey:t});if(!l.success)return {ok:false,error:{code:"RECOVER_BOOT_FAILED",message:"Recover via service failed during boot of recompiled artifact",data:{errors:l.errors}}}}return r.app.restore(e)},state:{get(e,t){return n("state.get"),r.app.get(e,t)},hasState(e){return n("state.hasState"),r.app.hasState(e)},getStateIds(){return n("state.getStateIds"),r.app.getStateIds()}},getTick(){return n("getTick"),r.app.getTick()},getPhase(){return n("getPhase"),r.getPhase()},isIdle(){return n("isIdle"),r.app.isIdle()},getPhysics(){return n("getPhysics"),r.app.getPhysics()},invoke(e,t){return n("invoke"),p("invoke"),r.system.invoke(e,t)},invokeAsync(e,t){return n("invokeAsync"),p("invokeAsync"),r.system.invokeAsync(e,t)},dispatch(e,t,o){return n("dispatch"),p("dispatch"),r.system.dispatch(e,t,o)},emit(e,t){n("emit"),p("emit"),r.system.emit(e,t);},processEvents(){return n("processEvents"),p("processEvents"),r.system.processEvents()},hasAction(e){return n("hasAction"),p("hasAction"),r.system.hasAction(e)},getActionIds(){return n("getActionIds"),p("getActionIds"),r.system.getActionIds()},hasRule(e){return n("hasRule"),p("hasRule"),r.system.hasRule(e)},getRuleCount(){return n("getRuleCount"),p("getRuleCount"),r.system.getRuleCount()},watch(e){return n("watch"),r.app.watch(e)},on(e,t){return n("on"),r.app.on(e,o=>{c==="recovery"&&e!=="error"||t(o);})}}}export{h as createDeltaBuffer,k as createRuntime};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@statedelta-axiom/runtime",
+  "version": "0.1.0",
+  "description": "Runtime — lib TOP do ecossistema StateDelta Axiom. Define environment, instancia Sandbox main, expõe primitivos de persistência (applyEffect/collectDelta/snapshot)",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@statedelta-actions/sdk": "^0.7.0",
+    "@statedelta-axiom/compiler": "0.1.0",
+    "@statedelta-axiom/contracts": "0.1.0",
+    "@statedelta-axiom/realm-system": "0.1.0",
+    "@statedelta-axiom/sandbox": "0.1.0"
+  },
+  "devDependencies": {
+    "@statedelta-axiom/builders": "0.1.0"
+  },
+  "author": "Anderson D. Rosa <andersondrosa@outlook.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/andersondrosa/statedelta-axiom.git",
+    "directory": "packages/runtime"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}