@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,900 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  exportStaticIr
+} from "./chunk-7KQFTS2Y.js";
+import {
+  installSourceRefresh
+} from "./chunk-3BHC6JAV.js";
+import {
+  getAtPath
+} from "./chunk-Z6LV34RO.js";
+import {
+  compareFieldPath,
+  getFieldPathId,
+  makeFieldPathIdRegistry,
+  normalizeFieldPath
+} from "./chunk-BCEO3MGD.js";
+import {
+  getBoundInternals
+} from "./chunk-F743SKYD.js";
+
+// ../logix-core/src/internal/state-trait/meta.ts
+var uniqSortedStrings = (input) => {
+  const set = /* @__PURE__ */ new Set();
+  for (const item of input) {
+    const v = item.trim();
+    if (!v) continue;
+    set.add(v);
+  }
+  return Array.from(set).sort((a, b) => a.localeCompare(b));
+};
+var isPlainRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var sanitizeJsonValue = (input, depth) => {
+  if (input === null) return null;
+  if (typeof input === "string") return input;
+  if (typeof input === "boolean") return input;
+  if (typeof input === "number") {
+    return Number.isFinite(input) ? input : void 0;
+  }
+  if (depth >= 6) return void 0;
+  if (Array.isArray(input)) {
+    const out = [];
+    for (const item of input) {
+      const v = sanitizeJsonValue(item, depth + 1);
+      if (v !== void 0) out.push(v);
+    }
+    return out;
+  }
+  if (isPlainRecord(input)) {
+    const keys = Object.keys(input).sort();
+    const out = {};
+    for (const key of keys) {
+      const v = sanitizeJsonValue(input[key], depth + 1);
+      if (v !== void 0) out[key] = v;
+    }
+    return out;
+  }
+  return void 0;
+};
+var sanitize = (input) => {
+  if (input === null || input === void 0) return void 0;
+  if (typeof input !== "object" || Array.isArray(input)) return void 0;
+  const record = input;
+  const out = {};
+  const pickString = (key) => {
+    const value = record[key];
+    if (typeof value !== "string") return;
+    const trimmed = value.trim();
+    if (!trimmed) return;
+    out[key] = trimmed;
+  };
+  pickString("label");
+  pickString("description");
+  pickString("group");
+  pickString("docsUrl");
+  pickString("cacheGroup");
+  const canonical = record.canonical;
+  if (typeof canonical === "boolean") {
+    out.canonical = canonical;
+  }
+  const tagsRaw = record.tags;
+  if (typeof tagsRaw === "string") {
+    const tags = uniqSortedStrings([tagsRaw]);
+    if (tags.length > 0) out.tags = tags;
+  } else if (Array.isArray(tagsRaw)) {
+    const tags = uniqSortedStrings(tagsRaw.filter((x) => typeof x === "string"));
+    if (tags.length > 0) out.tags = tags;
+  }
+  const annotations = {};
+  const annotationKeys = Object.keys(record).filter((k) => k.startsWith("x-")).sort((a, b) => a.localeCompare(b));
+  for (const key of annotationKeys) {
+    const v = sanitizeJsonValue(record[key], 0);
+    if (v !== void 0) annotations[key] = v;
+  }
+  const annotationsRaw = record.annotations;
+  if (isPlainRecord(annotationsRaw)) {
+    const keys = Object.keys(annotationsRaw).filter((k) => k.startsWith("x-")).sort((a, b) => a.localeCompare(b));
+    for (const key of keys) {
+      const v = sanitizeJsonValue(annotationsRaw[key], 0);
+      if (v !== void 0) annotations[key] = v;
+    }
+  }
+  if (Object.keys(annotations).length > 0) out.annotations = annotations;
+  return Object.keys(out).length > 0 ? out : void 0;
+};
+var stableStringify = (meta) => {
+  const out = {};
+  const keys = Object.keys(meta).sort();
+  for (const k of keys) {
+    out[k] = meta[k];
+  }
+  return JSON.stringify(out);
+};
+var equals = (a, b) => {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return stableStringify(a) === stableStringify(b);
+};
+var mergeCanonical = (current, incoming) => {
+  const existing = current.meta;
+  if (!existing) {
+    return {
+      meta: incoming.meta,
+      origin: incoming.origin,
+      conflicts: current.conflicts
+    };
+  }
+  if (equals(existing, incoming.meta)) {
+    return current;
+  }
+  const conflicts = [...current.conflicts ?? []];
+  const push = (conflict) => {
+    const exists = conflicts.some((c) => c.origin === conflict.origin && equals(c.meta, conflict.meta));
+    if (!exists) conflicts.push(conflict);
+  };
+  const existingCanonical = existing.canonical === true;
+  const incomingCanonical = incoming.meta.canonical === true;
+  if (!existingCanonical && incomingCanonical) {
+    push({
+      origin: current.origin ?? "unknown",
+      meta: existing
+    });
+    return {
+      meta: incoming.meta,
+      origin: incoming.origin,
+      conflicts
+    };
+  }
+  push({
+    origin: incoming.origin,
+    meta: incoming.meta
+  });
+  return {
+    meta: existing,
+    origin: current.origin ?? incoming.origin,
+    conflicts
+  };
+};
+
+// ../logix-core/src/internal/state-trait/model.ts
+var normalizeSpec = (spec) => {
+  const entries = [];
+  const isNode = (value) => typeof value === "object" && value !== null && value._tag === "StateTraitNode";
+  const isList = (value) => typeof value === "object" && value !== null && value._tag === "StateTraitList";
+  const joinPath = (prefix, suffix) => {
+    if (!prefix) return suffix;
+    if (!suffix) return prefix;
+    return `${prefix}.${suffix}`;
+  };
+  const prefixDeps = (deps, prefix) => {
+    if (!deps || deps.length === 0) return [];
+    return deps.map((d) => prefix ? joinPath(prefix, d) : d);
+  };
+  const normalizeEntry = (entry, fieldPath, depPrefix) => {
+    if (entry.kind === "computed") {
+      const meta = entry.meta;
+      const rawDeps = meta.deps;
+      const deps = rawDeps !== void 0 ? prefixDeps(rawDeps, depPrefix) : void 0;
+      return {
+        ...entry,
+        fieldPath,
+        meta: { ...meta, deps }
+      };
+    }
+    if (entry.kind === "source") {
+      const meta = entry.meta;
+      const rawDeps = meta.deps;
+      const deps = rawDeps !== void 0 ? prefixDeps(rawDeps, depPrefix) : void 0;
+      return {
+        ...entry,
+        fieldPath,
+        meta: { ...meta, deps, _fieldPath: fieldPath }
+      };
+    }
+    if (entry.kind === "link") {
+      const meta = entry.meta;
+      const from2 = prefixDeps([meta.from], depPrefix)[0] ?? meta.from;
+      return {
+        ...entry,
+        fieldPath,
+        meta: { ...meta, from: from2 }
+      };
+    }
+    return {
+      ...entry,
+      fieldPath
+    };
+  };
+  const expandNode = (scopeId, joinPrefix, node2, options) => {
+    const addEntry = (relativeTarget, raw) => {
+      const rel = raw.fieldPath ?? relativeTarget;
+      const fieldPath = joinPrefix ? joinPath(joinPrefix, String(rel)) : String(rel);
+      entries.push(normalizeEntry(raw, fieldPath, joinPrefix));
+    };
+    const expandMaybeRecord = (value) => {
+      if (!value) return;
+      if (typeof value.kind === "string") {
+        addEntry("", value);
+        return;
+      }
+      const record = value;
+      for (const key in record) {
+        if (!Object.prototype.hasOwnProperty.call(record, key)) continue;
+        const entry = record[key];
+        if (!entry) continue;
+        addEntry(key, entry);
+      }
+    };
+    expandMaybeRecord(node2.computed);
+    expandMaybeRecord(node2.source);
+    expandMaybeRecord(node2.link);
+    if (node2.check) {
+      const rules = {};
+      const checkDepsPrefix = options?.checkDepsPrefix ?? (joinPrefix.endsWith("[]") ? joinPrefix : "");
+      const prefixCheckDeps = (deps) => {
+        if (!deps || deps.length === 0) return [];
+        return deps.map((d) => d === "" ? scopeId : checkDepsPrefix ? joinPath(checkDepsPrefix, d) : d);
+      };
+      for (const name of Object.keys(node2.check)) {
+        const rule = node2.check[name];
+        if (typeof rule === "function") {
+          rules[name] = rule;
+          continue;
+        }
+        if (rule && typeof rule === "object") {
+          const meta = sanitize(rule.meta);
+          rules[name] = {
+            ...rule,
+            deps: prefixCheckDeps(rule.deps),
+            meta
+          };
+          continue;
+        }
+      }
+      entries.push({
+        fieldPath: scopeId,
+        kind: "check",
+        meta: {
+          rules,
+          writeback: { kind: "errors" }
+        }
+      });
+    }
+  };
+  for (const key in spec) {
+    if (!Object.prototype.hasOwnProperty.call(spec, key)) continue;
+    const raw = spec[key];
+    if (!raw) continue;
+    if (isList(raw)) {
+      const listPath = key;
+      if (raw.item) {
+        expandNode(`${listPath}[]`, `${listPath}[]`, raw.item);
+      }
+      if (raw.list) {
+        expandNode(listPath, listPath, raw.list, {
+          checkDepsPrefix: `${listPath}[]`
+        });
+      }
+      continue;
+    }
+    if (isNode(raw)) {
+      if (key === "$root") {
+        expandNode("$root", "", raw);
+      } else {
+        expandNode(key, key, raw);
+      }
+      continue;
+    }
+    const entry = raw;
+    const fieldPath = entry.fieldPath ?? key;
+    entries.push(normalizeEntry(entry, String(fieldPath), ""));
+  }
+  return entries;
+};
+var collectNodeMeta = (spec) => {
+  const out = /* @__PURE__ */ new Map();
+  const isNode = (value) => typeof value === "object" && value !== null && value._tag === "StateTraitNode";
+  const isList = (value) => typeof value === "object" && value !== null && value._tag === "StateTraitList";
+  const add = (scopeId, node2) => {
+    const meta = sanitize(node2.meta);
+    if (meta) out.set(scopeId, meta);
+  };
+  for (const key in spec) {
+    if (!Object.prototype.hasOwnProperty.call(spec, key)) continue;
+    const raw = spec[key];
+    if (!raw) continue;
+    if (isList(raw)) {
+      const listPath = key;
+      if (raw.item) add(`${listPath}[]`, raw.item);
+      if (raw.list) add(listPath, raw.list);
+      continue;
+    }
+    if (isNode(raw)) {
+      if (key === "$root") add("$root", raw);
+      else add(key, raw);
+      continue;
+    }
+  }
+  return out;
+};
+
+// ../logix-core/src/internal/state-trait/build.ts
+var nowPerf = () => typeof globalThis.performance !== "undefined" && typeof globalThis.performance.now === "function" ? globalThis.performance.now() : Date.now();
+var getConvergeWriterDeps = (entry) => {
+  if (entry.kind === "computed") {
+    return entry.meta?.deps ?? [];
+  }
+  return [entry.meta.from];
+};
+var computeConvergeTopoOrder = (writers) => {
+  const writerByPath = /* @__PURE__ */ new Map();
+  for (const entry of writers) {
+    const existing = writerByPath.get(entry.fieldPath);
+    if (existing) {
+      return {
+        order: [],
+        configError: {
+          code: "MULTIPLE_WRITERS",
+          message: `[StateTrait.converge] Multiple writers for field "${entry.fieldPath}" (${existing.kind} + ${entry.kind}).`,
+          fields: [entry.fieldPath]
+        }
+      };
+    }
+    writerByPath.set(entry.fieldPath, entry);
+  }
+  const nodes = /* @__PURE__ */ new Set();
+  for (const entry of writers) {
+    nodes.add(entry.fieldPath);
+  }
+  const indegree = /* @__PURE__ */ new Map();
+  const forward = /* @__PURE__ */ new Map();
+  for (const node2 of nodes) {
+    indegree.set(node2, 0);
+    forward.set(node2, []);
+  }
+  for (const entry of writers) {
+    const to = entry.fieldPath;
+    const deps = getConvergeWriterDeps(entry);
+    for (const dep of deps) {
+      if (!nodes.has(dep)) continue;
+      forward.get(dep).push(to);
+      indegree.set(to, (indegree.get(to) ?? 0) + 1);
+    }
+  }
+  const queue = [];
+  for (const [node2, deg] of indegree.entries()) {
+    if (deg === 0) queue.push(node2);
+  }
+  const order = [];
+  while (queue.length) {
+    const n = queue.shift();
+    order.push(n);
+    const outs = forward.get(n);
+    for (const to of outs) {
+      const next = (indegree.get(to) ?? 0) - 1;
+      indegree.set(to, next);
+      if (next === 0) queue.push(to);
+    }
+  }
+  if (order.length !== nodes.size) {
+    const remaining = Array.from(nodes).filter((n) => !order.includes(n));
+    return {
+      order: [],
+      configError: {
+        code: "CYCLE_DETECTED",
+        message: `[StateTrait.converge] Cycle detected in computed/link graph: ${remaining.join(", ")}`,
+        fields: remaining
+      }
+    };
+  }
+  return { order };
+};
+var buildConvergeIr = (entries) => {
+  const startedAt = nowPerf();
+  const generation = 0;
+  const writers = entries.filter((e) => e.kind === "computed" || e.kind === "link");
+  const writersKey = writers.map((entry) => `${entry.kind}:${entry.fieldPath}`).sort().join("|");
+  const depsKey = writers.map((entry) => {
+    const deps = getConvergeWriterDeps(entry).slice().sort().join(",");
+    const scheduling = entry.meta?.scheduling === "deferred" ? "d" : "i";
+    return `${entry.kind}:${entry.fieldPath}@${scheduling}=>${deps}`;
+  }).sort().join("|");
+  const writerByPath = /* @__PURE__ */ new Map();
+  for (const entry of writers) {
+    writerByPath.set(entry.fieldPath, entry);
+  }
+  const topo = writers.length > 0 ? computeConvergeTopoOrder(writers) : { order: [] };
+  const stepsById = topo.configError ? [] : topo.order.map((path) => writerByPath.get(path));
+  const fieldPathTable = /* @__PURE__ */ new Map();
+  const addPath = (path) => {
+    for (let i = 1; i <= path.length; i++) {
+      const prefix = path.slice(0, i);
+      const key = JSON.stringify(prefix);
+      if (!fieldPathTable.has(key)) fieldPathTable.set(key, prefix);
+    }
+  };
+  for (const entry of writers) {
+    const out = normalizeFieldPath(entry.fieldPath);
+    if (out) addPath(out);
+    for (const dep of getConvergeWriterDeps(entry)) {
+      const depPath = normalizeFieldPath(dep);
+      if (depPath) addPath(depPath);
+    }
+  }
+  const fieldPaths = Array.from(fieldPathTable.values()).sort(compareFieldPath);
+  const fieldPathIdRegistry = makeFieldPathIdRegistry(fieldPaths);
+  const stepOutFieldPathIdByStepId = [];
+  const stepDepsFieldPathIdsByStepId = [];
+  const stepSchedulingByStepId = [];
+  for (const entry of stepsById) {
+    const out = normalizeFieldPath(entry.fieldPath);
+    const outId = out != null ? getFieldPathId(fieldPathIdRegistry, out) : void 0;
+    if (outId == null) {
+      throw new Error(`[StateTrait.build] Failed to map converge output fieldPath "${entry.fieldPath}" to FieldPathId.`);
+    }
+    const depIds = [];
+    for (const dep of getConvergeWriterDeps(entry)) {
+      const depPath = normalizeFieldPath(dep);
+      if (!depPath) continue;
+      const depId = getFieldPathId(fieldPathIdRegistry, depPath);
+      if (depId != null) depIds.push(depId);
+    }
+    stepOutFieldPathIdByStepId.push(outId);
+    stepDepsFieldPathIdsByStepId.push(depIds);
+    stepSchedulingByStepId.push(entry.meta?.scheduling === "deferred" ? "deferred" : "immediate");
+  }
+  const topoOrder = stepsById.map((_, i) => i);
+  const buildDurationMs = Math.max(0, nowPerf() - startedAt);
+  return {
+    generation,
+    writersKey,
+    depsKey,
+    fieldPaths,
+    fieldPathIdRegistry,
+    ...topo.configError ? { configError: topo.configError } : null,
+    stepsById,
+    stepOutFieldPathIdByStepId,
+    stepDepsFieldPathIdsByStepId,
+    stepSchedulingByStepId,
+    topoOrder,
+    buildDurationMs
+  };
+};
+var toFieldTrait = (entry) => {
+  const deps = [];
+  if (entry.kind === "computed") {
+    const meta = entry.meta;
+    const list2 = meta.deps;
+    if (list2) deps.push(...list2);
+  } else if (entry.kind === "source") {
+    const meta = entry.meta;
+    const list2 = meta.deps;
+    if (list2) deps.push(...list2);
+  } else if (entry.kind === "link") {
+    deps.push(entry.meta.from);
+  } else if (entry.kind === "check") {
+    const meta = entry.meta;
+    const rules = meta?.rules ?? {};
+    for (const name of Object.keys(rules)) {
+      const rule = rules[name];
+      if (rule && typeof rule === "object") {
+        const list2 = rule.deps;
+        if (list2) deps.push(...list2);
+      }
+    }
+  }
+  return {
+    fieldId: entry.fieldPath,
+    kind: entry.kind,
+    // meta 在运行时保持与 Entry.meta 一致，便于 install 直接复用。
+    meta: entry.meta,
+    deps
+  };
+};
+var buildGraph = (entries, nodeMetaByFieldPath) => {
+  const fieldMap = /* @__PURE__ */ new Map();
+  const nodes = [];
+  const edges = [];
+  const resourcesById = /* @__PURE__ */ new Map();
+  const planSteps = [];
+  const ensureField = (fieldPath) => {
+    let field = fieldMap.get(fieldPath);
+    if (!field) {
+      field = {
+        id: fieldPath,
+        path: fieldPath,
+        traits: []
+      };
+      fieldMap.set(fieldPath, field);
+    }
+    return field;
+  };
+  for (const entry of entries) {
+    const fieldPath = entry.fieldPath;
+    const field = ensureField(fieldPath);
+    const trait = toFieldTrait(entry);
+    field.traits.push(trait);
+    if (entry.kind === "computed") {
+      const stepId = `computed:${fieldPath}`;
+      planSteps.push({
+        id: stepId,
+        kind: "computed-update",
+        targetFieldPath: fieldPath
+        // 说明：当前版本不静态分析 computed 依赖字段，sourceFieldPaths 留空。
+      });
+      const deps = entry.meta.deps;
+      if (deps) {
+        for (const dep of deps) {
+          ensureField(dep);
+          edges.push({
+            id: `computed:${dep}->${fieldPath}`,
+            from: dep,
+            to: fieldPath,
+            kind: "computed"
+          });
+        }
+      }
+    } else if (entry.kind === "link") {
+      const from2 = entry.meta.from;
+      ensureField(from2);
+      const edgeId = `link:${from2}->${fieldPath}`;
+      edges.push({
+        id: edgeId,
+        from: from2,
+        to: fieldPath,
+        kind: "link"
+      });
+      planSteps.push({
+        id: `link:${fieldPath}`,
+        kind: "link-propagate",
+        targetFieldPath: fieldPath,
+        sourceFieldPaths: [from2],
+        debugInfo: {
+          graphEdgeId: edgeId
+        }
+      });
+    } else if (entry.kind === "source") {
+      const resourceId = entry.meta.resource;
+      const resourceMeta = sanitize(entry.meta.meta);
+      const existing = resourcesById.get(resourceId);
+      if (existing) {
+        const ownerFields = [...existing.ownerFields, fieldPath];
+        let meta = existing.meta;
+        let metaOrigin = existing.metaOrigin;
+        let metaConflicts = existing.metaConflicts;
+        if (resourceMeta) {
+          const merged = mergeCanonical(
+            { meta, origin: metaOrigin, conflicts: metaConflicts },
+            { origin: fieldPath, meta: resourceMeta }
+          );
+          meta = merged.meta;
+          metaOrigin = merged.origin;
+          metaConflicts = merged.conflicts;
+        }
+        resourcesById.set(resourceId, {
+          ...existing,
+          ownerFields,
+          meta,
+          metaOrigin,
+          metaConflicts
+        });
+      } else {
+        resourcesById.set(resourceId, {
+          resourceId,
+          // 暂时使用简单的标识字符串，后续可根据 key 规则进一步结构化。
+          keySelector: `StateTrait.source@${fieldPath}`,
+          ownerFields: [fieldPath],
+          meta: resourceMeta,
+          metaOrigin: resourceMeta ? fieldPath : void 0
+        });
+      }
+      planSteps.push({
+        id: `source:${fieldPath}`,
+        kind: "source-refresh",
+        targetFieldPath: fieldPath,
+        resourceId,
+        keySelectorId: `StateTrait.source@${fieldPath}`
+      });
+      const deps = entry.meta.deps;
+      if (deps) {
+        for (const dep of deps) {
+          ensureField(dep);
+          edges.push({
+            id: `source-dep:${dep}->${fieldPath}`,
+            from: dep,
+            to: fieldPath,
+            kind: "source-dep"
+          });
+        }
+      }
+    } else if (entry.kind === "check") {
+      planSteps.push({
+        id: `check:${fieldPath}`,
+        kind: "check-validate",
+        targetFieldPath: fieldPath
+      });
+      if (trait.deps.length > 0) {
+        for (const dep of trait.deps) {
+          ensureField(dep);
+          edges.push({
+            id: `check-dep:${dep}->${fieldPath}`,
+            from: dep,
+            to: fieldPath,
+            kind: "check-dep"
+          });
+        }
+      }
+    }
+  }
+  for (const field of fieldMap.values()) {
+    nodes.push({
+      id: field.id,
+      field,
+      traits: field.traits,
+      meta: nodeMetaByFieldPath.get(field.id)
+    });
+  }
+  const graph = {
+    _tag: "StateTraitGraph",
+    nodes,
+    edges,
+    resources: Array.from(resourcesById.values())
+  };
+  const plan = {
+    _tag: "StateTraitPlan",
+    steps: planSteps
+  };
+  return { graph, plan };
+};
+var assertNoLinkCycles = (edges) => {
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    if (edge.kind !== "link") continue;
+    const list2 = adjacency.get(edge.from) ?? [];
+    list2.push(edge.to);
+    adjacency.set(edge.from, list2);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const stack = /* @__PURE__ */ new Set();
+  const dfs = (node2) => {
+    if (stack.has(node2)) {
+      throw new Error(
+        `[StateTrait.build] link cycle detected at field "${node2}". Please check link traits for circular dependencies.`
+      );
+    }
+    if (visited.has(node2)) return;
+    visited.add(node2);
+    stack.add(node2);
+    const nexts = adjacency.get(node2);
+    if (nexts) {
+      for (const to of nexts) {
+        dfs(to);
+      }
+    }
+    stack.delete(node2);
+  };
+  for (const node2 of adjacency.keys()) {
+    if (!visited.has(node2)) {
+      dfs(node2);
+    }
+  }
+};
+var collectSchemaPaths = (entries) => {
+  const byKey = /* @__PURE__ */ new Map();
+  const add = (ref) => {
+    if (!ref.path) return;
+    const k = `${ref.kind}|${ref.entryKind}|${ref.entryFieldPath}|${ref.ruleName ?? ""}|${ref.path}`;
+    byKey.set(k, ref);
+  };
+  const getCheckWritebackPath = (entry) => {
+    const wb = entry.meta?.writeback;
+    const p = wb && typeof wb === "object" ? wb.path : void 0;
+    const writebackPath = typeof p === "string" && p.startsWith("errors.") ? p : void 0;
+    if (writebackPath) return writebackPath;
+    const fieldPath = entry.fieldPath;
+    if (fieldPath.endsWith("[]")) {
+      return `errors.${fieldPath.slice(0, -2)}`;
+    }
+    return `errors.${fieldPath}`;
+  };
+  for (const entry of entries) {
+    add({
+      kind: "fieldPath",
+      entryKind: entry.kind,
+      entryFieldPath: entry.fieldPath,
+      path: entry.fieldPath
+    });
+    if (entry.kind === "computed" || entry.kind === "source") {
+      const deps = entry.meta?.deps ?? [];
+      for (const dep of deps) {
+        add({
+          kind: "dep",
+          entryKind: entry.kind,
+          entryFieldPath: entry.fieldPath,
+          path: dep
+        });
+      }
+    }
+    if (entry.kind === "link") {
+      add({
+        kind: "link_from",
+        entryKind: "link",
+        entryFieldPath: entry.fieldPath,
+        path: entry.meta.from
+      });
+    }
+    if (entry.kind === "check") {
+      add({
+        kind: "check_writeback",
+        entryKind: "check",
+        entryFieldPath: entry.fieldPath,
+        path: getCheckWritebackPath(entry)
+      });
+      const rules = entry.meta?.rules ?? {};
+      for (const name of Object.keys(rules)) {
+        const rule = rules[name];
+        if (!rule || typeof rule !== "object") continue;
+        const deps = rule.deps ?? [];
+        for (const dep of deps) {
+          add({
+            kind: "dep",
+            entryKind: "check",
+            entryFieldPath: entry.fieldPath,
+            ruleName: name,
+            path: dep
+          });
+        }
+      }
+    }
+  }
+  return Array.from(byKey.entries()).sort((a, b) => a[0].localeCompare(b[0])).map(([, v]) => v);
+};
+var build = (stateSchema, spec) => {
+  const entries = normalizeSpec(spec);
+  const nodeMetaByFieldPath = collectNodeMeta(spec);
+  for (const entry of entries) {
+    if (entry.kind === "computed") {
+      const deps = entry.meta.deps;
+      if (deps === void 0) {
+        throw new Error(
+          `[StateTrait.build] Missing explicit deps for computed "${entry.fieldPath}". Please use StateTrait.computed({ deps: [...], get: ... }).`
+        );
+      }
+    }
+    if (entry.kind === "source") {
+      const deps = entry.meta.deps;
+      if (deps === void 0) {
+        throw new Error(
+          `[StateTrait.build] Missing explicit deps for source "${entry.fieldPath}". Please provide meta.deps for StateTrait.source({ deps: [...], ... }).`
+        );
+      }
+    }
+    if (entry.kind === "check") {
+      const rules = entry.meta?.rules ?? {};
+      for (const name of Object.keys(rules)) {
+        const rule = rules[name];
+        if (typeof rule === "function" || !rule || typeof rule !== "object") {
+          throw new Error(
+            `[StateTrait.build] Missing explicit deps for check "${entry.fieldPath}" rule "${name}". Please use { deps: [...], validate: ... } form.`
+          );
+        }
+        if (rule.deps === void 0) {
+          throw new Error(
+            `[StateTrait.build] Missing explicit deps for check "${entry.fieldPath}" rule "${name}". Please provide deps: [...].`
+          );
+        }
+      }
+    }
+  }
+  const { graph, plan } = buildGraph(entries, nodeMetaByFieldPath);
+  assertNoLinkCycles(graph.edges);
+  return {
+    stateSchema,
+    spec,
+    entries,
+    graph,
+    plan,
+    convergeIr: buildConvergeIr(entries),
+    schemaPaths: collectSchemaPaths(entries)
+  };
+};
+
+// ../logix-core/src/internal/state-trait/install.ts
+import { Effect } from "../effect.js";
+var buildEntryIndex = (entries) => {
+  const index = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const list2 = index.get(entry.fieldPath) ?? [];
+    list2.push(entry);
+    index.set(entry.fieldPath, list2);
+  }
+  return index;
+};
+var install = (bound, program) => {
+  try {
+    const internals = getBoundInternals(bound);
+    internals.traits.registerStateTraitProgram(program, {
+      bumpReason: "logic_installed"
+    });
+  } catch {
+  }
+  const entryIndex = buildEntryIndex(program.entries);
+  const installStep = (step) => {
+    if (!step.targetFieldPath) {
+      return Effect.void;
+    }
+    if (step.kind !== "source-refresh") {
+      return Effect.void;
+    }
+    const candidates = entryIndex.get(step.targetFieldPath);
+    if (!candidates || candidates.length === 0) {
+      return Effect.void;
+    }
+    const entry = candidates.find((e) => e.kind === "source");
+    if (!entry) {
+      return Effect.void;
+    }
+    return installSourceRefresh(bound, step, entry);
+  };
+  return Effect.forEach(program.plan.steps, (step) => installStep(step)).pipe(Effect.asVoid);
+};
+
+// ../logix-core/src/StateTrait.ts
+var $root = "$root";
+var from = (_schema) => (spec) => spec;
+var node = (spec) => ({
+  _tag: "StateTraitNode",
+  ...spec
+});
+var list = (spec) => ({
+  _tag: "StateTraitList",
+  ...spec
+});
+var computed = (input) => {
+  const derive = (state) => {
+    const args = input.deps.map((dep) => getAtPath(state, dep));
+    return input.get(...args);
+  };
+  return {
+    fieldPath: void 0,
+    kind: "computed",
+    meta: {
+      deps: input.deps,
+      derive,
+      equals: input.equals,
+      ...input.scheduling ? { scheduling: input.scheduling } : {}
+    }
+  };
+};
+var source = (meta) => ({
+  fieldPath: void 0,
+  kind: "source",
+  meta
+});
+var link = (meta) => ({
+  fieldPath: void 0,
+  kind: "link",
+  meta: { ...meta, ...meta.scheduling ? { scheduling: meta.scheduling } : {} }
+});
+var build2 = (stateSchema, spec) => build(stateSchema, spec);
+var install2 = (bound, program) => install(bound, program);
+var exportStaticIr2 = (program, moduleId, options) => exportStaticIr({
+  program,
+  moduleId,
+  version: options?.version
+});
+
+export {
+  $root,
+  from,
+  node,
+  list,
+  computed,
+  source,
+  link,
+  build2 as build,
+  install2 as install,
+  exportStaticIr2 as exportStaticIr
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/state-trait/meta.ts", "../../../../logix-core/src/internal/state-trait/model.ts", "../../../../logix-core/src/internal/state-trait/build.ts", "../../../../logix-core/src/internal/state-trait/install.ts", "../../../../logix-core/src/StateTrait.ts"],
  "sourcesContent": ["export type TraitMeta = Readonly<{\n  readonly label?: string\n  readonly description?: string\n  readonly tags?: ReadonlyArray<string>\n  readonly group?: string\n  readonly docsUrl?: string\n  readonly cacheGroup?: string\n  /**\n   * \u6269\u5C55\u6CE8\u89E3\u4F4D\uFF1A\u4EC5\u63A5\u53D7 `x-*` key\uFF08\u7528\u4E8E Phantom Source / Drift Detection \u7B49\u80FD\u529B\u7684\u951A\u70B9\uFF09\u3002\n   *\n   * \u7EA6\u675F\uFF1A\n   * - \u5FC5\u987B\u53EF\u5E8F\u5217\u5316\uFF08JSON \u503C\uFF09\uFF1B\n   * - \u5FC5\u987B Slim\uFF08\u5EFA\u8BAE\u53EA\u653E\u5C11\u91CF\u5173\u952E\u63D0\u793A\uFF0C\u4E0D\u8981\u585E\u5927\u5BF9\u8C61\uFF09\u3002\n   */\n  readonly annotations?: Readonly<Record<string, JsonValue>>\n  /**\n   * \u8BED\u4E49\u63D0\u793A\uFF1A\u5F53\u540C\u4E00\u5B9E\u4F53\uFF08\u4F8B\u5982\u540C\u4E00 resourceId\uFF09\u51FA\u73B0\u591A\u5904 meta \u58F0\u660E\u4E14\u4E0D\u4E00\u81F4\u65F6\uFF0C\n   * canonical=true \u7684\u58F0\u660E\u4F18\u5148\u6210\u4E3A\u201C\u5C55\u793A\u7528 canonical\u201D\uFF1B\u5176\u4ED6\u58F0\u660E\u4F1A\u8BB0\u5F55\u4E3A conflicts\u3002\n   */\n  readonly canonical?: boolean\n}>\n\nexport type TraitMetaConflict = Readonly<{\n  readonly origin: string\n  readonly meta: TraitMeta\n}>\n\nexport type JsonPrimitive = string | number | boolean | null\nexport type JsonValue = JsonPrimitive | ReadonlyArray<JsonValue> | { readonly [key: string]: JsonValue }\n\nconst uniqSortedStrings = (input: ReadonlyArray<string>): ReadonlyArray<string> => {\n  const set = new Set<string>()\n  for (const item of input) {\n    const v = item.trim()\n    if (!v) continue\n    set.add(v)\n  }\n  return Array.from(set).sort((a, b) => a.localeCompare(b))\n}\n\nconst isPlainRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value)\n\nconst sanitizeJsonValue = (input: unknown, depth: number): JsonValue | undefined => {\n  if (input === null) return null\n\n  if (typeof input === 'string') return input\n  if (typeof input === 'boolean') return input\n  if (typeof input === 'number') {\n    return Number.isFinite(input) ? input : undefined\n  }\n\n  if (depth >= 6) return undefined\n\n  if (Array.isArray(input)) {\n    const out: Array<JsonValue> = []\n    for (const item of input) {\n      const v = sanitizeJsonValue(item, depth + 1)\n      if (v !== undefined) out.push(v)\n    }\n    return out\n  }\n\n  if (isPlainRecord(input)) {\n    const keys = Object.keys(input).sort()\n    const out: Record<string, JsonValue> = {}\n    for (const key of keys) {\n      const v = sanitizeJsonValue(input[key], depth + 1)\n      if (v !== undefined) out[key] = v\n    }\n    return out\n  }\n\n  return undefined\n}\n\nexport const sanitize = (input: unknown): TraitMeta | undefined => {\n  if (input === null || input === undefined) return undefined\n  if (typeof input !== 'object' || Array.isArray(input)) return undefined\n\n  const record = input as Record<string, unknown>\n  const out: Record<string, unknown> = {}\n\n  const pickString = (key: keyof TraitMeta): void => {\n    const value = record[key as string]\n    if (typeof value !== 'string') return\n    const trimmed = value.trim()\n    if (!trimmed) return\n    out[key] = trimmed\n  }\n\n  pickString('label')\n  pickString('description')\n  pickString('group')\n  pickString('docsUrl')\n  pickString('cacheGroup')\n\n  const canonical = record.canonical\n  if (typeof canonical === 'boolean') {\n    out.canonical = canonical\n  }\n\n  const tagsRaw = record.tags\n  if (typeof tagsRaw === 'string') {\n    const tags = uniqSortedStrings([tagsRaw])\n    if (tags.length > 0) out.tags = tags\n  } else if (Array.isArray(tagsRaw)) {\n    const tags = uniqSortedStrings(tagsRaw.filter((x): x is string => typeof x === 'string'))\n    if (tags.length > 0) out.tags = tags\n  }\n\n  const annotations: Record<string, JsonValue> = {}\n\n  // legacy: allow passing `x-*` keys at the top-level (untyped input), then normalize into `annotations`.\n  const annotationKeys = Object.keys(record)\n    .filter((k) => k.startsWith('x-'))\n    .sort((a, b) => a.localeCompare(b))\n  for (const key of annotationKeys) {\n    const v = sanitizeJsonValue(record[key], 0)\n    if (v !== undefined) annotations[key] = v\n  }\n\n  // preferred: typed `annotations` field (only accepts `x-*` keys).\n  const annotationsRaw = record.annotations\n  if (isPlainRecord(annotationsRaw)) {\n    const keys = Object.keys(annotationsRaw)\n      .filter((k) => k.startsWith('x-'))\n      .sort((a, b) => a.localeCompare(b))\n    for (const key of keys) {\n      const v = sanitizeJsonValue(annotationsRaw[key], 0)\n      if (v !== undefined) annotations[key] = v\n    }\n  }\n\n  if (Object.keys(annotations).length > 0) out.annotations = annotations\n\n  return Object.keys(out).length > 0 ? (out as TraitMeta) : undefined\n}\n\nconst stableStringify = (meta: TraitMeta): string => {\n  const out: Record<string, unknown> = {}\n  const keys = Object.keys(meta).sort()\n  for (const k of keys) {\n    out[k] = (meta as any)[k]\n  }\n  return JSON.stringify(out)\n}\n\nexport const equals = (a: TraitMeta | undefined, b: TraitMeta | undefined): boolean => {\n  if (a === b) return true\n  if (!a || !b) return false\n  return stableStringify(a) === stableStringify(b)\n}\n\nexport type CanonicalMergeInput = Readonly<{\n  readonly meta?: TraitMeta\n  readonly origin?: string\n  readonly conflicts?: ReadonlyArray<TraitMetaConflict>\n}>\n\nexport type CanonicalMergeResult = Readonly<{\n  readonly meta?: TraitMeta\n  readonly origin?: string\n  readonly conflicts?: ReadonlyArray<TraitMetaConflict>\n}>\n\nexport const mergeCanonical = (\n  current: CanonicalMergeInput,\n  incoming: Readonly<{ readonly origin: string; readonly meta: TraitMeta }>,\n): CanonicalMergeResult => {\n  const existing = current.meta\n  if (!existing) {\n    return {\n      meta: incoming.meta,\n      origin: incoming.origin,\n      conflicts: current.conflicts,\n    }\n  }\n\n  if (equals(existing, incoming.meta)) {\n    return current\n  }\n\n  const conflicts: Array<TraitMetaConflict> = [...((current.conflicts ?? []) as ReadonlyArray<TraitMetaConflict>)]\n\n  const push = (conflict: TraitMetaConflict): void => {\n    const exists = conflicts.some((c) => c.origin === conflict.origin && equals(c.meta, conflict.meta))\n    if (!exists) conflicts.push(conflict)\n  }\n\n  const existingCanonical = existing.canonical === true\n  const incomingCanonical = incoming.meta.canonical === true\n\n  if (!existingCanonical && incomingCanonical) {\n    push({\n      origin: current.origin ?? 'unknown',\n      meta: existing,\n    })\n    return {\n      meta: incoming.meta,\n      origin: incoming.origin,\n      conflicts,\n    }\n  }\n\n  push({\n    origin: incoming.origin,\n    meta: incoming.meta,\n  })\n\n  return {\n    meta: existing,\n    origin: current.origin ?? incoming.origin,\n    conflicts,\n  }\n}\n", "import type { Schema } from 'effect'\nimport type { StateAtPath, StateFieldPath } from './field-path.js'\nimport type { DirtyAllReason } from '../field-path.js'\nimport * as Meta from './meta.js'\nimport type { ConvergeStaticIrRegistry } from './converge-ir.js'\nimport type { ConvergeExecIr } from './converge-exec-ir.js'\n\n// StateTrait core model\u3002\n// \u5177\u4F53\u5B57\u6BB5\u8BED\u4E49\u4E0E data-model.md / references/state-trait-core.md \u4FDD\u6301\u5BF9\u9F50\u3002\n\n/**\n * StateTraitSpec<S>\uFF1A\n * - Module \u56FE\u7EB8\u4E2D traits \u69FD\u4F4D\u7684\u6807\u51C6\u5F62\u6001\uFF1B\n * - key \u53D7 StateFieldPath<S> \u7EA6\u675F\uFF0Cvalue \u4E3A\u5BF9\u5E94 scope \u7684\u58F0\u660E\uFF08Entry / Node / List\uFF09\u3002\n */\nexport type StateTraitSpec<S> = S extends object\n  ? {\n      [Path in StateFieldPath<S> | '$root']?: StateTraitSpecValue<S, Path>\n    }\n  : never\n\nexport type StateTraitKind = 'computed' | 'source' | 'link' | 'check'\n\n/**\n * TraitConvergeScheduling\uFF1A\n * - \u7528\u4E8E converge/dirty-check \u7684\u8C03\u5EA6\u8BED\u4E49\uFF08043\uFF09\uFF1A\u51B3\u5B9A\u8BE5 step \u5728\u6BCF\u4E2A\u4E8B\u52A1\u7A97\u53E3\u5185\u662F\u5426\u5FC5\u987B\u6536\u655B\uFF1B\n * - \u9ED8\u8BA4 `immediate`\uFF08\u4FDD\u6301\u65E2\u6709\u884C\u4E3A\uFF09\uFF1B`deferred` \u4EC5\u5728\u663E\u5F0F\u58F0\u660E + time-slicing \u542F\u7528\u65F6\u751F\u6548\u3002\n */\nexport type TraitConvergeScheduling = 'immediate' | 'deferred'\n\nexport interface ComputedMeta<S, P> {\n  /**\n   * \u663E\u5F0F\u4F9D\u8D56\u5B57\u6BB5\u8DEF\u5F84\u96C6\u5408\uFF08\u5FC5\u987B\uFF09\uFF1A\n   *\n   * - deps \u662F\u552F\u4E00\u4F9D\u8D56\u4E8B\u5B9E\u6E90\uFF1AGraph/ReverseClosure/\u589E\u91CF\u8C03\u5EA6/\u6027\u80FD\u4F18\u5316\u90FD\u53EA\u8BA4 deps\uFF1B\n   * - DSL \u4FA7 `StateTrait.computed({ deps, get })` \u7684 `get` \u91C7\u7528 deps-as-args\uFF0C\u4E0D\u66B4\u9732 `(state) => ...`\uFF1B\n   * - build \u9636\u6BB5\u4F1A\u5C06 `get(...depsValues)` \u964D\u89E3\u4E3A `derive(state)` \u4F9B\u8FD0\u884C\u65F6\u6267\u884C\uFF0C\u4F46\u4F9D\u8D56\u8BFB\u96C6\u4ECD\u4EE5 deps \u4E3A\u51C6\uFF1B\n   * - dev-mode \u4E0B\u82E5 `derive(state)` \u7684\u5B9E\u9645\u8BFB\u53D6\u4E0E deps \u4E0D\u4E00\u81F4\uFF0C\u4F1A\u4EA7\u751F `deps_mismatch` \u8BCA\u65AD\u544A\u8B66\u3002\n   *\n   * - \u5BF9\u4E8E Root \u89C4\u5219\uFF1Adeps \u4E3A StateFieldPath<State>\uFF1B\n   * - \u5BF9\u4E8E list.item scope\uFF1Adeps \u4E3A StateFieldPath<Item>\uFF08\u76F8\u5BF9\u8DEF\u5F84\uFF0Cbuild \u9636\u6BB5\u4F1A\u524D\u7F00\u5316\uFF09\u3002\n   */\n  readonly deps: ReadonlyArray<StateFieldPath<S>>\n  readonly derive: (state: Readonly<S>) => StateAtPath<S, P>\n  /**\n   * \u53EF\u9009\uFF1A\u7B49\u4EF7\u5224\u5B9A\uFF08\u7528\u4E8E\u8DF3\u8FC7\u65E0\u53D8\u5316\u5199\u56DE\uFF09\u3002\n   */\n  readonly equals?: (prev: StateAtPath<S, P>, next: StateAtPath<S, P>) => boolean\n  /**\n   * converge \u8C03\u5EA6\u7B56\u7565\uFF08043\uFF09\uFF1A\u9ED8\u8BA4 immediate\u3002\n   */\n  readonly scheduling?: TraitConvergeScheduling\n}\n\nexport interface SourceMeta<S, P> {\n  readonly deps: ReadonlyArray<StateFieldPath<S>>\n  /**\n   * \u903B\u8F91\u8D44\u6E90\u6807\u8BC6\uFF08\u5982 \"user/profile\"\uFF09\u3002\n   *\n   * - StateTrait.source DSL \u4E2D\u7684 `resource` \u5B57\u6BB5\u5728 build \u9636\u6BB5\u4F1A\u843D\u5728\u6B64\u5904\uFF1B\n   * - data-model.md \u4E2D\u8BB0\u4E3A resourceId\uFF0C\u8FD9\u91CC\u6CBF\u7528 DSL \u547D\u540D\u907F\u514D\u6DF7\u6DC6\u3002\n   */\n  readonly resource: string\n  /**\n   * \u4ECE\u5B8C\u6574 State \u8BA1\u7B97\u8BBF\u95EE\u8BE5\u8D44\u6E90\u6240\u9700 key \u7684\u89C4\u5219\u3002\n   *\n   * - \u5141\u8BB8\u8FD4\u56DE undefined\uFF1A\u8868\u793A\u8BE5\u8D44\u6E90\u5728\u5F53\u524D state \u4E0B\u672A\u6FC0\u6D3B\uFF08\u5E94\u56DE\u6536\u4E3A idle\uFF09\u3002\n   */\n  readonly key: (state: Readonly<S>) => unknown\n  readonly triggers?: ReadonlyArray<'onMount' | 'onValueChange' | 'manual'>\n  readonly debounceMs?: number\n  readonly concurrency?: 'switch' | 'exhaust-trailing'\n  /**\n   * \u7528\u4E8E Devtools/\u6587\u6863\u7684\u53EF\u5E8F\u5217\u5316\u5143\u4FE1\u606F\uFF08\u767D\u540D\u5355\u5B57\u6BB5\uFF09\u3002\n   */\n  readonly meta?: Meta.TraitMeta\n  /**\n   * \u9884\u7559\uFF1A\u5728 build \u9636\u6BB5\u53EF\u586B\u5145\u8BE5 Trait \u6240\u5728\u5B57\u6BB5\u8DEF\u5F84\uFF0C\u4FBF\u4E8E\u8C03\u8BD5\u3002\n   */\n  readonly _fieldPath?: P\n}\n\nexport interface LinkMeta<S> {\n  /**\n   * \u6E90\u5B57\u6BB5\u8DEF\u5F84\uFF0C\u540C\u6837\u53D7 StateFieldPath<S> \u7EA6\u675F\u3002\n   */\n  readonly from: StateFieldPath<S>\n  /**\n   * converge \u8C03\u5EA6\u7B56\u7565\uFF08043\uFF09\uFF1A\u9ED8\u8BA4 immediate\u3002\n   */\n  readonly scheduling?: TraitConvergeScheduling\n}\n\nexport type CheckRule<Input = unknown, Ctx = unknown> = {\n  readonly deps: ReadonlyArray<string>\n  /**\n   * validateOn\uFF1A\n   * - \u4EC5\u5F71\u54CD\u81EA\u52A8\u6821\u9A8C\u9636\u6BB5\uFF08onChange/onBlur\uFF09\uFF1Bsubmit/manual \u59CB\u7EC8\u6267\u884C\uFF1B\n   * - \u4E3A\u7A7A\u6570\u7EC4\u8868\u793A\u7981\u7528\u81EA\u52A8\u6821\u9A8C\uFF08\u4EC5 submit/manual \u6267\u884C\uFF09\u3002\n   */\n  readonly validateOn?: ReadonlyArray<'onChange' | 'onBlur'>\n  readonly validate: (input: Input, ctx: Ctx) => unknown\n  readonly meta?: Meta.TraitMeta\n}\n\nexport interface CheckMeta<Input = unknown, Ctx = unknown> {\n  /**\n   * \u547D\u540D\u89C4\u5219\u96C6\u5408\uFF08\u8BB0\u5F55\u7528\u4E8E\u786E\u5B9A\u6027\u5408\u5E76\u4E0E\u8BCA\u65AD\u5C55\u793A\uFF09\u3002\n   */\n  readonly rules: Readonly<Record<string, CheckRule<Input, Ctx>>>\n  /**\n   * \u9519\u8BEF\u6811\u5199\u56DE\uFF08Phase 2\uFF1A\u4EC5\u56FA\u5316\u7ED3\u6784\uFF1B\u5177\u4F53\u5199\u56DE\u8BED\u4E49\u5728\u540E\u7EED Phase \u5B9E\u73B0\uFF09\u3002\n   */\n  readonly writeback?: {\n    readonly kind: 'errors'\n    readonly path?: string\n  }\n}\n\n/**\n * StateTraitEntry<S, P>\uFF1A\n * - \u8868\u793A\u67D0\u4E2A\u5B57\u6BB5\u8DEF\u5F84 P \u4E0A\u7684\u4E00\u9879 Trait \u914D\u7F6E\uFF1B\n * - kind \u4E0E meta \u6210\u5BF9\u51FA\u73B0\uFF0C\u7528\u4E8E\u5728 build/install \u9636\u6BB5\u5206\u6D3E\u884C\u4E3A\u3002\n */\nexport type StateTraitEntry<S = unknown, P extends string = StateFieldPath<S>> =\n  | {\n      readonly fieldPath: P\n      readonly kind: 'computed'\n      readonly meta: ComputedMeta<S, P>\n    }\n  | {\n      readonly fieldPath: P\n      readonly kind: 'source'\n      readonly meta: SourceMeta<S, P>\n    }\n  | {\n      readonly fieldPath: P\n      readonly kind: 'link'\n      readonly meta: LinkMeta<S>\n    }\n  | {\n      readonly fieldPath: P\n      readonly kind: 'check'\n      readonly meta: CheckMeta<unknown, unknown>\n    }\n\nexport interface StateTraitNode<Input = unknown, Ctx = unknown> {\n  readonly _tag: 'StateTraitNode'\n  readonly computed?: StateTraitEntry<Input, any> | Readonly<Record<string, StateTraitEntry<Input, any>>>\n  readonly source?: StateTraitEntry<Input, any> | Readonly<Record<string, StateTraitEntry<Input, any>>>\n  readonly link?: StateTraitEntry<Input, any> | Readonly<Record<string, StateTraitEntry<Input, any>>>\n  readonly check?: Readonly<Record<string, CheckRule<Input, Ctx>>>\n  readonly meta?: Meta.TraitMeta\n}\n\nexport interface StateTraitList<Item = unknown> {\n  readonly _tag: 'StateTraitList'\n  readonly item?: StateTraitNode<Item, any>\n  readonly list?: StateTraitNode<ReadonlyArray<Item>, any>\n  readonly identityHint?: {\n    readonly trackBy?: string\n  }\n}\n\nexport type StateTraitSpecValue<S, P extends string> =\n  | StateTraitEntry<S, P>\n  | StateTraitNode<any, any>\n  | StateTraitList<any>\n\n/**\n * StateTraitField\uFF1A\n * - \u8868\u793A State \u4E2D\u7684\u4E00\u4E2A\u5B57\u6BB5\u8282\u70B9\uFF08\u4E0D\u8BBA\u662F\u5426\u6302 Trait\uFF09\uFF1B\n * - \u7531 build \u9636\u6BB5\u4ECE StateTraitSpec \u5F52\u4E00\u5316\u800C\u6765\u3002\n */\nexport interface StateTraitField {\n  readonly id: string\n  readonly path: string\n  readonly displayName?: string\n  readonly valueType?: string\n  readonly traits: ReadonlyArray<StateTraitFieldTrait>\n}\n\n/**\n * StateTraitFieldTrait\uFF1A\n * - \u67D0\u4E2A\u5B57\u6BB5\u4E0A\u7684\u4E00\u9879 Trait\uFF08computed / source / link\uFF09\u7684\u7ED3\u6784\u5316\u63CF\u8FF0\uFF1B\n * - meta \u4E0E StateTraitEntry.meta \u5BF9\u9F50\uFF0Cdeps \u8868\u793A\u8BE5 Trait \u6240\u4F9D\u8D56\u7684\u5B57\u6BB5\u8DEF\u5F84\u96C6\u5408\u3002\n */\nexport interface StateTraitFieldTrait {\n  readonly fieldId: string\n  readonly kind: StateTraitKind\n  readonly meta:\n    | ComputedMeta<unknown, string>\n    | SourceMeta<unknown, string>\n    | LinkMeta<unknown>\n    | CheckMeta<unknown, unknown>\n  readonly deps: ReadonlyArray<string>\n}\n\n/**\n * StateTraitResource\uFF1A\n * - \u63CF\u8FF0 source \u578B Trait \u6240\u4F9D\u8D56\u7684\u903B\u8F91\u8D44\u6E90\u5143\u4FE1\u606F\uFF1B\n * - ResourceSpec \u7684\u5177\u4F53\u5B9E\u73B0\u7531 Resource \u547D\u540D\u7A7A\u95F4\u8D1F\u8D23\uFF0C\u8FD9\u91CC\u53EA\u4FDD\u7559 Trait \u89C6\u89D2\u7684\u4F9D\u8D56\u4FE1\u606F\u3002\n */\nexport interface StateTraitResource {\n  readonly resourceId: string\n  readonly keySelector: string\n  readonly keyExample?: unknown\n  readonly ownerFields: ReadonlyArray<string>\n  readonly meta?: Meta.TraitMeta\n  readonly metaOrigin?: string\n  readonly metaConflicts?: ReadonlyArray<Meta.TraitMetaConflict>\n}\n\n/**\n * Graph Node / Edge\uFF1A\n * - \u8282\u70B9\u901A\u5E38\u5BF9\u5E94\u4E00\u4E2A\u5B57\u6BB5\uFF1B\n * - \u8FB9\u8868\u793A\u5B57\u6BB5\u4E4B\u95F4\u6216\u5B57\u6BB5\u4E0E\u8D44\u6E90\u4E4B\u95F4\u7684\u4F9D\u8D56\u5173\u7CFB\u3002\n */\nexport interface StateTraitGraphNode {\n  readonly id: string\n  readonly field: StateTraitField\n  readonly traits: ReadonlyArray<StateTraitFieldTrait>\n  readonly meta?: Meta.TraitMeta\n}\n\nexport interface StateTraitGraphEdge {\n  readonly id: string\n  readonly from: string\n  readonly to: string\n  readonly kind: 'computed' | 'link' | 'source-dep' | 'check-dep'\n}\n\n/**\n * StateTraitGraph\uFF1A\n * - StateTrait \u5F15\u64CE\u7684\u7ED3\u6784\u89C6\u56FE\uFF0C\u4E00\u5F20\u5305\u542B\u8282\u70B9\u4E0E\u4F9D\u8D56\u8FB9\u7684\u56FE\uFF1B\n * - \u4F9B Devtools / Studio \u4E0E Runtime \u505A\u7ED3\u6784\u5206\u6790\u4E0E\u53EF\u89C6\u5316\u4F7F\u7528\u3002\n */\nexport interface StateTraitGraph {\n  readonly _tag: 'StateTraitGraph'\n  readonly nodes: ReadonlyArray<StateTraitGraphNode>\n  readonly edges: ReadonlyArray<StateTraitGraphEdge>\n  readonly resources: ReadonlyArray<StateTraitResource>\n  readonly meta?: {\n    readonly moduleId?: string\n    readonly version?: string\n  }\n}\n\n/**\n * StateTraitPlanStep\uFF1A\n * - StateTrait.install / Runtime \u6267\u884C\u65F6\u7684\u6700\u5C0F\u6307\u4EE4\u5355\u5143\uFF1B\n * - \u7531 Graph \u63A8\u5BFC\u800C\u6765\uFF0C\u7528\u4E8E\u5728\u8FD0\u884C\u65F6\u5B89\u88C5 watcher \u6216\u89E6\u53D1\u5916\u90E8\u8C03\u7528\u3002\n */\nexport interface StateTraitPlanStep {\n  readonly id: string\n  readonly kind: 'computed-update' | 'link-propagate' | 'source-refresh' | 'check-validate'\n  readonly targetFieldPath?: string\n  readonly sourceFieldPaths?: ReadonlyArray<string>\n  readonly resourceId?: string\n  readonly keySelectorId?: string\n  readonly debugInfo?: {\n    readonly graphNodeId?: string\n    readonly graphEdgeId?: string\n  }\n}\n\n/**\n * StateTraitPlan\uFF1A\n * - \u6C47\u603B\u67D0\u6A21\u5757\u6240\u6709 Trait \u884C\u4E3A\u7684\u6267\u884C\u8BA1\u5212\uFF1B\n * - install \u9636\u6BB5\u6309 Plan \u5C06\u884C\u4E3A\u6302\u8F7D\u5230 Bound API / EffectOp \u7BA1\u9053\u4E0A\u3002\n */\nexport interface StateTraitPlan {\n  readonly _tag: 'StateTraitPlan'\n  readonly moduleId?: string\n  readonly steps: ReadonlyArray<StateTraitPlanStep>\n  readonly meta?: Record<string, unknown>\n}\n\nexport type StateTraitSchemaPathKind = 'fieldPath' | 'dep' | 'link_from' | 'check_writeback'\n\nexport interface StateTraitSchemaPathRef {\n  readonly kind: StateTraitSchemaPathKind\n  readonly entryKind: StateTraitKind\n  readonly entryFieldPath: string\n  readonly path: string\n  readonly ruleName?: string\n}\n\n/**\n * StateTraitProgram<S>\uFF1A\n * - StateTrait \u5F15\u64CE\u7684 Program \u8F93\u51FA\uFF0C\u662F Runtime / Devtools \u7684\u7EDF\u4E00\u5165\u53E3\uFF1B\n * - stateSchema \u4E0E spec \u4FDD\u7559\u539F\u59CB\u8F93\u5165\uFF0Cgraph/plan \u4E3A\u5185\u90E8 IR\u3002\n */\nexport interface StateTraitProgram<S> {\n  readonly stateSchema: Schema.Schema<S, any>\n  readonly spec: StateTraitSpec<S>\n  /**\n   * Program.entries\uFF1A\n   * - build \u9636\u6BB5\u4ECE spec\uFF08\u542B node/list/$root\uFF09\u5F52\u4E00\u5316\u5F97\u5230\u7684\u6700\u5C0F\u89C4\u5219\u96C6\u5408\uFF1B\n   * - Phase 2 \u5148\u4FDD\u8BC1\u201C\u53EF\u8BFB\u53EF\u8BCA\u65AD\u7684\u7ED3\u6784\u201D\uFF0C\u540E\u7EED Phase \u624D\u63A5\u5165\u6267\u884C\u4E0E\u6536\u655B\u8BED\u4E49\u3002\n   */\n  readonly entries: ReadonlyArray<StateTraitEntry<any, string>>\n  readonly graph: StateTraitGraph\n  readonly plan: StateTraitPlan\n  readonly convergeIr?: ConvergeStaticIrRegistry\n  readonly convergeExecIr?: ConvergeExecIr\n  /**\n   * schemaPaths\uFF1A\n   * - build \u9636\u6BB5\u4ECE entries \u6C47\u603B\u51FA\u7684\u201C\u9700\u8981\u5B58\u5728\u4E8E stateSchema \u7684\u8DEF\u5F84\u5F15\u7528\u201D\uFF1B\u4EC5\u7528\u4E8E dev \u8BCA\u65AD\uFF08\u4F8B\u5982 schema_mismatch\uFF09\u3002\n   * - diagnostics=off \u65F6\u53EF\u5B8C\u5168\u8DF3\u8FC7\u6821\u9A8C\u4EE5\u4FDD\u6301\u8FD1\u96F6\u6210\u672C\u3002\n   */\n  readonly schemaPaths?: ReadonlyArray<StateTraitSchemaPathRef>\n}\n\n/**\n * \u4ECE StateTraitSpec \u6784\u5EFA\u5F52\u4E00\u5316\u7684 entry \u5217\u8868\u3002\n *\n * - Phase 2\uFF1A\u652F\u6301 node/list/$root \u7684\u7ED3\u6784\u5C55\u5F00\uFF0C\u5E76\u5728\u5FC5\u8981\u65F6\u8865\u5168/\u524D\u7F00\u5316 fieldPath \u4E0E deps\uFF1B\n * - \u540E\u7EED Phase \u53EF\u5728\u6B64\u5904\u6269\u5C55\u6821\u9A8C\u903B\u8F91\uFF08\u4F8B\u5982\u68C0\u6D4B\u91CD\u590D\u5B9A\u4E49\u3001\u8986\u76D6\u673A\u5236\u7B49\uFF09\u3002\n */\nexport const normalizeSpec = <S>(spec: StateTraitSpec<S>): ReadonlyArray<StateTraitEntry<any, string>> => {\n  const entries: Array<StateTraitEntry<any, string>> = []\n\n  const isNode = (value: unknown): value is StateTraitNode<any, any> =>\n    typeof value === 'object' && value !== null && (value as any)._tag === 'StateTraitNode'\n\n  const isList = (value: unknown): value is StateTraitList<any> =>\n    typeof value === 'object' && value !== null && (value as any)._tag === 'StateTraitList'\n\n  const joinPath = (prefix: string, suffix: string): string => {\n    if (!prefix) return suffix\n    if (!suffix) return prefix\n    return `${prefix}.${suffix}`\n  }\n\n  const prefixDeps = (deps: ReadonlyArray<string> | undefined, prefix: string): ReadonlyArray<string> => {\n    if (!deps || deps.length === 0) return []\n    return deps.map((d) => (prefix ? joinPath(prefix, d) : d))\n  }\n\n  const normalizeEntry = (\n    entry: StateTraitEntry<any, string>,\n    fieldPath: string,\n    depPrefix: string,\n  ): StateTraitEntry<any, string> => {\n    if (entry.kind === 'computed') {\n      const meta = entry.meta as any\n      const rawDeps = meta.deps as ReadonlyArray<string> | undefined\n      const deps = rawDeps !== undefined ? prefixDeps(rawDeps, depPrefix) : undefined\n      return {\n        ...(entry as any),\n        fieldPath,\n        meta: { ...meta, deps },\n      }\n    }\n    if (entry.kind === 'source') {\n      const meta = entry.meta as any\n      const rawDeps = meta.deps as ReadonlyArray<string> | undefined\n      const deps = rawDeps !== undefined ? prefixDeps(rawDeps, depPrefix) : undefined\n      return {\n        ...(entry as any),\n        fieldPath,\n        meta: { ...meta, deps, _fieldPath: fieldPath },\n      }\n    }\n    if (entry.kind === 'link') {\n      const meta = entry.meta as any\n      const from = prefixDeps([meta.from as string], depPrefix)[0] ?? meta.from\n      return {\n        ...(entry as any),\n        fieldPath,\n        meta: { ...meta, from },\n      }\n    }\n    // check\uFF1APhase 2 \u4EC5\u8C03\u6574 fieldPath\uFF0Cdeps \u4ECD\u7531 meta.rules \u5728 build \u9636\u6BB5\u6C47\u603B\u3002\n    return {\n      ...(entry as any),\n      fieldPath,\n    }\n  }\n\n  const expandNode = (\n    scopeId: string,\n    joinPrefix: string,\n    node: StateTraitNode<any, any>,\n    options?: {\n      /**\n       * check deps \u524D\u7F00\uFF1A\u7528\u4E8E list-scope check \u7684\u9ED8\u8BA4\u8BED\u4E49\uFF08deps \u76F8\u5BF9\u201C\u884C\u5143\u7D20\u201D\u800C\u975E list \u6839\uFF09\u3002\n       *\n       * - item scope\uFF1AdepsPrefix = `${listPath}[]`\uFF08\u4E0E joinPrefix \u4E00\u81F4\uFF09\uFF1B\n       * - list scope\uFF1AfieldPath = `${listPath}`\uFF0C\u4F46 depsPrefix \u5E94\u4E3A `${listPath}[]`\u3002\n       */\n      readonly checkDepsPrefix?: string\n    },\n  ): void => {\n    const addEntry = (relativeTarget: string, raw: StateTraitEntry<any, string>): void => {\n      const rel = (raw as any).fieldPath ?? relativeTarget\n      const fieldPath = joinPrefix ? joinPath(joinPrefix, String(rel)) : String(rel)\n      entries.push(normalizeEntry(raw, fieldPath, joinPrefix))\n    }\n\n    const expandMaybeRecord = (\n      value: StateTraitEntry<any, any> | Readonly<Record<string, StateTraitEntry<any, any>>> | undefined,\n    ): void => {\n      if (!value) return\n      if (typeof (value as any).kind === 'string') {\n        addEntry('', value as any)\n        return\n      }\n      const record = value as Readonly<Record<string, StateTraitEntry<any, any>>>\n      for (const key in record) {\n        if (!Object.prototype.hasOwnProperty.call(record, key)) continue\n        const entry = record[key]\n        if (!entry) continue\n        addEntry(key, entry as any)\n      }\n    }\n\n    expandMaybeRecord(node.computed)\n    expandMaybeRecord(node.source)\n    expandMaybeRecord(node.link)\n\n    if (node.check) {\n      const rules: Record<string, CheckRule<any, any>> = {}\n      const checkDepsPrefix = options?.checkDepsPrefix ?? (joinPrefix.endsWith('[]') ? joinPrefix : '')\n\n      const prefixCheckDeps = (deps: ReadonlyArray<string> | undefined): ReadonlyArray<string> => {\n        if (!deps || deps.length === 0) return []\n        return deps.map((d) => (d === '' ? scopeId : checkDepsPrefix ? joinPath(checkDepsPrefix, d) : d))\n      }\n      for (const name of Object.keys(node.check)) {\n        const rule = (node.check as any)[name] as CheckRule<any, any>\n        if (typeof rule === 'function') {\n          rules[name] = rule\n          continue\n        }\n        if (rule && typeof rule === 'object') {\n          const meta = Meta.sanitize((rule as any).meta)\n          rules[name] = {\n            ...rule,\n            deps: prefixCheckDeps(rule.deps),\n            meta,\n          }\n          continue\n        }\n        // \u975E\u6CD5\u8F93\u5165\uFF1A\u5FFD\u7565\uFF08\u540E\u7EED Phase \u5C06\u5728 build \u9636\u6BB5\u63D0\u5347\u4E3A\u914D\u7F6E\u9519\u8BEF\uFF09\u3002\n      }\n\n      entries.push({\n        fieldPath: scopeId,\n        kind: 'check',\n        meta: {\n          rules,\n          writeback: { kind: 'errors' },\n        },\n      } as StateTraitEntry<any, any>)\n    }\n  }\n\n  for (const key in spec) {\n    if (!Object.prototype.hasOwnProperty.call(spec, key)) continue\n    const raw = spec[key as keyof typeof spec] as StateTraitSpecValue<S, any> | undefined\n    if (!raw) continue\n\n    if (isList(raw)) {\n      const listPath = key\n      if (raw.item) {\n        expandNode(`${listPath}[]`, `${listPath}[]`, raw.item)\n      }\n      if (raw.list) {\n        expandNode(listPath, listPath, raw.list, {\n          checkDepsPrefix: `${listPath}[]`,\n        })\n      }\n      continue\n    }\n\n    if (isNode(raw)) {\n      if (key === '$root') {\n        expandNode('$root', '', raw)\n      } else {\n        expandNode(key, key, raw)\n      }\n      continue\n    }\n\n    const entry = raw as any as StateTraitEntry<any, string>\n    const fieldPath = (entry as any).fieldPath ?? key\n    entries.push(normalizeEntry(entry, String(fieldPath), ''))\n  }\n\n  return entries\n}\n\n/**\n * collectNodeMeta\uFF1A\n * - \u4ECE StateTraitSpec \u4E2D\u63D0\u53D6 StateTraitNode.meta\uFF08\u767D\u540D\u5355\u5B57\u6BB5\uFF09\uFF0C\u4F9B Devtools \u8FDB\u884C\u7ED3\u6784\u5C55\u793A\uFF1B\n * - meta \u4EC5\u7528\u4E8E\u8BCA\u65AD\u4E0E\u5C55\u793A\uFF0C\u4E0D\u53C2\u4E0E\u8FD0\u884C\u65F6\u8BED\u4E49\u3002\n */\nexport const collectNodeMeta = <S>(spec: StateTraitSpec<S>): ReadonlyMap<string, Meta.TraitMeta> => {\n  const out = new Map<string, Meta.TraitMeta>()\n\n  const isNode = (value: unknown): value is StateTraitNode<any, any> =>\n    typeof value === 'object' && value !== null && (value as any)._tag === 'StateTraitNode'\n\n  const isList = (value: unknown): value is StateTraitList<any> =>\n    typeof value === 'object' && value !== null && (value as any)._tag === 'StateTraitList'\n\n  const add = (scopeId: string, node: StateTraitNode<any, any>): void => {\n    const meta = Meta.sanitize(node.meta)\n    if (meta) out.set(scopeId, meta)\n  }\n\n  for (const key in spec) {\n    if (!Object.prototype.hasOwnProperty.call(spec, key)) continue\n    const raw = spec[key as keyof typeof spec] as StateTraitSpecValue<S, any> | undefined\n    if (!raw) continue\n\n    if (isList(raw)) {\n      const listPath = key\n      if (raw.item) add(`${listPath}[]`, raw.item)\n      if (raw.list) add(listPath, raw.list)\n      continue\n    }\n\n    if (isNode(raw)) {\n      if (key === '$root') add('$root', raw)\n      else add(key, raw)\n      continue\n    }\n  }\n\n  return out\n}\n\n// ---- Converge (013) evidence model ----\n\nexport type TraitConvergeRequestedMode = 'auto' | 'full' | 'dirty'\nexport type TraitConvergeExecutedMode = 'full' | 'dirty'\nexport type TraitConvergeOutcome = 'Converged' | 'Noop' | 'Degraded'\n\nexport type TraitConvergeConfigScope = 'provider' | 'runtime_module' | 'runtime_default' | 'builtin'\n\nexport type TraitConvergeReason =\n  | 'cold_start'\n  | 'cache_hit'\n  | 'cache_miss'\n  | 'budget_cutoff'\n  | 'near_full'\n  | 'unknown_write'\n  | 'dirty_all'\n  | 'generation_bumped'\n  | 'low_hit_rate_protection'\n  | 'module_override'\n  | 'time_slicing_immediate'\n  | 'time_slicing_deferred'\n\nexport interface TraitConvergeStepStats {\n  readonly totalSteps: number\n  readonly executedSteps: number\n  readonly skippedSteps: number\n  readonly changedSteps: number\n  readonly affectedSteps?: number\n}\n\nexport interface TraitConvergeDirtySummary {\n  readonly dirtyAll: boolean\n  readonly reason?: DirtyAllReason\n  readonly rootCount?: number\n  readonly rootIds?: ReadonlyArray<number>\n  readonly rootIdsTruncated?: boolean\n}\n\nexport interface TraitConvergePlanCacheEvidence {\n  readonly capacity: number\n  readonly size: number\n  readonly hits: number\n  readonly misses: number\n  readonly evicts: number\n  readonly hit: boolean\n  readonly keySize?: number\n  readonly missReason?: 'cold_start' | 'generation_bumped' | 'not_cached' | 'unknown'\n  readonly disabled?: boolean\n  readonly disableReason?: 'low_hit_rate' | 'generation_thrash' | 'manual_override' | 'unknown'\n}\n\nexport type TraitConvergeGenerationBumpReason =\n  | 'writers_changed'\n  | 'deps_changed'\n  | 'logic_installed'\n  | 'logic_uninstalled'\n  | 'imports_changed'\n  | 'unknown'\n\nexport interface TraitConvergeGenerationEvidence {\n  readonly generation: number\n  readonly generationBumpCount?: number\n  readonly lastBumpReason?: TraitConvergeGenerationBumpReason\n}\n\nexport interface TraitConvergeStaticIrEvidence {\n  readonly fieldPathCount: number\n  readonly stepCount: number\n  readonly buildDurationMs?: number\n}\n\nexport interface TraitConvergeHotspot {\n  readonly kind?: string\n  readonly stepId: number\n  readonly outFieldPathId?: number\n  readonly durationMs: number\n  readonly changed: boolean\n}\n\nexport interface TraitConvergeTimeSlicingSummary {\n  readonly scope: 'all' | 'immediate' | 'deferred'\n  readonly immediateStepCount: number\n  readonly deferredStepCount: number\n}\n\nexport interface TraitConvergeDiagnosticsSamplingSummary {\n  /**\n   * \u786E\u5B9A\u6027\u91C7\u6837\u7B56\u7565\uFF1A\u4EE5\u7A33\u5B9A txnSeq \u4E3A\u951A\u70B9\uFF0C\u6BCF\u9694 N \u4E2A txn \u91C7\u6837\u4E00\u6B21\u3002\n   * - sampled=true \u8868\u793A\u672C\u6B21 invocation \u91C7\u96C6\u4E86 per-step \u8BA1\u65F6\u5E76\u751F\u6210 hotspots\u3002\n   */\n  readonly strategy: 'txnSeq_interval'\n  readonly sampleEveryN: number\n  readonly topK: number\n  readonly sampled: boolean\n}\n\nexport interface TraitConvergeDecisionSummary {\n  readonly requestedMode: TraitConvergeRequestedMode\n  readonly executedMode: TraitConvergeExecutedMode\n  readonly outcome: TraitConvergeOutcome\n  readonly configScope: TraitConvergeConfigScope\n  readonly staticIrDigest: string\n  readonly executionBudgetMs: number\n  readonly executionDurationMs: number\n  readonly decisionBudgetMs?: number\n  readonly decisionDurationMs?: number\n  readonly reasons: ReadonlyArray<TraitConvergeReason>\n  readonly stepStats: TraitConvergeStepStats\n  readonly dirty?: TraitConvergeDirtySummary\n  readonly cache?: TraitConvergePlanCacheEvidence\n  readonly generation?: TraitConvergeGenerationEvidence\n  readonly staticIr?: TraitConvergeStaticIrEvidence\n  readonly timeSlicing?: TraitConvergeTimeSlicingSummary\n  readonly thresholds?: { readonly floorRatio?: number }\n  readonly diagnosticsSampling?: TraitConvergeDiagnosticsSamplingSummary\n  readonly top3?: ReadonlyArray<TraitConvergeHotspot>\n}\n", "import type { Schema } from 'effect'\nimport {\n  type StateTraitProgram,\n  type StateTraitSpec,\n  type StateTraitEntry,\n  type StateTraitGraph,\n  type StateTraitGraphEdge,\n  type StateTraitGraphNode,\n  type StateTraitField,\n  type StateTraitFieldTrait,\n  type StateTraitPlan,\n  type StateTraitPlanStep,\n  type StateTraitResource,\n  type StateTraitSchemaPathRef,\n  collectNodeMeta,\n  normalizeSpec,\n} from './model.js'\nimport * as Meta from './meta.js'\nimport {\n  compareFieldPath,\n  getFieldPathId,\n  makeFieldPathIdRegistry,\n  normalizeFieldPath,\n  type FieldPath,\n  type FieldPathId,\n} from '../field-path.js'\nimport type { ConvergeStaticIrRegistry } from './converge-ir.js'\n\nconst nowPerf = (): number =>\n  typeof globalThis.performance !== 'undefined' && typeof globalThis.performance.now === 'function'\n    ? globalThis.performance.now()\n    : Date.now()\n\ntype ConvergeWriter = Extract<StateTraitEntry<any, string>, { readonly kind: 'computed' | 'link' }>\n\nconst getConvergeWriterDeps = (entry: ConvergeWriter): ReadonlyArray<string> => {\n  if (entry.kind === 'computed') {\n    return ((entry.meta as any)?.deps ?? []) as ReadonlyArray<string>\n  }\n  return [entry.meta.from as string]\n}\n\nconst computeConvergeTopoOrder = (\n  writers: ReadonlyArray<ConvergeWriter>,\n): { readonly order: ReadonlyArray<string>; readonly configError?: ConvergeStaticIrRegistry['configError'] } => {\n  const writerByPath = new Map<string, ConvergeWriter>()\n  for (const entry of writers) {\n    const existing = writerByPath.get(entry.fieldPath)\n    if (existing) {\n      return {\n        order: [],\n        configError: {\n          code: 'MULTIPLE_WRITERS',\n          message: `[StateTrait.converge] Multiple writers for field \"${entry.fieldPath}\" (${existing.kind} + ${entry.kind}).`,\n          fields: [entry.fieldPath],\n        },\n      }\n    }\n    writerByPath.set(entry.fieldPath, entry)\n  }\n\n  const nodes = new Set<string>()\n  for (const entry of writers) {\n    nodes.add(entry.fieldPath)\n  }\n\n  const indegree = new Map<string, number>()\n  const forward = new Map<string, Array<string>>()\n\n  for (const node of nodes) {\n    indegree.set(node, 0)\n    forward.set(node, [])\n  }\n\n  for (const entry of writers) {\n    const to = entry.fieldPath\n    const deps = getConvergeWriterDeps(entry)\n    for (const dep of deps) {\n      if (!nodes.has(dep)) continue\n      forward.get(dep)!.push(to)\n      indegree.set(to, (indegree.get(to) ?? 0) + 1)\n    }\n  }\n\n  const queue: Array<string> = []\n  for (const [node, deg] of indegree.entries()) {\n    if (deg === 0) queue.push(node)\n  }\n\n  const order: Array<string> = []\n  while (queue.length) {\n    const n = queue.shift()!\n    order.push(n)\n    const outs = forward.get(n)!\n    for (const to of outs) {\n      const next = (indegree.get(to) ?? 0) - 1\n      indegree.set(to, next)\n      if (next === 0) queue.push(to)\n    }\n  }\n\n  if (order.length !== nodes.size) {\n    const remaining = Array.from(nodes).filter((n) => !order.includes(n))\n    return {\n      order: [],\n      configError: {\n        code: 'CYCLE_DETECTED',\n        message: `[StateTrait.converge] Cycle detected in computed/link graph: ${remaining.join(', ')}`,\n        fields: remaining,\n      },\n    }\n  }\n\n  return { order }\n}\n\nconst buildConvergeIr = (entries: ReadonlyArray<StateTraitEntry<any, string>>): ConvergeStaticIrRegistry => {\n  const startedAt = nowPerf()\n  const generation = 0\n\n  const writers = entries.filter((e): e is ConvergeWriter => e.kind === 'computed' || e.kind === 'link')\n\n  const writersKey = writers\n    .map((entry) => `${entry.kind}:${entry.fieldPath}`)\n    .sort()\n    .join('|')\n\n  const depsKey = writers\n    .map((entry) => {\n      const deps = getConvergeWriterDeps(entry).slice().sort().join(',')\n      const scheduling = (entry.meta as any)?.scheduling === 'deferred' ? 'd' : 'i'\n      return `${entry.kind}:${entry.fieldPath}@${scheduling}=>${deps}`\n    })\n    .sort()\n    .join('|')\n\n  const writerByPath = new Map<string, ConvergeWriter>()\n  for (const entry of writers) {\n    writerByPath.set(entry.fieldPath, entry)\n  }\n\n  const topo = writers.length > 0 ? computeConvergeTopoOrder(writers) : { order: [] as ReadonlyArray<string> }\n  const stepsById: Array<ConvergeWriter> = topo.configError ? [] : topo.order.map((path) => writerByPath.get(path)!)\n\n  const fieldPathTable = new Map<string, FieldPath>()\n  const addPath = (path: FieldPath): void => {\n    for (let i = 1; i <= path.length; i++) {\n      const prefix = path.slice(0, i)\n      const key = JSON.stringify(prefix)\n      if (!fieldPathTable.has(key)) fieldPathTable.set(key, prefix)\n    }\n  }\n\n  for (const entry of writers) {\n    const out = normalizeFieldPath(entry.fieldPath)\n    if (out) addPath(out)\n    for (const dep of getConvergeWriterDeps(entry)) {\n      const depPath = normalizeFieldPath(dep)\n      if (depPath) addPath(depPath)\n    }\n  }\n\n  const fieldPaths = Array.from(fieldPathTable.values()).sort(compareFieldPath)\n  const fieldPathIdRegistry = makeFieldPathIdRegistry(fieldPaths)\n\n  const stepOutFieldPathIdByStepId: Array<FieldPathId> = []\n  const stepDepsFieldPathIdsByStepId: Array<ReadonlyArray<FieldPathId>> = []\n  const stepSchedulingByStepId: Array<'immediate' | 'deferred'> = []\n\n  for (const entry of stepsById) {\n    const out = normalizeFieldPath(entry.fieldPath)\n    const outId = out != null ? getFieldPathId(fieldPathIdRegistry, out) : undefined\n    if (outId == null) {\n      throw new Error(`[StateTrait.build] Failed to map converge output fieldPath \"${entry.fieldPath}\" to FieldPathId.`)\n    }\n\n    const depIds: Array<FieldPathId> = []\n    for (const dep of getConvergeWriterDeps(entry)) {\n      const depPath = normalizeFieldPath(dep)\n      if (!depPath) continue\n      const depId = getFieldPathId(fieldPathIdRegistry, depPath)\n      if (depId != null) depIds.push(depId)\n    }\n\n    stepOutFieldPathIdByStepId.push(outId)\n    stepDepsFieldPathIdsByStepId.push(depIds)\n    stepSchedulingByStepId.push((entry.meta as any)?.scheduling === 'deferred' ? 'deferred' : 'immediate')\n  }\n\n  const topoOrder = stepsById.map((_, i) => i)\n  const buildDurationMs = Math.max(0, nowPerf() - startedAt)\n\n  return {\n    generation,\n    writersKey,\n    depsKey,\n    fieldPaths,\n    fieldPathIdRegistry,\n    ...(topo.configError ? { configError: topo.configError } : null),\n    stepsById,\n    stepOutFieldPathIdByStepId,\n    stepDepsFieldPathIdsByStepId,\n    stepSchedulingByStepId,\n    topoOrder,\n    buildDurationMs,\n  }\n}\n\n/**\n * \u6839\u636E StateTraitEntry \u6784\u9020\u6807\u51C6\u5316\u7684 FieldTrait\u3002\n *\n * - \u76EE\u524D\u4EC5\u5BF9 link/source \u586B\u5145 deps \u4FE1\u606F\uFF0Ccomputed \u7684\u4F9D\u8D56\u6682\u4E0D\u9759\u6001\u5206\u6790\uFF1B\n * - \u540E\u7EED\u82E5\u5F15\u5165\u663E\u5F0F\u4F9D\u8D56\u58F0\u660E\uFF0C\u53EF\u4EE5\u5728\u6B64\u5904\u6269\u5C55\u3002\n */\nconst toFieldTrait = (entry: StateTraitEntry<any, string>): StateTraitFieldTrait => {\n  const deps: Array<string> = []\n\n  if (entry.kind === 'computed') {\n    const meta = entry.meta as any\n    const list = meta.deps as ReadonlyArray<string> | undefined\n    if (list) deps.push(...list)\n  } else if (entry.kind === 'source') {\n    const meta = entry.meta as any\n    const list = meta.deps as ReadonlyArray<string> | undefined\n    if (list) deps.push(...list)\n  } else if (entry.kind === 'link') {\n    deps.push(entry.meta.from as string)\n  } else if (entry.kind === 'check') {\n    const meta = entry.meta as any\n    const rules = (meta?.rules ?? {}) as Record<string, any>\n    for (const name of Object.keys(rules)) {\n      const rule = rules[name]\n      if (rule && typeof rule === 'object') {\n        const list = rule.deps as ReadonlyArray<string> | undefined\n        if (list) deps.push(...list)\n      }\n    }\n  }\n\n  return {\n    fieldId: entry.fieldPath,\n    kind: entry.kind,\n    // meta \u5728\u8FD0\u884C\u65F6\u4FDD\u6301\u4E0E Entry.meta \u4E00\u81F4\uFF0C\u4FBF\u4E8E install \u76F4\u63A5\u590D\u7528\u3002\n    meta: entry.meta as any,\n    deps,\n  }\n}\n\n/**\n * \u4ECE\u5F52\u4E00\u5316\u7684 Entry \u5217\u8868\u6784\u5EFA Field / Node / Edge / Resource \u96C6\u5408\u3002\n */\nconst buildGraph = (\n  entries: ReadonlyArray<StateTraitEntry<any, string>>,\n  nodeMetaByFieldPath: ReadonlyMap<string, Meta.TraitMeta>,\n): {\n  readonly graph: StateTraitGraph\n  readonly plan: StateTraitPlan\n} => {\n  const fieldMap = new Map<string, StateTraitField>()\n  const nodes: Array<StateTraitGraphNode> = []\n  const edges: Array<StateTraitGraphEdge> = []\n  const resourcesById = new Map<string, StateTraitResource>()\n  const planSteps: Array<StateTraitPlanStep> = []\n\n  const ensureField = (fieldPath: string): StateTraitField => {\n    let field = fieldMap.get(fieldPath)\n    if (!field) {\n      field = {\n        id: fieldPath,\n        path: fieldPath,\n        traits: [],\n      }\n      fieldMap.set(fieldPath, field)\n    }\n    return field\n  }\n\n  for (const entry of entries) {\n    const fieldPath = entry.fieldPath\n    const field = ensureField(fieldPath)\n    const trait = toFieldTrait(entry)\n\n    ;(field.traits as Array<StateTraitFieldTrait>).push(trait)\n\n    // \u9488\u5BF9\u4E0D\u540C kind \u6784\u5EFA Graph \u8FB9\u4E0E Plan \u6B65\u9AA4\u3002\n    if (entry.kind === 'computed') {\n      const stepId = `computed:${fieldPath}`\n      planSteps.push({\n        id: stepId,\n        kind: 'computed-update',\n        targetFieldPath: fieldPath,\n        // \u8BF4\u660E\uFF1A\u5F53\u524D\u7248\u672C\u4E0D\u9759\u6001\u5206\u6790 computed \u4F9D\u8D56\u5B57\u6BB5\uFF0CsourceFieldPaths \u7559\u7A7A\u3002\n      })\n      // \u82E5\u663E\u5F0F\u58F0\u660E deps\uFF0C\u5219\u8865\u5145 Graph \u8FB9\uFF08\u7528\u4E8E\u8BCA\u65AD/\u53CD\u5411\u95ED\u5305\u8BA1\u7B97\uFF09\u3002\n      const deps = (entry.meta as any).deps as ReadonlyArray<string> | undefined\n      if (deps) {\n        for (const dep of deps) {\n          ensureField(dep)\n          edges.push({\n            id: `computed:${dep}->${fieldPath}`,\n            from: dep,\n            to: fieldPath,\n            kind: 'computed',\n          })\n        }\n      }\n    } else if (entry.kind === 'link') {\n      const from = entry.meta.from as string\n      ensureField(from)\n\n      const edgeId = `link:${from}->${fieldPath}`\n      edges.push({\n        id: edgeId,\n        from,\n        to: fieldPath,\n        kind: 'link',\n      })\n\n      planSteps.push({\n        id: `link:${fieldPath}`,\n        kind: 'link-propagate',\n        targetFieldPath: fieldPath,\n        sourceFieldPaths: [from],\n        debugInfo: {\n          graphEdgeId: edgeId,\n        },\n      })\n    } else if (entry.kind === 'source') {\n      const resourceId = entry.meta.resource\n      const resourceMeta = Meta.sanitize((entry.meta as any).meta)\n\n      const existing = resourcesById.get(resourceId)\n      if (existing) {\n        const ownerFields = [...existing.ownerFields, fieldPath]\n        let meta = existing.meta\n        let metaOrigin = existing.metaOrigin\n        let metaConflicts = existing.metaConflicts\n\n        if (resourceMeta) {\n          const merged = Meta.mergeCanonical(\n            { meta, origin: metaOrigin, conflicts: metaConflicts },\n            { origin: fieldPath, meta: resourceMeta },\n          )\n          meta = merged.meta\n          metaOrigin = merged.origin\n          metaConflicts = merged.conflicts\n        }\n\n        resourcesById.set(resourceId, {\n          ...existing,\n          ownerFields,\n          meta,\n          metaOrigin,\n          metaConflicts,\n        })\n      } else {\n        resourcesById.set(resourceId, {\n          resourceId,\n          // \u6682\u65F6\u4F7F\u7528\u7B80\u5355\u7684\u6807\u8BC6\u5B57\u7B26\u4E32\uFF0C\u540E\u7EED\u53EF\u6839\u636E key \u89C4\u5219\u8FDB\u4E00\u6B65\u7ED3\u6784\u5316\u3002\n          keySelector: `StateTrait.source@${fieldPath}`,\n          ownerFields: [fieldPath],\n          meta: resourceMeta,\n          metaOrigin: resourceMeta ? fieldPath : undefined,\n        })\n      }\n\n      planSteps.push({\n        id: `source:${fieldPath}`,\n        kind: 'source-refresh',\n        targetFieldPath: fieldPath,\n        resourceId,\n        keySelectorId: `StateTrait.source@${fieldPath}`,\n      })\n\n      const deps = (entry.meta as any).deps as ReadonlyArray<string> | undefined\n      if (deps) {\n        for (const dep of deps) {\n          ensureField(dep)\n          edges.push({\n            id: `source-dep:${dep}->${fieldPath}`,\n            from: dep,\n            to: fieldPath,\n            kind: 'source-dep',\n          })\n        }\n      }\n    } else if (entry.kind === 'check') {\n      planSteps.push({\n        id: `check:${fieldPath}`,\n        kind: 'check-validate',\n        targetFieldPath: fieldPath,\n      })\n\n      // \u82E5\u89C4\u5219\u663E\u5F0F\u58F0\u660E deps\uFF0C\u5219\u8865\u5145 Graph \u8FB9\uFF08\u7528\u4E8E ReverseClosure scoped validate\uFF09\u3002\n      if (trait.deps.length > 0) {\n        for (const dep of trait.deps) {\n          ensureField(dep)\n          edges.push({\n            id: `check-dep:${dep}->${fieldPath}`,\n            from: dep,\n            to: fieldPath,\n            kind: 'check-dep',\n          })\n        }\n      }\n    }\n  }\n\n  for (const field of fieldMap.values()) {\n    nodes.push({\n      id: field.id,\n      field,\n      traits: field.traits,\n      meta: nodeMetaByFieldPath.get(field.id),\n    })\n  }\n\n  const graph: StateTraitGraph = {\n    _tag: 'StateTraitGraph',\n    nodes,\n    edges,\n    resources: Array.from(resourcesById.values()),\n  }\n\n  const plan: StateTraitPlan = {\n    _tag: 'StateTraitPlan',\n    steps: planSteps,\n  }\n\n  return { graph, plan }\n}\n\n/**\n * \u9488\u5BF9 link \u8FB9\u8FDB\u884C\u7B80\u5355\u7684\u73AF\u8DEF\u68C0\u6D4B\u3002\n *\n * - \u4EC5\u8003\u8651 kind = \"link\" \u7684\u8FB9\uFF0Ccomputed/source \u9996\u7248\u4E0D\u53C2\u4E0E\u73AF\u68C0\u6D4B\uFF1B\n * - \u82E5\u53D1\u73B0\u73AF\u8DEF\uFF0C\u629B\u51FA\u5E26\u6709\u8DEF\u5F84\u4FE1\u606F\u7684\u9519\u8BEF\uFF0C\u907F\u514D\u5728\u8FD0\u884C\u65F6\u8FDB\u5165\u65E0\u9650\u66F4\u65B0\u3002\n */\nconst assertNoLinkCycles = (edges: ReadonlyArray<StateTraitGraphEdge>): void => {\n  const adjacency = new Map<string, string[]>()\n\n  for (const edge of edges) {\n    if (edge.kind !== 'link') continue\n    const list = adjacency.get(edge.from) ?? []\n    list.push(edge.to)\n    adjacency.set(edge.from, list)\n  }\n\n  const visited = new Set<string>()\n  const stack = new Set<string>()\n\n  const dfs = (node: string): void => {\n    if (stack.has(node)) {\n      throw new Error(\n        `[StateTrait.build] link cycle detected at field \"${node}\". ` +\n          'Please check link traits for circular dependencies.',\n      )\n    }\n    if (visited.has(node)) return\n    visited.add(node)\n    stack.add(node)\n\n    const nexts = adjacency.get(node)\n    if (nexts) {\n      for (const to of nexts) {\n        dfs(to)\n      }\n    }\n\n    stack.delete(node)\n  }\n\n  for (const node of adjacency.keys()) {\n    if (!visited.has(node)) {\n      dfs(node)\n    }\n  }\n}\n\nconst collectSchemaPaths = (\n  entries: ReadonlyArray<StateTraitEntry<any, string>>,\n): ReadonlyArray<StateTraitSchemaPathRef> => {\n  const byKey = new Map<string, StateTraitSchemaPathRef>()\n\n  const add = (ref: StateTraitSchemaPathRef): void => {\n    if (!ref.path) return\n    const k = `${ref.kind}|${ref.entryKind}|${ref.entryFieldPath}|${ref.ruleName ?? ''}|${ref.path}`\n    byKey.set(k, ref)\n  }\n\n  const getCheckWritebackPath = (entry: Extract<StateTraitEntry<any, string>, { readonly kind: 'check' }>): string => {\n    const wb = (entry.meta as any)?.writeback\n    const p = wb && typeof wb === 'object' ? (wb as any).path : undefined\n    const writebackPath = typeof p === 'string' && p.startsWith('errors.') ? p : undefined\n\n    if (writebackPath) return writebackPath\n\n    const fieldPath = entry.fieldPath\n    if (fieldPath.endsWith('[]')) {\n      return `errors.${fieldPath.slice(0, -2)}`\n    }\n    return `errors.${fieldPath}`\n  }\n\n  for (const entry of entries) {\n    add({\n      kind: 'fieldPath',\n      entryKind: entry.kind,\n      entryFieldPath: entry.fieldPath,\n      path: entry.fieldPath,\n    })\n\n    if (entry.kind === 'computed' || entry.kind === 'source') {\n      const deps = ((entry.meta as any)?.deps ?? []) as ReadonlyArray<string>\n      for (const dep of deps) {\n        add({\n          kind: 'dep',\n          entryKind: entry.kind,\n          entryFieldPath: entry.fieldPath,\n          path: dep,\n        })\n      }\n    }\n\n    if (entry.kind === 'link') {\n      add({\n        kind: 'link_from',\n        entryKind: 'link',\n        entryFieldPath: entry.fieldPath,\n        path: entry.meta.from as string,\n      })\n    }\n\n    if (entry.kind === 'check') {\n      add({\n        kind: 'check_writeback',\n        entryKind: 'check',\n        entryFieldPath: entry.fieldPath,\n        path: getCheckWritebackPath(entry),\n      })\n\n      const rules = ((entry.meta as any)?.rules ?? {}) as Record<string, any>\n      for (const name of Object.keys(rules)) {\n        const rule = rules[name]\n        if (!rule || typeof rule !== 'object') continue\n        const deps = (rule.deps ?? []) as ReadonlyArray<string>\n        for (const dep of deps) {\n          add({\n            kind: 'dep',\n            entryKind: 'check',\n            entryFieldPath: entry.fieldPath,\n            ruleName: name,\n            path: dep,\n          })\n        }\n      }\n    }\n  }\n\n  return Array.from(byKey.entries())\n    .sort((a, b) => a[0].localeCompare(b[0]))\n    .map(([, v]) => v)\n}\n\n/**\n * \u6839\u636E\u7ED9\u5B9A\u7684 stateSchema \u4E0E traits spec \u6784\u9020 StateTraitProgram\u3002\n *\n * - \u7EAF\u51FD\u6570\uFF1A\u4E0D\u4F9D\u8D56\u5916\u90E8 Env / \u5168\u5C40\u72B6\u6001\uFF1B\n * - \u5F53\u524D\u5B9E\u73B0\u805A\u7126\u4E8E\uFF1A\n *   - \u4ECE Spec \u5F52\u4E00\u5316\u51FA Entry \u5217\u8868\uFF1B\n *   - \u57FA\u4E8E Entry \u6784\u5EFA\u8F7B\u91CF\u7248 Graph / Plan\uFF1B\n *   - \u5BF9 link \u8FB9\u505A\u57FA\u672C\u73AF\u8DEF\u68C0\u6D4B\u3002\n *\n * \u540E\u7EED\u82E5\u9700\u8981\u66F4\u7CBE\u7EC6\u7684\u4F9D\u8D56\u5206\u6790\uFF08\u4F8B\u5982\u5BF9 computed/key \u505A\u9759\u6001\u89E3\u6790\uFF09\uFF0C\n * \u53EF\u4EE5\u5728\u672C\u6A21\u5757\u5185\u6F14\u8FDB\u5B9E\u73B0\uFF0C\u800C\u4E0D\u5F71\u54CD\u5BF9\u5916 API\u3002\n */\nexport const build = <S extends object>(\n  stateSchema: Schema.Schema<S, any>,\n  spec: StateTraitSpec<S>,\n): StateTraitProgram<S> => {\n  const entries = normalizeSpec(spec) as ReadonlyArray<StateTraitEntry<S, string>>\n  const nodeMetaByFieldPath = collectNodeMeta(spec)\n\n  // Phase 4\uFF08US2\uFF09\uFF1A\u5F3A\u5236\u663E\u5F0F deps\uFF08Graph/diagnostics/replay \u53EA\u8BA4 deps \u4F5C\u4E3A\u4F9D\u8D56\u4E8B\u5B9E\u6E90\uFF09\u3002\n  for (const entry of entries) {\n    if (entry.kind === 'computed') {\n      const deps = (entry.meta as any).deps as ReadonlyArray<string> | undefined\n      if (deps === undefined) {\n        throw new Error(\n          `[StateTrait.build] Missing explicit deps for computed \"${entry.fieldPath}\". ` +\n            'Please use StateTrait.computed({ deps: [...], get: ... }).',\n        )\n      }\n    }\n    if (entry.kind === 'source') {\n      const deps = (entry.meta as any).deps as ReadonlyArray<string> | undefined\n      if (deps === undefined) {\n        throw new Error(\n          `[StateTrait.build] Missing explicit deps for source \"${entry.fieldPath}\". ` +\n            'Please provide meta.deps for StateTrait.source({ deps: [...], ... }).',\n        )\n      }\n    }\n    if (entry.kind === 'check') {\n      const rules = ((entry.meta as any)?.rules ?? {}) as Record<string, any>\n      for (const name of Object.keys(rules)) {\n        const rule = rules[name]\n        if (typeof rule === 'function' || !rule || typeof rule !== 'object') {\n          throw new Error(\n            `[StateTrait.build] Missing explicit deps for check \"${entry.fieldPath}\" rule \"${name}\". ` +\n              'Please use { deps: [...], validate: ... } form.',\n          )\n        }\n        if ((rule as any).deps === undefined) {\n          throw new Error(\n            `[StateTrait.build] Missing explicit deps for check \"${entry.fieldPath}\" rule \"${name}\". ` +\n              'Please provide deps: [...].',\n          )\n        }\n      }\n    }\n  }\n\n  const { graph, plan } = buildGraph(entries, nodeMetaByFieldPath)\n\n  // \u9488\u5BF9 link \u8FB9\u8FDB\u884C\u4E00\u6B21\u73AF\u8DEF\u68C0\u6D4B\uFF0C\u907F\u514D\u660E\u663E\u7684\u914D\u7F6E\u9519\u8BEF\u3002\n  assertNoLinkCycles(graph.edges)\n\n  return {\n    stateSchema,\n    spec,\n    entries: entries as ReadonlyArray<StateTraitEntry<any, string>>,\n    graph,\n    plan,\n    convergeIr: buildConvergeIr(entries as ReadonlyArray<StateTraitEntry<any, string>>),\n    schemaPaths: collectSchemaPaths(entries as ReadonlyArray<StateTraitEntry<any, string>>),\n  }\n}\n", "import { Effect } from 'effect'\nimport type { BoundApi } from '../runtime/core/module.js'\nimport { getBoundInternals } from '../runtime/core/runtimeInternalsAccessor.js'\nimport * as SourceRuntime from './source.js'\nimport type {\n  StateTraitProgram,\n  StateTraitPlanStep,\n  StateTraitEntry,\n  TraitConvergeGenerationBumpReason,\n} from './model.js'\n\nconst buildEntryIndex = <S>(\n  entries: ReadonlyArray<StateTraitEntry<S, string>>,\n): Map<string, Array<StateTraitEntry<S, string>>> => {\n  const index = new Map<string, Array<StateTraitEntry<S, string>>>()\n  for (const entry of entries) {\n    const list = index.get(entry.fieldPath) ?? []\n    list.push(entry)\n    index.set(entry.fieldPath, list)\n  }\n  return index\n}\n\n/**\n * \u5728\u7ED9\u5B9A Bound API \u4E0A\u5B89\u88C5 StateTraitProgram \u63CF\u8FF0\u7684\u884C\u4E3A\u3002\n *\n * - Phase 2 \u6700\u5C0F\u5B9E\u73B0\uFF1A\n *   - \u4E3A computed \u5B57\u6BB5\u6CE8\u518C watcher\uFF1A\u5F53 State \u53D8\u5316\u65F6\u91CD\u7B97\u76EE\u6807\u5B57\u6BB5\uFF1B\n *   - \u4E3A link \u5B57\u6BB5\u6CE8\u518C watcher\uFF1A\u5F53\u6E90\u5B57\u6BB5\u53D8\u5316\u65F6\u540C\u6B65\u76EE\u6807\u5B57\u6BB5\uFF1B\n *   - \u4E3A source \u5B57\u6BB5\u9884\u7559\u5237\u65B0\u5165\u53E3\uFF08\u6682\u4E0D\u89E6\u53D1\u5916\u90E8\u8C03\u7528\uFF09\u3002\n *\n * \u8BF4\u660E\uFF1A\n * - \u6240\u6709 watcher \u90FD\u901A\u8FC7 Bound API `$` \u5B89\u88C5\uFF0C\u4E0D\u76F4\u63A5\u4F9D\u8D56 ModuleRuntime\uFF1B\n * - \u6BCF\u4E2A PlanStep \u5BF9\u5E94\u4E00\u4E2A\u957F\u751F\u547D\u5468\u671F Effect\uFF0C\u901A\u8FC7 forkScoped \u6302\u8F7D\u5230 Runtime Scope\u3002\n */\nexport const install = <S>(\n  bound: BoundApi<any, any>,\n  program: StateTraitProgram<S>,\n): Effect.Effect<void, never, any> => {\n  // \u4F18\u5148\u5C06 Program \u6CE8\u518C\u5230 Runtime\uFF08\u6536\u655B\u5F15\u64CE\u5728\u4E8B\u52A1\u63D0\u4EA4\u524D\u7EDF\u4E00\u6267\u884C computed/link/check\uFF09\u3002\n  try {\n    const internals = getBoundInternals(bound as any)\n    ;(internals.traits.registerStateTraitProgram as any)(program, {\n      bumpReason: 'logic_installed' as TraitConvergeGenerationBumpReason,\n    })\n  } catch {\n    // no-op for legacy/mocked bound\n  }\n\n  const entryIndex = buildEntryIndex(program.entries as any)\n\n  const installStep = (step: StateTraitPlanStep): Effect.Effect<void, never, any> => {\n    if (!step.targetFieldPath) {\n      return Effect.void\n    }\n\n    if (step.kind !== 'source-refresh') {\n      // computed/link/check \u5DF2\u7531 Runtime \u5185\u6838\u5728\u4E8B\u52A1\u7A97\u53E3\u5185\u5904\u7406\uFF1Binstall \u9636\u6BB5\u4EC5\u4FDD\u7559 source.refresh \u5165\u53E3\u3002\n      return Effect.void\n    }\n\n    const candidates = entryIndex.get(step.targetFieldPath)\n    if (!candidates || candidates.length === 0) {\n      // Plan \u4E2D\u5F15\u7528\u4E86\u4E0D\u5B58\u5728\u7684 Spec\uFF1A\u89C6\u4E3A\u6784\u5EFA\u9636\u6BB5\u7684 bug\uFF0C\u8FD9\u91CC\u76F4\u63A5\u5FFD\u7565\u8BE5\u6B65\u9AA4\u3002\n      return Effect.void\n    }\n\n    const entry = candidates.find((e) => e.kind === 'source')\n\n    if (!entry) {\n      return Effect.void\n    }\n\n    return SourceRuntime.installSourceRefresh(bound, step, entry as any)\n  }\n\n  return Effect.forEach(program.plan.steps, (step) => installStep(step)).pipe(Effect.asVoid)\n}\n", "// StateTrait \u547D\u540D\u7A7A\u95F4\u6A21\u5757\uFF08@logix/core/StateTrait\uFF09\uFF1A\n// - \u63D0\u4F9B traits spec \u7684 DSL\uFF08from/node/list/computed/source/link\uFF09\uFF1B\n// - build\uFF1A\u5F52\u4E00\u5316 spec \u5E76\u751F\u6210 Program/Graph/Plan\uFF1B\n// - install\uFF1A\u5C06 Program \u5B89\u88C5\u5230\u8FD0\u884C\u65F6\uFF08\u6CE8\u518C source.refresh \u7B49\u5165\u53E3\uFF0C\u5E76\u5728\u4E8B\u52A1\u7A97\u53E3\u6267\u884C converge/validate\uFF09\u3002\n\nimport type { Schema } from 'effect'\nimport { Effect } from 'effect'\nimport type { BoundApi } from './Bound.js'\nimport * as Model from './internal/state-trait/model.js'\nimport * as FieldPath from './internal/state-trait/field-path.js'\nimport * as RowId from './internal/state-trait/rowid.js'\nimport * as InternalBuild from './internal/state-trait/build.js'\nimport * as InternalInstall from './internal/state-trait/install.js'\nimport * as InternalIr from './internal/state-trait/ir.js'\n\n// \u5BF9\u5916\u66B4\u9732\u7684\u6838\u5FC3\u7C7B\u578B\u522B\u540D\u3002\nexport type StateTraitSpec<S> = Model.StateTraitSpec<S>\nexport type StateTraitEntry<S = unknown, P extends string = string> = Model.StateTraitEntry<S, P>\nexport type StateTraitProgram<S> = Model.StateTraitProgram<S>\nexport type StateTraitGraph = Model.StateTraitGraph\nexport type StateTraitPlan = Model.StateTraitPlan\nexport type StateTraitNode<Input = unknown, Ctx = unknown> = Model.StateTraitNode<Input, Ctx>\nexport type StateTraitList<Item = unknown> = Model.StateTraitList<Item>\nexport type CheckRule<Input = unknown, Ctx = unknown> = Model.CheckRule<Input, Ctx>\n\nexport type StateFieldPath<S> = FieldPath.StateFieldPath<S>\nexport type StateAtPath<S, P> = FieldPath.StateAtPath<S, P>\n\nexport const $root = '$root' as const\n\ntype DepsArgs<S extends object, Deps extends ReadonlyArray<StateFieldPath<S>>> = {\n  readonly [K in keyof Deps]: StateAtPath<S, Deps[K]>\n}\n\n/**\n * StateTrait.from\uFF1A\n * - \u6839\u636E State Schema \u6536\u7A84\u53EF\u7528\u5B57\u6BB5\u8DEF\u5F84\uFF0C\u5E76\u4E3A traits spec \u63D0\u4F9B\u7C7B\u578B\u7EA6\u675F\uFF1B\n * - \u8FD0\u884C\u65F6\u4EC5\u8FD4\u56DE\u539F\u59CB spec \u5BF9\u8C61\uFF0C\u5177\u4F53\u5F52\u4E00\u5316\u7531 internal \u5C42\u5904\u7406\u3002\n */\nexport const from =\n  <S extends object, I>(_schema: Schema.Schema<S, I>) =>\n  (spec: StateTraitSpec<S>): StateTraitSpec<S> =>\n    spec\n\nexport const node = <Input = unknown, Ctx = unknown>(\n  spec: Omit<Model.StateTraitNode<Input, Ctx>, '_tag'>,\n): Model.StateTraitNode<Input, Ctx> => ({\n  _tag: 'StateTraitNode',\n  ...spec,\n})\n\nexport const list = <Item = unknown>(spec: Omit<Model.StateTraitList<Item>, '_tag'>): Model.StateTraitList<Item> => ({\n  _tag: 'StateTraitList',\n  ...spec,\n})\n\n/**\n * StateTrait.computed\uFF1A\n * - \u4E3A\u67D0\u4E2A\u5B57\u6BB5\u58F0\u660E computed \u80FD\u529B\uFF1B\n * - \u901A\u8FC7\u663E\u5F0F deps \u4F5C\u4E3A\u552F\u4E00\u4F9D\u8D56\u4E8B\u5B9E\u6E90\uFF08\u7528\u4E8E\u8BCA\u65AD/\u53CD\u5411\u95ED\u5305/\u540E\u7EED\u589E\u91CF\u8C03\u5EA6\uFF09\u3002\n */\nexport const computed = <\n  S extends object,\n  P extends StateFieldPath<S>,\n  const Deps extends ReadonlyArray<StateFieldPath<S>>,\n>(input: {\n  readonly deps: Deps\n  readonly get: (...depsValues: DepsArgs<S, Deps>) => StateAtPath<S, P>\n  readonly equals?: (prev: StateAtPath<S, P>, next: StateAtPath<S, P>) => boolean\n  /**\n   * 043\uFF1A\u663E\u5F0F converge time-slicing \u8C03\u5EA6\u58F0\u660E\u3002\n   * - unset\uFF1Aimmediate\uFF08\u9ED8\u8BA4\u884C\u4E3A\u4E0D\u53D8\uFF09\n   * - deferred\uFF1A\u53EF\u5EF6\u8FDF\u5230\u540E\u7EED\u7A97\u53E3\u5408\u5E76\u6267\u884C\uFF08\u9700\u540C\u65F6\u542F\u7528 runtime time-slicing\uFF09\n   */\n  readonly scheduling?: Model.TraitConvergeScheduling\n}): StateTraitEntry<S, P> => {\n  const derive = (state: Readonly<S>): StateAtPath<S, P> => {\n    const args = (input.deps as ReadonlyArray<string>).map((dep) => RowId.getAtPath(state as any, dep))\n    return (input.get as any)(...args)\n  }\n  return {\n    fieldPath: undefined as unknown as P,\n    kind: 'computed',\n    meta: {\n      deps: input.deps,\n      derive,\n      equals: input.equals,\n      ...(input.scheduling ? { scheduling: input.scheduling } : {}),\n    },\n  } as StateTraitEntry<S, P>\n}\n\n/**\n * StateTrait.source\uFF1A\n * - \u4E3A\u67D0\u4E2A\u5B57\u6BB5\u58F0\u660E\u5916\u90E8\u8D44\u6E90\u6765\u6E90\uFF08Resource / Query \u96C6\u6210\u5728\u540E\u7EED Phase \u4E2D\u5B9E\u73B0\uFF09\uFF1B\n * - \u5185\u6838\u8D1F\u8D23 keyHash gate / concurrency / ReplayMode \u884C\u4E3A\u3002\n */\nexport const source = <S extends object, P extends StateFieldPath<S>>(meta: {\n  resource: string\n  deps: ReadonlyArray<StateFieldPath<S>>\n  key: (state: Readonly<S>) => unknown\n  triggers?: ReadonlyArray<'onMount' | 'onValueChange' | 'manual'>\n  debounceMs?: number\n  concurrency?: 'switch' | 'exhaust-trailing'\n  /**\n   * \u7528\u4E8E Devtools/\u6587\u6863\u7684\u53EF\u5E8F\u5217\u5316\u5143\u4FE1\u606F\uFF08\u767D\u540D\u5355\u5B57\u6BB5\u4F1A\u5728 build \u9636\u6BB5\u88AB\u63D0\u53D6\uFF09\u3002\n   */\n  meta?: Record<string, unknown>\n}): StateTraitEntry<S, P> =>\n  ({\n    fieldPath: undefined as unknown as P,\n    kind: 'source',\n    meta,\n  }) as StateTraitEntry<S, P>\n\n/**\n * StateTrait.link\uFF1A\n * - \u4E3A\u76EE\u6807\u5B57\u6BB5\u58F0\u660E\u4ECE\u5176\u4ED6\u5B57\u6BB5\u8054\u52A8\u7684\u80FD\u529B\uFF1B\n * - meta.from \u540C\u6837\u53D7 StateFieldPath<S> \u7EA6\u675F\u3002\n */\nexport const link = <S extends object, P extends StateFieldPath<S>>(meta: {\n  from: StateFieldPath<S>\n  /**\n   * 043\uFF1A\u663E\u5F0F converge time-slicing \u8C03\u5EA6\u58F0\u660E\u3002\n   * - unset\uFF1Aimmediate\uFF08\u9ED8\u8BA4\u884C\u4E3A\u4E0D\u53D8\uFF09\n   * - deferred\uFF1A\u53EF\u5EF6\u8FDF\u5230\u540E\u7EED\u7A97\u53E3\u5408\u5E76\u6267\u884C\uFF08\u9700\u540C\u65F6\u542F\u7528 runtime time-slicing\uFF09\n   */\n  scheduling?: Model.TraitConvergeScheduling\n}): StateTraitEntry<S, P> =>\n  ({\n    fieldPath: undefined as unknown as P,\n    kind: 'link',\n    meta: { ...meta, ...(meta.scheduling ? { scheduling: meta.scheduling } : {}) },\n  }) as StateTraitEntry<S, P>\n\n/**\n * StateTrait.build\uFF1A\n * - \u5C06 Spec \u5F52\u4E00\u5316\u4E3A\u53EF\u6267\u884C Program\uFF08\u542B Graph/Plan\uFF09\uFF1B\n * - DSL \u5C42\u4E0E build \u5C42\u7684\u7EA6\u675F\u4EE5 build \u4E3A\u6700\u7EC8\u88C1\u51B3\uFF08\u4F8B\u5982\u5F3A\u5236\u663E\u5F0F deps\uFF09\u3002\n */\nexport const build = <S extends object>(\n  stateSchema: Schema.Schema<S, any>,\n  spec: StateTraitSpec<S>,\n): StateTraitProgram<S> => InternalBuild.build(stateSchema, spec)\n\n/**\n * StateTrait.install\uFF1A\n * - \u5728\u7ED9\u5B9A Bound API \u4E0A\u5B89\u88C5 Program \u63CF\u8FF0\u7684\u884C\u4E3A\uFF08computed/link/source/check \u7B49\uFF09\uFF1B\n * - \u6BCF\u4E2A PlanStep \u5BF9\u5E94\u4E00\u4E2A\u957F\u751F\u547D\u5468\u671F Effect\uFF0C\u5E76\u6302\u8F7D\u5230 Runtime Scope\u3002\n */\nexport const install = <S extends object>(\n  bound: BoundApi<any, any>,\n  program: StateTraitProgram<S>,\n): Effect.Effect<void, never, any> => InternalInstall.install(bound, program)\n\n/**\n * StateTrait.exportStaticIr\uFF1A\n * - \u5BFC\u51FA\u6700\u5C0F Static IR\uFF08\u5BF9\u9F50 009 \u7684 canonical FieldPath \u7EA6\u675F\uFF09\uFF0C\u4F9B Devtools/\u5BF9\u9F50\u5B9E\u9A8C\u5BA4\u6D88\u8D39\uFF1B\n * - \u8FD4\u56DE\u503C\u5FC5\u987B\u53EF JSON.stringify\uFF08\u7528\u4E8E\u8BC1\u636E\u5305/\u56DE\u653E\u94FE\u8DEF\uFF09\u3002\n */\nexport type StaticIr = InternalIr.StaticIr\n\nexport const exportStaticIr = (\n  program: StateTraitProgram<any>,\n  moduleId: string,\n  options?: {\n    readonly version?: string\n  },\n): StaticIr =>\n  InternalIr.exportStaticIr({\n    program,\n    moduleId,\n    version: options?.version,\n  })\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAM,oBAAoB,CAAC,UAAwD;AACjF,QAAM,MAAM,oBAAI,IAAY;AAC5B,aAAW,QAAQ,OAAO;AACxB,UAAM,IAAI,KAAK,KAAK;AACpB,QAAI,CAAC,EAAG;AACR,QAAI,IAAI,CAAC;AAAA,EACX;AACA,SAAO,MAAM,KAAK,GAAG,EAAE,KAAK,CAAC,GAAG,MAAM,EAAE,cAAc,CAAC,CAAC;AAC1D;AAEA,IAAM,gBAAgB,CAAC,UACrB,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAErE,IAAM,oBAAoB,CAAC,OAAgB,UAAyC;AAClF,MAAI,UAAU,KAAM,QAAO;AAE3B,MAAI,OAAO,UAAU,SAAU,QAAO;AACtC,MAAI,OAAO,UAAU,UAAW,QAAO;AACvC,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO,OAAO,SAAS,KAAK,IAAI,QAAQ;AAAA,EAC1C;AAEA,MAAI,SAAS,EAAG,QAAO;AAEvB,MAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,UAAM,MAAwB,CAAC;AAC/B,eAAW,QAAQ,OAAO;AACxB,YAAM,IAAI,kBAAkB,MAAM,QAAQ,CAAC;AAC3C,UAAI,MAAM,OAAW,KAAI,KAAK,CAAC;AAAA,IACjC;AACA,WAAO;AAAA,EACT;AAEA,MAAI,cAAc,KAAK,GAAG;AACxB,UAAM,OAAO,OAAO,KAAK,KAAK,EAAE,KAAK;AACrC,UAAM,MAAiC,CAAC;AACxC,eAAW,OAAO,MAAM;AACtB,YAAM,IAAI,kBAAkB,MAAM,GAAG,GAAG,QAAQ,CAAC;AACjD,UAAI,MAAM,OAAW,KAAI,GAAG,IAAI;AAAA,IAClC;AACA,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAEO,IAAM,WAAW,CAAC,UAA0C;AACjE,MAAI,UAAU,QAAQ,UAAU,OAAW,QAAO;AAClD,MAAI,OAAO,UAAU,YAAY,MAAM,QAAQ,KAAK,EAAG,QAAO;AAE9D,QAAM,SAAS;AACf,QAAM,MAA+B,CAAC;AAEtC,QAAM,aAAa,CAAC,QAA+B;AACjD,UAAM,QAAQ,OAAO,GAAa;AAClC,QAAI,OAAO,UAAU,SAAU;AAC/B,UAAM,UAAU,MAAM,KAAK;AAC3B,QAAI,CAAC,QAAS;AACd,QAAI,GAAG,IAAI;AAAA,EACb;AAEA,aAAW,OAAO;AAClB,aAAW,aAAa;AACxB,aAAW,OAAO;AAClB,aAAW,SAAS;AACpB,aAAW,YAAY;AAEvB,QAAM,YAAY,OAAO;AACzB,MAAI,OAAO,cAAc,WAAW;AAClC,QAAI,YAAY;AAAA,EAClB;AAEA,QAAM,UAAU,OAAO;AACvB,MAAI,OAAO,YAAY,UAAU;AAC/B,UAAM,OAAO,kBAAkB,CAAC,OAAO,CAAC;AACxC,QAAI,KAAK,SAAS,EAAG,KAAI,OAAO;AAAA,EAClC,WAAW,MAAM,QAAQ,OAAO,GAAG;AACjC,UAAM,OAAO,kBAAkB,QAAQ,OAAO,CAAC,MAAmB,OAAO,MAAM,QAAQ,CAAC;AACxF,QAAI,KAAK,SAAS,EAAG,KAAI,OAAO;AAAA,EAClC;AAEA,QAAM,cAAyC,CAAC;AAGhD,QAAM,iBAAiB,OAAO,KAAK,MAAM,EACtC,OAAO,CAAC,MAAM,EAAE,WAAW,IAAI,CAAC,EAChC,KAAK,CAAC,GAAG,MAAM,EAAE,cAAc,CAAC,CAAC;AACpC,aAAW,OAAO,gBAAgB;AAChC,UAAM,IAAI,kBAAkB,OAAO,GAAG,GAAG,CAAC;AAC1C,QAAI,MAAM,OAAW,aAAY,GAAG,IAAI;AAAA,EAC1C;AAGA,QAAM,iBAAiB,OAAO;AAC9B,MAAI,cAAc,cAAc,GAAG;AACjC,UAAM,OAAO,OAAO,KAAK,cAAc,EACpC,OAAO,CAAC,MAAM,EAAE,WAAW,IAAI,CAAC,EAChC,KAAK,CAAC,GAAG,MAAM,EAAE,cAAc,CAAC,CAAC;AACpC,eAAW,OAAO,MAAM;AACtB,YAAM,IAAI,kBAAkB,eAAe,GAAG,GAAG,CAAC;AAClD,UAAI,MAAM,OAAW,aAAY,GAAG,IAAI;AAAA,IAC1C;AAAA,EACF;AAEA,MAAI,OAAO,KAAK,WAAW,EAAE,SAAS,EAAG,KAAI,cAAc;AAE3D,SAAO,OAAO,KAAK,GAAG,EAAE,SAAS,IAAK,MAAoB;AAC5D;AAEA,IAAM,kBAAkB,CAAC,SAA4B;AACnD,QAAM,MAA+B,CAAC;AACtC,QAAM,OAAO,OAAO,KAAK,IAAI,EAAE,KAAK;AACpC,aAAW,KAAK,MAAM;AACpB,QAAI,CAAC,IAAK,KAAa,CAAC;AAAA,EAC1B;AACA,SAAO,KAAK,UAAU,GAAG;AAC3B;AAEO,IAAM,SAAS,CAAC,GAA0B,MAAsC;AACrF,MAAI,MAAM,EAAG,QAAO;AACpB,MAAI,CAAC,KAAK,CAAC,EAAG,QAAO;AACrB,SAAO,gBAAgB,CAAC,MAAM,gBAAgB,CAAC;AACjD;AAcO,IAAM,iBAAiB,CAC5B,SACA,aACyB;AACzB,QAAM,WAAW,QAAQ;AACzB,MAAI,CAAC,UAAU;AACb,WAAO;AAAA,MACL,MAAM,SAAS;AAAA,MACf,QAAQ,SAAS;AAAA,MACjB,WAAW,QAAQ;AAAA,IACrB;AAAA,EACF;AAEA,MAAI,OAAO,UAAU,SAAS,IAAI,GAAG;AACnC,WAAO;AAAA,EACT;AAEA,QAAM,YAAsC,CAAC,GAAK,QAAQ,aAAa,CAAC,CAAuC;AAE/G,QAAM,OAAO,CAAC,aAAsC;AAClD,UAAM,SAAS,UAAU,KAAK,CAAC,MAAM,EAAE,WAAW,SAAS,UAAU,OAAO,EAAE,MAAM,SAAS,IAAI,CAAC;AAClG,QAAI,CAAC,OAAQ,WAAU,KAAK,QAAQ;AAAA,EACtC;AAEA,QAAM,oBAAoB,SAAS,cAAc;AACjD,QAAM,oBAAoB,SAAS,KAAK,cAAc;AAEtD,MAAI,CAAC,qBAAqB,mBAAmB;AAC3C,SAAK;AAAA,MACH,QAAQ,QAAQ,UAAU;AAAA,MAC1B,MAAM;AAAA,IACR,CAAC;AACD,WAAO;AAAA,MACL,MAAM,SAAS;AAAA,MACf,QAAQ,SAAS;AAAA,MACjB;AAAA,IACF;AAAA,EACF;AAEA,OAAK;AAAA,IACH,QAAQ,SAAS;AAAA,IACjB,MAAM,SAAS;AAAA,EACjB,CAAC;AAED,SAAO;AAAA,IACL,MAAM;AAAA,IACN,QAAQ,QAAQ,UAAU,SAAS;AAAA,IACnC;AAAA,EACF;AACF;;;ACyGO,IAAM,gBAAgB,CAAI,SAAyE;AACxG,QAAM,UAA+C,CAAC;AAEtD,QAAM,SAAS,CAAC,UACd,OAAO,UAAU,YAAY,UAAU,QAAS,MAAc,SAAS;AAEzE,QAAM,SAAS,CAAC,UACd,OAAO,UAAU,YAAY,UAAU,QAAS,MAAc,SAAS;AAEzE,QAAM,WAAW,CAAC,QAAgB,WAA2B;AAC3D,QAAI,CAAC,OAAQ,QAAO;AACpB,QAAI,CAAC,OAAQ,QAAO;AACpB,WAAO,GAAG,MAAM,IAAI,MAAM;AAAA,EAC5B;AAEA,QAAM,aAAa,CAAC,MAAyC,WAA0C;AACrG,QAAI,CAAC,QAAQ,KAAK,WAAW,EAAG,QAAO,CAAC;AACxC,WAAO,KAAK,IAAI,CAAC,MAAO,SAAS,SAAS,QAAQ,CAAC,IAAI,CAAE;AAAA,EAC3D;AAEA,QAAM,iBAAiB,CACrB,OACA,WACA,cACiC;AACjC,QAAI,MAAM,SAAS,YAAY;AAC7B,YAAM,OAAO,MAAM;AACnB,YAAM,UAAU,KAAK;AACrB,YAAM,OAAO,YAAY,SAAY,WAAW,SAAS,SAAS,IAAI;AACtE,aAAO;AAAA,QACL,GAAI;AAAA,QACJ;AAAA,QACA,MAAM,EAAE,GAAG,MAAM,KAAK;AAAA,MACxB;AAAA,IACF;AACA,QAAI,MAAM,SAAS,UAAU;AAC3B,YAAM,OAAO,MAAM;AACnB,YAAM,UAAU,KAAK;AACrB,YAAM,OAAO,YAAY,SAAY,WAAW,SAAS,SAAS,IAAI;AACtE,aAAO;AAAA,QACL,GAAI;AAAA,QACJ;AAAA,QACA,MAAM,EAAE,GAAG,MAAM,MAAM,YAAY,UAAU;AAAA,MAC/C;AAAA,IACF;AACA,QAAI,MAAM,SAAS,QAAQ;AACzB,YAAM,OAAO,MAAM;AACnB,YAAMA,QAAO,WAAW,CAAC,KAAK,IAAc,GAAG,SAAS,EAAE,CAAC,KAAK,KAAK;AACrE,aAAO;AAAA,QACL,GAAI;AAAA,QACJ;AAAA,QACA,MAAM,EAAE,GAAG,MAAM,MAAAA,MAAK;AAAA,MACxB;AAAA,IACF;AAEA,WAAO;AAAA,MACL,GAAI;AAAA,MACJ;AAAA,IACF;AAAA,EACF;AAEA,QAAM,aAAa,CACjB,SACA,YACAC,OACA,YASS;AACT,UAAM,WAAW,CAAC,gBAAwB,QAA4C;AACpF,YAAM,MAAO,IAAY,aAAa;AACtC,YAAM,YAAY,aAAa,SAAS,YAAY,OAAO,GAAG,CAAC,IAAI,OAAO,GAAG;AAC7E,cAAQ,KAAK,eAAe,KAAK,WAAW,UAAU,CAAC;AAAA,IACzD;AAEA,UAAM,oBAAoB,CACxB,UACS;AACT,UAAI,CAAC,MAAO;AACZ,UAAI,OAAQ,MAAc,SAAS,UAAU;AAC3C,iBAAS,IAAI,KAAY;AACzB;AAAA,MACF;AACA,YAAM,SAAS;AACf,iBAAW,OAAO,QAAQ;AACxB,YAAI,CAAC,OAAO,UAAU,eAAe,KAAK,QAAQ,GAAG,EAAG;AACxD,cAAM,QAAQ,OAAO,GAAG;AACxB,YAAI,CAAC,MAAO;AACZ,iBAAS,KAAK,KAAY;AAAA,MAC5B;AAAA,IACF;AAEA,sBAAkBA,MAAK,QAAQ;AAC/B,sBAAkBA,MAAK,MAAM;AAC7B,sBAAkBA,MAAK,IAAI;AAE3B,QAAIA,MAAK,OAAO;AACd,YAAM,QAA6C,CAAC;AACpD,YAAM,kBAAkB,SAAS,oBAAoB,WAAW,SAAS,IAAI,IAAI,aAAa;AAE9F,YAAM,kBAAkB,CAAC,SAAmE;AAC1F,YAAI,CAAC,QAAQ,KAAK,WAAW,EAAG,QAAO,CAAC;AACxC,eAAO,KAAK,IAAI,CAAC,MAAO,MAAM,KAAK,UAAU,kBAAkB,SAAS,iBAAiB,CAAC,IAAI,CAAE;AAAA,MAClG;AACA,iBAAW,QAAQ,OAAO,KAAKA,MAAK,KAAK,GAAG;AAC1C,cAAM,OAAQA,MAAK,MAAc,IAAI;AACrC,YAAI,OAAO,SAAS,YAAY;AAC9B,gBAAM,IAAI,IAAI;AACd;AAAA,QACF;AACA,YAAI,QAAQ,OAAO,SAAS,UAAU;AACpC,gBAAM,OAAY,SAAU,KAAa,IAAI;AAC7C,gBAAM,IAAI,IAAI;AAAA,YACZ,GAAG;AAAA,YACH,MAAM,gBAAgB,KAAK,IAAI;AAAA,YAC/B;AAAA,UACF;AACA;AAAA,QACF;AAAA,MAEF;AAEA,cAAQ,KAAK;AAAA,QACX,WAAW;AAAA,QACX,MAAM;AAAA,QACN,MAAM;AAAA,UACJ;AAAA,UACA,WAAW,EAAE,MAAM,SAAS;AAAA,QAC9B;AAAA,MACF,CAA8B;AAAA,IAChC;AAAA,EACF;AAEA,aAAW,OAAO,MAAM;AACtB,QAAI,CAAC,OAAO,UAAU,eAAe,KAAK,MAAM,GAAG,EAAG;AACtD,UAAM,MAAM,KAAK,GAAwB;AACzC,QAAI,CAAC,IAAK;AAEV,QAAI,OAAO,GAAG,GAAG;AACf,YAAM,WAAW;AACjB,UAAI,IAAI,MAAM;AACZ,mBAAW,GAAG,QAAQ,MAAM,GAAG,QAAQ,MAAM,IAAI,IAAI;AAAA,MACvD;AACA,UAAI,IAAI,MAAM;AACZ,mBAAW,UAAU,UAAU,IAAI,MAAM;AAAA,UACvC,iBAAiB,GAAG,QAAQ;AAAA,QAC9B,CAAC;AAAA,MACH;AACA;AAAA,IACF;AAEA,QAAI,OAAO,GAAG,GAAG;AACf,UAAI,QAAQ,SAAS;AACnB,mBAAW,SAAS,IAAI,GAAG;AAAA,MAC7B,OAAO;AACL,mBAAW,KAAK,KAAK,GAAG;AAAA,MAC1B;AACA;AAAA,IACF;AAEA,UAAM,QAAQ;AACd,UAAM,YAAa,MAAc,aAAa;AAC9C,YAAQ,KAAK,eAAe,OAAO,OAAO,SAAS,GAAG,EAAE,CAAC;AAAA,EAC3D;AAEA,SAAO;AACT;AAOO,IAAM,kBAAkB,CAAI,SAAiE;AAClG,QAAM,MAAM,oBAAI,IAA4B;AAE5C,QAAM,SAAS,CAAC,UACd,OAAO,UAAU,YAAY,UAAU,QAAS,MAAc,SAAS;AAEzE,QAAM,SAAS,CAAC,UACd,OAAO,UAAU,YAAY,UAAU,QAAS,MAAc,SAAS;AAEzE,QAAM,MAAM,CAAC,SAAiBA,UAAyC;AACrE,UAAM,OAAY,SAASA,MAAK,IAAI;AACpC,QAAI,KAAM,KAAI,IAAI,SAAS,IAAI;AAAA,EACjC;AAEA,aAAW,OAAO,MAAM;AACtB,QAAI,CAAC,OAAO,UAAU,eAAe,KAAK,MAAM,GAAG,EAAG;AACtD,UAAM,MAAM,KAAK,GAAwB;AACzC,QAAI,CAAC,IAAK;AAEV,QAAI,OAAO,GAAG,GAAG;AACf,YAAM,WAAW;AACjB,UAAI,IAAI,KAAM,KAAI,GAAG,QAAQ,MAAM,IAAI,IAAI;AAC3C,UAAI,IAAI,KAAM,KAAI,UAAU,IAAI,IAAI;AACpC;AAAA,IACF;AAEA,QAAI,OAAO,GAAG,GAAG;AACf,UAAI,QAAQ,QAAS,KAAI,SAAS,GAAG;AAAA,UAChC,KAAI,KAAK,GAAG;AACjB;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;;;ACzfA,IAAM,UAAU,MACd,OAAO,WAAW,gBAAgB,eAAe,OAAO,WAAW,YAAY,QAAQ,aACnF,WAAW,YAAY,IAAI,IAC3B,KAAK,IAAI;AAIf,IAAM,wBAAwB,CAAC,UAAiD;AAC9E,MAAI,MAAM,SAAS,YAAY;AAC7B,WAAS,MAAM,MAAc,QAAQ,CAAC;AAAA,EACxC;AACA,SAAO,CAAC,MAAM,KAAK,IAAc;AACnC;AAEA,IAAM,2BAA2B,CAC/B,YAC8G;AAC9G,QAAM,eAAe,oBAAI,IAA4B;AACrD,aAAW,SAAS,SAAS;AAC3B,UAAM,WAAW,aAAa,IAAI,MAAM,SAAS;AACjD,QAAI,UAAU;AACZ,aAAO;AAAA,QACL,OAAO,CAAC;AAAA,QACR,aAAa;AAAA,UACX,MAAM;AAAA,UACN,SAAS,qDAAqD,MAAM,SAAS,MAAM,SAAS,IAAI,MAAM,MAAM,IAAI;AAAA,UAChH,QAAQ,CAAC,MAAM,SAAS;AAAA,QAC1B;AAAA,MACF;AAAA,IACF;AACA,iBAAa,IAAI,MAAM,WAAW,KAAK;AAAA,EACzC;AAEA,QAAM,QAAQ,oBAAI,IAAY;AAC9B,aAAW,SAAS,SAAS;AAC3B,UAAM,IAAI,MAAM,SAAS;AAAA,EAC3B;AAEA,QAAM,WAAW,oBAAI,IAAoB;AACzC,QAAM,UAAU,oBAAI,IAA2B;AAE/C,aAAWC,SAAQ,OAAO;AACxB,aAAS,IAAIA,OAAM,CAAC;AACpB,YAAQ,IAAIA,OAAM,CAAC,CAAC;AAAA,EACtB;AAEA,aAAW,SAAS,SAAS;AAC3B,UAAM,KAAK,MAAM;AACjB,UAAM,OAAO,sBAAsB,KAAK;AACxC,eAAW,OAAO,MAAM;AACtB,UAAI,CAAC,MAAM,IAAI,GAAG,EAAG;AACrB,cAAQ,IAAI,GAAG,EAAG,KAAK,EAAE;AACzB,eAAS,IAAI,KAAK,SAAS,IAAI,EAAE,KAAK,KAAK,CAAC;AAAA,IAC9C;AAAA,EACF;AAEA,QAAM,QAAuB,CAAC;AAC9B,aAAW,CAACA,OAAM,GAAG,KAAK,SAAS,QAAQ,GAAG;AAC5C,QAAI,QAAQ,EAAG,OAAM,KAAKA,KAAI;AAAA,EAChC;AAEA,QAAM,QAAuB,CAAC;AAC9B,SAAO,MAAM,QAAQ;AACnB,UAAM,IAAI,MAAM,MAAM;AACtB,UAAM,KAAK,CAAC;AACZ,UAAM,OAAO,QAAQ,IAAI,CAAC;AAC1B,eAAW,MAAM,MAAM;AACrB,YAAM,QAAQ,SAAS,IAAI,EAAE,KAAK,KAAK;AACvC,eAAS,IAAI,IAAI,IAAI;AACrB,UAAI,SAAS,EAAG,OAAM,KAAK,EAAE;AAAA,IAC/B;AAAA,EACF;AAEA,MAAI,MAAM,WAAW,MAAM,MAAM;AAC/B,UAAM,YAAY,MAAM,KAAK,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,SAAS,CAAC,CAAC;AACpE,WAAO;AAAA,MACL,OAAO,CAAC;AAAA,MACR,aAAa;AAAA,QACX,MAAM;AAAA,QACN,SAAS,gEAAgE,UAAU,KAAK,IAAI,CAAC;AAAA,QAC7F,QAAQ;AAAA,MACV;AAAA,IACF;AAAA,EACF;AAEA,SAAO,EAAE,MAAM;AACjB;AAEA,IAAM,kBAAkB,CAAC,YAAmF;AAC1G,QAAM,YAAY,QAAQ;AAC1B,QAAM,aAAa;AAEnB,QAAM,UAAU,QAAQ,OAAO,CAAC,MAA2B,EAAE,SAAS,cAAc,EAAE,SAAS,MAAM;AAErG,QAAM,aAAa,QAChB,IAAI,CAAC,UAAU,GAAG,MAAM,IAAI,IAAI,MAAM,SAAS,EAAE,EACjD,KAAK,EACL,KAAK,GAAG;AAEX,QAAM,UAAU,QACb,IAAI,CAAC,UAAU;AACd,UAAM,OAAO,sBAAsB,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG;AACjE,UAAM,aAAc,MAAM,MAAc,eAAe,aAAa,MAAM;AAC1E,WAAO,GAAG,MAAM,IAAI,IAAI,MAAM,SAAS,IAAI,UAAU,KAAK,IAAI;AAAA,EAChE,CAAC,EACA,KAAK,EACL,KAAK,GAAG;AAEX,QAAM,eAAe,oBAAI,IAA4B;AACrD,aAAW,SAAS,SAAS;AAC3B,iBAAa,IAAI,MAAM,WAAW,KAAK;AAAA,EACzC;AAEA,QAAM,OAAO,QAAQ,SAAS,IAAI,yBAAyB,OAAO,IAAI,EAAE,OAAO,CAAC,EAA2B;AAC3G,QAAM,YAAmC,KAAK,cAAc,CAAC,IAAI,KAAK,MAAM,IAAI,CAAC,SAAS,aAAa,IAAI,IAAI,CAAE;AAEjH,QAAM,iBAAiB,oBAAI,IAAuB;AAClD,QAAM,UAAU,CAAC,SAA0B;AACzC,aAAS,IAAI,GAAG,KAAK,KAAK,QAAQ,KAAK;AACrC,YAAM,SAAS,KAAK,MAAM,GAAG,CAAC;AAC9B,YAAM,MAAM,KAAK,UAAU,MAAM;AACjC,UAAI,CAAC,eAAe,IAAI,GAAG,EAAG,gBAAe,IAAI,KAAK,MAAM;AAAA,IAC9D;AAAA,EACF;AAEA,aAAW,SAAS,SAAS;AAC3B,UAAM,MAAM,mBAAmB,MAAM,SAAS;AAC9C,QAAI,IAAK,SAAQ,GAAG;AACpB,eAAW,OAAO,sBAAsB,KAAK,GAAG;AAC9C,YAAM,UAAU,mBAAmB,GAAG;AACtC,UAAI,QAAS,SAAQ,OAAO;AAAA,IAC9B;AAAA,EACF;AAEA,QAAM,aAAa,MAAM,KAAK,eAAe,OAAO,CAAC,EAAE,KAAK,gBAAgB;AAC5E,QAAM,sBAAsB,wBAAwB,UAAU;AAE9D,QAAM,6BAAiD,CAAC;AACxD,QAAM,+BAAkE,CAAC;AACzE,QAAM,yBAA0D,CAAC;AAEjE,aAAW,SAAS,WAAW;AAC7B,UAAM,MAAM,mBAAmB,MAAM,SAAS;AAC9C,UAAM,QAAQ,OAAO,OAAO,eAAe,qBAAqB,GAAG,IAAI;AACvE,QAAI,SAAS,MAAM;AACjB,YAAM,IAAI,MAAM,+DAA+D,MAAM,SAAS,mBAAmB;AAAA,IACnH;AAEA,UAAM,SAA6B,CAAC;AACpC,eAAW,OAAO,sBAAsB,KAAK,GAAG;AAC9C,YAAM,UAAU,mBAAmB,GAAG;AACtC,UAAI,CAAC,QAAS;AACd,YAAM,QAAQ,eAAe,qBAAqB,OAAO;AACzD,UAAI,SAAS,KAAM,QAAO,KAAK,KAAK;AAAA,IACtC;AAEA,+BAA2B,KAAK,KAAK;AACrC,iCAA6B,KAAK,MAAM;AACxC,2BAAuB,KAAM,MAAM,MAAc,eAAe,aAAa,aAAa,WAAW;AAAA,EACvG;AAEA,QAAM,YAAY,UAAU,IAAI,CAAC,GAAG,MAAM,CAAC;AAC3C,QAAM,kBAAkB,KAAK,IAAI,GAAG,QAAQ,IAAI,SAAS;AAEzD,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAI,KAAK,cAAc,EAAE,aAAa,KAAK,YAAY,IAAI;AAAA,IAC3D;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAQA,IAAM,eAAe,CAAC,UAA8D;AAClF,QAAM,OAAsB,CAAC;AAE7B,MAAI,MAAM,SAAS,YAAY;AAC7B,UAAM,OAAO,MAAM;AACnB,UAAMC,QAAO,KAAK;AAClB,QAAIA,MAAM,MAAK,KAAK,GAAGA,KAAI;AAAA,EAC7B,WAAW,MAAM,SAAS,UAAU;AAClC,UAAM,OAAO,MAAM;AACnB,UAAMA,QAAO,KAAK;AAClB,QAAIA,MAAM,MAAK,KAAK,GAAGA,KAAI;AAAA,EAC7B,WAAW,MAAM,SAAS,QAAQ;AAChC,SAAK,KAAK,MAAM,KAAK,IAAc;AAAA,EACrC,WAAW,MAAM,SAAS,SAAS;AACjC,UAAM,OAAO,MAAM;AACnB,UAAM,QAAS,MAAM,SAAS,CAAC;AAC/B,eAAW,QAAQ,OAAO,KAAK,KAAK,GAAG;AACrC,YAAM,OAAO,MAAM,IAAI;AACvB,UAAI,QAAQ,OAAO,SAAS,UAAU;AACpC,cAAMA,QAAO,KAAK;AAClB,YAAIA,MAAM,MAAK,KAAK,GAAGA,KAAI;AAAA,MAC7B;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AAAA,IACL,SAAS,MAAM;AAAA,IACf,MAAM,MAAM;AAAA;AAAA,IAEZ,MAAM,MAAM;AAAA,IACZ;AAAA,EACF;AACF;AAKA,IAAM,aAAa,CACjB,SACA,wBAIG;AACH,QAAM,WAAW,oBAAI,IAA6B;AAClD,QAAM,QAAoC,CAAC;AAC3C,QAAM,QAAoC,CAAC;AAC3C,QAAM,gBAAgB,oBAAI,IAAgC;AAC1D,QAAM,YAAuC,CAAC;AAE9C,QAAM,cAAc,CAAC,cAAuC;AAC1D,QAAI,QAAQ,SAAS,IAAI,SAAS;AAClC,QAAI,CAAC,OAAO;AACV,cAAQ;AAAA,QACN,IAAI;AAAA,QACJ,MAAM;AAAA,QACN,QAAQ,CAAC;AAAA,MACX;AACA,eAAS,IAAI,WAAW,KAAK;AAAA,IAC/B;AACA,WAAO;AAAA,EACT;AAEA,aAAW,SAAS,SAAS;AAC3B,UAAM,YAAY,MAAM;AACxB,UAAM,QAAQ,YAAY,SAAS;AACnC,UAAM,QAAQ,aAAa,KAAK;AAE/B,IAAC,MAAM,OAAuC,KAAK,KAAK;AAGzD,QAAI,MAAM,SAAS,YAAY;AAC7B,YAAM,SAAS,YAAY,SAAS;AACpC,gBAAU,KAAK;AAAA,QACb,IAAI;AAAA,QACJ,MAAM;AAAA,QACN,iBAAiB;AAAA;AAAA,MAEnB,CAAC;AAED,YAAM,OAAQ,MAAM,KAAa;AACjC,UAAI,MAAM;AACR,mBAAW,OAAO,MAAM;AACtB,sBAAY,GAAG;AACf,gBAAM,KAAK;AAAA,YACT,IAAI,YAAY,GAAG,KAAK,SAAS;AAAA,YACjC,MAAM;AAAA,YACN,IAAI;AAAA,YACJ,MAAM;AAAA,UACR,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF,WAAW,MAAM,SAAS,QAAQ;AAChC,YAAMC,QAAO,MAAM,KAAK;AACxB,kBAAYA,KAAI;AAEhB,YAAM,SAAS,QAAQA,KAAI,KAAK,SAAS;AACzC,YAAM,KAAK;AAAA,QACT,IAAI;AAAA,QACJ,MAAAA;AAAA,QACA,IAAI;AAAA,QACJ,MAAM;AAAA,MACR,CAAC;AAED,gBAAU,KAAK;AAAA,QACb,IAAI,QAAQ,SAAS;AAAA,QACrB,MAAM;AAAA,QACN,iBAAiB;AAAA,QACjB,kBAAkB,CAACA,KAAI;AAAA,QACvB,WAAW;AAAA,UACT,aAAa;AAAA,QACf;AAAA,MACF,CAAC;AAAA,IACH,WAAW,MAAM,SAAS,UAAU;AAClC,YAAM,aAAa,MAAM,KAAK;AAC9B,YAAM,eAAoB,SAAU,MAAM,KAAa,IAAI;AAE3D,YAAM,WAAW,cAAc,IAAI,UAAU;AAC7C,UAAI,UAAU;AACZ,cAAM,cAAc,CAAC,GAAG,SAAS,aAAa,SAAS;AACvD,YAAI,OAAO,SAAS;AACpB,YAAI,aAAa,SAAS;AAC1B,YAAI,gBAAgB,SAAS;AAE7B,YAAI,cAAc;AAChB,gBAAM,SAAc;AAAA,YAClB,EAAE,MAAM,QAAQ,YAAY,WAAW,cAAc;AAAA,YACrD,EAAE,QAAQ,WAAW,MAAM,aAAa;AAAA,UAC1C;AACA,iBAAO,OAAO;AACd,uBAAa,OAAO;AACpB,0BAAgB,OAAO;AAAA,QACzB;AAEA,sBAAc,IAAI,YAAY;AAAA,UAC5B,GAAG;AAAA,UACH;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QACF,CAAC;AAAA,MACH,OAAO;AACL,sBAAc,IAAI,YAAY;AAAA,UAC5B;AAAA;AAAA,UAEA,aAAa,qBAAqB,SAAS;AAAA,UAC3C,aAAa,CAAC,SAAS;AAAA,UACvB,MAAM;AAAA,UACN,YAAY,eAAe,YAAY;AAAA,QACzC,CAAC;AAAA,MACH;AAEA,gBAAU,KAAK;AAAA,QACb,IAAI,UAAU,SAAS;AAAA,QACvB,MAAM;AAAA,QACN,iBAAiB;AAAA,QACjB;AAAA,QACA,eAAe,qBAAqB,SAAS;AAAA,MAC/C,CAAC;AAED,YAAM,OAAQ,MAAM,KAAa;AACjC,UAAI,MAAM;AACR,mBAAW,OAAO,MAAM;AACtB,sBAAY,GAAG;AACf,gBAAM,KAAK;AAAA,YACT,IAAI,cAAc,GAAG,KAAK,SAAS;AAAA,YACnC,MAAM;AAAA,YACN,IAAI;AAAA,YACJ,MAAM;AAAA,UACR,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF,WAAW,MAAM,SAAS,SAAS;AACjC,gBAAU,KAAK;AAAA,QACb,IAAI,SAAS,SAAS;AAAA,QACtB,MAAM;AAAA,QACN,iBAAiB;AAAA,MACnB,CAAC;AAGD,UAAI,MAAM,KAAK,SAAS,GAAG;AACzB,mBAAW,OAAO,MAAM,MAAM;AAC5B,sBAAY,GAAG;AACf,gBAAM,KAAK;AAAA,YACT,IAAI,aAAa,GAAG,KAAK,SAAS;AAAA,YAClC,MAAM;AAAA,YACN,IAAI;AAAA,YACJ,MAAM;AAAA,UACR,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,aAAW,SAAS,SAAS,OAAO,GAAG;AACrC,UAAM,KAAK;AAAA,MACT,IAAI,MAAM;AAAA,MACV;AAAA,MACA,QAAQ,MAAM;AAAA,MACd,MAAM,oBAAoB,IAAI,MAAM,EAAE;AAAA,IACxC,CAAC;AAAA,EACH;AAEA,QAAM,QAAyB;AAAA,IAC7B,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA,WAAW,MAAM,KAAK,cAAc,OAAO,CAAC;AAAA,EAC9C;AAEA,QAAM,OAAuB;AAAA,IAC3B,MAAM;AAAA,IACN,OAAO;AAAA,EACT;AAEA,SAAO,EAAE,OAAO,KAAK;AACvB;AAQA,IAAM,qBAAqB,CAAC,UAAoD;AAC9E,QAAM,YAAY,oBAAI,IAAsB;AAE5C,aAAW,QAAQ,OAAO;AACxB,QAAI,KAAK,SAAS,OAAQ;AAC1B,UAAMD,QAAO,UAAU,IAAI,KAAK,IAAI,KAAK,CAAC;AAC1C,IAAAA,MAAK,KAAK,KAAK,EAAE;AACjB,cAAU,IAAI,KAAK,MAAMA,KAAI;AAAA,EAC/B;AAEA,QAAM,UAAU,oBAAI,IAAY;AAChC,QAAM,QAAQ,oBAAI,IAAY;AAE9B,QAAM,MAAM,CAACD,UAAuB;AAClC,QAAI,MAAM,IAAIA,KAAI,GAAG;AACnB,YAAM,IAAI;AAAA,QACR,oDAAoDA,KAAI;AAAA,MAE1D;AAAA,IACF;AACA,QAAI,QAAQ,IAAIA,KAAI,EAAG;AACvB,YAAQ,IAAIA,KAAI;AAChB,UAAM,IAAIA,KAAI;AAEd,UAAM,QAAQ,UAAU,IAAIA,KAAI;AAChC,QAAI,OAAO;AACT,iBAAW,MAAM,OAAO;AACtB,YAAI,EAAE;AAAA,MACR;AAAA,IACF;AAEA,UAAM,OAAOA,KAAI;AAAA,EACnB;AAEA,aAAWA,SAAQ,UAAU,KAAK,GAAG;AACnC,QAAI,CAAC,QAAQ,IAAIA,KAAI,GAAG;AACtB,UAAIA,KAAI;AAAA,IACV;AAAA,EACF;AACF;AAEA,IAAM,qBAAqB,CACzB,YAC2C;AAC3C,QAAM,QAAQ,oBAAI,IAAqC;AAEvD,QAAM,MAAM,CAAC,QAAuC;AAClD,QAAI,CAAC,IAAI,KAAM;AACf,UAAM,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,SAAS,IAAI,IAAI,cAAc,IAAI,IAAI,YAAY,EAAE,IAAI,IAAI,IAAI;AAC9F,UAAM,IAAI,GAAG,GAAG;AAAA,EAClB;AAEA,QAAM,wBAAwB,CAAC,UAAqF;AAClH,UAAM,KAAM,MAAM,MAAc;AAChC,UAAM,IAAI,MAAM,OAAO,OAAO,WAAY,GAAW,OAAO;AAC5D,UAAM,gBAAgB,OAAO,MAAM,YAAY,EAAE,WAAW,SAAS,IAAI,IAAI;AAE7E,QAAI,cAAe,QAAO;AAE1B,UAAM,YAAY,MAAM;AACxB,QAAI,UAAU,SAAS,IAAI,GAAG;AAC5B,aAAO,UAAU,UAAU,MAAM,GAAG,EAAE,CAAC;AAAA,IACzC;AACA,WAAO,UAAU,SAAS;AAAA,EAC5B;AAEA,aAAW,SAAS,SAAS;AAC3B,QAAI;AAAA,MACF,MAAM;AAAA,MACN,WAAW,MAAM;AAAA,MACjB,gBAAgB,MAAM;AAAA,MACtB,MAAM,MAAM;AAAA,IACd,CAAC;AAED,QAAI,MAAM,SAAS,cAAc,MAAM,SAAS,UAAU;AACxD,YAAM,OAAS,MAAM,MAAc,QAAQ,CAAC;AAC5C,iBAAW,OAAO,MAAM;AACtB,YAAI;AAAA,UACF,MAAM;AAAA,UACN,WAAW,MAAM;AAAA,UACjB,gBAAgB,MAAM;AAAA,UACtB,MAAM;AAAA,QACR,CAAC;AAAA,MACH;AAAA,IACF;AAEA,QAAI,MAAM,SAAS,QAAQ;AACzB,UAAI;AAAA,QACF,MAAM;AAAA,QACN,WAAW;AAAA,QACX,gBAAgB,MAAM;AAAA,QACtB,MAAM,MAAM,KAAK;AAAA,MACnB,CAAC;AAAA,IACH;AAEA,QAAI,MAAM,SAAS,SAAS;AAC1B,UAAI;AAAA,QACF,MAAM;AAAA,QACN,WAAW;AAAA,QACX,gBAAgB,MAAM;AAAA,QACtB,MAAM,sBAAsB,KAAK;AAAA,MACnC,CAAC;AAED,YAAM,QAAU,MAAM,MAAc,SAAS,CAAC;AAC9C,iBAAW,QAAQ,OAAO,KAAK,KAAK,GAAG;AACrC,cAAM,OAAO,MAAM,IAAI;AACvB,YAAI,CAAC,QAAQ,OAAO,SAAS,SAAU;AACvC,cAAM,OAAQ,KAAK,QAAQ,CAAC;AAC5B,mBAAW,OAAO,MAAM;AACtB,cAAI;AAAA,YACF,MAAM;AAAA,YACN,WAAW;AAAA,YACX,gBAAgB,MAAM;AAAA,YACtB,UAAU;AAAA,YACV,MAAM;AAAA,UACR,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,SAAO,MAAM,KAAK,MAAM,QAAQ,CAAC,EAC9B,KAAK,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC,EACvC,IAAI,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC;AACrB;AAcO,IAAM,QAAQ,CACnB,aACA,SACyB;AACzB,QAAM,UAAU,cAAc,IAAI;AAClC,QAAM,sBAAsB,gBAAgB,IAAI;AAGhD,aAAW,SAAS,SAAS;AAC3B,QAAI,MAAM,SAAS,YAAY;AAC7B,YAAM,OAAQ,MAAM,KAAa;AACjC,UAAI,SAAS,QAAW;AACtB,cAAM,IAAI;AAAA,UACR,0DAA0D,MAAM,SAAS;AAAA,QAE3E;AAAA,MACF;AAAA,IACF;AACA,QAAI,MAAM,SAAS,UAAU;AAC3B,YAAM,OAAQ,MAAM,KAAa;AACjC,UAAI,SAAS,QAAW;AACtB,cAAM,IAAI;AAAA,UACR,wDAAwD,MAAM,SAAS;AAAA,QAEzE;AAAA,MACF;AAAA,IACF;AACA,QAAI,MAAM,SAAS,SAAS;AAC1B,YAAM,QAAU,MAAM,MAAc,SAAS,CAAC;AAC9C,iBAAW,QAAQ,OAAO,KAAK,KAAK,GAAG;AACrC,cAAM,OAAO,MAAM,IAAI;AACvB,YAAI,OAAO,SAAS,cAAc,CAAC,QAAQ,OAAO,SAAS,UAAU;AACnE,gBAAM,IAAI;AAAA,YACR,uDAAuD,MAAM,SAAS,WAAW,IAAI;AAAA,UAEvF;AAAA,QACF;AACA,YAAK,KAAa,SAAS,QAAW;AACpC,gBAAM,IAAI;AAAA,YACR,uDAAuD,MAAM,SAAS,WAAW,IAAI;AAAA,UAEvF;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,QAAM,EAAE,OAAO,KAAK,IAAI,WAAW,SAAS,mBAAmB;AAG/D,qBAAmB,MAAM,KAAK;AAE9B,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,YAAY,gBAAgB,OAAsD;AAAA,IAClF,aAAa,mBAAmB,OAAsD;AAAA,EACxF;AACF;;;AC7nBA,SAAS,cAAc;AAWvB,IAAM,kBAAkB,CACtB,YACmD;AACnD,QAAM,QAAQ,oBAAI,IAA+C;AACjE,aAAW,SAAS,SAAS;AAC3B,UAAMG,QAAO,MAAM,IAAI,MAAM,SAAS,KAAK,CAAC;AAC5C,IAAAA,MAAK,KAAK,KAAK;AACf,UAAM,IAAI,MAAM,WAAWA,KAAI;AAAA,EACjC;AACA,SAAO;AACT;AAcO,IAAM,UAAU,CACrB,OACA,YACoC;AAEpC,MAAI;AACF,UAAM,YAAY,kBAAkB,KAAY;AAC/C,IAAC,UAAU,OAAO,0BAAkC,SAAS;AAAA,MAC5D,YAAY;AAAA,IACd,CAAC;AAAA,EACH,QAAQ;AAAA,EAER;AAEA,QAAM,aAAa,gBAAgB,QAAQ,OAAc;AAEzD,QAAM,cAAc,CAAC,SAA8D;AACjF,QAAI,CAAC,KAAK,iBAAiB;AACzB,aAAO,OAAO;AAAA,IAChB;AAEA,QAAI,KAAK,SAAS,kBAAkB;AAElC,aAAO,OAAO;AAAA,IAChB;AAEA,UAAM,aAAa,WAAW,IAAI,KAAK,eAAe;AACtD,QAAI,CAAC,cAAc,WAAW,WAAW,GAAG;AAE1C,aAAO,OAAO;AAAA,IAChB;AAEA,UAAM,QAAQ,WAAW,KAAK,CAAC,MAAM,EAAE,SAAS,QAAQ;AAExD,QAAI,CAAC,OAAO;AACV,aAAO,OAAO;AAAA,IAChB;AAEA,WAAqB,qBAAqB,OAAO,MAAM,KAAY;AAAA,EACrE;AAEA,SAAO,OAAO,QAAQ,QAAQ,KAAK,OAAO,CAAC,SAAS,YAAY,IAAI,CAAC,EAAE,KAAK,OAAO,MAAM;AAC3F;;;ACjDO,IAAM,QAAQ;AAWd,IAAM,OACX,CAAsB,YACtB,CAAC,SACC;AAEG,IAAM,OAAO,CAClB,UACsC;AAAA,EACtC,MAAM;AAAA,EACN,GAAG;AACL;AAEO,IAAM,OAAO,CAAiB,UAAgF;AAAA,EACnH,MAAM;AAAA,EACN,GAAG;AACL;AAOO,IAAM,WAAW,CAItB,UAU2B;AAC3B,QAAM,SAAS,CAAC,UAA0C;AACxD,UAAM,OAAQ,MAAM,KAA+B,IAAI,CAAC,QAAc,UAAU,OAAc,GAAG,CAAC;AAClG,WAAQ,MAAM,IAAY,GAAG,IAAI;AAAA,EACnC;AACA,SAAO;AAAA,IACL,WAAW;AAAA,IACX,MAAM;AAAA,IACN,MAAM;AAAA,MACJ,MAAM,MAAM;AAAA,MACZ;AAAA,MACA,QAAQ,MAAM;AAAA,MACd,GAAI,MAAM,aAAa,EAAE,YAAY,MAAM,WAAW,IAAI,CAAC;AAAA,IAC7D;AAAA,EACF;AACF;AAOO,IAAM,SAAS,CAAgD,UAYnE;AAAA,EACC,WAAW;AAAA,EACX,MAAM;AAAA,EACN;AACF;AAOK,IAAM,OAAO,CAAgD,UASjE;AAAA,EACC,WAAW;AAAA,EACX,MAAM;AAAA,EACN,MAAM,EAAE,GAAG,MAAM,GAAI,KAAK,aAAa,EAAE,YAAY,KAAK,WAAW,IAAI,CAAC,EAAG;AAC/E;AAOK,IAAMC,SAAQ,CACnB,aACA,SACuC,MAAM,aAAa,IAAI;AAOzD,IAAMC,WAAU,CACrB,OACA,YACoD,QAAQ,OAAO,OAAO;AASrE,IAAMC,kBAAiB,CAC5B,SACA,UACA,YAIW,eAAe;AAAA,EACxB;AAAA,EACA;AAAA,EACA,SAAS,SAAS;AACpB,CAAC;",
  "names": ["from", "node", "node", "list", "from", "list", "build", "install", "exportStaticIr"]
}
