@skygraph/core 0.0.0-placeholder.0 → 0.4.0

package/dist/runtime-internal.cjs

@@ -0,0 +1,339 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runtime-internal.ts
+var runtime_internal_exports = {};
+__export(runtime_internal_exports, {
+  Batch: () => Batch,
+  ComputedEngine: () => ComputedEngine,
+  CycleDetector: () => CycleDetector,
+  Scheduler: () => Scheduler,
+  Store: () => Store,
+  SubscriptionEngine: () => SubscriptionEngine,
+  Transaction: () => Transaction,
+  createNode: () => createNode
+});
+module.exports = __toCommonJS(runtime_internal_exports);
+
+// src/runtime/Node.ts
+function createNode(id, value) {
+  return { id, value, version: 0 };
+}
+
+// src/runtime/Store.ts
+var Store = class {
+  nodes = /* @__PURE__ */ new Map();
+  has(path) {
+    return this.nodes.has(path);
+  }
+  get(path) {
+    return this.nodes.get(path)?.value;
+  }
+  getNode(path) {
+    return this.nodes.get(path);
+  }
+  set(path, value) {
+    let node = this.nodes.get(path);
+    if (node) {
+      node.value = value;
+      node.version++;
+      return node;
+    }
+    node = createNode(path, value);
+    this.nodes.set(path, node);
+    return node;
+  }
+  delete(path) {
+    return this.nodes.delete(path);
+  }
+  paths() {
+    return this.nodes.keys();
+  }
+  size() {
+    return this.nodes.size;
+  }
+};
+
+// src/runtime/SubscriptionEngine.ts
+var SubscriptionEngine = class {
+  listeners = /* @__PURE__ */ new Map();
+  subscribe(path, cb) {
+    let set = this.listeners.get(path);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(path, set);
+    }
+    set.add(cb);
+    return () => {
+      set.delete(cb);
+      if (set.size === 0) {
+        this.listeners.delete(path);
+      }
+    };
+  }
+  notify(path, value) {
+    const set = this.listeners.get(path);
+    if (!set) return;
+    for (const cb of set) {
+      cb(value);
+    }
+  }
+  notifyMany(changes) {
+    for (const [path, value] of changes) {
+      this.notify(path, value);
+    }
+  }
+  hasListeners(path) {
+    const set = this.listeners.get(path);
+    return set !== void 0 && set.size > 0;
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+// src/runtime/Batch.ts
+var Batch = class {
+  depth = 0;
+  pending = /* @__PURE__ */ new Map();
+  get isActive() {
+    return this.depth > 0;
+  }
+  start() {
+    this.depth++;
+  }
+  end() {
+    this.depth--;
+    if (this.depth > 0) return null;
+    if (this.pending.size === 0) return null;
+    const changes = new Map(this.pending);
+    this.pending.clear();
+    return changes;
+  }
+  enqueue(path, value) {
+    this.pending.set(path, value);
+  }
+};
+
+// src/runtime/Transaction.ts
+var Transaction = class {
+  active = false;
+  staged = [];
+  get isActive() {
+    return this.active;
+  }
+  start() {
+    if (this.active) {
+      throw new Error("SkyGraph: nested transactions are not supported");
+    }
+    this.active = true;
+    this.staged = [];
+  }
+  /** STAGE: record a write without mutating the store */
+  stage(path, value, prevValue) {
+    this.staged.push({ path, value, prevValue });
+  }
+  /**
+   * RESOLVE + COMMIT: drop unchanged values, apply the rest to store.
+   * Returns the map of actually changed paths and their new values.
+   */
+  commit(store) {
+    const changes = /* @__PURE__ */ new Map();
+    for (const write of this.staged) {
+      if (Object.is(write.value, write.prevValue)) continue;
+      store.set(write.path, write.value);
+      changes.set(write.path, write.value);
+    }
+    this.active = false;
+    this.staged = [];
+    return changes;
+  }
+  getStaged() {
+    return this.staged;
+  }
+  complete() {
+    this.active = false;
+    this.staged = [];
+  }
+  rollback() {
+    this.active = false;
+    this.staged = [];
+  }
+};
+
+// src/runtime/CycleDetector.ts
+var CycleDetector = class {
+  graph = /* @__PURE__ */ new Map();
+  addEdge(from, to) {
+    let deps = this.graph.get(from);
+    if (!deps) {
+      deps = /* @__PURE__ */ new Set();
+      this.graph.set(from, deps);
+    }
+    deps.add(to);
+    if (this.hasCycle(to, /* @__PURE__ */ new Set([from]))) {
+      deps.delete(to);
+      if (deps.size === 0) this.graph.delete(from);
+      throw new Error(
+        `SkyGraph: circular dependency detected: ${from} -> ${to}`
+      );
+    }
+  }
+  removeNode(id) {
+    this.graph.delete(id);
+    for (const deps of this.graph.values()) {
+      deps.delete(id);
+    }
+  }
+  getDependents(id) {
+    const targets = this.graph.get(id);
+    return targets ? [...targets] : [];
+  }
+  hasCycle(node, visited) {
+    if (visited.has(node)) return true;
+    const deps = this.graph.get(node);
+    if (!deps) return false;
+    visited.add(node);
+    for (const dep of deps) {
+      if (this.hasCycle(dep, new Set(visited))) return true;
+    }
+    return false;
+  }
+};
+
+// src/runtime/ComputedEngine.ts
+var ComputedEngine = class {
+  computedNodes = /* @__PURE__ */ new Map();
+  cycleDetector = new CycleDetector();
+  register(target, deps, fn) {
+    if (this.computedNodes.has(target)) {
+      this.remove(target);
+    }
+    for (const dep of deps) {
+      this.cycleDetector.addEdge(dep, target);
+    }
+    this.computedNodes.set(target, { target, deps, fn });
+  }
+  remove(target) {
+    this.computedNodes.delete(target);
+    this.cycleDetector.removeNode(target);
+  }
+  isComputed(path) {
+    return this.computedNodes.has(path);
+  }
+  /**
+   * Like propagate, but returns both new and old values for middleware support.
+   * Does NOT write to the store — the caller handles that via dispatchWrite.
+   */
+  propagateRaw(changedPaths, store) {
+    const result = /* @__PURE__ */ new Map();
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [...changedPaths];
+    while (queue.length > 0) {
+      const path = queue.shift();
+      if (visited.has(path)) continue;
+      visited.add(path);
+      const dependents = this.cycleDetector.getDependents(path);
+      for (const depTarget of dependents) {
+        const computed = this.computedNodes.get(depTarget);
+        if (!computed) continue;
+        const depValues = computed.deps.map((d) => {
+          const pending = result.get(d);
+          return pending ? pending.value : store.get(d);
+        });
+        const newValue = computed.fn(...depValues);
+        const oldValue = result.has(depTarget) ? result.get(depTarget).oldValue : store.get(depTarget);
+        if (!Object.is(newValue, oldValue)) {
+          result.set(depTarget, { value: newValue, oldValue });
+          queue.push(depTarget);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Initialize all computed values based on current store state.
+   */
+  initializeAll(store) {
+    for (const computed of this.computedNodes.values()) {
+      const depValues = computed.deps.map((d) => store.get(d));
+      const value = computed.fn(...depValues);
+      store.set(computed.target, value);
+    }
+  }
+};
+
+// src/runtime/Scheduler.ts
+var Scheduler = class {
+  microQueue = [];
+  macroQueue = [];
+  renderQueue = [];
+  renderScheduled = false;
+  enqueueMicro(task) {
+    this.microQueue.push(task);
+  }
+  enqueueMacro(task) {
+    this.macroQueue.push(task);
+    queueMicrotask(() => this.flushMacro());
+  }
+  enqueueRender(task) {
+    this.renderQueue.push(task);
+    if (!this.renderScheduled) {
+      this.renderScheduled = true;
+      if (typeof requestAnimationFrame !== "undefined") {
+        requestAnimationFrame(() => this.flushRender());
+      } else {
+        queueMicrotask(() => this.flushRender());
+      }
+    }
+  }
+  flushMicro() {
+    while (this.microQueue.length > 0) {
+      const task = this.microQueue.shift();
+      task();
+    }
+  }
+  flushMacro() {
+    const tasks = [...this.macroQueue];
+    this.macroQueue = [];
+    for (const task of tasks) {
+      task();
+    }
+  }
+  flushRender() {
+    this.renderScheduled = false;
+    const tasks = [...this.renderQueue];
+    this.renderQueue = [];
+    for (const task of tasks) {
+      task();
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Batch,
+  ComputedEngine,
+  CycleDetector,
+  Scheduler,
+  Store,
+  SubscriptionEngine,
+  Transaction,
+  createNode
+});
+//# sourceMappingURL=runtime-internal.cjs.map

package/dist/runtime-internal.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/runtime-internal.ts","../src/runtime/Node.ts","../src/runtime/Store.ts","../src/runtime/SubscriptionEngine.ts","../src/runtime/Batch.ts","../src/runtime/Transaction.ts","../src/runtime/CycleDetector.ts","../src/runtime/ComputedEngine.ts","../src/runtime/Scheduler.ts"],"sourcesContent":["/**\r\n * @internal — runtime primitives for engine authors\r\n *\r\n * This entry point exposes low-level runtime building blocks (Store,\r\n * SubscriptionEngine, Batch, Transaction, ComputedEngine, Scheduler). It is\r\n * intended for authors of custom engines who need primitives beyond what the\r\n * public `Core` interface provides.\r\n *\r\n * STABILITY: these exports are NOT part of the semver-stable public API.\r\n * Signatures may change between minor versions. Production code should prefer\r\n * the main `@skygraph/core` entry point and the `Core` interface.\r\n *\r\n * The runtime MUST NOT import from `engines/*`. If a future change requires\r\n * runtime to know about engine categories, that is an architecture violation\r\n * — push the feature into middleware or a dedicated extension surface.\r\n */\r\nexport {\r\n  Store,\r\n  createNode,\r\n  SubscriptionEngine,\r\n  Batch,\r\n  Transaction,\r\n  ComputedEngine,\r\n  CycleDetector,\r\n  Scheduler,\r\n} from './runtime/index'\r\n\r\nexport type {\r\n  Node,\r\n  Listener,\r\n  Unsubscribe,\r\n  StagedWrite,\r\n  ComputeFn,\r\n  Task,\r\n} from './runtime/index'\r\n","export interface Node {\n  readonly id: string\n  value: unknown\n  version: number\n}\n\nexport function createNode(id: string, value: unknown): Node {\n  return { id, value, version: 0 }\n}\n","import { createNode } from './Node'\nimport type { Node } from './Node'\n\nexport class Store {\n  private nodes: Map<string, Node> = new Map()\n\n  has(path: string): boolean {\n    return this.nodes.has(path)\n  }\n\n  get(path: string): unknown {\n    return this.nodes.get(path)?.value\n  }\n\n  getNode(path: string): Node | undefined {\n    return this.nodes.get(path)\n  }\n\n  set(path: string, value: unknown): Node {\n    let node = this.nodes.get(path)\n    if (node) {\n      node.value = value\n      node.version++\n      return node\n    }\n    node = createNode(path, value)\n    this.nodes.set(path, node)\n    return node\n  }\n\n  delete(path: string): boolean {\n    return this.nodes.delete(path)\n  }\n\n  paths(): IterableIterator<string> {\n    return this.nodes.keys()\n  }\n\n  size(): number {\n    return this.nodes.size\n  }\n}\n","export type Listener = (value: unknown) => void\nexport type Unsubscribe = () => void\n\nexport class SubscriptionEngine {\n  private listeners: Map<string, Set<Listener>> = new Map()\n\n  subscribe(path: string, cb: Listener): Unsubscribe {\n    let set = this.listeners.get(path)\n    if (!set) {\n      set = new Set()\n      this.listeners.set(path, set)\n    }\n    set.add(cb)\n\n    return () => {\n      set!.delete(cb)\n      if (set!.size === 0) {\n        this.listeners.delete(path)\n      }\n    }\n  }\n\n  notify(path: string, value: unknown): void {\n    const set = this.listeners.get(path)\n    if (!set) return\n    for (const cb of set) {\n      cb(value)\n    }\n  }\n\n  notifyMany(changes: Map<string, unknown>): void {\n    for (const [path, value] of changes) {\n      this.notify(path, value)\n    }\n  }\n\n  hasListeners(path: string): boolean {\n    const set = this.listeners.get(path)\n    return set !== undefined && set.size > 0\n  }\n\n  clear(): void {\n    this.listeners.clear()\n  }\n}\n","/**\n * Batch collects path changes during a batch callback\n * and defers notifications until the callback completes.\n */\nexport class Batch {\n  private depth = 0\n  private pending: Map<string, unknown> = new Map()\n\n  get isActive(): boolean {\n    return this.depth > 0\n  }\n\n  start(): void {\n    this.depth++\n  }\n\n  end(): Map<string, unknown> | null {\n    this.depth--\n    if (this.depth > 0) return null\n\n    if (this.pending.size === 0) return null\n\n    const changes = new Map(this.pending)\n    this.pending.clear()\n    return changes\n  }\n\n  enqueue(path: string, value: unknown): void {\n    this.pending.set(path, value)\n  }\n}\n","import type { Store } from './Store'\n\nexport interface StagedWrite {\n  path: string\n  value: unknown\n  prevValue: unknown\n}\n\n/**\n * Transaction implements the pipeline:\n * SET -> STAGE -> RESOLVE -> PROPAGATE -> COMMIT -> NOTIFY\n *\n * PROPAGATE is handled externally by ComputedEngine.\n * NOTIFY is handled externally by SubscriptionEngine via Batch.\n */\nexport class Transaction {\n  private active = false\n  private staged: StagedWrite[] = []\n\n  get isActive(): boolean {\n    return this.active\n  }\n\n  start(): void {\n    if (this.active) {\n      throw new Error('SkyGraph: nested transactions are not supported')\n    }\n    this.active = true\n    this.staged = []\n  }\n\n  /** STAGE: record a write without mutating the store */\n  stage(path: string, value: unknown, prevValue: unknown): void {\n    this.staged.push({ path, value, prevValue })\n  }\n\n  /**\n   * RESOLVE + COMMIT: drop unchanged values, apply the rest to store.\n   * Returns the map of actually changed paths and their new values.\n   */\n  commit(store: Store): Map<string, unknown> {\n    const changes = new Map<string, unknown>()\n\n    for (const write of this.staged) {\n      if (Object.is(write.value, write.prevValue)) continue\n      store.set(write.path, write.value)\n      changes.set(write.path, write.value)\n    }\n\n    this.active = false\n    this.staged = []\n    return changes\n  }\n\n  getStaged(): readonly StagedWrite[] {\n    return this.staged\n  }\n\n  complete(): void {\n    this.active = false\n    this.staged = []\n  }\n\n  rollback(): void {\n    this.active = false\n    this.staged = []\n  }\n}\n","/**\n * Detects cycles in the computed dependency graph using DFS.\n * Throws on cycle detection to prevent infinite recomputation.\n */\nexport class CycleDetector {\n  private graph: Map<string, Set<string>> = new Map()\n\n  addEdge(from: string, to: string): void {\n    let deps = this.graph.get(from)\n    if (!deps) {\n      deps = new Set()\n      this.graph.set(from, deps)\n    }\n    deps.add(to)\n\n    if (this.hasCycle(to, new Set([from]))) {\n      deps.delete(to)\n      if (deps.size === 0) this.graph.delete(from)\n      throw new Error(\n        `SkyGraph: circular dependency detected: ${from} -> ${to}`\n      )\n    }\n  }\n\n  removeNode(id: string): void {\n    this.graph.delete(id)\n    for (const deps of this.graph.values()) {\n      deps.delete(id)\n    }\n  }\n\n  getDependents(id: string): string[] {\n    const targets = this.graph.get(id)\n    return targets ? [...targets] : []\n  }\n\n  private hasCycle(node: string, visited: Set<string>): boolean {\n    if (visited.has(node)) return true\n    const deps = this.graph.get(node)\n    if (!deps) return false\n    visited.add(node)\n    for (const dep of deps) {\n      if (this.hasCycle(dep, new Set(visited))) return true\n    }\n    return false\n  }\n}\n","import { CycleDetector } from './CycleDetector'\nimport type { Store } from './Store'\n\nexport type ComputeFn = (...values: unknown[]) => unknown\n\ninterface ComputedNode {\n  target: string\n  deps: string[]\n  fn: ComputeFn\n}\n\n/**\n * Manages computed (derived) values in the reactive graph.\n * When a dependency changes, the computed value is recomputed\n * and only propagated if the result actually changed.\n */\nexport class ComputedEngine {\n  private computedNodes: Map<string, ComputedNode> = new Map()\n  private cycleDetector = new CycleDetector()\n\n  register(target: string, deps: string[], fn: ComputeFn): void {\n    if (this.computedNodes.has(target)) {\n      this.remove(target)\n    }\n\n    for (const dep of deps) {\n      this.cycleDetector.addEdge(dep, target)\n    }\n\n    this.computedNodes.set(target, { target, deps, fn })\n  }\n\n  remove(target: string): void {\n    this.computedNodes.delete(target)\n    this.cycleDetector.removeNode(target)\n  }\n\n  isComputed(path: string): boolean {\n    return this.computedNodes.has(path)\n  }\n\n  /**\n   * Like propagate, but returns both new and old values for middleware support.\n   * Does NOT write to the store — the caller handles that via dispatchWrite.\n   */\n  propagateRaw(\n    changedPaths: Set<string>,\n    store: Store,\n  ): Map<string, { value: unknown; oldValue: unknown }> {\n    const result = new Map<string, { value: unknown; oldValue: unknown }>()\n    const visited = new Set<string>()\n    const queue = [...changedPaths]\n\n    while (queue.length > 0) {\n      const path = queue.shift()!\n      if (visited.has(path)) continue\n      visited.add(path)\n\n      const dependents = this.cycleDetector.getDependents(path)\n\n      for (const depTarget of dependents) {\n        const computed = this.computedNodes.get(depTarget)\n        if (!computed) continue\n\n        const depValues = computed.deps.map((d) => {\n          const pending = result.get(d)\n          return pending ? pending.value : store.get(d)\n        })\n        const newValue = computed.fn(...depValues)\n        const oldValue = result.has(depTarget)\n          ? result.get(depTarget)!.oldValue\n          : store.get(depTarget)\n\n        if (!Object.is(newValue, oldValue)) {\n          result.set(depTarget, { value: newValue, oldValue })\n          queue.push(depTarget)\n        }\n      }\n    }\n\n    return result\n  }\n\n  /**\n   * Initialize all computed values based on current store state.\n   */\n  initializeAll(store: Store): void {\n    for (const computed of this.computedNodes.values()) {\n      const depValues = computed.deps.map((d) => store.get(d))\n      const value = computed.fn(...depValues)\n      store.set(computed.target, value)\n    }\n  }\n}\n","export type Task = () => void\n\n/**\n * Scheduler manages different priority queues for updates.\n * - micro: synchronous, within current transaction\n * - macro: deferred async effects (validation, server sync)\n * - render: batched UI notifications (grouped per frame)\n */\nexport class Scheduler {\n  private microQueue: Task[] = []\n  private macroQueue: Task[] = []\n  private renderQueue: Task[] = []\n  private renderScheduled = false\n\n  enqueueMicro(task: Task): void {\n    this.microQueue.push(task)\n  }\n\n  enqueueMacro(task: Task): void {\n    this.macroQueue.push(task)\n    queueMicrotask(() => this.flushMacro())\n  }\n\n  enqueueRender(task: Task): void {\n    this.renderQueue.push(task)\n    if (!this.renderScheduled) {\n      this.renderScheduled = true\n      if (typeof requestAnimationFrame !== 'undefined') {\n        requestAnimationFrame(() => this.flushRender())\n      } else {\n        queueMicrotask(() => this.flushRender())\n      }\n    }\n  }\n\n  flushMicro(): void {\n    while (this.microQueue.length > 0) {\n      const task = this.microQueue.shift()!\n      task()\n    }\n  }\n\n  private flushMacro(): void {\n    const tasks = [...this.macroQueue]\n    this.macroQueue = []\n    for (const task of tasks) {\n      task()\n    }\n  }\n\n  private flushRender(): void {\n    this.renderScheduled = false\n    const tasks = [...this.renderQueue]\n    this.renderQueue = []\n    for (const task of tasks) {\n      task()\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/runtime-internal.d.cts

@@ -0,0 +1,130 @@
+interface Node {
+    readonly id: string;
+    value: unknown;
+    version: number;
+}
+declare function createNode(id: string, value: unknown): Node;
+
+declare class Store {
+    private nodes;
+    has(path: string): boolean;
+    get(path: string): unknown;
+    getNode(path: string): Node | undefined;
+    set(path: string, value: unknown): Node;
+    delete(path: string): boolean;
+    paths(): IterableIterator<string>;
+    size(): number;
+}
+
+type Listener = (value: unknown) => void;
+type Unsubscribe = () => void;
+declare class SubscriptionEngine {
+    private listeners;
+    subscribe(path: string, cb: Listener): Unsubscribe;
+    notify(path: string, value: unknown): void;
+    notifyMany(changes: Map<string, unknown>): void;
+    hasListeners(path: string): boolean;
+    clear(): void;
+}
+
+/**
+ * Batch collects path changes during a batch callback
+ * and defers notifications until the callback completes.
+ */
+declare class Batch {
+    private depth;
+    private pending;
+    get isActive(): boolean;
+    start(): void;
+    end(): Map<string, unknown> | null;
+    enqueue(path: string, value: unknown): void;
+}
+
+interface StagedWrite {
+    path: string;
+    value: unknown;
+    prevValue: unknown;
+}
+/**
+ * Transaction implements the pipeline:
+ * SET -> STAGE -> RESOLVE -> PROPAGATE -> COMMIT -> NOTIFY
+ *
+ * PROPAGATE is handled externally by ComputedEngine.
+ * NOTIFY is handled externally by SubscriptionEngine via Batch.
+ */
+declare class Transaction {
+    private active;
+    private staged;
+    get isActive(): boolean;
+    start(): void;
+    /** STAGE: record a write without mutating the store */
+    stage(path: string, value: unknown, prevValue: unknown): void;
+    /**
+     * RESOLVE + COMMIT: drop unchanged values, apply the rest to store.
+     * Returns the map of actually changed paths and their new values.
+     */
+    commit(store: Store): Map<string, unknown>;
+    getStaged(): readonly StagedWrite[];
+    complete(): void;
+    rollback(): void;
+}
+
+type ComputeFn = (...values: unknown[]) => unknown;
+/**
+ * Manages computed (derived) values in the reactive graph.
+ * When a dependency changes, the computed value is recomputed
+ * and only propagated if the result actually changed.
+ */
+declare class ComputedEngine {
+    private computedNodes;
+    private cycleDetector;
+    register(target: string, deps: string[], fn: ComputeFn): void;
+    remove(target: string): void;
+    isComputed(path: string): boolean;
+    /**
+     * Like propagate, but returns both new and old values for middleware support.
+     * Does NOT write to the store — the caller handles that via dispatchWrite.
+     */
+    propagateRaw(changedPaths: Set<string>, store: Store): Map<string, {
+        value: unknown;
+        oldValue: unknown;
+    }>;
+    /**
+     * Initialize all computed values based on current store state.
+     */
+    initializeAll(store: Store): void;
+}
+
+/**
+ * Detects cycles in the computed dependency graph using DFS.
+ * Throws on cycle detection to prevent infinite recomputation.
+ */
+declare class CycleDetector {
+    private graph;
+    addEdge(from: string, to: string): void;
+    removeNode(id: string): void;
+    getDependents(id: string): string[];
+    private hasCycle;
+}
+
+type Task = () => void;
+/**
+ * Scheduler manages different priority queues for updates.
+ * - micro: synchronous, within current transaction
+ * - macro: deferred async effects (validation, server sync)
+ * - render: batched UI notifications (grouped per frame)
+ */
+declare class Scheduler {
+    private microQueue;
+    private macroQueue;
+    private renderQueue;
+    private renderScheduled;
+    enqueueMicro(task: Task): void;
+    enqueueMacro(task: Task): void;
+    enqueueRender(task: Task): void;
+    flushMicro(): void;
+    private flushMacro;
+    private flushRender;
+}
+
+export { Batch, type ComputeFn, ComputedEngine, CycleDetector, type Listener, type Node, Scheduler, type StagedWrite, Store, SubscriptionEngine, type Task, Transaction, type Unsubscribe, createNode };

package/dist/runtime-internal.d.ts

@@ -0,0 +1,130 @@
+interface Node {
+    readonly id: string;
+    value: unknown;
+    version: number;
+}
+declare function createNode(id: string, value: unknown): Node;
+
+declare class Store {
+    private nodes;
+    has(path: string): boolean;
+    get(path: string): unknown;
+    getNode(path: string): Node | undefined;
+    set(path: string, value: unknown): Node;
+    delete(path: string): boolean;
+    paths(): IterableIterator<string>;
+    size(): number;
+}
+
+type Listener = (value: unknown) => void;
+type Unsubscribe = () => void;
+declare class SubscriptionEngine {
+    private listeners;
+    subscribe(path: string, cb: Listener): Unsubscribe;
+    notify(path: string, value: unknown): void;
+    notifyMany(changes: Map<string, unknown>): void;
+    hasListeners(path: string): boolean;
+    clear(): void;
+}
+
+/**
+ * Batch collects path changes during a batch callback
+ * and defers notifications until the callback completes.
+ */
+declare class Batch {
+    private depth;
+    private pending;
+    get isActive(): boolean;
+    start(): void;
+    end(): Map<string, unknown> | null;
+    enqueue(path: string, value: unknown): void;
+}
+
+interface StagedWrite {
+    path: string;
+    value: unknown;
+    prevValue: unknown;
+}
+/**
+ * Transaction implements the pipeline:
+ * SET -> STAGE -> RESOLVE -> PROPAGATE -> COMMIT -> NOTIFY
+ *
+ * PROPAGATE is handled externally by ComputedEngine.
+ * NOTIFY is handled externally by SubscriptionEngine via Batch.
+ */
+declare class Transaction {
+    private active;
+    private staged;
+    get isActive(): boolean;
+    start(): void;
+    /** STAGE: record a write without mutating the store */
+    stage(path: string, value: unknown, prevValue: unknown): void;
+    /**
+     * RESOLVE + COMMIT: drop unchanged values, apply the rest to store.
+     * Returns the map of actually changed paths and their new values.
+     */
+    commit(store: Store): Map<string, unknown>;
+    getStaged(): readonly StagedWrite[];
+    complete(): void;
+    rollback(): void;
+}
+
+type ComputeFn = (...values: unknown[]) => unknown;
+/**
+ * Manages computed (derived) values in the reactive graph.
+ * When a dependency changes, the computed value is recomputed
+ * and only propagated if the result actually changed.
+ */
+declare class ComputedEngine {
+    private computedNodes;
+    private cycleDetector;
+    register(target: string, deps: string[], fn: ComputeFn): void;
+    remove(target: string): void;
+    isComputed(path: string): boolean;
+    /**
+     * Like propagate, but returns both new and old values for middleware support.
+     * Does NOT write to the store — the caller handles that via dispatchWrite.
+     */
+    propagateRaw(changedPaths: Set<string>, store: Store): Map<string, {
+        value: unknown;
+        oldValue: unknown;
+    }>;
+    /**
+     * Initialize all computed values based on current store state.
+     */
+    initializeAll(store: Store): void;
+}
+
+/**
+ * Detects cycles in the computed dependency graph using DFS.
+ * Throws on cycle detection to prevent infinite recomputation.
+ */
+declare class CycleDetector {
+    private graph;
+    addEdge(from: string, to: string): void;
+    removeNode(id: string): void;
+    getDependents(id: string): string[];
+    private hasCycle;
+}
+
+type Task = () => void;
+/**
+ * Scheduler manages different priority queues for updates.
+ * - micro: synchronous, within current transaction
+ * - macro: deferred async effects (validation, server sync)
+ * - render: batched UI notifications (grouped per frame)
+ */
+declare class Scheduler {
+    private microQueue;
+    private macroQueue;
+    private renderQueue;
+    private renderScheduled;
+    enqueueMicro(task: Task): void;
+    enqueueMacro(task: Task): void;
+    enqueueRender(task: Task): void;
+    flushMicro(): void;
+    private flushMacro;
+    private flushRender;
+}
+
+export { Batch, type ComputeFn, ComputedEngine, CycleDetector, type Listener, type Node, Scheduler, type StagedWrite, Store, SubscriptionEngine, type Task, Transaction, type Unsubscribe, createNode };

package/dist/runtime-internal.js

@@ -0,0 +1,67 @@
+import {
+  Batch,
+  ComputedEngine,
+  CycleDetector,
+  Store,
+  SubscriptionEngine,
+  Transaction,
+  createNode
+} from "./chunk-GEMALROQ.js";
+
+// src/runtime/Scheduler.ts
+var Scheduler = class {
+  microQueue = [];
+  macroQueue = [];
+  renderQueue = [];
+  renderScheduled = false;
+  enqueueMicro(task) {
+    this.microQueue.push(task);
+  }
+  enqueueMacro(task) {
+    this.macroQueue.push(task);
+    queueMicrotask(() => this.flushMacro());
+  }
+  enqueueRender(task) {
+    this.renderQueue.push(task);
+    if (!this.renderScheduled) {
+      this.renderScheduled = true;
+      if (typeof requestAnimationFrame !== "undefined") {
+        requestAnimationFrame(() => this.flushRender());
+      } else {
+        queueMicrotask(() => this.flushRender());
+      }
+    }
+  }
+  flushMicro() {
+    while (this.microQueue.length > 0) {
+      const task = this.microQueue.shift();
+      task();
+    }
+  }
+  flushMacro() {
+    const tasks = [...this.macroQueue];
+    this.macroQueue = [];
+    for (const task of tasks) {
+      task();
+    }
+  }
+  flushRender() {
+    this.renderScheduled = false;
+    const tasks = [...this.renderQueue];
+    this.renderQueue = [];
+    for (const task of tasks) {
+      task();
+    }
+  }
+};
+export {
+  Batch,
+  ComputedEngine,
+  CycleDetector,
+  Scheduler,
+  Store,
+  SubscriptionEngine,
+  Transaction,
+  createNode
+};
+//# sourceMappingURL=runtime-internal.js.map