@logixjs/core 0.0.1

package/dist/chunk-M3WTHJHJ.js

@@ -0,0 +1,1051 @@
+import {
+  makeApp,
+  makeProgramRunnerKernel,
+  provide
+} from "./chunk-EGK3KN7B.js";
+import {
+  evidenceCollectorLayer,
+  makeEvidenceCollector
+} from "./chunk-PAYXCY6A.js";
+import {
+  RuntimeServicesInstanceOverridesTag,
+  getKernelImplementationRef,
+  getRuntimeServicesEvidence
+} from "./chunk-ZGDVUPTM.js";
+import {
+  isActionToken
+} from "./chunk-YS3AZQ2G.js";
+import {
+  exportStaticIr
+} from "./chunk-ZFY7U2FR.js";
+import {
+  appendConvergeStaticIrCollectors
+} from "./chunk-M3BFQ7HK.js";
+import {
+  getModuleTraitsProgram
+} from "./chunk-3RMKLXHX.js";
+import {
+  appendSinks,
+  diagnosticsLevel,
+  toSerializableErrorSummary
+} from "./chunk-DMBALCE2.js";
+import {
+  fnv1a32,
+  stableStringify
+} from "./chunk-GMPEOUP2.js";
+import {
+  makeRunSession,
+  runSessionLayer
+} from "./chunk-OFADUJWJ.js";
+import {
+  isJsonValue
+} from "./chunk-JWOYLO27.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/internal/reflection/staticIr.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isModuleImpl = (value) => isRecord(value) && value._tag === "ModuleImpl" && isRecord(value.module);
+var resolveModuleId = (input) => {
+  if (isModuleImpl(input)) {
+    const id = input.module.id;
+    return typeof id === "string" && id.length > 0 ? id : "unknown";
+  }
+  if (isRecord(input)) {
+    const id = input.id;
+    if (typeof id === "string" && id.length > 0) return id;
+    const tag = input.tag;
+    if (tag && (typeof tag === "object" || typeof tag === "function")) {
+      const tagId = tag.id;
+      if (typeof tagId === "string" && tagId.length > 0) return tagId;
+    }
+  }
+  return "unknown";
+};
+var resolveModuleTag = (input) => {
+  if (isModuleImpl(input)) return input.module;
+  if (isRecord(input) && input.tag) return input.tag;
+  return void 0;
+};
+var exportStaticIr2 = (module) => {
+  const tag = resolveModuleTag(module);
+  if (!tag) return void 0;
+  const program = getModuleTraitsProgram(tag);
+  if (!program) return void 0;
+  return exportStaticIr({
+    program,
+    moduleId: resolveModuleId(module)
+  });
+};
+
+// src/internal/reflection/manifest.ts
+import { Schema } from "effect";
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isModuleImpl2 = (value) => isRecord2(value) && value._tag === "ModuleImpl" && isRecord2(value.module);
+var resolveModuleId2 = (input) => {
+  if (isModuleImpl2(input)) {
+    const id = input.module.id;
+    return typeof id === "string" && id.length > 0 ? id : "unknown";
+  }
+  if (isRecord2(input)) {
+    const id = input.id;
+    if (typeof id === "string" && id.length > 0) return id;
+    const tag = input.tag;
+    if (tag && (typeof tag === "object" || typeof tag === "function")) {
+      const tagId = tag.id;
+      if (typeof tagId === "string" && tagId.length > 0) return tagId;
+    }
+  }
+  return "unknown";
+};
+var resolveActionKeys = (input) => {
+  const tag = isModuleImpl2(input) ? input.module : input?.tag;
+  const actionMap = tag?.shape?.actionMap;
+  if (!isRecord2(actionMap)) return [];
+  return Object.keys(actionMap).sort();
+};
+var resolveDevSource = (input) => {
+  if (!isRecord2(input)) return void 0;
+  const file = input.file;
+  const line = input.line;
+  const column = input.column;
+  if (typeof file !== "string" || file.length === 0) return void 0;
+  if (typeof line !== "number" || !Number.isInteger(line) || line < 1) return void 0;
+  if (typeof column !== "number" || !Number.isInteger(column) || column < 1) return void 0;
+  return { file, line, column };
+};
+var resolveTokenSource = (token) => {
+  if (!token || typeof token !== "object" && typeof token !== "function") return void 0;
+  return resolveDevSource(token.source);
+};
+var resolveActions = (input) => {
+  const tag = isModuleImpl2(input) ? input.module : input?.tag;
+  const actionMap = tag?.shape?.actionMap;
+  if (!isRecord2(actionMap)) return [];
+  const moduleSource = resolveSource(input);
+  const reducers = isRecord2(tag?.reducers) ? tag.reducers : void 0;
+  const actionTags = Object.keys(actionMap).sort();
+  const out = [];
+  for (const actionTag of actionTags) {
+    const token = actionMap[actionTag];
+    const source = resolveTokenSource(token) ?? moduleSource;
+    const payloadKind = isActionToken(token) && Schema.isSchema(token.schema) ? token.schema === Schema.Void ? "void" : "nonVoid" : "unknown";
+    const primaryReducer = reducers && typeof reducers[actionTag] === "function" ? { kind: "declared" } : void 0;
+    out.push({
+      actionTag,
+      payload: { kind: payloadKind },
+      ...primaryReducer ? { primaryReducer } : {},
+      ...source ? { source } : {}
+    });
+  }
+  return out;
+};
+var MODULE_DECLARED_EFFECTS = /* @__PURE__ */ Symbol.for("logix.module.effects.declared");
+var resolveEffects = (input) => {
+  const tag = isModuleImpl2(input) ? input.module : input?.tag;
+  const actionMap = tag?.shape?.actionMap;
+  if (!isRecord2(actionMap)) return void 0;
+  const effectsRaw = tag?.[MODULE_DECLARED_EFFECTS];
+  if (!isRecord2(effectsRaw)) return void 0;
+  const source = resolveSource(input);
+  const logicUnitId = "__logix_internal:effects:declared";
+  const handlerIds = /* @__PURE__ */ new WeakMap();
+  let nextHandlerSeq = 0;
+  const out = [];
+  for (const actionTag of Object.keys(effectsRaw).sort()) {
+    if (!(actionTag in actionMap)) continue;
+    const handlers = effectsRaw[actionTag];
+    if (!Array.isArray(handlers)) continue;
+    for (const handler of handlers) {
+      if (typeof handler !== "function") continue;
+      let handlerId = handlerIds.get(handler);
+      if (!handlerId) {
+        nextHandlerSeq += 1;
+        handlerId = `h${nextHandlerSeq}`;
+        handlerIds.set(handler, handlerId);
+      }
+      const sourceKey = `${logicUnitId}::${handlerId}`;
+      out.push({
+        actionTag,
+        sourceKey,
+        kind: "declared",
+        ...source ? { source } : {}
+      });
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const item of out) {
+    const key = `${item.actionTag}\0${item.sourceKey}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(item);
+  }
+  deduped.sort(
+    (a, b) => a.actionTag < b.actionTag ? -1 : a.actionTag > b.actionTag ? 1 : a.sourceKey.localeCompare(b.sourceKey)
+  );
+  return deduped.length > 0 ? deduped : void 0;
+};
+var resolveSchemaKeys = (input) => {
+  if (!isRecord2(input)) return void 0;
+  const schemas = input.schemas;
+  if (!isRecord2(schemas)) return void 0;
+  return Object.keys(schemas).sort();
+};
+var resolveSource = (input) => {
+  if (!isRecord2(input)) return void 0;
+  const dev = input.dev;
+  return resolveDevSource(dev?.source);
+};
+var resolveMeta = (input) => {
+  if (!isRecord2(input)) return void 0;
+  const meta = input.meta;
+  if (!isRecord2(meta)) return void 0;
+  const out = {};
+  for (const key of Object.keys(meta).sort()) {
+    const value = meta[key];
+    if (isJsonValue(value)) {
+      out[key] = value;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+};
+var MODULE_INTERNAL = /* @__PURE__ */ Symbol.for("logix.module.internal");
+var resolveLogicUnits = (input) => {
+  if (!isRecord2(input)) return void 0;
+  const internal = input[MODULE_INTERNAL];
+  const mounted = internal?.mounted;
+  if (!Array.isArray(mounted)) return void 0;
+  const out = [];
+  for (const unit of mounted) {
+    if (!isRecord2(unit)) continue;
+    const kind = unit.kind;
+    const id = unit.id;
+    if (typeof kind !== "string" || kind.length === 0) continue;
+    if (typeof id !== "string" || id.length === 0) continue;
+    const derived = unit.derived === true ? true : void 0;
+    const name = typeof unit.name === "string" ? unit.name : void 0;
+    out.push({ kind, id, derived, name });
+  }
+  out.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : a.kind.localeCompare(b.kind));
+  return out.length > 0 ? out : void 0;
+};
+var digestOf = (base) => `manifest:067:${fnv1a32(stableStringify(base))}`;
+var utf8ByteLength = (value) => {
+  const json = JSON.stringify(value);
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(json).length;
+  }
+  return json.length;
+};
+var applyMaxBytes = (manifest, maxBytes) => {
+  const originalBytes = utf8ByteLength(manifest);
+  if (originalBytes <= maxBytes) return manifest;
+  const dropped = [];
+  const truncatedArrays = [];
+  const baseMarker = () => ({
+    truncated: true,
+    maxBytes,
+    originalBytes,
+    dropped,
+    truncatedArrays
+  });
+  const withMarker = (next2) => {
+    const meta = {
+      __logix: baseMarker()
+    };
+    return { ...next2, meta };
+  };
+  let next = withMarker(manifest);
+  const markTruncatedArray = (name) => {
+    if (!truncatedArrays.includes(name)) {
+      truncatedArrays.push(name);
+    }
+  };
+  const dropField = (field) => {
+    if (next[field] !== void 0) {
+      dropped.push(String(field));
+      next = withMarker({ ...next, [field]: void 0 });
+    }
+  };
+  dropField("meta");
+  if (utf8ByteLength(next) <= maxBytes) return next;
+  dropField("source");
+  if (utf8ByteLength(next) <= maxBytes) return next;
+  dropField("staticIr");
+  if (utf8ByteLength(next) <= maxBytes) return next;
+  dropField("logicUnits");
+  if (utf8ByteLength(next) <= maxBytes) return next;
+  dropField("schemaKeys");
+  if (utf8ByteLength(next) <= maxBytes) return next;
+  dropField("effects");
+  if (utf8ByteLength(next) <= maxBytes) return next;
+  const truncateActionsToFit = () => {
+    const total = next.actions.length;
+    if (total <= 1) return;
+    let lo = 1;
+    let hi = total;
+    let best = 1;
+    while (lo <= hi) {
+      const mid = Math.floor((lo + hi) / 2);
+      const candidate = withMarker({
+        ...next,
+        actions: next.actions.slice(0, mid),
+        actionKeys: next.actionKeys.slice(0, mid)
+      });
+      if (utf8ByteLength(candidate) <= maxBytes) {
+        best = mid;
+        lo = mid + 1;
+      } else {
+        hi = mid - 1;
+      }
+    }
+    if (best < total) {
+      markTruncatedArray("actions");
+      markTruncatedArray("actionKeys");
+      next = withMarker({
+        ...next,
+        actions: next.actions.slice(0, best),
+        actionKeys: next.actionKeys.slice(0, best)
+      });
+    }
+  };
+  while (utf8ByteLength(next) > maxBytes) {
+    const beforeLen = next.actions.length;
+    truncateActionsToFit();
+    if (next.actions.length === beforeLen) {
+      break;
+    }
+  }
+  return next;
+};
+var extractManifest = (module, options) => {
+  const manifestVersion = "067";
+  const moduleId = resolveModuleId2(module);
+  const actionKeys = resolveActionKeys(module);
+  const actions = resolveActions(module);
+  const effects = resolveEffects(module);
+  const schemaKeys = resolveSchemaKeys(module);
+  const logicUnits = resolveLogicUnits(module);
+  const source = resolveSource(module);
+  const meta = resolveMeta(module);
+  const staticIr = options?.includeStaticIr ? exportStaticIr2(module) : void 0;
+  const digestBase = {
+    manifestVersion,
+    moduleId,
+    actionKeys,
+    actions,
+    effects,
+    schemaKeys,
+    logicUnits,
+    staticIrDigest: staticIr?.digest
+  };
+  const digest = digestOf(digestBase);
+  const manifest = {
+    manifestVersion,
+    moduleId,
+    actionKeys,
+    actions,
+    effects,
+    schemaKeys,
+    logicUnits,
+    source,
+    meta,
+    staticIr,
+    digest
+  };
+  const maxBytes = options?.budgets?.maxBytes;
+  if (typeof maxBytes === "number" && Number.isFinite(maxBytes) && maxBytes > 0) {
+    return applyMaxBytes(manifest, maxBytes);
+  }
+  return manifest;
+};
+
+// src/internal/observability/artifacts/registry.ts
+var ARTIFACT_EXPORTERS = /* @__PURE__ */ Symbol.for("logix.module.trialRunArtifactExporters");
+var registerTrialRunArtifactExporter = (tag, exporter) => {
+  if (!tag || typeof tag !== "object" && typeof tag !== "function") {
+    throw new Error("[Logix] registerTrialRunArtifactExporter: invalid module tag");
+  }
+  const current = tag[ARTIFACT_EXPORTERS] ?? [];
+  const next = Array.isArray(current) ? [...current, exporter] : [exporter];
+  tag[ARTIFACT_EXPORTERS] = next;
+};
+var getTrialRunArtifactExporters = (tag) => {
+  if (!tag || typeof tag !== "object" && typeof tag !== "function") {
+    return [];
+  }
+  const current = tag[ARTIFACT_EXPORTERS];
+  if (!Array.isArray(current)) return [];
+  return current.filter((x) => x && typeof x === "object");
+};
+
+// src/internal/observability/trialRunModule.ts
+import { Cause as Cause2, Effect as Effect4, Exit, Fiber, Layer as Layer4, Option } from "effect";
+
+// src/internal/platform/BuildEnv.ts
+var BuildEnv_exports = {};
+__export(BuildEnv_exports, {
+  layer: () => layer2,
+  run: () => run
+});
+import { ConfigProvider, Effect as Effect2, Layer as Layer2 } from "effect";
+
+// src/internal/platform/ConstructionGuard.ts
+var ConstructionGuard_exports = {};
+__export(ConstructionGuard_exports, {
+  guardBuildTime: () => guardBuildTime,
+  makeConstructionGuardError: () => makeConstructionGuardError
+});
+import { Cause, Effect } from "effect";
+var makeConstructionGuardError = (options) => Object.assign(new Error(options.message), {
+  _tag: "ConstructionGuardError",
+  kind: options.kind,
+  missingService: options.missingService,
+  hint: options.hint
+});
+var extractMissingService = (cause) => {
+  const candidates = [...Array.from(Cause.defects(cause)), ...Array.from(Cause.failures(cause))];
+  for (const candidate of candidates) {
+    const message = candidate instanceof Error ? candidate.message : typeof candidate === "string" ? candidate : void 0;
+    if (!message) continue;
+    const match = /Service not found: ([^\s(]+)/.exec(message);
+    if (match?.[1]) return match[1];
+  }
+  return void 0;
+};
+var guardBuildTime = (self) => self.pipe(
+  Effect.catchAllCause((cause) => {
+    const missing = extractMissingService(cause);
+    if (missing) {
+      return Effect.fail(
+        makeConstructionGuardError({
+          kind: "missing_service",
+          missingService: missing,
+          message: `[ConstructionGuardError] Build-time dependency violation: service "${missing}" is not available in Build Env.`,
+          hint: "Build-time (Reflection) can only depend on a small set of mockable primitives (e.g. Config/RuntimeHost). Move business service access to runtime (e.g. Trait handler / Logic run section) or isolate it via explicit injection."
+        })
+      );
+    }
+    return Effect.failCause(cause);
+  })
+);
+
+// src/internal/platform/RuntimeHost.ts
+var RuntimeHost_exports = {};
+__export(RuntimeHost_exports, {
+  RuntimeHost: () => RuntimeHost,
+  defaultLayer: () => defaultLayer,
+  layer: () => layer,
+  make: () => make,
+  mock: () => mock
+});
+import { Context, Layer } from "effect";
+var detectKind = () => {
+  const isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+  if (isBrowser) return "browser";
+  const isNode = typeof process !== "undefined" && typeof process?.versions?.node === "string";
+  if (isNode) return "node";
+  return "unknown";
+};
+var make = (kind) => ({
+  kind,
+  isNode: kind === "node",
+  isBrowser: kind === "browser"
+});
+var RuntimeHost = class extends Context.Tag("@logixjs/RuntimeHost")() {
+};
+var layer = (service) => Layer.succeed(RuntimeHost, service);
+var mock = (kind) => layer(make(kind));
+var defaultLayer = layer(make(detectKind()));
+
+// src/internal/platform/BuildEnv.ts
+var toConfigProviderFromRecord = (record) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const [k, v] of Object.entries(record ?? {})) {
+    if (!k) continue;
+    if (v === void 0) continue;
+    map.set(k, String(v));
+  }
+  return ConfigProvider.fromMap(map);
+};
+var layer2 = (options = {}) => {
+  const runtimeHost = options.runtimeHost ? layer(options.runtimeHost) : options.runtimeHostKind ? layer(make(options.runtimeHostKind)) : defaultLayer;
+  const configProvider = options.configProvider ? options.configProvider : toConfigProviderFromRecord(options.config);
+  const config = Layer2.setConfigProvider(configProvider);
+  return Layer2.mergeAll(runtimeHost, config);
+};
+var run = (builder, options = {}) => builder.pipe(Effect2.provide(layer2(options)), guardBuildTime);
+
+// src/internal/runtime/Runtime.ts
+import { Layer as Layer3 } from "effect";
+var make2 = (rootImpl, options) => {
+  const appConfig = {
+    layer: options?.layer ?? Layer3.empty,
+    modules: [provide(rootImpl.module, rootImpl.layer)],
+    processes: rootImpl.processes ?? [],
+    onError: options?.onError
+  };
+  const app = makeApp(appConfig);
+  return app.makeRuntime();
+};
+
+// src/internal/observability/artifacts/model.ts
+var isArtifactKey = (input) => typeof input === "string" && /^@[^\s/]+\/[^\s@]+@v\d+$/.test(input);
+
+// src/internal/observability/artifacts/digest.ts
+var utf8ByteLengthString = (text) => {
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(text).length;
+  }
+  return text.length;
+};
+var digestJsonValue = (value) => {
+  const stableJson = stableStringify(value);
+  const bytes = utf8ByteLengthString(stableJson);
+  return {
+    stableJson,
+    bytes,
+    digest: `artifact:031:${fnv1a32(stableJson)}`
+  };
+};
+
+// src/internal/observability/artifacts/collect.ts
+var toErrorSummaryWithCode = (cause, code, hint) => {
+  const base = toSerializableErrorSummary(cause).errorSummary;
+  return {
+    name: base.name,
+    message: base.message,
+    code,
+    hint: hint ?? base.hint
+  };
+};
+var defaultArtifactBudgetBytes = 50 * 1024;
+var budgetOf = (budgets) => typeof budgets?.maxBytes === "number" && Number.isFinite(budgets.maxBytes) && budgets.maxBytes > 0 ? budgets.maxBytes : defaultArtifactBudgetBytes;
+var makeConflictEnvelope = (artifactKey, exporterIds) => {
+  const ids = Array.from(new Set(exporterIds.map((s) => String(s)).filter((s) => s.length > 0))).sort(
+    (a, b) => a.localeCompare(b)
+  );
+  return {
+    artifactKey,
+    envelope: {
+      artifactKey,
+      ok: false,
+      error: {
+        name: "ArtifactKeyConflictError",
+        message: `[Logix] TrialRun artifact key conflict: ${artifactKey}`,
+        code: "ArtifactKeyConflict",
+        hint: ids.length > 0 ? `conflictingExporters=${ids.join(",")}` : void 0
+      }
+    }
+  };
+};
+var truncateJsonValue = (value, maxBytes) => {
+  const analyzed = digestJsonValue(value);
+  const json = analyzed.stableJson;
+  const bytes = analyzed.bytes;
+  if (bytes <= maxBytes) {
+    return { value, actualBytes: bytes, digest: analyzed.digest };
+  }
+  const previewChars = Math.min(json.length, Math.max(0, Math.min(256, maxBytes)));
+  const preview = json.slice(0, previewChars);
+  return {
+    value: {
+      _tag: "oversized",
+      bytes,
+      preview
+    },
+    actualBytes: bytes,
+    digest: analyzed.digest
+  };
+};
+var collectTrialRunArtifacts = (options) => {
+  const exportersSorted = Array.from(options.exporters).sort((a, b) => {
+    const ka = String(a?.artifactKey ?? "");
+    const kb = String(b?.artifactKey ?? "");
+    if (ka < kb) return -1;
+    if (ka > kb) return 1;
+    const ia = String(a?.exporterId ?? "");
+    const ib = String(b?.exporterId ?? "");
+    return ia.localeCompare(ib);
+  });
+  const conflicts = /* @__PURE__ */ new Map();
+  for (const ex of exportersSorted) {
+    const key = ex?.artifactKey;
+    const id = String(ex?.exporterId ?? "");
+    if (!isArtifactKey(key)) {
+      continue;
+    }
+    const current = conflicts.get(key);
+    if (current) current.push(id);
+    else conflicts.set(key, [id]);
+  }
+  const conflictKeys = /* @__PURE__ */ new Set();
+  for (const [k, ids] of conflicts) {
+    const unique = Array.from(new Set(ids));
+    if (unique.length > 1) {
+      conflictKeys.add(k);
+    }
+  }
+  const maxBytes = budgetOf(options.budgets);
+  const collected = [];
+  for (const exporter of exportersSorted) {
+    const artifactKey = exporter?.artifactKey;
+    if (!isArtifactKey(artifactKey)) {
+      continue;
+    }
+    if (conflictKeys.has(artifactKey)) {
+      continue;
+    }
+    try {
+      const value = exporter.export(options.ctx);
+      if (value === void 0) continue;
+      if (!isJsonValue(value)) {
+        collected.push({
+          artifactKey,
+          envelope: {
+            artifactKey,
+            ok: false,
+            error: toErrorSummaryWithCode(
+              new Error(`[Logix] Artifact exporter returned non-JsonValue: ${exporter.exporterId}`),
+              "ArtifactNonSerializable",
+              `artifactKey=${artifactKey} exporterId=${exporter.exporterId}`
+            )
+          }
+        });
+        continue;
+      }
+      const truncated = truncateJsonValue(value, maxBytes);
+      const envelope = {
+        artifactKey,
+        ok: true,
+        value: truncated.value,
+        digest: truncated.digest,
+        ...truncated.actualBytes > maxBytes ? {
+          truncated: true,
+          budgetBytes: maxBytes,
+          actualBytes: truncated.actualBytes
+        } : {
+          budgetBytes: maxBytes,
+          actualBytes: truncated.actualBytes
+        }
+      };
+      collected.push({ artifactKey, envelope });
+    } catch (e) {
+      collected.push({
+        artifactKey,
+        envelope: {
+          artifactKey,
+          ok: false,
+          error: toErrorSummaryWithCode(
+            e,
+            "ArtifactExportFailed",
+            `artifactKey=${artifactKey} exporterId=${exporter.exporterId}`
+          )
+        }
+      });
+    }
+  }
+  for (const conflictKey of Array.from(conflictKeys).sort((a, b) => a.localeCompare(b))) {
+    collected.push(makeConflictEnvelope(conflictKey, conflicts.get(conflictKey) ?? []));
+  }
+  if (collected.length === 0) return void 0;
+  collected.sort((a, b) => a.artifactKey.localeCompare(b.artifactKey));
+  return Object.fromEntries(collected.map((c) => [c.artifactKey, c.envelope]));
+};
+
+// src/internal/observability/trialRunModule.ts
+var defaultHost = () => {
+  if (typeof window !== "undefined" && typeof document !== "undefined") return "browser";
+  return "node";
+};
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var resolveRootImpl = (root) => root?._tag === "ModuleImpl" ? root : root?.impl;
+var utf8ByteLength2 = (value) => {
+  const json = JSON.stringify(value);
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(json).length;
+  }
+  return json.length;
+};
+var parseMissingConfigKeys = (message) => {
+  const out = [];
+  const patterns = [
+    /\bMissing (?:data|value) for (?:key|path) "?([A-Z0-9_./:-]+)"?/g,
+    /\bMissing (?:data|value) at ([A-Z0-9_./:-]+)\b/g,
+    /\bMissing configuration:? "?([A-Z0-9_./:-]+)"?/g,
+    /\bConfig\b.*\bmissing\b.*"?([A-Z0-9_./:-]+)"?/gi
+  ];
+  for (const re of patterns) {
+    let match;
+    while (match = re.exec(message)) {
+      const key = match[1];
+      if (typeof key === "string" && key.length > 0) out.push(key);
+    }
+  }
+  return Array.from(new Set(out)).sort((a, b) => a.localeCompare(b));
+};
+var parseMissingServiceIds = (message) => {
+  const out = [];
+  const re = /Service not found: ([^\s(]+)/g;
+  let match;
+  while (match = re.exec(message)) {
+    const id = match[1]?.replace(/[,:.;]+$/, "");
+    if (typeof id === "string" && id.length > 0) out.push(id);
+  }
+  return Array.from(new Set(out)).sort((a, b) => a.localeCompare(b));
+};
+var parseMissingDependencyFromCause = (cause) => {
+  const missingServices = [];
+  const missingConfigKeys = [];
+  const candidates = [...Array.from(Cause2.failures(cause)), ...Array.from(Cause2.defects(cause))];
+  for (const candidate of candidates) {
+    if (isRecord3(candidate) && candidate._tag === "ConstructionGuardError") {
+      const missingService = candidate.missingService;
+      if (typeof missingService === "string" && missingService.length > 0) {
+        missingServices.push(missingService);
+      }
+    }
+    if (isRecord3(candidate) && candidate._tag === "ConfigError" && candidate._op === "MissingData" && Array.isArray(candidate.path) && candidate.path.every((k) => typeof k === "string" && k.length > 0)) {
+      const key = candidate.path.join(".");
+      if (key.length > 0) missingConfigKeys.push(key);
+    }
+  }
+  const messages = [];
+  for (const candidate of candidates) {
+    if (candidate instanceof Error) {
+      messages.push(candidate.message);
+      continue;
+    }
+    if (typeof candidate === "string") {
+      messages.push(candidate);
+      continue;
+    }
+    if (isRecord3(candidate) && typeof candidate.message === "string") {
+      messages.push(String(candidate.message));
+    }
+  }
+  try {
+    messages.push(Cause2.pretty(cause, { renderErrorCause: true }));
+  } catch {
+  }
+  const merged = messages.filter((s) => s.length > 0).join("\n");
+  if (merged) {
+    missingServices.push(...parseMissingServiceIds(merged));
+    missingConfigKeys.push(...parseMissingConfigKeys(merged));
+  }
+  return {
+    missingServices: Array.from(new Set(missingServices)).sort((a, b) => a.localeCompare(b)),
+    missingConfigKeys: Array.from(new Set(missingConfigKeys)).sort((a, b) => a.localeCompare(b))
+  };
+};
+var buildEnvironmentIr = (params) => {
+  const providedConfigKeys = Object.keys(params.buildEnvConfig ?? {}).filter((k) => k.length > 0 && params.buildEnvConfig[k] !== void 0).sort((a, b) => a.localeCompare(b));
+  const missingServices = Array.from(new Set(params.missingServices ?? [])).sort((a, b) => a.localeCompare(b));
+  const missingConfigKeys = Array.from(new Set(params.missingConfigKeys ?? [])).sort((a, b) => a.localeCompare(b));
+  const runtimeServiceIds = params.runtimeServicesEvidence?.bindings?.map((b) => b.serviceId).filter((s) => typeof s === "string") ?? [];
+  const tagIds = Array.from(/* @__PURE__ */ new Set([...runtimeServiceIds, ...missingServices])).sort((a, b) => a.localeCompare(b));
+  const configKeys = Array.from(/* @__PURE__ */ new Set([...providedConfigKeys, ...missingConfigKeys])).sort(
+    (a, b) => a.localeCompare(b)
+  );
+  return {
+    tagIds,
+    configKeys,
+    missingServices,
+    missingConfigKeys,
+    kernelImplementationRef: params.kernelImplementationRef,
+    runtimeServicesEvidence: params.runtimeServicesEvidence
+  };
+};
+var toErrorSummaryWithCode2 = (cause, code, hint) => {
+  const base = toSerializableErrorSummary(cause).errorSummary;
+  return {
+    name: base.name,
+    message: base.message,
+    code,
+    hint: hint ?? base.hint
+  };
+};
+var makeTrialRunTimeoutError = () => Object.assign(new Error("[Logix] trialRunModule timed out"), {
+  name: "TrialRunTimeoutError"
+});
+var awaitFiberExitWithTimeout = (fiber, timeoutMs) => Effect4.gen(function* () {
+  const hasTimeout = typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0;
+  const start = hasTimeout ? Date.now() : 0;
+  while (true) {
+    const exitOpt = yield* Fiber.poll(fiber);
+    if (Option.isSome(exitOpt)) {
+      return exitOpt.value;
+    }
+    if (hasTimeout) {
+      const elapsedMs = Date.now() - start;
+      if (elapsedMs >= timeoutMs) {
+        yield* Fiber.interruptFork(fiber);
+        return Exit.fail(makeTrialRunTimeoutError());
+      }
+    }
+    yield* Effect4.promise(() => new Promise((r) => setTimeout(r, 1)));
+  }
+});
+var trialRunModule = (root, options) => Effect4.gen(function* () {
+  const rootImpl = resolveRootImpl(root);
+  const session = makeRunSession({
+    runId: options?.runId,
+    source: options?.source ?? { host: defaultHost(), label: "trial-run-module" },
+    startedAt: options?.startedAt
+  });
+  const collector = makeEvidenceCollector(session);
+  const convergeCollector = {
+    register: (ir) => {
+      collector.registerConvergeStaticIr(ir);
+    }
+  };
+  const sinksLayer = appendSinks([collector.debugSink]);
+  const resolvedDiagnosticsLevel = options?.diagnosticsLevel ?? "light";
+  const diagnosticsLayer = diagnosticsLevel(resolvedDiagnosticsLevel);
+  const convergeLayer = appendConvergeStaticIrCollectors([convergeCollector]);
+  const collectorLayer = evidenceCollectorLayer(collector);
+  const sessionLayer = runSessionLayer(session);
+  const buildEnvConfig = options?.buildEnv?.config;
+  const buildEnvLayer = layer2({
+    runtimeHostKind: options?.buildEnv?.hostKind,
+    config: buildEnvConfig,
+    configProvider: options?.buildEnv?.configProvider
+  });
+  const trialLayer = Layer4.mergeAll(
+    buildEnvLayer,
+    options?.layer ?? Layer4.empty,
+    sessionLayer,
+    collectorLayer,
+    diagnosticsLayer,
+    sinksLayer,
+    convergeLayer
+  );
+  const kernel = yield* makeProgramRunnerKernel(
+    (impl) => make2(impl, {
+      layer: trialLayer
+      // trial-run does not enable devtools by default; diagnostics is controlled by diagnosticsLevel.
+    }),
+    rootImpl
+  );
+  const identity = kernel.identity;
+  const bootFiber = kernel.runtime.runFork(rootImpl.module);
+  const bootExit = yield* awaitFiberExitWithTimeout(bootFiber, options?.trialRunTimeoutMs);
+  let kernelImplementationRef;
+  let runtimeServicesEvidence;
+  let instanceId;
+  if (Exit.isSuccess(bootExit)) {
+    const moduleRuntime = bootExit.value;
+    instanceId = typeof moduleRuntime?.instanceId === "string" && moduleRuntime.instanceId.length > 0 ? moduleRuntime.instanceId : void 0;
+    kernel.setInstanceId(instanceId);
+    try {
+      kernelImplementationRef = getKernelImplementationRef(moduleRuntime);
+    } catch {
+      kernelImplementationRef = void 0;
+    }
+    if (resolvedDiagnosticsLevel !== "off") {
+      try {
+        runtimeServicesEvidence = getRuntimeServicesEvidence(moduleRuntime);
+      } catch {
+        runtimeServicesEvidence = void 0;
+      }
+    }
+  } else {
+    const failure = Cause2.failureOption(bootExit.cause);
+    if (Option.isSome(failure)) {
+      const err = failure.value;
+      const instanceIdFromErr = typeof err?.instanceId === "string" ? err.instanceId : void 0;
+      if (instanceIdFromErr && instanceIdFromErr.length > 0) {
+        kernel.setInstanceId(instanceIdFromErr);
+      }
+    }
+  }
+  const closeExit = yield* Effect4.exit(
+    kernel.close({
+      timeoutMs: typeof options?.closeScopeTimeout === "number" && Number.isFinite(options.closeScopeTimeout) && options.closeScopeTimeout > 0 ? options.closeScopeTimeout : 1e3
+    })
+  );
+  const evidence = collector.exportEvidencePackage({
+    maxEvents: options?.maxEvents ?? 1e3
+  });
+  const manifest = (() => {
+    try {
+      return extractManifest(root, {
+        includeStaticIr: true,
+        budgets: { maxBytes: 2e5 }
+      });
+    } catch {
+      return void 0;
+    }
+  })();
+  const staticIr = (() => {
+    try {
+      return exportStaticIr2(root);
+    } catch {
+      return void 0;
+    }
+  })();
+  let ok = Exit.isSuccess(bootExit) && Exit.isSuccess(closeExit);
+  let error;
+  let summary;
+  const depsFromBootFailure = Exit.isFailure(bootExit) ? parseMissingDependencyFromCause(bootExit.cause) : { missingServices: [], missingConfigKeys: [] };
+  const missingServices = depsFromBootFailure.missingServices;
+  const missingConfigKeys = depsFromBootFailure.missingConfigKeys;
+  const closeError = Exit.isFailure(closeExit) ? Option.getOrUndefined(Cause2.dieOption(closeExit.cause)) : void 0;
+  if (!Exit.isSuccess(bootExit)) {
+    const failure = Option.getOrUndefined(Cause2.failureOption(bootExit.cause));
+    const defect = Option.getOrUndefined(Cause2.dieOption(bootExit.cause));
+    const base = failure ?? defect ?? bootExit.cause;
+    if (missingServices.length > 0 || missingConfigKeys.length > 0) {
+      ok = false;
+      error = toErrorSummaryWithCode2(
+        base,
+        "MissingDependency",
+        missingServices.length > 0 ? "Build-time missing service: provide a Layer mock/implementation via options.layer, or move the dependency access to runtime." : "Build-time missing config: provide the missing key(s) in buildEnv.config, or add a default value to Config."
+      );
+    } else if (isRecord3(base) && (base.name === "TrialRunTimeoutError" || base._tag === "TrialRunTimeout")) {
+      ok = false;
+      error = toErrorSummaryWithCode2(
+        base,
+        "TrialRunTimeout",
+        "Trial run timed out: check for Layer/assembly phase blocking (Effect.never / unfinished acquire)."
+      );
+    } else {
+      ok = false;
+      error = toErrorSummaryWithCode2(base, "RuntimeFailure");
+    }
+  }
+  if (Exit.isFailure(closeExit)) {
+    const died = Option.getOrUndefined(Cause2.dieOption(closeExit.cause));
+    const failure = Option.getOrUndefined(Cause2.failureOption(closeExit.cause));
+    const base = died ?? failure ?? closeExit.cause;
+    const closeErrorSummary = (() => {
+      const tag = isRecord3(base) ? base._tag : void 0;
+      if (tag === "DisposeTimeout") {
+        return toErrorSummaryWithCode2(
+          base,
+          "DisposeTimeout",
+          "Dispose timed out: check for unclosed resource handles, fibers not interrupted, or event listeners not unregistered."
+        );
+      }
+      return toErrorSummaryWithCode2(base, "RuntimeFailure");
+    })();
+    ok = false;
+    if (!error) {
+      error = closeErrorSummary;
+    } else {
+      summary = { __logix: { closeError: closeErrorSummary } };
+    }
+  }
+  const environment = buildEnvironmentIr({
+    kernelImplementationRef,
+    runtimeServicesEvidence,
+    buildEnvConfig,
+    missingServices,
+    missingConfigKeys
+  });
+  const moduleId = typeof rootImpl.module?.id === "string" && rootImpl.module.id.length > 0 ? String(rootImpl.module.id) : manifest?.moduleId ?? "unknown";
+  const artifacts = collectTrialRunArtifacts({
+    exporters: getTrialRunArtifactExporters(rootImpl.module),
+    ctx: {
+      moduleId,
+      manifest,
+      staticIr,
+      environment
+    }
+  });
+  let report = {
+    runId: session.runId,
+    ok,
+    manifest,
+    staticIr,
+    artifacts,
+    environment,
+    evidence,
+    summary,
+    error
+  };
+  const maxBytes = options?.budgets?.maxBytes;
+  if (typeof maxBytes === "number" && Number.isFinite(maxBytes) && maxBytes > 0) {
+    const originalBytes = utf8ByteLength2(report);
+    if (originalBytes > maxBytes) {
+      report = {
+        runId: session.runId,
+        ok: false,
+        environment,
+        error: {
+          message: `[Logix] TrialRunReport exceeded maxBytes (${originalBytes} > ${maxBytes})`,
+          code: "Oversized",
+          hint: "Reduce maxEvents or budgets.maxBytes, or split manifest/evidence artifacts in CI."
+        },
+        summary: {
+          __logix: {
+            truncated: true,
+            maxBytes,
+            originalBytes,
+            dropped: ["manifest", "staticIr", "artifacts", "evidence"]
+          }
+        }
+      };
+    }
+  }
+  return report;
+});
+
+// src/internal/observability/trialRun.ts
+import { Effect as Effect5, Layer as Layer5, Scope } from "effect";
+var defaultHost2 = () => {
+  if (typeof window !== "undefined" && typeof document !== "undefined") return "browser";
+  return "node";
+};
+var trialRun = (program, options) => Effect5.gen(function* () {
+  const session = makeRunSession({
+    runId: options?.runId,
+    source: options?.source ?? { host: defaultHost2(), label: "trial-run" },
+    startedAt: options?.startedAt
+  });
+  const collector = makeEvidenceCollector(session);
+  const convergeCollector = {
+    register: (ir) => {
+      collector.registerConvergeStaticIr(ir);
+    }
+  };
+  const sinksLayer = appendSinks([collector.debugSink]);
+  const diagnosticsLayer = diagnosticsLevel(options?.diagnosticsLevel ?? "light");
+  const convergeLayer = appendConvergeStaticIrCollectors([convergeCollector]);
+  const collectorLayer = evidenceCollectorLayer(collector);
+  const sessionLayer = runSessionLayer(session);
+  const overridesLayer = options?.runtimeServicesInstanceOverrides != null ? Layer5.succeed(
+    RuntimeServicesInstanceOverridesTag,
+    options.runtimeServicesInstanceOverrides
+  ) : Layer5.empty;
+  const trialLayer = Layer5.mergeAll(
+    options?.layer ?? Layer5.empty,
+    sessionLayer,
+    collectorLayer,
+    overridesLayer,
+    diagnosticsLayer,
+    sinksLayer,
+    convergeLayer
+  );
+  const scope = yield* Scope.make();
+  const exit = yield* Effect5.exit(program).pipe(Effect5.provideService(Scope.Scope, scope), Effect5.provide(trialLayer));
+  yield* Scope.close(scope, exit);
+  const evidence = collector.exportEvidencePackage({
+    maxEvents: options?.maxEvents
+  });
+  return { session, exit, evidence };
+});
+
+export {
+  ConstructionGuard_exports,
+  RuntimeHost_exports,
+  BuildEnv_exports,
+  exportStaticIr2 as exportStaticIr,
+  extractManifest,
+  registerTrialRunArtifactExporter,
+  trialRunModule,
+  trialRun
+};
+//# sourceMappingURL=chunk-M3WTHJHJ.js.map