@logixjs/sandbox 0.0.1 → 0.0.2

package/public/sandbox/logix-core/ExternalStore.js

@@ -0,0 +1,239 @@
+// @logixjs/core subpath bundles for @logixjs/sandbox
+
+import {
+  compile
+} from "../chunks/chunk-BWTGJZVP.js";
+import {
+  attachExternalStoreDescriptor
+} from "../chunks/chunk-NMGFJZ4I.js";
+import {
+  getGlobalHostScheduler
+} from "../chunks/chunk-UJGVDFZN.js";
+import "../chunks/chunk-LWI7BXFN.js";
+import {
+  fnv1a32,
+  stableStringify
+} from "../chunks/chunk-DT7YIIWE.js";
+
+// ../logix-core/src/ExternalStore.ts
+import { Effect, Fiber, Stream, SubscriptionRef } from "../effect.js";
+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 = (module) => {
+  if (module && typeof module === "object") {
+    const moduleId = module.moduleId;
+    if (typeof moduleId === "string" && moduleId.length > 0) return moduleId;
+    const id = module.id;
+    if (typeof id === "string" && id.length > 0) return id;
+    const tag = module.tag;
+    if (tag && (typeof tag === "object" || typeof tag === "function")) {
+      const tagId = tag.id;
+      if (typeof tagId === "string" && tagId.length > 0) return tagId;
+    }
+    const moduleTagId = module.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 = Effect.runFork(
+      Stream.runForEach(
+        ref.changes,
+        (value) => Effect.sync(() => {
+          current = value;
+          hasSnapshot = true;
+          scheduleNotify();
+        })
+      )
+    );
+  };
+  const refreshSnapshotIfStale = () => {
+    if (!hasSnapshot) return;
+    try {
+      const latest = Effect.runSync(SubscriptionRef.get(ref));
+      if (!Object.is(current, latest)) {
+        current = latest;
+        scheduleNotify();
+      }
+    } catch {
+    }
+  };
+  const store = {
+    getSnapshot: () => {
+      if (hasSnapshot) return current;
+      current = Effect.runSync(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;
+        Effect.runFork(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 = Effect.runFork(
+      Stream.runForEach(
+        stream,
+        (value) => 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;
+        Effect.runFork(Fiber.interrupt(running));
+      };
+    }
+  };
+  return defineDescriptor(store, { kind: "stream", storeId, stream, initial, initialHint });
+};
+var fromModule = (module, selector) => {
+  const moduleId = resolveModuleIdOrThrow(module);
+  const instanceId = module && typeof module === "object" && typeof module.instanceId === "string" && module.instanceId.length > 0 ? module.instanceId : void 0;
+  const compiled = compile(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,
+    moduleId,
+    ...instanceId ? { instanceId } : {},
+    readQuery: compiled
+  });
+};
+export {
+  fromModule,
+  fromService,
+  fromStream,
+  fromSubscriptionRef
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/ExternalStore.ts"],
  "sourcesContent": ["import { Effect, Fiber, Stream, SubscriptionRef } from 'effect'\nimport type { Context } from 'effect'\nimport * as ReadQuery from './ReadQuery.js'\nimport { fnv1a32, stableStringify } from './internal/digest.js'\nimport { attachExternalStoreDescriptor, type ExternalStoreDescriptor } from './internal/external-store-descriptor.js'\nimport { getGlobalHostScheduler } from './internal/runtime/core/HostScheduler.js'\n\nexport type ExternalStore<T> = {\n  readonly getSnapshot: () => T\n  readonly getServerSnapshot?: () => T\n  readonly subscribe: (listener: () => void) => () => void\n}\n\nexport interface ExternalStoreRuntimeError extends Error {\n  readonly _tag: 'ExternalStoreRuntimeError'\n  readonly code:\n    | 'external_store::unresolved'\n    | 'external_store::missing_initial'\n    | 'external_store::unresolvable_module_id'\n    | 'external_store::unstable_selector_id'\n}\n\nconst makeError = (code: ExternalStoreRuntimeError['code'], message: string): ExternalStoreRuntimeError =>\n  Object.assign(new Error(message), { _tag: 'ExternalStoreRuntimeError' as const, code })\n\nconst hasOwn = (value: unknown, key: string): boolean =>\n  !!value && typeof value === 'object' && Object.prototype.hasOwnProperty.call(value, key)\n\nconst makeStoreId = (payload: unknown): string => `es_${fnv1a32(stableStringify(payload))}`\n\nconst defineDescriptor = <T>(store: ExternalStore<T>, descriptor: ExternalStoreDescriptor): ExternalStore<T> => {\n  attachExternalStoreDescriptor(store as object, descriptor)\n  return store\n}\n\nconst makeNotifyScheduler = (listeners: Set<() => void>): (() => void) => {\n  let scheduled = false\n  return () => {\n    if (scheduled) return\n    scheduled = true\n    getGlobalHostScheduler().scheduleMicrotask(() => {\n      scheduled = false\n      for (const listener of listeners) {\n        listener()\n      }\n    })\n  }\n}\n\nconst resolveTagId = (tag: Context.Tag<any, any>): string | undefined => {\n  const id = (tag as any).id\n  if (typeof id === 'string' && id.length > 0) return id\n\n  const key = (tag as any).key\n  return typeof key === 'string' && key.length > 0 ? key : undefined\n}\n\nconst resolveModuleIdOrThrow = (module: unknown): string => {\n  if (module && typeof module === 'object') {\n    const moduleId = (module as any).moduleId\n    if (typeof moduleId === 'string' && moduleId.length > 0) return moduleId\n\n    const id = (module as any).id\n    if (typeof id === 'string' && id.length > 0) return id\n\n    const tag = (module as any).tag\n    if (tag && (typeof tag === 'object' || typeof tag === 'function')) {\n      const tagId = (tag as any).id\n      if (typeof tagId === 'string' && tagId.length > 0) return tagId\n    }\n\n    const moduleTagId = (module as any).id\n    if (typeof moduleTagId === 'string' && moduleTagId.length > 0) return moduleTagId\n  }\n\n  throw makeError(\n    'external_store::unresolvable_module_id',\n    '[ExternalStore.fromModule] Failed to resolve moduleId.\\n' +\n      'Fix: pass a ModuleTag/Module/ModuleImpl/ModuleRuntime (has .id/.tag.id/.moduleId), not a read-only ModuleHandle.',\n  )\n}\n\n/**\n * Create an ExternalStore by resolving a service from the Effect Context.\n *\n * Notes:\n * - This sugar is intended to be used via `StateTrait.externalStore` (resolved during install/runtime).\n * - `map(service)` must return a sync `getSnapshot()` (no IO) and a `subscribe(listener)` that signals change.\n */\nexport const fromService = <Id, Svc, T>(\n  tag: Context.Tag<Id, Svc>,\n  map: (service: Svc) => ExternalStore<T>,\n): ExternalStore<T> => {\n  const tagId = resolveTagId(tag as any)\n  if (!tagId) {\n    throw makeError(\n      'external_store::unresolved',\n      '[ExternalStore.fromService] Tag.id is missing; cannot build a stable storeId.',\n    )\n  }\n\n  const storeId = makeStoreId({ kind: 'service', tagId })\n\n  const store: ExternalStore<T> = {\n    getSnapshot: () => {\n      throw makeError(\n        'external_store::unresolved',\n        `[ExternalStore.fromService] Store is unresolved (tagId=${tagId}). Use it via StateTrait.externalStore install/runtime.`,\n      )\n    },\n    subscribe: () => {\n      throw makeError(\n        'external_store::unresolved',\n        `[ExternalStore.fromService] Store is unresolved (tagId=${tagId}). Use it via StateTrait.externalStore install/runtime.`,\n      )\n    },\n  }\n\n  return defineDescriptor(store, { kind: 'service', storeId, tagId, tag: tag as any, map: map as any })\n}\n\nlet nextAnonStoreSeq = 0\nconst storeIdByRef = new WeakMap<object, string>()\n\nconst getOrAssignAnonStoreId = (key: object, prefix: string): string => {\n  const existing = storeIdByRef.get(key)\n  if (existing) return existing\n  nextAnonStoreSeq += 1\n  const storeId = `${prefix}_u${nextAnonStoreSeq}`\n  storeIdByRef.set(key, storeId)\n  return storeId\n}\n\n/**\n * Create an ExternalStore from a SubscriptionRef.\n *\n * Notes:\n * - `getSnapshot()` is implemented via `SubscriptionRef.get(ref)` (must be a synchronous pure read; do not hide IO inside).\n * - change notifications are batched via microtask (multiple updates in the same microtask trigger a single notify).\n */\nexport const fromSubscriptionRef = <T>(ref: SubscriptionRef.SubscriptionRef<T>): ExternalStore<T> => {\n  const storeId = getOrAssignAnonStoreId(ref as any, 'es_ref')\n\n  let hasSnapshot = false\n  let current: T | undefined\n  const listeners = new Set<() => void>()\n  const scheduleNotify = makeNotifyScheduler(listeners)\n\n  let fiber: Fiber.Fiber<void, any> | undefined\n\n  const ensureSubscription = () => {\n    if (fiber) return\n    fiber = Effect.runFork(\n      Stream.runForEach(ref.changes, (value) =>\n        Effect.sync(() => {\n          current = value\n          hasSnapshot = true\n          scheduleNotify()\n        }),\n      ),\n    )\n  }\n\n  const refreshSnapshotIfStale = () => {\n    if (!hasSnapshot) return\n    try {\n      const latest = Effect.runSync(SubscriptionRef.get(ref)) as T\n      if (!Object.is(current, latest)) {\n        current = latest\n        scheduleNotify()\n      }\n    } catch {\n      // best-effort\n    }\n  }\n\n  const store: ExternalStore<T> = {\n    getSnapshot: () => {\n      if (hasSnapshot) return current as T\n      current = Effect.runSync(SubscriptionRef.get(ref)) as T\n      hasSnapshot = true\n      return current\n    },\n    subscribe: (listener) => {\n      listeners.add(listener)\n      ensureSubscription()\n      refreshSnapshotIfStale()\n      return () => {\n        listeners.delete(listener)\n        if (listeners.size > 0) return\n        const running = fiber\n        if (!running) return\n        fiber = undefined\n        Effect.runFork(Fiber.interrupt(running))\n      }\n    },\n  }\n\n  return defineDescriptor(store, { kind: 'subscriptionRef', storeId, ref: ref as any })\n}\n\n/**\n * Create an ExternalStore from a Stream.\n *\n * Notes:\n * - Stream has no synchronous \"current\" snapshot; you MUST provide `{ initial }` (or `{ current }`).\n * - `{ initial }` may be stale if the stream already emitted before subscription; prefer `fromService/fromSubscriptionRef` for reliable current.\n */\nexport const fromStream = <A, E>(\n  stream: Stream.Stream<A, E, never>,\n  options?: { readonly initial?: A; readonly current?: A },\n): ExternalStore<A> => {\n  const hasCurrent = hasOwn(options, 'current')\n  const hasInitial = hasOwn(options, 'initial')\n\n  if (!hasCurrent && !hasInitial) {\n    throw makeError(\n      'external_store::missing_initial',\n      '[ExternalStore.fromStream] Missing { initial } or { current } (Stream has no current snapshot).',\n    )\n  }\n\n  const initial = hasCurrent ? (options as any).current : (options as any).initial\n  const initialHint = hasCurrent ? ('current' as const) : ('initial' as const)\n\n  const storeId = getOrAssignAnonStoreId(stream as any, 'es_stream')\n\n  let current = initial as A\n  const listeners = new Set<() => void>()\n  const scheduleNotify = makeNotifyScheduler(listeners)\n\n  let fiber: Fiber.Fiber<void, any> | undefined\n\n  const ensureSubscription = () => {\n    if (fiber) return\n    fiber = Effect.runFork(\n      Stream.runForEach(stream, (value) =>\n        Effect.sync(() => {\n          current = value\n          scheduleNotify()\n        }),\n      ),\n    )\n  }\n\n  const store: ExternalStore<A> = {\n    getSnapshot: () => current,\n    subscribe: (listener) => {\n      listeners.add(listener)\n      ensureSubscription()\n      return () => {\n        listeners.delete(listener)\n        if (listeners.size > 0) return\n        const running = fiber\n        if (!running) return\n        fiber = undefined\n        Effect.runFork(Fiber.interrupt(running))\n      }\n    },\n  }\n\n  return defineDescriptor(store, { kind: 'stream', storeId, stream: stream as any, initial, initialHint })\n}\n\n/**\n * Module-as-Source: treat a module selector as an ExternalStore source (IR-recognizable dependency).\n *\n * Notes:\n * - `moduleId` must be resolvable; passing a read-only `ModuleHandle` is forbidden (fail-fast).\n * - selectorId must be stable: `ReadQuery.compile(selector)` must NOT fall back to `fallbackReason=\"unstableSelectorId\"` (fail-fast).\n * - Value semantics: the runtime does not clone; writeback stores the selector return value as-is (keep selectors small and stable).\n */\nexport const fromModule = <S, V>(module: unknown, selector: ReadQuery.ReadQueryInput<S, V>): ExternalStore<V> => {\n  const moduleId = resolveModuleIdOrThrow(module)\n  const instanceId =\n    module && typeof module === 'object' && typeof (module as any).instanceId === 'string' && (module as any).instanceId.length > 0\n      ? ((module as any).instanceId as string)\n      : undefined\n  const compiled = ReadQuery.compile(selector)\n\n  if (compiled.fallbackReason === 'unstableSelectorId' || compiled.staticIr.fallbackReason === 'unstableSelectorId') {\n    throw makeError(\n      'external_store::unstable_selector_id',\n      `[ExternalStore.fromModule] selectorId is unstable (fallbackReason=unstableSelectorId). ` +\n        'Fix: add a stable debugKey, or pass an explicit ReadQuery (manual/static lane).',\n    )\n  }\n\n  const storeId = makeStoreId({ kind: 'module', moduleId, selectorId: compiled.selectorId })\n\n  const store: ExternalStore<V> = {\n    getSnapshot: () => {\n      throw makeError(\n        'external_store::unresolved',\n        `[ExternalStore.fromModule] Store is unresolved (moduleId=${moduleId}, selectorId=${compiled.selectorId}). ` +\n          'Use it via StateTrait.externalStore + TickScheduler/RuntimeStore (Module-as-Source).',\n      )\n    },\n    subscribe: () => {\n      throw makeError(\n        'external_store::unresolved',\n        `[ExternalStore.fromModule] Store is unresolved (moduleId=${moduleId}, selectorId=${compiled.selectorId}). ` +\n          'Use it via StateTrait.externalStore + TickScheduler/RuntimeStore (Module-as-Source).',\n      )\n    },\n  }\n\n  return defineDescriptor(store, {\n    kind: 'module',\n    storeId,\n    module,\n    moduleId,\n    ...(instanceId ? { instanceId } : {}),\n    readQuery: compiled,\n  })\n}\n"],
  "mappings": "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",
  "names": []
}


package/public/sandbox/logix-core/Flow.js

@@ -2,17 +2,16 @@
 
 import {
   make
-} from "../chunks/chunk-VLYP4WUS.js";
-import "../chunks/chunk-UMVN3AWO.js";
-import "../chunks/chunk-UKYAF3NL.js";
-import "../chunks/chunk-S46P7MC6.js";
-import "../chunks/chunk-3LX3KIQQ.js";
-import "../chunks/chunk-BWSNPKO5.js";
-import "../chunks/chunk-TOQ6SJ6O.js";
+} from "../chunks/chunk-2XVE7F26.js";
+import "../chunks/chunk-W365QUZ5.js";
+import "../chunks/chunk-SH7TP5CJ.js";
+import "../chunks/chunk-SI5OKFFY.js";
+import "../chunks/chunk-LWI7BXFN.js";
+import "../chunks/chunk-DT7YIIWE.js";
 
 // ../logix-core/src/Flow.ts
 var make2 = make;
 export {
   make2 as make
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vbG9naXgtY29yZS9zcmMvRmxvdy50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiaW1wb3J0IHR5cGUgeyBBbnlNb2R1bGVTaGFwZSwgTW9kdWxlU2hhcGUgfSBmcm9tICcuL2ludGVybmFsL21vZHVsZS5qcydcbmltcG9ydCB0eXBlICogYXMgTG9naWMgZnJvbSAnLi9Mb2dpYy5qcydcbmltcG9ydCAqIGFzIEZsb3dSdW50aW1lIGZyb20gJy4vaW50ZXJuYWwvcnVudGltZS9GbG93UnVudGltZS5qcydcblxuLy8gRmxvdzogcHVibGljIEFQSSBmb3IgYnVzaW5lc3MgZmxvdyBvcmNoZXN0cmF0aW9uICh3cmFwcyBpbnRlcm5hbC9ydW50aW1lL0Zsb3dSdW50aW1lIGtlcm5lbCkuXG5cbmV4cG9ydCB0eXBlIEVudjxTaCBleHRlbmRzIEFueU1vZHVsZVNoYXBlLCBSID0gdW5rbm93bj4gPSBMb2dpYy5FbnY8U2gsIFI+XG5cbmV4cG9ydCB0eXBlIEFwaTxTaCBleHRlbmRzIE1vZHVsZVNoYXBlPGFueSwgYW55PiwgUiA9IG5ldmVyPiA9IEZsb3dSdW50aW1lLkFwaTxTaCwgUj5cblxuZXhwb3J0IGNvbnN0IG1ha2UgPSBGbG93UnVudGltZS5tYWtlXG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7O0FBVU8sSUFBTUEsUUFBbUI7IiwKICAibmFtZXMiOiBbIm1ha2UiXQp9Cg==
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vbG9naXgtY29yZS9zcmMvRmxvdy50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiaW1wb3J0IHR5cGUgeyBBbnlNb2R1bGVTaGFwZSwgTW9kdWxlU2hhcGUgfSBmcm9tICcuL2ludGVybmFsL21vZHVsZS5qcydcbmltcG9ydCB0eXBlICogYXMgTG9naWMgZnJvbSAnLi9Mb2dpYy5qcydcbmltcG9ydCAqIGFzIEZsb3dSdW50aW1lIGZyb20gJy4vaW50ZXJuYWwvcnVudGltZS9GbG93UnVudGltZS5qcydcblxuLy8gRmxvdzogcHVibGljIEFQSSBmb3IgYnVzaW5lc3MgZmxvdyBvcmNoZXN0cmF0aW9uICh3cmFwcyBpbnRlcm5hbC9ydW50aW1lL0Zsb3dSdW50aW1lIGtlcm5lbCkuXG5cbmV4cG9ydCB0eXBlIEVudjxTaCBleHRlbmRzIEFueU1vZHVsZVNoYXBlLCBSID0gdW5rbm93bj4gPSBMb2dpYy5FbnY8U2gsIFI+XG5cbmV4cG9ydCB0eXBlIEFwaTxTaCBleHRlbmRzIE1vZHVsZVNoYXBlPGFueSwgYW55PiwgUiA9IG5ldmVyPiA9IEZsb3dSdW50aW1lLkFwaTxTaCwgUj5cblxuZXhwb3J0IGNvbnN0IG1ha2UgPSBGbG93UnVudGltZS5tYWtlXG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7QUFVTyxJQUFNQSxRQUFtQjsiLAogICJuYW1lcyI6IFsibWFrZSJdCn0K

package/public/sandbox/logix-core/Kernel.js

@@ -13,12 +13,15 @@ import {
   kernelLayer,
   runtimeDefaultServicesOverridesLayer,
   runtimeServicesRegistryLayer
-} from "../chunks/chunk-WE4STGO2.js";
+} from "../chunks/chunk-L4ZNW5DI.js";
 import {
   RuntimeServiceBuiltinsTag
-} from "../chunks/chunk-ZUBABAAO.js";
-import "../chunks/chunk-HNEDTEGQ.js";
-import "../chunks/chunk-CZRI7MHA.js";
+} from "../chunks/chunk-6TUOP63Q.js";
+import "../chunks/chunk-L4PNO2H6.js";
+import "../chunks/chunk-YMVMZA3U.js";
+import "../chunks/chunk-UJGVDFZN.js";
+import "../chunks/chunk-SH7TP5CJ.js";
+import "../chunks/chunk-SI5OKFFY.js";
 export {
   CutoverCoverageMatrix,
   KernelContractMetaAllowlist,

package/public/sandbox/logix-core/Link.js

@@ -1,41 +1,49 @@
 // @logixjs/core subpath bundles for @logixjs/sandbox
 
 import {
-  link
-} from "../chunks/chunk-5SOP6EKV.js";
-import "../chunks/chunk-YF6IO732.js";
-import "../chunks/chunk-PQ652ULI.js";
-import "../chunks/chunk-MPUSOFJ3.js";
-import "../chunks/chunk-HFV5GJPK.js";
-import "../chunks/chunk-CEGSWZ5S.js";
-import "../chunks/chunk-ZUBABAAO.js";
-import "../chunks/chunk-4LRLOTMA.js";
-import "../chunks/chunk-HNEDTEGQ.js";
+  link,
+  linkDeclarative
+} from "../chunks/chunk-DVB5WRCI.js";
+import "../chunks/chunk-5GEYCJW2.js";
+import "../chunks/chunk-KTFZSXOW.js";
+import "../chunks/chunk-FQRUTYAD.js";
+import "../chunks/chunk-C2MYMMO4.js";
+import "../chunks/chunk-BJOWSSEL.js";
+import "../chunks/chunk-KDJR27JV.js";
+import "../chunks/chunk-EZTMVCJF.js";
+import "../chunks/chunk-6TUOP63Q.js";
+import "../chunks/chunk-L4PNO2H6.js";
 import "../chunks/chunk-NTN6T6I6.js";
-import "../chunks/chunk-JIXTOQXJ.js";
+import "../chunks/chunk-RIWOEI3T.js";
 import "../chunks/chunk-KE2H62D6.js";
-import "../chunks/chunk-WFV5PPWJ.js";
 import "../chunks/chunk-CTSYKMM6.js";
-import "../chunks/chunk-RJQ4PG2F.js";
+import "../chunks/chunk-NWCJJZNQ.js";
+import "../chunks/chunk-UBMUY7WO.js";
 import "../chunks/chunk-GFOF7NCX.js";
 import "../chunks/chunk-DOBF6YTQ.js";
 import "../chunks/chunk-2LZ43SWS.js";
-import "../chunks/chunk-IP63FME6.js";
-import "../chunks/chunk-UCFEP3BH.js";
-import "../chunks/chunk-CZRI7MHA.js";
-import "../chunks/chunk-VLYP4WUS.js";
-import "../chunks/chunk-UMVN3AWO.js";
-import "../chunks/chunk-UKYAF3NL.js";
-import "../chunks/chunk-S46P7MC6.js";
-import "../chunks/chunk-3LX3KIQQ.js";
-import "../chunks/chunk-BWSNPKO5.js";
-import "../chunks/chunk-TOQ6SJ6O.js";
+import "../chunks/chunk-X2Z5VYG3.js";
+import "../chunks/chunk-ASVMK364.js";
+import "../chunks/chunk-7GPAF2UK.js";
+import "../chunks/chunk-YMVMZA3U.js";
+import "../chunks/chunk-BWTGJZVP.js";
+import "../chunks/chunk-UJGVDFZN.js";
+import "../chunks/chunk-2XVE7F26.js";
+import "../chunks/chunk-W365QUZ5.js";
+import "../chunks/chunk-SH7TP5CJ.js";
+import "../chunks/chunk-SI5OKFFY.js";
+import "../chunks/chunk-LWI7BXFN.js";
+import "../chunks/chunk-DT7YIIWE.js";
 
 // ../logix-core/src/Link.ts
 function make(config, logic) {
   return link(config, logic);
 }
+function makeDeclarative(config, build) {
+  return linkDeclarative(config, build);
+}
 export {
-  make
+  make,
+  makeDeclarative
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/public/sandbox/logix-core/Middleware.js

@@ -6,18 +6,20 @@ import {
   makeDebugLogger,
   makeDebugObserver,
   withDebug
-} from "../chunks/chunk-X72PZOFA.js";
-import "../chunks/chunk-S4EXG3OS.js";
-import "../chunks/chunk-A6JFUNQQ.js";
-import "../chunks/chunk-ON2LY6HJ.js";
+} from "../chunks/chunk-K2MQ66O7.js";
+import "../chunks/chunk-RBB6SHW2.js";
+import "../chunks/chunk-74C5VW7Z.js";
+import "../chunks/chunk-4MY35XR3.js";
 import "../chunks/chunk-2LZ43SWS.js";
-import "../chunks/chunk-IP63FME6.js";
-import "../chunks/chunk-UCFEP3BH.js";
-import "../chunks/chunk-CZRI7MHA.js";
-import "../chunks/chunk-UKYAF3NL.js";
-import "../chunks/chunk-S46P7MC6.js";
-import "../chunks/chunk-BWSNPKO5.js";
-import "../chunks/chunk-TOQ6SJ6O.js";
+import "../chunks/chunk-X2Z5VYG3.js";
+import "../chunks/chunk-ASVMK364.js";
+import "../chunks/chunk-7GPAF2UK.js";
+import "../chunks/chunk-YMVMZA3U.js";
+import "../chunks/chunk-NMGFJZ4I.js";
+import "../chunks/chunk-UJGVDFZN.js";
+import "../chunks/chunk-SH7TP5CJ.js";
+import "../chunks/chunk-SI5OKFFY.js";
+import "../chunks/chunk-DT7YIIWE.js";
 export {
   applyDebug,
   applyDebugObserver,