@logixjs/core 0.0.1 → 0.0.2

package/dist/ExternalStore.cjs

@@ -0,0 +1,746 @@
+"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/ExternalStore.ts
+var ExternalStore_exports = {};
+__export(ExternalStore_exports, {
+  fromModule: () => fromModule,
+  fromService: () => fromService,
+  fromStream: () => fromStream,
+  fromSubscriptionRef: () => fromSubscriptionRef
+});
+module.exports = __toCommonJS(ExternalStore_exports);
+var import_effect = require("effect");
+
+// src/internal/digest.ts
+var stableStringify = (value) => {
+  if (value === null) return "null";
+  const t = typeof value;
+  if (t === "string") return JSON.stringify(value);
+  if (t === "number") return Number.isFinite(value) ? String(value) : "null";
+  if (t === "boolean") return value ? "true" : "false";
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  if (t === "object") {
+    const record = value;
+    const keys = Object.keys(record).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(record[k])}`).join(",")}}`;
+  }
+  return "null";
+};
+var fnv1a32 = (input) => {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = hash * 16777619 >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+};
+
+// src/internal/runtime/core/ReadQuery.ts
+function isReadQuery(input) {
+  if (!input || typeof input !== "object" && typeof input !== "function") return false;
+  const maybe = input;
+  return typeof maybe.selectorId === "string" && typeof maybe.select === "function" && Array.isArray(maybe.reads);
+}
+var normalizeReads = (reads) => {
+  const unique = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const r of reads) {
+    const key = typeof r === "number" ? `n:${r}` : `s:${r}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(r);
+  }
+  return unique.slice().sort();
+};
+var toHash32Number = (hex) => Number.parseInt(hex, 16);
+var makeReadsDigest = (reads) => {
+  const normalized = normalizeReads(reads);
+  return {
+    count: normalized.length,
+    hash: toHash32Number(fnv1a32(stableStringify(normalized)))
+  };
+};
+var computeSelectorId = (value) => `rq_${fnv1a32(stableStringify(value))}`;
+var nextUnstableSelectorSeq = 0;
+var unstableSelectorIdByFn = /* @__PURE__ */ new WeakMap();
+var computeUnstableSelectorId = (selector) => {
+  const existing = unstableSelectorIdByFn.get(selector);
+  if (existing) return existing;
+  nextUnstableSelectorSeq += 1;
+  const selectorId = `rq_u${nextUnstableSelectorSeq}`;
+  unstableSelectorIdByFn.set(selector, selectorId);
+  return selectorId;
+};
+var unwrapParens = (input) => {
+  const trimmed = input.trim();
+  if (trimmed.startsWith("(") && trimmed.endsWith(")")) {
+    const inner = trimmed.slice(1, -1).trim();
+    if (!inner.startsWith("(") || !inner.endsWith(")")) {
+      return inner;
+    }
+  }
+  return trimmed;
+};
+var extractArrow = (source) => {
+  const idx = source.indexOf("=>");
+  if (idx < 0) return void 0;
+  const left = source.slice(0, idx).trim();
+  const right = source.slice(idx + 2).trim();
+  const paramRaw = unwrapParens(left);
+  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(paramRaw)) return void 0;
+  if (right.startsWith("{")) {
+    const m = right.match(/^\{\s*return\s+(.+?);?\s*\}\s*$/s);
+    if (!m) return void 0;
+    return { param: paramRaw, body: m[1]?.trim() ?? "" };
+  }
+  return { param: paramRaw, body: right };
+};
+var extractFunctionReturn = (source) => {
+  const trimmed = source.trim();
+  const m = trimmed.match(
+    /^function\s*(?:[A-Za-z_$][A-Za-z0-9_$]*\s*)?\(\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*\)\s*\{\s*return\s+(.+?);?\s*\}\s*$/s
+  );
+  if (!m) return void 0;
+  const param = m[1]?.trim() ?? "";
+  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(param)) return void 0;
+  const body = m[2]?.trim() ?? "";
+  if (body.length === 0) return void 0;
+  return { param, body };
+};
+var tryParseSelectorSource = (source) => {
+  const arrowOrFn = extractArrow(source) ?? extractFunctionReturn(source);
+  if (!arrowOrFn) return void 0;
+  const expr = unwrapParens(arrowOrFn.body).trim().replace(/;$/, "").trim();
+  {
+    const re = new RegExp(`^${arrowOrFn.param}\\.([A-Za-z0-9_$]+(?:\\.[A-Za-z0-9_$]+)*)$`);
+    const m = expr.match(re);
+    if (m) {
+      return { kind: "path", path: m[1] };
+    }
+  }
+  if (expr.startsWith("{") && expr.endsWith("}")) {
+    const inner = expr.slice(1, -1).trim();
+    if (inner.length === 0) return { kind: "struct", entries: [] };
+    const parts = inner.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+    const entries = [];
+    for (const part of parts) {
+      const idx = part.indexOf(":");
+      if (idx < 0) return void 0;
+      const key = part.slice(0, idx).trim();
+      const value = part.slice(idx + 1).trim();
+      if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)) return void 0;
+      const re = new RegExp(`^${arrowOrFn.param}\\.([A-Za-z0-9_$]+(?:\\.[A-Za-z0-9_$]+)*)$`);
+      const m = value.match(re);
+      if (!m) return void 0;
+      entries.push([key, m[1]]);
+    }
+    entries.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+    return { kind: "struct", entries };
+  }
+  return void 0;
+};
+var READ_QUERY_TEMPLATE_CACHE_MAX = 2048;
+var readQueryTemplateByFn = /* @__PURE__ */ new WeakMap();
+var readQueryTemplateBySource = /* @__PURE__ */ new Map();
+var lruGet = (map, key) => {
+  const value = map.get(key);
+  if (value === void 0) return void 0;
+  map.delete(key);
+  map.set(key, value);
+  return value;
+};
+var lruSet = (map, key, value, maxSize) => {
+  if (map.has(key)) map.delete(key);
+  map.set(key, value);
+  if (map.size <= maxSize) return;
+  const oldestKey = map.keys().next().value;
+  if (oldestKey !== void 0) {
+    map.delete(oldestKey);
+  }
+};
+var safeToString = (fn) => {
+  try {
+    return fn.toString();
+  } catch {
+    return "";
+  }
+};
+var compile = (input) => {
+  if (isReadQuery(input)) {
+    const reads = normalizeReads(input.reads);
+    const readsDigest = reads.length > 0 ? makeReadsDigest(reads) : void 0;
+    const equalsKind = input.equalsKind;
+    const staticIr2 = {
+      selectorId: input.selectorId,
+      debugKey: input.debugKey,
+      lane: "static",
+      producer: "manual",
+      reads,
+      readsDigest,
+      equalsKind
+    };
+    return {
+      ...input,
+      reads,
+      lane: "static",
+      producer: "manual",
+      readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  const selector = input;
+  const debugKey = (typeof selector?.debugKey === "string" && selector.debugKey.length > 0 ? selector.debugKey : void 0) ?? (typeof selector.name === "string" && selector.name.length > 0 ? selector.name : void 0);
+  const declaredReads = Array.isArray(selector?.fieldPaths) ? selector.fieldPaths.filter((x) => typeof x === "string") : void 0;
+  if (declaredReads && declaredReads.length > 0) {
+    const reads = normalizeReads(declaredReads);
+    const readsDigest = makeReadsDigest(reads);
+    const selectorId2 = computeSelectorId({ kind: "reads", reads });
+    const staticIr2 = {
+      selectorId: selectorId2,
+      debugKey,
+      lane: "static",
+      producer: "jit",
+      reads,
+      readsDigest,
+      equalsKind: "objectIs"
+    };
+    return {
+      selectorId: selectorId2,
+      debugKey,
+      reads,
+      select: selector,
+      equalsKind: "objectIs",
+      lane: "static",
+      producer: "jit",
+      readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  const cachedByFn = readQueryTemplateByFn.get(selector);
+  if (cachedByFn) {
+    const staticIr2 = {
+      selectorId: cachedByFn.selectorId,
+      debugKey,
+      lane: "static",
+      producer: "jit",
+      reads: cachedByFn.reads,
+      readsDigest: cachedByFn.readsDigest,
+      equalsKind: cachedByFn.equalsKind
+    };
+    return {
+      selectorId: cachedByFn.selectorId,
+      debugKey,
+      reads: cachedByFn.reads,
+      select: selector,
+      equalsKind: cachedByFn.equalsKind,
+      lane: "static",
+      producer: "jit",
+      readsDigest: cachedByFn.readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  const srcTrimmed = safeToString(selector).trim();
+  const cachedBySource = srcTrimmed.length > 0 ? lruGet(readQueryTemplateBySource, srcTrimmed) : void 0;
+  if (cachedBySource) {
+    readQueryTemplateByFn.set(selector, cachedBySource);
+    const staticIr2 = {
+      selectorId: cachedBySource.selectorId,
+      debugKey,
+      lane: "static",
+      producer: "jit",
+      reads: cachedBySource.reads,
+      readsDigest: cachedBySource.readsDigest,
+      equalsKind: cachedBySource.equalsKind
+    };
+    return {
+      selectorId: cachedBySource.selectorId,
+      debugKey,
+      reads: cachedBySource.reads,
+      select: selector,
+      equalsKind: cachedBySource.equalsKind,
+      lane: "static",
+      producer: "jit",
+      readsDigest: cachedBySource.readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  const parsed = srcTrimmed.length > 0 ? tryParseSelectorSource(srcTrimmed) : void 0;
+  if (parsed?.kind === "path") {
+    const reads = [parsed.path];
+    const readsDigest = makeReadsDigest(reads);
+    const selectorId2 = computeSelectorId({ kind: "path", path: parsed.path });
+    const template = { selectorId: selectorId2, reads, readsDigest, equalsKind: "objectIs" };
+    readQueryTemplateByFn.set(selector, template);
+    lruSet(readQueryTemplateBySource, srcTrimmed, template, READ_QUERY_TEMPLATE_CACHE_MAX);
+    const staticIr2 = {
+      selectorId: selectorId2,
+      debugKey,
+      lane: "static",
+      producer: "jit",
+      reads,
+      readsDigest,
+      equalsKind: "objectIs"
+    };
+    return {
+      selectorId: selectorId2,
+      debugKey,
+      reads,
+      select: selector,
+      equalsKind: "objectIs",
+      lane: "static",
+      producer: "jit",
+      readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  if (parsed?.kind === "struct") {
+    const reads = normalizeReads(parsed.entries.map(([, path]) => path));
+    const readsDigest = makeReadsDigest(reads);
+    const selectorId2 = computeSelectorId({ kind: "struct", entries: parsed.entries });
+    const template = { selectorId: selectorId2, reads, readsDigest, equalsKind: "shallowStruct" };
+    readQueryTemplateByFn.set(selector, template);
+    lruSet(readQueryTemplateBySource, srcTrimmed, template, READ_QUERY_TEMPLATE_CACHE_MAX);
+    const staticIr2 = {
+      selectorId: selectorId2,
+      debugKey,
+      lane: "static",
+      producer: "jit",
+      reads,
+      readsDigest,
+      equalsKind: "shallowStruct"
+    };
+    return {
+      selectorId: selectorId2,
+      debugKey,
+      reads,
+      select: selector,
+      equalsKind: "shallowStruct",
+      lane: "static",
+      producer: "jit",
+      readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  const baseFallbackReason = srcTrimmed.includes("=>") || srcTrimmed.startsWith("function") ? "unsupportedSyntax" : "missingDeps";
+  const lowDiscriminabilitySource = srcTrimmed.length === 0 || srcTrimmed.includes("[native code]");
+  const fallbackReason = !debugKey || lowDiscriminabilitySource ? "unstableSelectorId" : baseFallbackReason;
+  const selectorId = fallbackReason === "unstableSelectorId" ? computeUnstableSelectorId(selector) : computeSelectorId({ kind: "dynamic", debugKey, src: srcTrimmed });
+  const staticIr = {
+    selectorId,
+    debugKey,
+    lane: "dynamic",
+    producer: "dynamic",
+    fallbackReason,
+    equalsKind: "objectIs"
+  };
+  return {
+    selectorId,
+    debugKey,
+    reads: [],
+    select: selector,
+    equalsKind: "objectIs",
+    lane: "dynamic",
+    producer: "dynamic",
+    fallbackReason,
+    staticIr
+  };
+};
+
+// src/ReadQuery.ts
+var compile2 = compile;
+
+// src/internal/external-store-descriptor.ts
+var EXTERNAL_STORE_DESCRIPTOR = /* @__PURE__ */ Symbol.for("@logixjs/core/externalStoreDescriptor");
+var defineHidden = (target, key, value) => {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+};
+var attachExternalStoreDescriptor = (store, descriptor) => {
+  defineHidden(store, EXTERNAL_STORE_DESCRIPTOR, descriptor);
+};
+
+// src/internal/runtime/core/HostScheduler.ts
+var noopCancel = () => {
+};
+var safeNowMs = () => {
+  const perf = globalThis.performance;
+  if (perf && typeof perf.now === "function") {
+    try {
+      const v = perf.now();
+      if (typeof v === "number" && Number.isFinite(v)) return v;
+    } catch {
+    }
+  }
+  return Date.now();
+};
+var safeQueueMicrotask = (cb) => {
+  const qm = globalThis.queueMicrotask;
+  if (typeof qm === "function") {
+    try {
+      qm(cb);
+      return;
+    } catch {
+    }
+  }
+  try {
+    Promise.resolve().then(cb);
+  } catch {
+    setTimeout(cb, 0);
+  }
+};
+var safeSetTimeout = (ms, cb) => {
+  const id = setTimeout(cb, ms);
+  return () => {
+    try {
+      clearTimeout(id);
+    } catch {
+    }
+  };
+};
+var makeMessageChannelMacrotask = () => {
+  const MC = globalThis.MessageChannel;
+  if (typeof MC !== "function") return void 0;
+  let channel;
+  try {
+    channel = new MC();
+  } catch {
+    return void 0;
+  }
+  const queue = [];
+  let scheduled = false;
+  const flush = () => {
+    scheduled = false;
+    const tasks = queue.splice(0, queue.length);
+    for (const t of tasks) {
+      if (t.canceled) continue;
+      try {
+        t.cb();
+      } catch {
+      }
+    }
+  };
+  try {
+    channel.port1.onmessage = flush;
+  } catch {
+    return void 0;
+  }
+  const schedule = (cb) => {
+    const task = { canceled: false, cb };
+    queue.push(task);
+    if (!scheduled) {
+      scheduled = true;
+      try {
+        channel.port2.postMessage(void 0);
+      } catch {
+        scheduled = false;
+        return safeSetTimeout(0, cb);
+      }
+    }
+    return () => {
+      task.canceled = true;
+    };
+  };
+  return schedule;
+};
+var makeSetImmediateMacrotask = () => {
+  const si = globalThis.setImmediate;
+  const ci = globalThis.clearImmediate;
+  if (typeof si !== "function") return void 0;
+  return (cb) => {
+    let id;
+    try {
+      id = si(cb);
+    } catch {
+      return safeSetTimeout(0, cb);
+    }
+    return () => {
+      if (typeof ci !== "function") return;
+      try {
+        ci(id);
+      } catch {
+      }
+    };
+  };
+};
+var makeRaf = () => {
+  const raf = globalThis.requestAnimationFrame;
+  const cancel = globalThis.cancelAnimationFrame;
+  if (typeof raf !== "function") return void 0;
+  return (cb) => {
+    let id;
+    try {
+      id = raf(cb);
+    } catch {
+      return noopCancel;
+    }
+    return () => {
+      if (typeof cancel !== "function") return;
+      try {
+        cancel(id);
+      } catch {
+      }
+    };
+  };
+};
+var makeDefaultHostScheduler = () => {
+  const macrotask = makeSetImmediateMacrotask() ?? makeMessageChannelMacrotask() ?? ((cb) => safeSetTimeout(0, cb));
+  const raf = makeRaf();
+  return {
+    nowMs: safeNowMs,
+    scheduleMicrotask: safeQueueMicrotask,
+    scheduleMacrotask: macrotask,
+    scheduleAnimationFrame: (cb) => raf?.(cb) ?? macrotask(cb),
+    scheduleTimeout: safeSetTimeout
+  };
+};
+var globalHostScheduler;
+var getGlobalHostScheduler = () => {
+  globalHostScheduler ?? (globalHostScheduler = makeDefaultHostScheduler());
+  return globalHostScheduler;
+};
+
+// src/ExternalStore.ts
+var makeError = (code, message) => Object.assign(new Error(message), { _tag: "ExternalStoreRuntimeError", code });
+var hasOwn = (value, key) => !!value && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, key);
+var makeStoreId = (payload) => `es_${fnv1a32(stableStringify(payload))}`;
+var defineDescriptor = (store, descriptor) => {
+  attachExternalStoreDescriptor(store, descriptor);
+  return store;
+};
+var makeNotifyScheduler = (listeners) => {
+  let scheduled = false;
+  return () => {
+    if (scheduled) return;
+    scheduled = true;
+    getGlobalHostScheduler().scheduleMicrotask(() => {
+      scheduled = false;
+      for (const listener of listeners) {
+        listener();
+      }
+    });
+  };
+};
+var resolveTagId = (tag) => {
+  const id = tag.id;
+  if (typeof id === "string" && id.length > 0) return id;
+  const key = tag.key;
+  return typeof key === "string" && key.length > 0 ? key : void 0;
+};
+var resolveModuleIdOrThrow = (module2) => {
+  if (module2 && typeof module2 === "object") {
+    const moduleId = module2.moduleId;
+    if (typeof moduleId === "string" && moduleId.length > 0) return moduleId;
+    const id = module2.id;
+    if (typeof id === "string" && id.length > 0) return id;
+    const tag = module2.tag;
+    if (tag && (typeof tag === "object" || typeof tag === "function")) {
+      const tagId = tag.id;
+      if (typeof tagId === "string" && tagId.length > 0) return tagId;
+    }
+    const moduleTagId = module2.id;
+    if (typeof moduleTagId === "string" && moduleTagId.length > 0) return moduleTagId;
+  }
+  throw makeError(
+    "external_store::unresolvable_module_id",
+    "[ExternalStore.fromModule] Failed to resolve moduleId.\nFix: pass a ModuleTag/Module/ModuleImpl/ModuleRuntime (has .id/.tag.id/.moduleId), not a read-only ModuleHandle."
+  );
+};
+var fromService = (tag, map) => {
+  const tagId = resolveTagId(tag);
+  if (!tagId) {
+    throw makeError(
+      "external_store::unresolved",
+      "[ExternalStore.fromService] Tag.id is missing; cannot build a stable storeId."
+    );
+  }
+  const storeId = makeStoreId({ kind: "service", tagId });
+  const store = {
+    getSnapshot: () => {
+      throw makeError(
+        "external_store::unresolved",
+        `[ExternalStore.fromService] Store is unresolved (tagId=${tagId}). Use it via StateTrait.externalStore install/runtime.`
+      );
+    },
+    subscribe: () => {
+      throw makeError(
+        "external_store::unresolved",
+        `[ExternalStore.fromService] Store is unresolved (tagId=${tagId}). Use it via StateTrait.externalStore install/runtime.`
+      );
+    }
+  };
+  return defineDescriptor(store, { kind: "service", storeId, tagId, tag, map });
+};
+var nextAnonStoreSeq = 0;
+var storeIdByRef = /* @__PURE__ */ new WeakMap();
+var getOrAssignAnonStoreId = (key, prefix) => {
+  const existing = storeIdByRef.get(key);
+  if (existing) return existing;
+  nextAnonStoreSeq += 1;
+  const storeId = `${prefix}_u${nextAnonStoreSeq}`;
+  storeIdByRef.set(key, storeId);
+  return storeId;
+};
+var fromSubscriptionRef = (ref) => {
+  const storeId = getOrAssignAnonStoreId(ref, "es_ref");
+  let hasSnapshot = false;
+  let current;
+  const listeners = /* @__PURE__ */ new Set();
+  const scheduleNotify = makeNotifyScheduler(listeners);
+  let fiber;
+  const ensureSubscription = () => {
+    if (fiber) return;
+    fiber = import_effect.Effect.runFork(
+      import_effect.Stream.runForEach(
+        ref.changes,
+        (value) => import_effect.Effect.sync(() => {
+          current = value;
+          hasSnapshot = true;
+          scheduleNotify();
+        })
+      )
+    );
+  };
+  const refreshSnapshotIfStale = () => {
+    if (!hasSnapshot) return;
+    try {
+      const latest = import_effect.Effect.runSync(import_effect.SubscriptionRef.get(ref));
+      if (!Object.is(current, latest)) {
+        current = latest;
+        scheduleNotify();
+      }
+    } catch {
+    }
+  };
+  const store = {
+    getSnapshot: () => {
+      if (hasSnapshot) return current;
+      current = import_effect.Effect.runSync(import_effect.SubscriptionRef.get(ref));
+      hasSnapshot = true;
+      return current;
+    },
+    subscribe: (listener) => {
+      listeners.add(listener);
+      ensureSubscription();
+      refreshSnapshotIfStale();
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size > 0) return;
+        const running = fiber;
+        if (!running) return;
+        fiber = void 0;
+        import_effect.Effect.runFork(import_effect.Fiber.interrupt(running));
+      };
+    }
+  };
+  return defineDescriptor(store, { kind: "subscriptionRef", storeId, ref });
+};
+var fromStream = (stream, options) => {
+  const hasCurrent = hasOwn(options, "current");
+  const hasInitial = hasOwn(options, "initial");
+  if (!hasCurrent && !hasInitial) {
+    throw makeError(
+      "external_store::missing_initial",
+      "[ExternalStore.fromStream] Missing { initial } or { current } (Stream has no current snapshot)."
+    );
+  }
+  const initial = hasCurrent ? options.current : options.initial;
+  const initialHint = hasCurrent ? "current" : "initial";
+  const storeId = getOrAssignAnonStoreId(stream, "es_stream");
+  let current = initial;
+  const listeners = /* @__PURE__ */ new Set();
+  const scheduleNotify = makeNotifyScheduler(listeners);
+  let fiber;
+  const ensureSubscription = () => {
+    if (fiber) return;
+    fiber = import_effect.Effect.runFork(
+      import_effect.Stream.runForEach(
+        stream,
+        (value) => import_effect.Effect.sync(() => {
+          current = value;
+          scheduleNotify();
+        })
+      )
+    );
+  };
+  const store = {
+    getSnapshot: () => current,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      ensureSubscription();
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size > 0) return;
+        const running = fiber;
+        if (!running) return;
+        fiber = void 0;
+        import_effect.Effect.runFork(import_effect.Fiber.interrupt(running));
+      };
+    }
+  };
+  return defineDescriptor(store, { kind: "stream", storeId, stream, initial, initialHint });
+};
+var fromModule = (module2, selector) => {
+  const moduleId = resolveModuleIdOrThrow(module2);
+  const instanceId = module2 && typeof module2 === "object" && typeof module2.instanceId === "string" && module2.instanceId.length > 0 ? module2.instanceId : void 0;
+  const compiled = compile2(selector);
+  if (compiled.fallbackReason === "unstableSelectorId" || compiled.staticIr.fallbackReason === "unstableSelectorId") {
+    throw makeError(
+      "external_store::unstable_selector_id",
+      `[ExternalStore.fromModule] selectorId is unstable (fallbackReason=unstableSelectorId). Fix: add a stable debugKey, or pass an explicit ReadQuery (manual/static lane).`
+    );
+  }
+  const storeId = makeStoreId({ kind: "module", moduleId, selectorId: compiled.selectorId });
+  const store = {
+    getSnapshot: () => {
+      throw makeError(
+        "external_store::unresolved",
+        `[ExternalStore.fromModule] Store is unresolved (moduleId=${moduleId}, selectorId=${compiled.selectorId}). Use it via StateTrait.externalStore + TickScheduler/RuntimeStore (Module-as-Source).`
+      );
+    },
+    subscribe: () => {
+      throw makeError(
+        "external_store::unresolved",
+        `[ExternalStore.fromModule] Store is unresolved (moduleId=${moduleId}, selectorId=${compiled.selectorId}). Use it via StateTrait.externalStore + TickScheduler/RuntimeStore (Module-as-Source).`
+      );
+    }
+  };
+  return defineDescriptor(store, {
+    kind: "module",
+    storeId,
+    module: module2,
+    moduleId,
+    ...instanceId ? { instanceId } : {},
+    readQuery: compiled
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fromModule,
+  fromService,
+  fromStream,
+  fromSubscriptionRef
+});
+//# sourceMappingURL=ExternalStore.cjs.map