@logixjs/sandbox 0.0.1 → 0.0.2

package/public/sandbox/chunks/chunk-Z5L7EZXS.js

@@ -0,0 +1,81 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  isJsonValue
+} from "./chunk-RYSSJBGX.js";
+
+// ../logix-core/src/internal/observability/evidence.ts
+var OBSERVABILITY_PROTOCOL_VERSION = "v1";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var asNonEmptyString = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
+var asFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var asPositiveInt = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+  const n = Math.floor(value);
+  return n >= 1 ? n : void 0;
+};
+var exportEvidencePackage = (options) => {
+  const protocolVersion = options.protocolVersion ?? OBSERVABILITY_PROTOCOL_VERSION;
+  return {
+    protocolVersion,
+    runId: options.runId,
+    createdAt: options.createdAt ?? Date.now(),
+    source: options.source,
+    events: options.events.slice().sort((a, b) => a.seq - b.seq),
+    summary: options.summary
+  };
+};
+var importEvidencePackage = (input) => {
+  const fallback = {
+    protocolVersion: OBSERVABILITY_PROTOCOL_VERSION,
+    runId: "unknown",
+    createdAt: Date.now(),
+    source: { host: "unknown" },
+    events: []
+  };
+  if (!isRecord(input)) return fallback;
+  const protocolVersion = asNonEmptyString(input.protocolVersion) ?? fallback.protocolVersion;
+  const runId = asNonEmptyString(input.runId) ?? fallback.runId;
+  const createdAt = asFiniteNumber(input.createdAt) ?? fallback.createdAt;
+  const sourceRaw = input.source;
+  const source = isRecord(sourceRaw) ? {
+    host: asNonEmptyString(sourceRaw.host) ?? "unknown",
+    label: typeof sourceRaw.label === "string" ? sourceRaw.label : void 0
+  } : fallback.source;
+  const eventsRaw = Array.isArray(input.events) ? input.events : [];
+  const events = [];
+  for (const e of eventsRaw) {
+    if (!isRecord(e)) continue;
+    const seq = asPositiveInt(e.seq);
+    const timestamp = asFiniteNumber(e.timestamp);
+    const type = asNonEmptyString(e.type);
+    const payloadRaw = e.payload;
+    if (!seq || timestamp === void 0 || !type || !isJsonValue(payloadRaw)) {
+      continue;
+    }
+    events.push({
+      protocolVersion: asNonEmptyString(e.protocolVersion) ?? protocolVersion,
+      runId: asNonEmptyString(e.runId) ?? runId,
+      seq,
+      timestamp,
+      type,
+      payload: payloadRaw
+    });
+  }
+  const summary = isJsonValue(input.summary) ? input.summary : void 0;
+  return {
+    protocolVersion,
+    runId,
+    createdAt,
+    source,
+    events: events.sort((a, b) => a.seq - b.seq),
+    summary
+  };
+};
+
+export {
+  OBSERVABILITY_PROTOCOL_VERSION,
+  exportEvidencePackage,
+  importEvidencePackage
+};
+//# sourceMappingURL=data:application/json;base64,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

package/public/sandbox/chunks/chunk-Z65I5ET2.js

@@ -0,0 +1,108 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  isDevEnv
+} from "./chunk-LTFCYZQ6.js";
+
+// ../logix-core/src/internal/resource.ts
+import { Context, Layer } from "../effect.js";
+var stableStringify = (value) => {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const encode = (input) => {
+    if (input === null) return null;
+    if (typeof input === "string" || typeof input === "number" || typeof input === "boolean") {
+      return input;
+    }
+    if (typeof input === "bigint") return input.toString();
+    if (typeof input === "undefined") return "__undefined__";
+    if (typeof input === "symbol") return `__symbol__:${String(input)}`;
+    if (typeof input === "function") return "__function__";
+    if (Array.isArray(input)) {
+      return input.map((v) => encode(v));
+    }
+    if (input instanceof Date) {
+      return `__date__:${input.toISOString()}`;
+    }
+    if (input instanceof Error) {
+      return {
+        _tag: "Error",
+        name: input.name,
+        message: input.message
+      };
+    }
+    if (input && typeof input === "object") {
+      const obj = input;
+      if (seen.has(obj)) return "__cycle__";
+      seen.add(obj);
+      const record = input;
+      const keys = Object.keys(record).sort();
+      const out = {};
+      for (const k of keys) {
+        out[k] = encode(record[k]);
+      }
+      return out;
+    }
+    return String(input);
+  };
+  try {
+    return JSON.stringify(encode(value));
+  } catch {
+    return String(value);
+  }
+};
+var keyHash = (key) => stableStringify(key);
+var Snapshot = {
+  idle: () => ({
+    status: "idle",
+    keyHash: void 0,
+    data: void 0,
+    error: void 0
+  }),
+  loading: (params) => ({
+    status: "loading",
+    keyHash: params.keyHash,
+    data: void 0,
+    error: void 0
+  }),
+  success: (params) => ({
+    status: "success",
+    keyHash: params.keyHash,
+    data: params.data,
+    error: void 0
+  }),
+  error: (params) => ({
+    status: "error",
+    keyHash: params.keyHash,
+    data: void 0,
+    error: params.error
+  })
+};
+var ResourceRegistryTag = class extends Context.Tag("@logix/core/ResourceRegistry")() {
+};
+var internal = {
+  ResourceRegistryTag
+};
+var make = (spec) => spec;
+var layer = (specs) => Layer.succeed(
+  ResourceRegistryTag,
+  (() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const spec of specs) {
+      if (isDevEnv() && map.has(spec.id) && map.get(spec.id) !== spec) {
+        throw new Error(`[Resource.layer] Duplicate resource id "${spec.id}" detected in the same runtime scope`);
+      }
+      map.set(spec.id, spec);
+    }
+    return { specs: map };
+  })()
+);
+
+export {
+  keyHash,
+  Snapshot,
+  ResourceRegistryTag,
+  internal,
+  make,
+  layer
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/resource.ts"],
  "sourcesContent": ["import { Context, Layer } from 'effect'\nimport { isDevEnv } from './runtime/core/env.js'\n\nexport interface ResourceSpec<Key, Out, Err, Env> {\n  readonly id: string\n  readonly keySchema: import('effect').Schema.Schema<Key, any>\n  readonly load: (key: Key) => import('effect').Effect.Effect<Out, Err, Env>\n  readonly meta?: {\n    readonly cacheGroup?: string\n    readonly description?: string\n    readonly [k: string]: unknown\n  }\n}\n\nexport type AnyResourceSpec = ResourceSpec<any, any, any, any>\n\nexport type ResourceStatus = 'idle' | 'loading' | 'success' | 'error'\n\nexport interface ResourceSnapshot<Data = unknown, Err = unknown> {\n  readonly status: ResourceStatus\n  readonly keyHash?: string\n  readonly data?: Data\n  readonly error?: Err\n}\n\nconst stableStringify = (value: unknown): string => {\n  const seen = new WeakSet<object>()\n  const encode = (input: unknown): unknown => {\n    if (input === null) return null\n    if (typeof input === 'string' || typeof input === 'number' || typeof input === 'boolean') {\n      return input\n    }\n    if (typeof input === 'bigint') return input.toString()\n    if (typeof input === 'undefined') return '__undefined__'\n    if (typeof input === 'symbol') return `__symbol__:${String(input)}`\n    if (typeof input === 'function') return '__function__'\n\n    if (Array.isArray(input)) {\n      return input.map((v) => encode(v))\n    }\n    if (input instanceof Date) {\n      return `__date__:${input.toISOString()}`\n    }\n    if (input instanceof Error) {\n      return {\n        _tag: 'Error',\n        name: input.name,\n        message: input.message,\n      }\n    }\n    if (input && typeof input === 'object') {\n      const obj = input as object\n      if (seen.has(obj)) return '__cycle__'\n      seen.add(obj)\n\n      const record = input as Record<string, unknown>\n      const keys = Object.keys(record).sort()\n      const out: Record<string, unknown> = {}\n      for (const k of keys) {\n        out[k] = encode(record[k])\n      }\n      return out\n    }\n    return String(input)\n  }\n\n  try {\n    return JSON.stringify(encode(value))\n  } catch {\n    return String(value)\n  }\n}\n\nexport const keyHash = (key: unknown): string => stableStringify(key)\n\nexport const Snapshot = {\n  idle: <Data = never, Err = never>(): ResourceSnapshot<Data, Err> => ({\n    status: 'idle',\n    keyHash: undefined,\n    data: undefined,\n    error: undefined,\n  }),\n  loading: <Data = never, Err = never>(params: { readonly keyHash: string }): ResourceSnapshot<Data, Err> => ({\n    status: 'loading',\n    keyHash: params.keyHash,\n    data: undefined,\n    error: undefined,\n  }),\n  success: <Data>(params: { readonly keyHash: string; readonly data: Data }): ResourceSnapshot<Data, never> => ({\n    status: 'success',\n    keyHash: params.keyHash,\n    data: params.data,\n    error: undefined,\n  }),\n  error: <Err>(params: { readonly keyHash: string; readonly error: Err }): ResourceSnapshot<never, Err> => ({\n    status: 'error',\n    keyHash: params.keyHash,\n    data: undefined,\n    error: params.error,\n  }),\n} as const\n\nexport interface ResourceRegistry {\n  readonly specs: ReadonlyMap<string, AnyResourceSpec>\n}\n\nexport class ResourceRegistryTag extends Context.Tag('@logix/core/ResourceRegistry')<\n  ResourceRegistryTag,\n  ResourceRegistry\n>() {}\n\nexport const internal = {\n  ResourceRegistryTag,\n}\n\nexport type Spec<Key, Out, Err, Env> = ResourceSpec<Key, Out, Err, Env>\n\nexport const make = <Key, Out, Err, Env>(spec: ResourceSpec<Key, Out, Err, Env>): ResourceSpec<Key, Out, Err, Env> =>\n  spec\n\nexport const layer = (specs: ReadonlyArray<AnyResourceSpec>): Layer.Layer<ResourceRegistryTag, never, never> =>\n  Layer.succeed(\n    ResourceRegistryTag,\n    (() => {\n      const map = new Map<string, AnyResourceSpec>()\n      for (const spec of specs) {\n        if (isDevEnv() && map.has(spec.id) && map.get(spec.id) !== spec) {\n          throw new Error(`[Resource.layer] Duplicate resource id \"${spec.id}\" detected in the same runtime scope`)\n        }\n        map.set(spec.id, spec)\n      }\n      return { specs: map }\n    })(),\n  )\n"],
  "mappings": ";;;;;;;AAAA,SAAS,SAAS,aAAa;AAyB/B,IAAM,kBAAkB,CAAC,UAA2B;AAClD,QAAM,OAAO,oBAAI,QAAgB;AACjC,QAAM,SAAS,CAAC,UAA4B;AAC1C,QAAI,UAAU,KAAM,QAAO;AAC3B,QAAI,OAAO,UAAU,YAAY,OAAO,UAAU,YAAY,OAAO,UAAU,WAAW;AACxF,aAAO;AAAA,IACT;AACA,QAAI,OAAO,UAAU,SAAU,QAAO,MAAM,SAAS;AACrD,QAAI,OAAO,UAAU,YAAa,QAAO;AACzC,QAAI,OAAO,UAAU,SAAU,QAAO,cAAc,OAAO,KAAK,CAAC;AACjE,QAAI,OAAO,UAAU,WAAY,QAAO;AAExC,QAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,aAAO,MAAM,IAAI,CAAC,MAAM,OAAO,CAAC,CAAC;AAAA,IACnC;AACA,QAAI,iBAAiB,MAAM;AACzB,aAAO,YAAY,MAAM,YAAY,CAAC;AAAA,IACxC;AACA,QAAI,iBAAiB,OAAO;AAC1B,aAAO;AAAA,QACL,MAAM;AAAA,QACN,MAAM,MAAM;AAAA,QACZ,SAAS,MAAM;AAAA,MACjB;AAAA,IACF;AACA,QAAI,SAAS,OAAO,UAAU,UAAU;AACtC,YAAM,MAAM;AACZ,UAAI,KAAK,IAAI,GAAG,EAAG,QAAO;AAC1B,WAAK,IAAI,GAAG;AAEZ,YAAM,SAAS;AACf,YAAM,OAAO,OAAO,KAAK,MAAM,EAAE,KAAK;AACtC,YAAM,MAA+B,CAAC;AACtC,iBAAW,KAAK,MAAM;AACpB,YAAI,CAAC,IAAI,OAAO,OAAO,CAAC,CAAC;AAAA,MAC3B;AACA,aAAO;AAAA,IACT;AACA,WAAO,OAAO,KAAK;AAAA,EACrB;AAEA,MAAI;AACF,WAAO,KAAK,UAAU,OAAO,KAAK,CAAC;AAAA,EACrC,QAAQ;AACN,WAAO,OAAO,KAAK;AAAA,EACrB;AACF;AAEO,IAAM,UAAU,CAAC,QAAyB,gBAAgB,GAAG;AAE7D,IAAM,WAAW;AAAA,EACtB,MAAM,OAA+D;AAAA,IACnE,QAAQ;AAAA,IACR,SAAS;AAAA,IACT,MAAM;AAAA,IACN,OAAO;AAAA,EACT;AAAA,EACA,SAAS,CAA4B,YAAuE;AAAA,IAC1G,QAAQ;AAAA,IACR,SAAS,OAAO;AAAA,IAChB,MAAM;AAAA,IACN,OAAO;AAAA,EACT;AAAA,EACA,SAAS,CAAO,YAA8F;AAAA,IAC5G,QAAQ;AAAA,IACR,SAAS,OAAO;AAAA,IAChB,MAAM,OAAO;AAAA,IACb,OAAO;AAAA,EACT;AAAA,EACA,OAAO,CAAM,YAA6F;AAAA,IACxG,QAAQ;AAAA,IACR,SAAS,OAAO;AAAA,IAChB,MAAM;AAAA,IACN,OAAO,OAAO;AAAA,EAChB;AACF;AAMO,IAAM,sBAAN,cAAkC,QAAQ,IAAI,8BAA8B,EAGjF,EAAE;AAAC;AAEE,IAAM,WAAW;AAAA,EACtB;AACF;AAIO,IAAM,OAAO,CAAqB,SACvC;AAEK,IAAM,QAAQ,CAAC,UACpB,MAAM;AAAA,EACJ;AAAA,GACC,MAAM;AACL,UAAM,MAAM,oBAAI,IAA6B;AAC7C,eAAW,QAAQ,OAAO;AACxB,UAAI,SAAS,KAAK,IAAI,IAAI,KAAK,EAAE,KAAK,IAAI,IAAI,KAAK,EAAE,MAAM,MAAM;AAC/D,cAAM,IAAI,MAAM,2CAA2C,KAAK,EAAE,sCAAsC;AAAA,MAC1G;AACA,UAAI,IAAI,KAAK,IAAI,IAAI;AAAA,IACvB;AACA,WAAO,EAAE,OAAO,IAAI;AAAA,EACtB,GAAG;AACL;",
  "names": []
}
