@arronqzy/blueprint-dsl 1.0.8 → 1.0.10

package/dist/index.cjs

@@ -0,0 +1,2885 @@
+'use strict';
+
+// src/lifecycle.ts
+var PAGE_LIFECYCLE_PHASES = [
+  "created",
+  "beforeMount",
+  "mounted",
+  "updated",
+  "beforeDestroy",
+  "destroy",
+  "activated",
+  "deactivated",
+  /** 被其他蓝图的蓝图配置节点引用且收到真信号时触发 */
+  "blueprintActivated"
+];
+var PAGE_LIFECYCLE_LABELS = {
+  created: "\u5DF2\u521B\u5EFA (created)",
+  beforeMount: "\u6302\u8F7D\u524D (beforeMount)",
+  mounted: "\u5DF2\u6302\u8F7D (mounted)",
+  updated: "\u5DF2\u66F4\u65B0 (updated)",
+  beforeDestroy: "\u9500\u6BC1\u524D (beforeDestroy)",
+  destroy: "\u5DF2\u9500\u6BC1 (destroy)",
+  activated: "\u5DF2\u6FC0\u6D3B (activated)",
+  deactivated: "\u5DF2\u505C\u7528 (deactivated)",
+  blueprintActivated: "\u84DD\u56FE\u6FC0\u6D3B (blueprintActivated)"
+};
+function createLifecycleSignal(phase) {
+  const timestamp = Date.now();
+  return {
+    phase,
+    timestamp,
+    isoTime: new Date(timestamp).toISOString()
+  };
+}
+
+// src/node-signal.ts
+function isTrueSignal(signal) {
+  return !!signal && typeof signal === "object" && signal.kind === "true";
+}
+function isFalseSignal(signal) {
+  return !!signal && typeof signal === "object" && signal.kind === "false";
+}
+function createTrueSignal(value) {
+  const timestamp = Date.now();
+  return {
+    kind: "true",
+    value,
+    timestamp,
+    isoTime: new Date(timestamp).toISOString()
+  };
+}
+function createFalseSignal(error) {
+  const timestamp = Date.now();
+  return {
+    kind: "false",
+    error,
+    timestamp,
+    isoTime: new Date(timestamp).toISOString()
+  };
+}
+function combinePortSignalsOr(values) {
+  const defined = values.filter((value) => value !== void 0);
+  if (defined.length === 0) return void 0;
+  for (const value of defined) {
+    if (isTrueSignal(value)) {
+      return createTrueSignal(value.value);
+    }
+  }
+  const falseSignals = defined.filter(isFalseSignal);
+  if (falseSignals.length > 0) {
+    return createFalseSignal(
+      falseSignals.map((signal) => signal.error).join("\uFF1B")
+    );
+  }
+  return void 0;
+}
+
+// src/core/behavior-registry.ts
+var BehaviorRegistry = class {
+  map = /* @__PURE__ */ new Map();
+  registerJS(id, fn) {
+    this.map.set(id, { kind: "js", run: fn });
+  }
+  registerBlueprint(id, blueprintId) {
+    this.map.set(id, { kind: "blueprint", blueprintId });
+  }
+  get(id) {
+    const b = this.map.get(id);
+    if (!b) throw new Error(`Behavior not found: ${id}`);
+    return b;
+  }
+};
+
+// src/core/executor.ts
+var Executor = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  async executeToken(token) {
+    const def = this.deps.getNodeDefinition(token.nodeType);
+    const behavior = this.deps.behaviors.get(def.behavior.ref);
+    const io = {
+      getInput: (name) => this.deps.getInputValue(token, name),
+      setOutput: (name, value) => this.deps.setNodeOutput(token, name, value),
+      emitFlow: (port = "out") => this.deps.emitFlow(token, port)
+    };
+    if (behavior.kind === "js") {
+      await behavior.run({ token, io });
+      return;
+    }
+    if (behavior.kind === "blueprint") {
+      await this.deps.runBlueprint({
+        blueprintId: behavior.blueprintId,
+        token
+      });
+      return;
+    }
+  }
+};
+
+// src/behaviors/default.ts
+var LIFECYCLE_SIGNAL_KEY = "__lifecycleSignal";
+var BLUEPRINT_ACTIVATION_INPUT_KEY = "__blueprintActivationInput";
+var UI_EVENT_PAYLOAD_KEY = "__uiEventPayload";
+var VIEW_EVENT_SIGNAL_KEY = "__viewEventSignal";
+function registerDefaultBehaviors(registry) {
+  registry.registerJS("logic-noop", async ({ io }) => {
+    const input = await io.getInput("in");
+    if (isFalseSignal(input)) {
+      io.setOutput("out", input);
+    } else if (isTrueSignal(input)) {
+      io.setOutput("out", createTrueSignal(input.value));
+    } else {
+      io.setOutput("out", createTrueSignal(void 0));
+    }
+    io.emitFlow("out");
+  });
+  registry.registerJS("lifecycle-emit", async ({ token, io }) => {
+    const lifecycle = token.scope.vars.get(LIFECYCLE_SIGNAL_KEY);
+    if (!lifecycle) {
+      io.setOutput("out", createFalseSignal("\u751F\u547D\u5468\u671F\u4FE1\u53F7\u7F3A\u5931"));
+    } else if (lifecycle.phase === "blueprintActivated") {
+      io.setOutput(
+        "out",
+        createTrueSignal(token.scope.vars.get(BLUEPRINT_ACTIVATION_INPUT_KEY))
+      );
+    } else {
+      io.setOutput("out", createTrueSignal(lifecycle));
+    }
+    io.emitFlow("out");
+  });
+  registry.registerJS("event-emit", async ({ token, io }) => {
+    const payload = token.scope.vars.get(VIEW_EVENT_SIGNAL_KEY);
+    if (!payload) {
+      return;
+    }
+    io.setOutput("out", createTrueSignal(payload));
+    io.emitFlow("out");
+  });
+}
+
+// src/scope-template.ts
+var SCOPE_TOKEN_RE = /\{(scope[^}]*)\}/g;
+function hasScopeTemplate(value) {
+  SCOPE_TOKEN_RE.lastIndex = 0;
+  return SCOPE_TOKEN_RE.test(value);
+}
+function evaluateScopeExpression(expression, scope) {
+  const trimmed = expression.trim();
+  if (!trimmed) return void 0;
+  try {
+    const fn = new Function("scope", `"use strict"; return (${trimmed});`);
+    return fn(scope);
+  } catch {
+    return void 0;
+  }
+}
+function stringifyScopeValue(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function isInsideJsonString(before) {
+  let inString = false;
+  let escape = false;
+  for (const ch of before) {
+    if (inString) {
+      if (escape) {
+        escape = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escape = true;
+        continue;
+      }
+      if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+  }
+  return inString;
+}
+function replaceScopeTokens(template, scope, replacer) {
+  SCOPE_TOKEN_RE.lastIndex = 0;
+  return template.replace(
+    SCOPE_TOKEN_RE,
+    (_match, rawExpr, offset) => replacer(evaluateScopeExpression(rawExpr, scope), offset)
+  );
+}
+function evaluateScopeTemplate(template, scope) {
+  if (!hasScopeTemplate(template)) return template;
+  return replaceScopeTokens(template, scope, (value) => stringifyScopeValue(value));
+}
+function evaluateScopeTemplateInJson(template, scope) {
+  if (!hasScopeTemplate(template)) return template;
+  return replaceScopeTokens(template, scope, (value, offset) => {
+    if (isInsideJsonString(template.slice(0, offset))) {
+      return JSON.stringify(stringifyScopeValue(value)).slice(1, -1);
+    }
+    if (value === void 0) return "null";
+    return JSON.stringify(value);
+  });
+}
+function looksLikeJsonText(text) {
+  const trimmed = text.trim();
+  return trimmed.startsWith("{") || trimmed.startsWith("[");
+}
+
+// src/fetch-config.ts
+var FETCH_HTTP_METHODS = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS"
+];
+var FETCH_RESPONSE_TYPES = ["json", "text"];
+var FETCH_CREDENTIALS = ["omit", "same-origin", "include"];
+var FETCH_MODES = ["cors", "no-cors", "same-origin", "navigate"];
+var FETCH_CACHES = [
+  "default",
+  "no-store",
+  "reload",
+  "no-cache",
+  "force-cache",
+  "only-if-cached"
+];
+var FETCH_REDIRECTS = ["follow", "error", "manual"];
+var DEFAULT_FETCH_REQUEST_CONFIG = {
+  url: "",
+  method: "GET",
+  headers: {},
+  body: "",
+  credentials: "same-origin",
+  mode: "cors",
+  cache: "default",
+  redirect: "follow",
+  responseType: "json",
+  timeoutMs: 3e4
+};
+function normalizeFetchRequestConfig(config) {
+  return {
+    ...DEFAULT_FETCH_REQUEST_CONFIG,
+    ...config,
+    headers: {
+      ...DEFAULT_FETCH_REQUEST_CONFIG.headers,
+      ...config?.headers
+    },
+    headersJson: config?.headersJson,
+    swaggerEndpoints: config?.swaggerEndpoints
+  };
+}
+function joinFetchUrl(base, path) {
+  const normalizedBase = base.replace(/\/+$/, "");
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  return `${normalizedBase}${normalizedPath}`;
+}
+function getUrlAuthorityPart(url) {
+  const trimmed = url.trim();
+  if (!trimmed || trimmed.startsWith("/")) return null;
+  const slashIndex = trimmed.indexOf("/");
+  return slashIndex === -1 ? trimmed : trimmed.slice(0, slashIndex);
+}
+function isAbsoluteHostAuthority(authority) {
+  if (/^localhost$/i.test(authority)) return true;
+  if (/^localhost:\d+$/i.test(authority)) return true;
+  if (/^\d{1,3}(?:\.\d{1,3}){3}$/.test(authority)) return true;
+  if (/^\d{1,3}(?:\.\d{1,3}){3}:\d+$/.test(authority)) return true;
+  if (/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test(authority) && authority.includes(".")) {
+    return true;
+  }
+  if (/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?\.[a-z]{2,}(?::\d+)?$/i.test(authority)) {
+    return true;
+  }
+  if (/^[a-z0-9-]+:\d+$/i.test(authority)) return true;
+  return false;
+}
+function hasExplicitUrlScheme(url) {
+  return /^[a-z][a-z0-9+.-]*:\/\//i.test(url) || url.startsWith("//");
+}
+function resolveFetchRequestUrl(config) {
+  const rawUrl = config.url?.trim() ?? "";
+  if (!rawUrl) {
+    throw new Error("\u8BF7\u6C42 URL \u672A\u914D\u7F6E");
+  }
+  if (hasExplicitUrlScheme(rawUrl)) {
+    return rawUrl;
+  }
+  const authority = getUrlAuthorityPart(rawUrl);
+  if (authority && isAbsoluteHostAuthority(authority)) {
+    return `http://${rawUrl}`;
+  }
+  const apiBaseUrl = config.apiBaseUrl?.trim();
+  if (!apiBaseUrl) {
+    return rawUrl;
+  }
+  return joinFetchUrl(apiBaseUrl, rawUrl);
+}
+function linkAbortSignal(controller, external) {
+  if (!external) return () => {
+  };
+  if (external.aborted) {
+    controller.abort();
+    return () => {
+    };
+  }
+  const onAbort = () => controller.abort();
+  external.addEventListener("abort", onAbort);
+  return () => external.removeEventListener("abort", onAbort);
+}
+async function executeFetch(config, options) {
+  const rawUrl = config.url?.trim();
+  if (!rawUrl) {
+    throw new Error("\u8BF7\u6C42 URL \u672A\u914D\u7F6E");
+  }
+  const url = resolveFetchRequestUrl(config);
+  const method = config.method ?? "GET";
+  const hasBody = method !== "GET" && method !== "HEAD";
+  const body = hasBody && config.body?.trim() ? config.body : void 0;
+  if (body && looksLikeJsonText(body)) {
+    try {
+      JSON.parse(body);
+    } catch (error) {
+      throw new Error(
+        `\u8BF7\u6C42\u4F53\u4E0D\u662F\u6709\u6548 JSON\uFF1A${error instanceof Error ? error.message : "\u683C\u5F0F\u65E0\u6548"}`
+      );
+    }
+  }
+  const headers = { ...config.headers ?? {} };
+  const hasContentType = Object.keys(headers).some(
+    (key) => key.toLowerCase() === "content-type"
+  );
+  if (body && looksLikeJsonText(body) && !hasContentType) {
+    headers["Content-Type"] = "application/json";
+  }
+  const timeoutMs = config.timeoutMs ?? 3e4;
+  const controller = new AbortController();
+  const unlinkExternal = linkAbortSignal(controller, options?.signal);
+  const timer = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : void 0;
+  try {
+    const response = await fetch(url, {
+      method,
+      headers: Object.keys(headers).length > 0 ? headers : void 0,
+      body,
+      credentials: config.credentials,
+      mode: config.mode,
+      cache: config.cache,
+      redirect: config.redirect,
+      signal: controller.signal
+    });
+    const responseType = config.responseType ?? "json";
+    let data;
+    if (responseType === "text") {
+      data = await response.text();
+    } else {
+      const text = await response.text();
+      if (!text) {
+        data = null;
+      } else {
+        try {
+          data = JSON.parse(text);
+        } catch {
+          if (options?.allowHttpError) {
+            data = text;
+          } else {
+            throw new Error("\u54CD\u5E94\u4E0D\u662F\u6709\u6548\u7684 JSON");
+          }
+        }
+      }
+    }
+    if (!response.ok && !options?.allowHttpError) {
+      const detail = typeof data === "string" ? data.slice(0, 200) : JSON.stringify(data).slice(0, 200);
+      throw new Error(
+        `HTTP ${response.status} ${response.statusText}${detail ? `: ${detail}` : ""}`
+      );
+    }
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      url: response.url,
+      data
+    };
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      if (options?.signal?.aborted) {
+        throw new Error("\u8BF7\u6C42\u5DF2\u4E2D\u6B62");
+      }
+      throw new Error(`\u8BF7\u6C42\u8D85\u65F6\uFF08${timeoutMs}ms\uFF09`);
+    }
+    throw error;
+  } finally {
+    unlinkExternal();
+    if (timer) clearTimeout(timer);
+  }
+}
+
+// src/scope-autocomplete.ts
+function getValueAtPath(scope, path) {
+  let current = scope;
+  for (const part of path) {
+    if (current === null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function listObjectKeys(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return [];
+  }
+  return Object.keys(value);
+}
+function parseScopeAutocomplete(text, cursor, scope) {
+  const before = text.slice(0, cursor);
+  const templateStart = before.lastIndexOf("{");
+  if (templateStart < 0) return null;
+  const inner = before.slice(templateStart + 1);
+  if (inner.includes("}")) return null;
+  if (!inner.startsWith("scope")) return null;
+  let body = inner.slice("scope".length);
+  if (body === "" || body === "?") {
+    return { templateStart, cursor, path: [], partialKey: "" };
+  }
+  if (!body.startsWith("?.")) return null;
+  body = body.slice(2);
+  if (body === "") {
+    return { templateStart, cursor, path: [], partialKey: "" };
+  }
+  const segments = body.split("?.");
+  const endsWithSeparator = inner.endsWith("?.");
+  if (endsWithSeparator) {
+    const path = segments.filter((segment) => segment.length > 0);
+    return { templateStart, cursor, path, partialKey: "" };
+  }
+  const lastSegment = segments[segments.length - 1] ?? "";
+  const prefixSegments = segments.slice(0, -1).filter((segment) => segment.length > 0);
+  const parent = getValueAtPath(scope, prefixSegments);
+  const keys = listObjectKeys(parent);
+  if (lastSegment.length === 0) {
+    return { templateStart, cursor, path: prefixSegments, partialKey: "" };
+  }
+  if (keys.includes(lastSegment)) {
+    return {
+      templateStart,
+      cursor,
+      path: [...prefixSegments, lastSegment],
+      partialKey: ""
+    };
+  }
+  return {
+    templateStart,
+    cursor,
+    path: prefixSegments,
+    partialKey: lastSegment
+  };
+}
+function getScopeAutocompleteSuggestions(scope, state) {
+  const parent = state.partialKey.length > 0 ? getValueAtPath(scope, state.path) : state.path.length > 0 ? getValueAtPath(scope, state.path) : scope;
+  const keys = listObjectKeys(parent);
+  if (state.partialKey.length === 0) return keys;
+  return keys.filter((key) => key.startsWith(state.partialKey));
+}
+function buildScopeExpression(path, selectedKey) {
+  return `scope?.${[...path, selectedKey].join("?.")}`;
+}
+function applyScopeAutocompleteSelection(text, state, selectedKey) {
+  const expr = buildScopeExpression(state.path, selectedKey);
+  const before = text.slice(0, state.templateStart + 1);
+  const after = text.slice(state.cursor);
+  const value = `${before}${expr}${after}`;
+  const cursor = before.length + expr.length;
+  return { value, cursor };
+}
+
+// src/incoming-node-scope.ts
+var FETCH_SCOPE_AUTOCOMPLETE_FALLBACK = {
+  id: "",
+  name: "",
+  type: "",
+  role: "",
+  port: "out",
+  kind: "pending",
+  value: {},
+  error: "",
+  timestamp: 0,
+  isoTime: ""
+};
+function resolveFetchScopeAutocompleteRoot(scope) {
+  return scope === void 0 ? FETCH_SCOPE_AUTOCOMPLETE_FALLBACK : scope;
+}
+function readOutputSignal(output) {
+  if (output === void 0) return { kind: "pending" };
+  if (isTrueSignal(output)) {
+    return {
+      kind: "true",
+      value: output.value,
+      timestamp: output.timestamp,
+      isoTime: output.isoTime
+    };
+  }
+  if (isFalseSignal(output)) {
+    return {
+      kind: "false",
+      error: output.error,
+      timestamp: output.timestamp,
+      isoTime: output.isoTime
+    };
+  }
+  if (output && typeof output === "object" && "kind" in output) {
+    const rec = output;
+    if (rec.kind === "true") {
+      return {
+        kind: "true",
+        value: rec.value,
+        timestamp: rec.timestamp,
+        isoTime: rec.isoTime
+      };
+    }
+    if (rec.kind === "false") {
+      return {
+        kind: "false",
+        error: rec.error,
+        timestamp: rec.timestamp,
+        isoTime: rec.isoTime
+      };
+    }
+  }
+  return { kind: "true", value: output };
+}
+function createIncomingNodeScopeEntry(node, port, output) {
+  const id = node?.id ?? "in";
+  const signal = readOutputSignal(output);
+  return {
+    id,
+    name: node?.label?.trim() || node?.name?.trim() || id,
+    type: node?.nodeType || node?.type || "unknown",
+    role: node?.role,
+    port,
+    ...signal
+  };
+}
+function buildIncomingNodeScope(entries) {
+  if (entries.length === 0) return void 0;
+  if (entries.length === 1) return entries[0];
+  const scoped = {};
+  for (const entry of entries) {
+    scoped[entry.id] = entry;
+  }
+  return scoped;
+}
+function collectIncomingNodeScopeEntries(options) {
+  const targetPort = options.targetPort ?? "in";
+  const nodeById = new Map(options.nodes.map((node) => [node.id, node]));
+  const inbound = options.edges.filter(
+    (edge) => edge.target === options.targetNodeId && (edge.targetHandle ?? "in") === targetPort
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const entries = [];
+  for (const edge of inbound) {
+    const port = edge.sourceHandle ?? "out";
+    const key = `${edge.source}:${port}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const output = options.getOutput?.(edge.source, port);
+    entries.push(
+      createIncomingNodeScopeEntry(nodeById.get(edge.source), port, output)
+    );
+  }
+  return entries;
+}
+function resolveFetchIncomingScope(options) {
+  const entries = collectIncomingNodeScopeEntries({
+    targetNodeId: options.fetchNodeId,
+    targetPort: options.inputPort,
+    nodes: options.nodes,
+    edges: options.edges,
+    getOutput: options.getOutput
+  });
+  if (entries.length > 0) return buildIncomingNodeScope(entries);
+  if (options.fallbackInput === void 0) return void 0;
+  return createIncomingNodeScopeEntry(
+    { id: "in", label: "in", nodeType: "input" },
+    options.inputPort ?? "in",
+    options.fallbackInput
+  );
+}
+function latestTraceOutputsByNode(entries) {
+  const map = {};
+  for (const entry of entries) {
+    map[entry.nodeId] = entry.outputs ?? {};
+  }
+  return map;
+}
+function resolveTemplateString(value, scope) {
+  if (value === void 0) return void 0;
+  if (!hasScopeTemplate(value)) return value;
+  return evaluateScopeTemplate(value, scope);
+}
+function parseJsonText(text) {
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : "JSON \u683C\u5F0F\u65E0\u6548"
+    };
+  }
+}
+function validateFetchJsonText(text, options) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    if (options?.allowEmpty === false) {
+      return { ok: false, error: "\u5185\u5BB9\u4E0D\u80FD\u4E3A\u7A7A" };
+    }
+    return { ok: true };
+  }
+  if (isWholeScopeExpression(trimmed)) {
+    return { ok: true };
+  }
+  if (!looksLikeJsonText(trimmed)) {
+    return { ok: true };
+  }
+  const parsed = parseJsonText(trimmed);
+  return parsed.ok ? { ok: true } : parsed;
+}
+function resolveFetchBody(body, scope) {
+  if (body === void 0) return void 0;
+  const trimmed = body.trim();
+  if (!trimmed) return body;
+  if (scope !== void 0 && isWholeScopeExpression(trimmed)) {
+    const value = evaluateScopeExpression(trimmed.slice(1, -1), scope);
+    if (value === void 0) return "";
+    if (typeof value === "string") return value;
+    return stringifyScopeValue(value);
+  }
+  if (scope === void 0 || !hasScopeTemplate(body)) return body;
+  if (looksLikeJsonText(trimmed)) {
+    return evaluateScopeTemplateInJson(body, scope);
+  }
+  return evaluateScopeTemplate(body, scope);
+}
+function getFetchBodyValidationError(body, resolvedBody) {
+  const source = (resolvedBody ?? body ?? "").trim();
+  if (!source) return null;
+  if (isWholeScopeExpression(source)) return null;
+  if (!looksLikeJsonText(source)) return null;
+  const parsed = parseJsonText(source);
+  if (parsed.ok) return null;
+  if (hasScopeTemplate(source)) return null;
+  return parsed.error;
+}
+function getFetchHeadersValidationError(config, scope) {
+  const raw = (config.headersJson ?? "").trim();
+  if (!raw) return null;
+  if (isWholeScopeExpression(raw) || hasScopeTemplate(raw)) {
+    if (scope === void 0) return null;
+    const parsed2 = parseFetchHeadersJson(raw, scope);
+    if (!parsed2) return "\u8BF7\u6C42\u5934\u6A21\u677F\u89E3\u6790\u540E\u4E0D\u662F\u6709\u6548\u7684 JSON \u5BF9\u8C61";
+    return null;
+  }
+  const result = validateFetchJsonText(raw);
+  if (!result.ok) return result.error;
+  const parsed = parseFetchHeadersJson(raw, scope);
+  if (!parsed) return "\u8BF7\u6C42\u5934\u4E0D\u662F\u6709\u6548\u7684 JSON \u5BF9\u8C61";
+  return null;
+}
+function isWholeScopeExpression(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return false;
+  return trimmed.slice(1, -1).trim().startsWith("scope");
+}
+function asHeaderRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const headers = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (raw === void 0 || raw === null) continue;
+    headers[key] = typeof raw === "string" ? raw : stringifyScopeValue(raw);
+  }
+  return headers;
+}
+function applyScopeToHeaderRecord(headers, scope) {
+  if (scope === void 0) return headers;
+  return Object.fromEntries(
+    Object.entries(headers).map(([key, value]) => [
+      evaluateScopeTemplate(String(key), scope),
+      evaluateScopeTemplate(value == null ? "" : String(value), scope)
+    ])
+  );
+}
+function parseFetchHeadersJson(text, scope) {
+  const trimmed = text.trim();
+  if (!trimmed) return {};
+  if (isWholeScopeExpression(trimmed)) {
+    if (scope === void 0) return void 0;
+    const inner = trimmed.slice(1, -1);
+    return asHeaderRecord(evaluateScopeExpression(inner, scope));
+  }
+  let jsonText = trimmed;
+  if (scope !== void 0 && hasScopeTemplate(trimmed) && looksLikeJsonText(trimmed)) {
+    jsonText = evaluateScopeTemplateInJson(trimmed, scope);
+  }
+  try {
+    const parsed = asHeaderRecord(JSON.parse(jsonText));
+    if (!parsed) return void 0;
+    if (jsonText === trimmed) {
+      return applyScopeToHeaderRecord(parsed, scope);
+    }
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+function draftFetchHeadersText(config) {
+  if (config.headersJson !== void 0) return config.headersJson;
+  try {
+    return JSON.stringify(config.headers ?? {}, null, 2);
+  } catch {
+    return "{}";
+  }
+}
+function resolveFetchHeaders(config, scope) {
+  const rawJson = config.headersJson;
+  if (rawJson !== void 0 && rawJson.trim() !== "") {
+    const parsed = parseFetchHeadersJson(rawJson, scope);
+    if (parsed) return parsed;
+  }
+  if (!config.headers) return config.headers;
+  return applyScopeToHeaderRecord(config.headers, scope);
+}
+function applyFetchConfigScope(config, scope) {
+  const headers = resolveFetchHeaders(config, scope);
+  const body = resolveFetchBody(config.body, scope);
+  if (scope === void 0) {
+    if (headers === config.headers && body === config.body) return config;
+    return { ...config, headers, body };
+  }
+  return {
+    ...config,
+    url: resolveTemplateString(config.url, scope) ?? "",
+    apiBaseUrl: resolveTemplateString(config.apiBaseUrl, scope),
+    body,
+    headers
+  };
+}
+function fetchConfigHasScopeTemplate(config) {
+  if (hasScopeTemplate(config.url ?? "")) return true;
+  if (hasScopeTemplate(config.apiBaseUrl ?? "")) return true;
+  if (hasScopeTemplate(config.body ?? "")) return true;
+  if (hasScopeTemplate(config.headersJson ?? "")) return true;
+  const headers = config.headers ?? {};
+  return Object.entries(headers).some(
+    ([key, value]) => hasScopeTemplate(key) || hasScopeTemplate(String(value ?? ""))
+  );
+}
+
+// src/json-config.ts
+var DEFAULT_JSON_NODE_CONFIG = {
+  jsonString: "{}"
+};
+function validateJsonString(jsonString) {
+  const raw = jsonString?.trim();
+  if (!raw) {
+    return { ok: false, error: "JSON \u4E0D\u80FD\u4E3A\u7A7A" };
+  }
+  try {
+    const value = JSON.parse(raw);
+    if (value === null || typeof value !== "object") {
+      return { ok: false, error: "JSON \u6839\u8282\u70B9\u5FC5\u987B\u662F object \u6216 array" };
+    }
+    return { ok: true, value };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : "JSON \u683C\u5F0F\u65E0\u6548"
+    };
+  }
+}
+function parseJsonConfig(config) {
+  const result = validateJsonString(config.jsonString ?? "");
+  if (!result.ok) {
+    throw new Error(result.error);
+  }
+  return result.value;
+}
+
+// src/storage-config.ts
+var STORAGE_KINDS = ["session", "local"];
+var DEFAULT_STORAGE_NODE_CONFIG = {
+  read: { storage: "local", key: "" },
+  set: { storages: [], key: "", value: "" }
+};
+function isStorageKind(value) {
+  return value === "session" || value === "local";
+}
+function uniqueStorageKinds(kinds) {
+  const next = /* @__PURE__ */ new Set();
+  for (const kind of kinds ?? []) {
+    if (isStorageKind(kind)) next.add(kind);
+  }
+  return STORAGE_KINDS.filter((kind) => next.has(kind));
+}
+function normalizeStorageConfig(config) {
+  const read = config?.read;
+  const set = config?.set;
+  return {
+    read: {
+      storage: read?.storage === "session" ? "session" : "local",
+      key: typeof read?.key === "string" ? read.key : ""
+    },
+    set: {
+      storages: uniqueStorageKinds(set?.storages),
+      key: typeof set?.key === "string" ? set.key : "",
+      value: typeof set?.value === "string" ? set.value : ""
+    }
+  };
+}
+function isStorageReadConfigured(config) {
+  return Boolean(config.read?.key?.trim());
+}
+function isStorageSetConfigured(config) {
+  return Boolean(config.set?.key?.trim()) && (config.set?.storages?.length ?? 0) > 0;
+}
+function resolveStorageWriteValue(template, scope) {
+  const raw = template ?? "";
+  const trimmed = raw.trim();
+  if (!trimmed) return "";
+  if (isWholeScopeExpression(trimmed)) {
+    const value = evaluateScopeExpression(trimmed.slice(1, -1), scope);
+    return value === void 0 ? "" : value;
+  }
+  if (hasScopeTemplate(raw)) {
+    return evaluateScopeTemplate(raw, scope);
+  }
+  return raw;
+}
+function serializeStorageValue(value) {
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function deserializeStorageValue(raw) {
+  if (raw === null) return null;
+  const trimmed = raw.trim();
+  if (!trimmed) return raw;
+  if (!looksLikeJsonText(trimmed)) return raw;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return raw;
+  }
+}
+function getDefaultStorageAccessors() {
+  if (typeof window === "undefined") return null;
+  try {
+    return {
+      session: window.sessionStorage,
+      local: window.localStorage
+    };
+  } catch {
+    return null;
+  }
+}
+function requireStorage(accessors, kind) {
+  const target = kind === "session" ? accessors?.session : accessors?.local;
+  if (!target) {
+    throw new Error(
+      kind === "session" ? "\u5F53\u524D\u73AF\u5883\u4E0D\u652F\u6301 sessionStorage" : "\u5F53\u524D\u73AF\u5883\u4E0D\u652F\u6301 localStorage"
+    );
+  }
+  return target;
+}
+function executeStorageConfig(config, incomingScope, accessors) {
+  const normalized = normalizeStorageConfig(config);
+  const store = accessors === void 0 ? getDefaultStorageAccessors() : accessors;
+  if (isStorageSetConfigured(normalized)) {
+    const value = resolveStorageWriteValue(normalized.set.value, incomingScope);
+    const serialized = serializeStorageValue(value);
+    const key = normalized.set.key.trim();
+    for (const kind of normalized.set.storages) {
+      requireStorage(store, kind).setItem(key, serialized);
+    }
+  }
+  if (!isStorageReadConfigured(normalized)) {
+    return null;
+  }
+  return deserializeStorageValue(
+    requireStorage(store, normalized.read.storage).getItem(
+      normalized.read.key.trim()
+    )
+  );
+}
+
+// src/logic-config.ts
+var DEFAULT_LOGIC_NODE_CONFIG = {
+  sourceCode: `function update(input) {
+  return input;
+}`
+};
+function compileLogicRunner(sourceCode) {
+  return new Function(
+    "input",
+    `"use strict";
+${sourceCode}
+if (typeof update !== "function") {
+  throw new TypeError("\u9700\u8981\u5B9A\u4E49 update(input) \u51FD\u6570");
+}
+return update(input);`
+  );
+}
+function validateLogicSourceCode(sourceCode) {
+  const raw = sourceCode?.trim();
+  if (!raw) {
+    return { ok: false, error: "\u4EE3\u7801\u4E0D\u80FD\u4E3A\u7A7A" };
+  }
+  try {
+    compileLogicRunner(raw);
+    return { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : "JavaScript \u8BED\u6CD5\u9519\u8BEF"
+    };
+  }
+}
+function executeLogicConfig(config, input) {
+  const validation = validateLogicSourceCode(config.sourceCode ?? "");
+  if (!validation.ok) {
+    throw new Error(validation.error);
+  }
+  const run = compileLogicRunner(config.sourceCode);
+  return run(input);
+}
+
+// src/clock-config.ts
+var DEFAULT_CLOCK_NODE_CONFIG = {
+  intervalSeconds: 0,
+  timeFormat: "YYYY-MM-DD HH:mm:ss",
+  outputCount: 1,
+  emitImmediately: true
+};
+function normalizeClockConfig(config) {
+  const intervalRaw = Number(config?.intervalSeconds);
+  const intervalSeconds = Number.isFinite(intervalRaw) && intervalRaw > 0 ? Math.floor(intervalRaw) : 0;
+  const outputCountRaw = Number(config?.outputCount);
+  const outputCount = Number.isFinite(outputCountRaw) && outputCountRaw > 0 ? Math.floor(outputCountRaw) : DEFAULT_CLOCK_NODE_CONFIG.outputCount;
+  const timeFormat = config?.timeFormat?.trim() || DEFAULT_CLOCK_NODE_CONFIG.timeFormat;
+  return {
+    intervalSeconds,
+    timeFormat,
+    outputCount,
+    emitImmediately: config?.emitImmediately !== false
+  };
+}
+function validateClockScheduleConfig(config) {
+  const normalized = normalizeClockConfig(config);
+  if (normalized.outputCount <= 0) {
+    return { ok: false, error: "\u8F93\u51FA\u6B21\u6570\u987B\u5927\u4E8E 0" };
+  }
+  const needsInterval = normalized.outputCount > 1 || normalized.outputCount === 1 && !normalized.emitImmediately;
+  if (needsInterval && normalized.intervalSeconds <= 0) {
+    return { ok: false, error: "\u5F53\u524D\u914D\u7F6E\u4E0B\u65F6\u949F\u4FE1\u53F7\u95F4\u9694\u987B\u5927\u4E8E 0 \u79D2" };
+  }
+  return { ok: true };
+}
+var pad2 = (value) => String(value).padStart(2, "0");
+function formatClockTime(date, pattern) {
+  const tokens = {
+    YYYY: String(date.getFullYear()).padStart(4, "0"),
+    MM: pad2(date.getMonth() + 1),
+    DD: pad2(date.getDate()),
+    HH: pad2(date.getHours()),
+    mm: pad2(date.getMinutes()),
+    ss: pad2(date.getSeconds())
+  };
+  return pattern.replace(/YYYY|MM|DD|HH|mm|ss/g, (token) => tokens[token] ?? token);
+}
+function buildClockSignalValue(config, now = /* @__PURE__ */ new Date()) {
+  const normalized = normalizeClockConfig(config);
+  return {
+    formatted: formatClockTime(now, normalized.timeFormat),
+    timestamp: now.getTime(),
+    isoTime: now.toISOString()
+  };
+}
+function sleep(ms, abort, sessionKey) {
+  if (ms <= 0 || abort.aborted) return Promise.resolve();
+  return new Promise((resolve) => {
+    const timerId = setTimeout(() => {
+      clearInterval(pollId);
+      resolve();
+    }, ms);
+    const pollId = setInterval(() => {
+      if (abort.aborted || sessionKey !== void 0 && isClockSessionAborted(sessionKey)) {
+        clearTimeout(timerId);
+        clearInterval(pollId);
+        resolve();
+      }
+    }, 50);
+  });
+}
+function getClockTickDelayOffsetMs(config, tickIndex) {
+  const normalized = normalizeClockConfig(config);
+  const intervalMs = normalized.intervalSeconds * 1e3;
+  if (tickIndex <= 0) {
+    return normalized.emitImmediately ? 0 : intervalMs;
+  }
+  if (normalized.emitImmediately) {
+    return tickIndex * intervalMs;
+  }
+  return (tickIndex + 1) * intervalMs;
+}
+function getClockTickWaitMs(config, tickIndex, scheduleStartMs, nowMs = Date.now()) {
+  const targetMs = scheduleStartMs + getClockTickDelayOffsetMs(config, tickIndex);
+  return Math.max(0, targetMs - nowMs);
+}
+var activeSessions = /* @__PURE__ */ new Map();
+var abortedClockSessions = /* @__PURE__ */ new Set();
+function stopClockSchedule(sessionKey) {
+  const session = activeSessions.get(sessionKey);
+  if (!session) return;
+  session.aborted = true;
+  activeSessions.delete(sessionKey);
+}
+function isClockScheduleActive(sessionKey) {
+  return activeSessions.has(sessionKey);
+}
+function abortClockSession(sessionKey) {
+  stopClockSchedule(sessionKey);
+  abortedClockSessions.add(sessionKey);
+}
+function isClockSessionAborted(sessionKey) {
+  return abortedClockSessions.has(sessionKey);
+}
+function clearClockSessionAbort(sessionKey) {
+  abortedClockSessions.delete(sessionKey);
+}
+function startClockSchedule(options) {
+  stopClockSchedule(options.sessionKey);
+  clearClockSessionAbort(options.sessionKey);
+  const abort = { aborted: false };
+  activeSessions.set(options.sessionKey, abort);
+  void (async () => {
+    try {
+      const config = normalizeClockConfig(options.config);
+      const total = config.outputCount;
+      const scheduleStartMs = Date.now();
+      for (let tickIndex = 0; tickIndex < total; tickIndex++) {
+        if (abort.aborted || isClockSessionAborted(options.sessionKey)) return;
+        const waitMs = getClockTickWaitMs(config, tickIndex, scheduleStartMs);
+        if (waitMs > 0) {
+          await sleep(waitMs, abort, options.sessionKey);
+        }
+        if (abort.aborted || isClockSessionAborted(options.sessionKey)) return;
+        await options.onTick();
+      }
+    } finally {
+      activeSessions.delete(options.sessionKey);
+      options.onSettled?.();
+    }
+  })();
+  return () => stopClockSchedule(options.sessionKey);
+}
+function stopAllClockSchedules() {
+  for (const key of [...activeSessions.keys()]) {
+    abortClockSession(key);
+  }
+}
+
+// src/event-config.ts
+var VIEW_EVENT_TYPES = [
+  "click",
+  "dblclick",
+  "contextmenu",
+  "mouseenter",
+  "mouseleave"
+];
+var DEFAULT_VIEW_EVENT_NODE_CONFIG = {
+  eventTypes: ["click"]
+};
+var VIEW_EVENT_TYPE_SET = new Set(VIEW_EVENT_TYPES);
+function isViewEventType(value) {
+  return typeof value === "string" && VIEW_EVENT_TYPE_SET.has(value);
+}
+function normalizeViewEventConfig(config) {
+  const raw = Array.isArray(config?.eventTypes) ? config.eventTypes : [];
+  const eventTypes = [
+    ...new Set(raw.filter(isViewEventType))
+  ];
+  return {
+    eventTypes: eventTypes.length > 0 ? eventTypes : [...DEFAULT_VIEW_EVENT_NODE_CONFIG.eventTypes]
+  };
+}
+function snapshotDomEvent(event) {
+  return {
+    type: event.type,
+    timeStamp: Number(event.timeStamp) || Date.now(),
+    clientX: event.clientX,
+    clientY: event.clientY,
+    pageX: event.pageX,
+    pageY: event.pageY,
+    button: event.button,
+    altKey: event.altKey,
+    ctrlKey: event.ctrlKey,
+    metaKey: event.metaKey,
+    shiftKey: event.shiftKey
+  };
+}
+function snapshotViewEventNode(node) {
+  return {
+    id: node.id,
+    name: node.name,
+    materialType: node.materialType,
+    x: node.x,
+    y: node.y,
+    width: node.width,
+    height: node.height,
+    layerId: node.layerId
+  };
+}
+function createViewEventSignal(input) {
+  return {
+    event: input.event,
+    node: input.node,
+    eventType: input.eventType
+  };
+}
+function collectArmedViewEventNodeIds(nodes, edges, eventNodeType, lifecycleNodeType, firedPhases) {
+  const byId = new Map(nodes.map((node) => [node.id, node]));
+  const armed = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    if (node.nodeType !== eventNodeType) continue;
+    const registered = edges.some((edge) => {
+      if (edge.target !== node.id) return false;
+      const source = byId.get(edge.source);
+      if (!source || source.nodeType !== lifecycleNodeType) return false;
+      const phase = source.lifecyclePhase || "mounted";
+      return firedPhases.has(phase);
+    });
+    if (registered) armed.add(node.id);
+  }
+  return armed;
+}
+function collectArmedViewEventBindings(nodes, edges, eventNodeType, lifecycleNodeType, firedPhases) {
+  const armed = collectArmedViewEventNodeIds(
+    nodes,
+    edges,
+    eventNodeType,
+    lifecycleNodeType,
+    firedPhases
+  );
+  return collectViewEventBindings(nodes, eventNodeType, armed);
+}
+function collectViewEventBindings(nodes, eventNodeType, armedNodeIds) {
+  const map = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (node.nodeType !== eventNodeType) continue;
+    if (armedNodeIds && (!node.id || !armedNodeIds.has(node.id))) continue;
+    const types = normalizeViewEventConfig(node.eventConfig).eventTypes;
+    for (const id of node.viewElementIds ?? []) {
+      if (!id) continue;
+      let set = map.get(id);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        map.set(id, set);
+      }
+      for (const type of types) set.add(type);
+    }
+  }
+  return map;
+}
+
+// src/swagger.ts
+var HTTP_METHODS = /* @__PURE__ */ new Set([
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete",
+  "head",
+  "options"
+]);
+function normalizeBaseUrl(url) {
+  return url.replace(/\/+$/, "");
+}
+function joinBaseAndPath(base, path) {
+  const normalizedBase = normalizeBaseUrl(base);
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  return `${normalizedBase}${normalizedPath}`;
+}
+function resolveAgainstDocsUrl(relativeOrAbsolute, docsUrl) {
+  const trimmed = relativeOrAbsolute.trim();
+  if (!trimmed) return "";
+  if (/^https?:\/\//i.test(trimmed)) {
+    return normalizeBaseUrl(trimmed);
+  }
+  try {
+    const docs = new URL(docsUrl);
+    if (trimmed.startsWith("/")) {
+      return normalizeBaseUrl(`${docs.origin}${trimmed}`);
+    }
+    return normalizeBaseUrl(new URL(trimmed, `${docs.origin}/`).href);
+  } catch {
+    return normalizeBaseUrl(trimmed);
+  }
+}
+function extractEndpointsFromPaths(paths) {
+  if (!paths || typeof paths !== "object") return [];
+  const endpoints = [];
+  for (const [path, item] of Object.entries(paths)) {
+    if (!item || typeof item !== "object") continue;
+    for (const [method, operation] of Object.entries(item)) {
+      if (!HTTP_METHODS.has(method.toLowerCase())) continue;
+      if (!operation || typeof operation !== "object") continue;
+      const op = operation;
+      endpoints.push({
+        method: method.toUpperCase(),
+        path,
+        summary: typeof op.summary === "string" ? op.summary : void 0,
+        operationId: typeof op.operationId === "string" ? op.operationId : void 0
+      });
+    }
+  }
+  return endpoints.sort(
+    (a, b) => `${a.path}:${a.method}`.localeCompare(`${b.path}:${b.method}`)
+  );
+}
+function parseOpenApiV3(spec, docsUrl) {
+  const servers = Array.isArray(spec.servers) ? spec.servers : [];
+  const firstServer = servers.find((item) => item && typeof item === "object");
+  const serverUrl = typeof firstServer?.url === "string" ? firstServer.url : "";
+  const apiBaseUrl = serverUrl ? resolveAgainstDocsUrl(serverUrl, docsUrl) : resolveAgainstDocsUrl(new URL(docsUrl).origin, docsUrl);
+  return {
+    apiBaseUrl,
+    endpoints: extractEndpointsFromPaths(spec.paths)
+  };
+}
+function parseSwaggerV2(spec, docsUrl) {
+  const schemes = Array.isArray(spec.schemes) ? spec.schemes : ["https"];
+  const scheme = typeof schemes[0] === "string" ? schemes[0] : "https";
+  const host = typeof spec.host === "string" ? spec.host : new URL(docsUrl).host;
+  const basePath = typeof spec.basePath === "string" ? spec.basePath : "";
+  const apiBaseUrl = normalizeBaseUrl(`${scheme}://${host}${basePath}`);
+  return {
+    apiBaseUrl,
+    endpoints: extractEndpointsFromPaths(spec.paths)
+  };
+}
+function parseSwaggerDocument(spec, docsUrl) {
+  if (!spec || typeof spec !== "object") {
+    throw new Error("Swagger \u6587\u6863\u683C\u5F0F\u65E0\u6548");
+  }
+  const document = spec;
+  if (typeof document.openapi === "string") {
+    const parsed = parseOpenApiV3(document, docsUrl);
+    if (parsed.endpoints.length === 0) {
+      throw new Error("\u672A\u5728 OpenAPI \u6587\u6863\u4E2D\u627E\u5230\u63A5\u53E3");
+    }
+    return parsed;
+  }
+  if (document.swagger === "2.0" || document.swagger === 2) {
+    const parsed = parseSwaggerV2(document, docsUrl);
+    if (parsed.endpoints.length === 0) {
+      throw new Error("\u672A\u5728 Swagger 2.0 \u6587\u6863\u4E2D\u627E\u5230\u63A5\u53E3");
+    }
+    return parsed;
+  }
+  throw new Error("\u4EC5\u652F\u6301 OpenAPI 3.x \u4E0E Swagger 2.0 \u6587\u6863");
+}
+function buildEndpointFullUrl(apiBaseUrl, pathOrEndpoint) {
+  const path = typeof pathOrEndpoint === "string" ? pathOrEndpoint : pathOrEndpoint.path;
+  return joinBaseAndPath(apiBaseUrl, path);
+}
+function buildEndpointSuggestions(apiBaseUrl, endpoints) {
+  return endpoints.map((endpoint) => {
+    const fullUrl = buildEndpointFullUrl(apiBaseUrl, endpoint);
+    const labelParts = [
+      endpoint.method,
+      endpoint.path,
+      endpoint.summary ? `\xB7 ${endpoint.summary}` : ""
+    ].filter(Boolean);
+    return {
+      ...endpoint,
+      fullUrl,
+      label: labelParts.join(" ")
+    };
+  });
+}
+function filterEndpointSuggestions(suggestions, query) {
+  const keyword = query.trim().toLowerCase();
+  if (!keyword) return suggestions;
+  return suggestions.filter(
+    (item) => item.fullUrl.toLowerCase().includes(keyword) || item.path.toLowerCase().includes(keyword) || item.method.toLowerCase().includes(keyword) || item.summary?.toLowerCase().includes(keyword) || item.operationId?.toLowerCase().includes(keyword)
+  );
+}
+
+// src/runtime/execution-trace.ts
+function serializeTraceValue(value) {
+  if (value === void 0) return void 0;
+  if (isTrueSignal(value)) {
+    return {
+      kind: "true",
+      value: value.value,
+      isoTime: value.isoTime
+    };
+  }
+  if (isFalseSignal(value)) {
+    return {
+      kind: "false",
+      error: value.error,
+      isoTime: value.isoTime
+    };
+  }
+  return value;
+}
+function createTraceEntryId() {
+  return `trace_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+}
+
+// src/nodes/definitions.ts
+var BLUEPRINT_NODE_TYPE = "Blueprint";
+var DEFAULT_LOGIC_NODE_TYPE = "Logic";
+var LIFECYCLE_NODE_TYPE = "Lifecycle";
+var FETCH_NODE_TYPE = "DataFetch";
+var JSON_NODE_TYPE = "JsonNode";
+var STORAGE_NODE_TYPE = "StorageNode";
+var CLOCK_NODE_TYPE = "Clock";
+var AND_NODE_TYPE = "AndLogic";
+var VIEW_NODE_TYPE = "ViewBind";
+var EVENT_NODE_TYPE = "ViewEvent";
+var blueprintNodeDefinition = {
+  type: BLUEPRINT_NODE_TYPE,
+  inputs: [{ name: "in", kind: "data" }],
+  outputs: [{ name: "out", kind: "data" }],
+  behavior: { kind: "js", ref: "blueprint-ref-run" }
+};
+var defaultLogicNodeDefinition = {
+  type: DEFAULT_LOGIC_NODE_TYPE,
+  inputs: [{ name: "in", kind: "data", optional: true }],
+  outputs: [{ name: "out", kind: "data" }],
+  behavior: { kind: "js", ref: "logic-run" }
+};
+var lifecycleNodeDefinition = {
+  type: LIFECYCLE_NODE_TYPE,
+  inputs: [],
+  outputs: [{ name: "out", kind: "data" }],
+  behavior: { kind: "js", ref: "lifecycle-emit" }
+};
+var fetchNodeDefinition = {
+  type: FETCH_NODE_TYPE,
+  inputs: [{ name: "in", kind: "data" }],
+  outputs: [{ name: "out", kind: "data" }],
+  behavior: { kind: "js", ref: "fetch-run" }
+};
+var jsonNodeDefinition = {
+  type: JSON_NODE_TYPE,
+  inputs: [{ name: "in", kind: "data" }],
+  outputs: [{ name: "out", kind: "data" }],
+  behavior: { kind: "js", ref: "json-parse-run" }
+};
+var storageNodeDefinition = {
+  type: STORAGE_NODE_TYPE,
+  inputs: [{ name: "in", kind: "data" }],
+  outputs: [{ name: "out", kind: "data" }],
+  behavior: { kind: "js", ref: "storage-run" }
+};
+var clockNodeDefinition = {
+  type: CLOCK_NODE_TYPE,
+  inputs: [{ name: "in", kind: "data" }],
+  outputs: [{ name: "out", kind: "data" }],
+  behavior: { kind: "js", ref: "clock-run" }
+};
+var andLogicNodeDefinition = {
+  type: AND_NODE_TYPE,
+  inputs: [
+    { name: "inA", kind: "data" },
+    { name: "inB", kind: "data" }
+  ],
+  outputs: [{ name: "out", kind: "data" }],
+  behavior: { kind: "js", ref: "and-run" }
+};
+var viewBindNodeDefinition = {
+  type: VIEW_NODE_TYPE,
+  inputs: [{ name: "in", kind: "data" }],
+  outputs: [{ name: "out", kind: "data" }],
+  behavior: { kind: "js", ref: "view-bind-run" }
+};
+var viewEventNodeDefinition = {
+  type: EVENT_NODE_TYPE,
+  inputs: [{ name: "in", kind: "data" }],
+  outputs: [{ name: "out", kind: "data" }],
+  behavior: { kind: "js", ref: "event-emit" }
+};
+var nodeDefinitionRegistry = {
+  [BLUEPRINT_NODE_TYPE]: blueprintNodeDefinition,
+  [DEFAULT_LOGIC_NODE_TYPE]: defaultLogicNodeDefinition,
+  [LIFECYCLE_NODE_TYPE]: lifecycleNodeDefinition,
+  [FETCH_NODE_TYPE]: fetchNodeDefinition,
+  [JSON_NODE_TYPE]: jsonNodeDefinition,
+  [STORAGE_NODE_TYPE]: storageNodeDefinition,
+  [CLOCK_NODE_TYPE]: clockNodeDefinition,
+  [AND_NODE_TYPE]: andLogicNodeDefinition,
+  [VIEW_NODE_TYPE]: viewBindNodeDefinition,
+  [EVENT_NODE_TYPE]: viewEventNodeDefinition
+};
+function getNodeDefinition(type) {
+  const def = nodeDefinitionRegistry[type];
+  if (!def) {
+    throw new Error(`NodeDefinition not found: ${type}`);
+  }
+  return def;
+}
+
+// src/runtime/blueprint-cycle.ts
+var BLUEPRINT_CALL_STACK_KEY = "__blueprintCallStack";
+var BlueprintCycleError = class extends Error {
+  cycleIds;
+  constructor(cycleIds, message) {
+    super(message);
+    this.name = "BlueprintCycleError";
+    this.cycleIds = cycleIds;
+  }
+};
+function collectBlueprintLibraryRefs(graph) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const node of graph.nodes) {
+    if (node.nodeType === BLUEPRINT_NODE_TYPE && node.libraryBlueprintId) {
+      ids.add(node.libraryBlueprintId);
+    }
+  }
+  return [...ids];
+}
+function formatBlueprintCycleMessage(cycleIds, resolveName) {
+  const labels = cycleIds.map((id) => resolveName?.(id) ?? id);
+  return `\u84DD\u56FE\u5F15\u7528\u5B58\u5728\u6B7B\u5FAA\u73AF\uFF1A${labels.join(" \u2192 ")}`;
+}
+async function detectBlueprintReferenceCycle(options) {
+  const {
+    rootGraph,
+    rootLibraryBlueprintId,
+    resolveLibraryBlueprint,
+    resolveBlueprintName
+  } = options;
+  const graphCache = /* @__PURE__ */ new Map();
+  const loadGraph = async (libraryBlueprintId) => {
+    if (!graphCache.has(libraryBlueprintId)) {
+      graphCache.set(
+        libraryBlueprintId,
+        await resolveLibraryBlueprint(libraryBlueprintId)
+      );
+    }
+    return graphCache.get(libraryBlueprintId) ?? null;
+  };
+  const visit = async (path, graph) => {
+    for (const refId of collectBlueprintLibraryRefs(graph)) {
+      const cycleIndex = path.indexOf(refId);
+      if (cycleIndex !== -1) {
+        return [...path.slice(cycleIndex), refId];
+      }
+      const nested = await loadGraph(refId);
+      if (!nested) continue;
+      const cycle = await visit([...path, refId], nested);
+      if (cycle) return cycle;
+    }
+    return null;
+  };
+  const initialPath = rootLibraryBlueprintId ? [rootLibraryBlueprintId] : [];
+  const cycleIds = await visit(initialPath, rootGraph);
+  if (!cycleIds) {
+    return { ok: true };
+  }
+  return {
+    ok: false,
+    cycleIds,
+    message: formatBlueprintCycleMessage(cycleIds, resolveBlueprintName)
+  };
+}
+async function assertNoBlueprintReferenceCycle(options) {
+  const result = await detectBlueprintReferenceCycle(options);
+  if (!result.ok) {
+    throw new BlueprintCycleError(result.cycleIds, result.message);
+  }
+}
+function resolveBlueprintCallStack(scopeStack, rootLibraryBlueprintId) {
+  if (scopeStack) return scopeStack;
+  return rootLibraryBlueprintId ? [rootLibraryBlueprintId] : [];
+}
+function detectRuntimeBlueprintCycle(callStack, targetLibraryBlueprintId, resolveName) {
+  const cycleIndex = callStack.indexOf(targetLibraryBlueprintId);
+  if (cycleIndex === -1) {
+    return { ok: true };
+  }
+  const cycleIds = [
+    ...callStack.slice(cycleIndex),
+    targetLibraryBlueprintId
+  ];
+  return {
+    ok: false,
+    cycleIds,
+    message: formatBlueprintCycleMessage(cycleIds, resolveName)
+  };
+}
+
+// src/runtime/clock-active-registry.ts
+var activeClockNodeIds = /* @__PURE__ */ new Set();
+var listeners = /* @__PURE__ */ new Set();
+function emit() {
+  listeners.forEach((listener) => listener());
+}
+function markClockNodeActive(nodeId) {
+  if (activeClockNodeIds.has(nodeId)) return;
+  activeClockNodeIds.add(nodeId);
+  emit();
+}
+function markClockNodeInactive(nodeId) {
+  if (!activeClockNodeIds.delete(nodeId)) return;
+  emit();
+}
+function isClockNodeActive(nodeId) {
+  return activeClockNodeIds.has(nodeId);
+}
+function getActiveClockNodeIds() {
+  return [...activeClockNodeIds];
+}
+function subscribeActiveClockNodes(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+// src/runtime/clock-scheduler.ts
+function buildClockSessionKey(scopeId, nodeId) {
+  return `${scopeId}:${nodeId}`;
+}
+function abortClockNode(scopeId, nodeId) {
+  abortClockSession(buildClockSessionKey(scopeId, nodeId));
+  markClockNodeInactive(nodeId);
+}
+function scheduleClockOutputs(options) {
+  return startClockSchedule(options);
+}
+function createClockOutputValue(config) {
+  return buildClockSignalValue(normalizeClockConfig(config));
+}
+
+// src/runtime/graph-runner.ts
+function createTokenId() {
+  return `token_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+}
+function cloneScope(scope) {
+  return {
+    parent: scope?.parent,
+    vars: new Map(scope?.vars ?? [])
+  };
+}
+function cloneOutputs(outputs) {
+  const next = /* @__PURE__ */ new Map();
+  for (const [nodeId, ports] of outputs.entries()) {
+    next.set(nodeId, new Map(ports));
+  }
+  return next;
+}
+function cloneToken(token) {
+  return {
+    tokenId: token.tokenId,
+    nodeId: token.nodeId,
+    nodeType: token.nodeType,
+    inPort: token.inPort,
+    scope: cloneScope(token.scope),
+    correlationId: token.correlationId
+  };
+}
+function cloneQueue(queue) {
+  return queue.map(cloneToken);
+}
+var BlueprintGraphRunner = class _BlueprintGraphRunner {
+  constructor(graph, options) {
+    this.graph = graph;
+    this.resolveLibraryBlueprint = options?.resolveLibraryBlueprint;
+    this.rootLibraryBlueprintId = options?.rootLibraryBlueprintId ?? null;
+    this.resolveBlueprintName = options?.resolveBlueprintName;
+    this.onViewScopeUpdate = options?.onViewScopeUpdate;
+    this.behaviors = new BehaviorRegistry();
+    registerDefaultBehaviors(this.behaviors);
+    this.registerBlueprintRefBehavior();
+    this.registerFetchBehavior();
+    this.registerJsonBehavior();
+    this.registerStorageBehavior();
+    this.registerLogicBehavior();
+    this.registerClockBehavior();
+    this.registerAndBehavior();
+    this.registerViewBindBehavior();
+  }
+  graph;
+  behaviors;
+  outputs = /* @__PURE__ */ new Map();
+  resolveLibraryBlueprint;
+  debugQueue = null;
+  debugExecutor = null;
+  traceEntries = [];
+  debugHistory = [];
+  rootLibraryBlueprintId;
+  resolveBlueprintName;
+  cycleValidated = false;
+  debugProgressCallback = null;
+  onViewScopeUpdate;
+  async ensureNoBlueprintCycle() {
+    if (this.cycleValidated || !this.resolveLibraryBlueprint) {
+      return;
+    }
+    await assertNoBlueprintReferenceCycle({
+      rootGraph: this.graph,
+      rootLibraryBlueprintId: this.rootLibraryBlueprintId,
+      resolveLibraryBlueprint: this.resolveLibraryBlueprint,
+      resolveBlueprintName: this.resolveBlueprintName
+    });
+    this.cycleValidated = true;
+  }
+  injectedInputs = /* @__PURE__ */ new Map();
+  /**
+   * 从视图交互触发指定蓝图节点：向该节点 in 口注入真信号并执行下游。
+   * payload 写入 scope（UI_EVENT_PAYLOAD_KEY）供 Logic 等节点读取。
+   */
+  async triggerNode(nodeId, inputValue) {
+    await this.ensureNoBlueprintCycle();
+    this.requireNode(nodeId);
+    const key = `${nodeId}:in`;
+    this.injectedInputs.set(key, createTrueSignal(inputValue ?? true));
+    try {
+      await this.runFromNodeWithUiPayload(nodeId, inputValue);
+    } finally {
+      this.injectedInputs.delete(key);
+    }
+  }
+  async runFromNodeWithUiPayload(nodeId, inputValue) {
+    const queue = [
+      {
+        tokenId: createTokenId(),
+        nodeId,
+        nodeType: this.requireNode(nodeId).nodeType,
+        inPort: "in",
+        scope: cloneScope()
+      }
+    ];
+    queue[0].scope.vars.set(UI_EVENT_PAYLOAD_KEY, inputValue);
+    const executor = this.createExecutor(queue);
+    while (queue.length > 0) {
+      const token = queue.shift();
+      if (!this.syncTokenFromGraph(token)) continue;
+      try {
+        await executor.executeToken(token);
+      } catch (error) {
+        this.setNodeOutput(
+          token.nodeId,
+          "out",
+          createFalseSignal(
+            error instanceof Error ? error.message : String(error)
+          )
+        );
+        const nextNodes = this.findSignalTargets(token.nodeId, "out");
+        for (const target of nextNodes) {
+          queue.push({
+            tokenId: createTokenId(),
+            nodeId: target.nodeId,
+            nodeType: target.nodeType,
+            inPort: target.inPort,
+            scope: token.scope,
+            correlationId: token.correlationId ?? token.tokenId
+          });
+        }
+      }
+    }
+  }
+  async emitLifecycle(phase) {
+    await this.ensureNoBlueprintCycle();
+    const signal = createLifecycleSignal(phase);
+    const targets = this.graph.nodes.filter(
+      (node) => node.nodeType === LIFECYCLE_NODE_TYPE && node.lifecyclePhase === phase
+    );
+    for (const node of targets) {
+      await this.runFromNode(node.id, signal);
+    }
+  }
+  /**
+   * 嵌套蓝图被引用且父级传入真信号时，触发 blueprintActivated 生命周期节点，
+   * 并将父级输入值写入 scope 供节点输出。
+   */
+  async emitBlueprintActivated(inputValue, parentScope) {
+    const signal = createLifecycleSignal("blueprintActivated");
+    const targets = this.graph.nodes.filter(
+      (node) => node.nodeType === LIFECYCLE_NODE_TYPE && node.lifecyclePhase === "blueprintActivated"
+    );
+    for (const node of targets) {
+      await this.runFromNode(node.id, signal, parentScope, inputValue);
+    }
+  }
+  /**
+   * 视图节点触发事件时，匹配已注册（上游生命周期已触发）且绑定了该元素、事件类型的事件节点，发出真信号。
+   */
+  async emitViewEvent(payload, armedNodeIds) {
+    await this.ensureNoBlueprintCycle();
+    const targets = this.graph.nodes.filter((node) => {
+      if (node.nodeType !== EVENT_NODE_TYPE) return false;
+      if (armedNodeIds && !armedNodeIds.has(node.id)) return false;
+      if (!(node.viewElementIds ?? []).includes(payload.node.id)) return false;
+      return normalizeViewEventConfig(node.eventConfig).eventTypes.includes(
+        payload.eventType
+      );
+    });
+    for (const node of targets) {
+      await this.runFromNode(node.id, void 0, void 0, void 0, payload);
+    }
+  }
+  /** 时钟节点单次输出：向下游传播含当前时间的真信号 */
+  async propagateClockOutput(nodeId, parentScope, sessionKey) {
+    const resolvedSessionKey = sessionKey ?? buildClockSessionKey(this.clockScopeId(), nodeId);
+    if (isClockSessionAborted(resolvedSessionKey)) return;
+    await this.ensureNoBlueprintCycle();
+    const node = this.requireNode(nodeId);
+    if (node.nodeType !== CLOCK_NODE_TYPE) return;
+    const config = normalizeClockConfig({
+      ...DEFAULT_CLOCK_NODE_CONFIG,
+      ...node.clockConfig
+    });
+    const value = buildClockSignalValue(config);
+    this.setNodeOutput(nodeId, "out", createTrueSignal(value));
+    const queue = [];
+    for (const target of this.findSignalTargets(nodeId, "out")) {
+      queue.push({
+        tokenId: createTokenId(),
+        nodeId: target.nodeId,
+        nodeType: target.nodeType,
+        inPort: target.inPort,
+        scope: cloneScope(parentScope)
+      });
+    }
+    const executor = this.createExecutor(queue);
+    while (queue.length > 0) {
+      if (isClockSessionAborted(resolvedSessionKey)) {
+        queue.length = 0;
+        return;
+      }
+      const token = queue.shift();
+      if (!this.syncTokenFromGraph(token)) continue;
+      try {
+        await executor.executeToken(token);
+      } catch (error) {
+        this.setNodeOutput(
+          token.nodeId,
+          "out",
+          createFalseSignal(
+            error instanceof Error ? error.message : String(error)
+          )
+        );
+        const nextNodes = this.findSignalTargets(token.nodeId, "out");
+        for (const target of nextNodes) {
+          queue.push({
+            tokenId: createTokenId(),
+            nodeId: target.nodeId,
+            nodeType: target.nodeType,
+            inPort: target.inPort,
+            scope: token.scope,
+            correlationId: token.correlationId ?? token.tokenId
+          });
+        }
+      }
+    }
+  }
+  clockScopeId() {
+    return this.rootLibraryBlueprintId ?? "local";
+  }
+  startClockSchedule(nodeId, config, scope) {
+    const sessionKey = buildClockSessionKey(this.clockScopeId(), nodeId);
+    markClockNodeActive(nodeId);
+    scheduleClockOutputs({
+      sessionKey,
+      config,
+      onTick: async () => {
+        if (isClockSessionAborted(sessionKey)) return;
+        await this.propagateClockOutput(nodeId, scope, sessionKey);
+      },
+      onSettled: () => markClockNodeInactive(nodeId)
+    });
+  }
+  /** 中止指定时钟节点：停止剩余 tick 与正在执行的下游任务 */
+  abortClockNode(nodeId) {
+    abortClockNode(this.clockScopeId(), nodeId);
+  }
+  /** 从所有无入流 signal 的节点开始执行（嵌套蓝图调用） */
+  async runFromFlowEntries(parentScope, options) {
+    if (!options?.preserveOutputs) {
+      this.outputs.clear();
+    }
+    const entries = this.findSignalEntryNodes();
+    for (const node of entries) {
+      await this.runFromNode(node.id, void 0, parentScope);
+    }
+    return this.collectOutputs();
+  }
+  getNodeOutputs() {
+    return this.collectOutputs();
+  }
+  getTraceEntries() {
+    return [...this.traceEntries];
+  }
+  isDebugSessionActive() {
+    return this.debugQueue !== null;
+  }
+  isDebugQueueEmpty() {
+    return !this.debugQueue || this.debugQueue.length === 0;
+  }
+  /** 调试过程中同步最新蓝图拓扑与节点配置 */
+  updateGraph(graph) {
+    this.graph = graph;
+    this.syncDebugQueueWithLatestGraph();
+  }
+  /**
+   * 按当前图结构重建待执行队列。
+   * 已有 trace 时，从最后执行的节点按最新出边重新入队；便于编辑连线后继续单步调试。
+   */
+  refreshPendingQueueFromLatestGraph() {
+    if (!this.debugQueue) return;
+    if (this.traceEntries.length === 0) {
+      this.syncDebugQueueWithLatestGraph();
+      return;
+    }
+    const lastEntry = this.traceEntries[this.traceEntries.length - 1];
+    const lastOutput = this.getNodeOutput(lastEntry.nodeId, "out");
+    if (lastOutput !== void 0 && isFalseSignal(lastOutput) && !this.graph.allowFalseSignalPropagation) {
+      this.debugQueue = [];
+      return;
+    }
+    const scope = this.debugQueue[0]?.scope ?? this.debugHistory[0]?.queue[0]?.scope ?? cloneScope();
+    const node = this.graph.nodes.find((n) => n.id === lastEntry.nodeId);
+    if (!node) {
+      this.debugQueue = [];
+      return;
+    }
+    let def;
+    try {
+      def = getNodeDefinition(node.nodeType);
+    } catch {
+      this.debugQueue = [];
+      return;
+    }
+    const newQueue = [];
+    for (const port of def.outputs) {
+      if (this.getNodeOutput(lastEntry.nodeId, port.name) === void 0) {
+        continue;
+      }
+      for (const target of this.findSignalTargets(lastEntry.nodeId, port.name)) {
+        newQueue.push({
+          tokenId: createTokenId(),
+          nodeId: target.nodeId,
+          nodeType: target.nodeType,
+          inPort: target.inPort,
+          scope: cloneScope(scope)
+        });
+      }
+    }
+    if (newQueue.length > 0 || this.debugQueue.length === 0) {
+      this.debugQueue = newQueue;
+    }
+  }
+  canDebugStepBack() {
+    return this.debugHistory.length > 1;
+  }
+  debugStepBack() {
+    if (!this.debugQueue || this.debugHistory.length <= 1) {
+      return false;
+    }
+    this.debugHistory.pop();
+    const snapshot = this.debugHistory[this.debugHistory.length - 1];
+    this.restoreDebugSnapshot(snapshot);
+    return true;
+  }
+  captureDebugSnapshot() {
+    return {
+      outputs: cloneOutputs(this.outputs),
+      queue: cloneQueue(this.debugQueue ?? []),
+      traceEntries: [...this.traceEntries]
+    };
+  }
+  restoreDebugSnapshot(snapshot) {
+    this.outputs = cloneOutputs(snapshot.outputs);
+    this.debugQueue = cloneQueue(snapshot.queue);
+    this.traceEntries = [...snapshot.traceEntries];
+  }
+  pushDebugSnapshot() {
+    this.debugHistory.push(this.captureDebugSnapshot());
+  }
+  beginDebugSession(lifecycleNodeId) {
+    stopAllClockSchedules();
+    const node = this.requireNode(lifecycleNodeId);
+    if (node.nodeType !== LIFECYCLE_NODE_TYPE) {
+      throw new Error("\u8C03\u8BD5\u4F1A\u8BDD\u53EA\u80FD\u4ECE\u751F\u547D\u5468\u671F\u8282\u70B9\u5F00\u59CB");
+    }
+    this.outputs.clear();
+    this.traceEntries = [];
+    this.debugQueue = [
+      {
+        tokenId: createTokenId(),
+        nodeId: lifecycleNodeId,
+        nodeType: node.nodeType,
+        inPort: "in",
+        scope: cloneScope()
+      }
+    ];
+    this.applyLifecycleScopeForNode(lifecycleNodeId);
+    this.debugExecutor = this.createExecutor(this.debugQueue, {
+      emitToActiveDebugQueue: true
+    });
+    this.debugHistory = [this.captureDebugSnapshot()];
+  }
+  /** 调试中修改生命周期阶段后，同步队列头部的 scope 信号 */
+  refreshDebugLifecycleScope(lifecycleNodeId) {
+    const head = this.debugQueue?.[0];
+    if (!head || head.nodeId !== lifecycleNodeId) return;
+    this.applyLifecycleScopeForNode(lifecycleNodeId);
+  }
+  applyLifecycleScopeForNode(lifecycleNodeId) {
+    const head = this.debugQueue?.[0];
+    if (!head || head.nodeId !== lifecycleNodeId) return;
+    const node = this.graph.nodes.find((n) => n.id === lifecycleNodeId);
+    if (!node?.lifecyclePhase) {
+      head.scope.vars.delete(LIFECYCLE_SIGNAL_KEY);
+      head.scope.vars.delete(BLUEPRINT_ACTIVATION_INPUT_KEY);
+      return;
+    }
+    head.scope.vars.set(
+      LIFECYCLE_SIGNAL_KEY,
+      createLifecycleSignal(node.lifecyclePhase)
+    );
+    if (node.lifecyclePhase === "blueprintActivated") {
+      head.scope.vars.set(BLUEPRINT_ACTIVATION_INPUT_KEY, void 0);
+    } else {
+      head.scope.vars.delete(BLUEPRINT_ACTIVATION_INPUT_KEY);
+    }
+  }
+  clearDebugSession() {
+    stopAllClockSchedules();
+    this.debugQueue = null;
+    this.debugExecutor = null;
+    this.traceEntries = [];
+    this.outputs.clear();
+    this.debugHistory = [];
+  }
+  async debugStep(nodeLabelById, onProgress) {
+    if (!this.debugQueue || !this.debugExecutor) {
+      return { done: true };
+    }
+    if (this.debugQueue.length === 0) {
+      return { done: true };
+    }
+    const prevCallback = this.debugProgressCallback;
+    this.debugProgressCallback = onProgress ?? null;
+    try {
+      this.pushDebugSnapshot();
+      const token = this.debugQueue.shift();
+      if (!this.syncTokenFromGraph(token)) {
+        this.pushDebugSnapshot();
+        return {
+          done: this.debugQueue.length === 0,
+          haltedByFalseSignal: false
+        };
+      }
+      if (token.nodeType === CLOCK_NODE_TYPE) {
+        const node = this.requireNode(token.nodeId);
+        const config = normalizeClockConfig({
+          ...DEFAULT_CLOCK_NODE_CONFIG,
+          ...node.clockConfig
+        });
+        const halted = await this.executeClockScheduleForDebug(
+          token,
+          config,
+          nodeLabelById
+        );
+        this.haltDebugQueueOnFalseOutput(token.nodeId);
+        this.pushDebugSnapshot();
+        return {
+          done: this.debugQueue.length === 0,
+          entry: this.traceEntries[this.traceEntries.length - 1],
+          haltedByFalseSignal: halted || this.isDebugHaltedByFalseOutput(token.nodeId)
+        };
+      }
+      const entry = await this.executeDebugToken(token, nodeLabelById);
+      this.haltDebugQueueOnFalseOutput(token.nodeId);
+      this.pushDebugSnapshot();
+      return {
+        done: this.debugQueue.length === 0,
+        entry,
+        haltedByFalseSignal: this.isDebugHaltedByFalseOutput(token.nodeId)
+      };
+    } finally {
+      this.debugProgressCallback = prevCallback;
+    }
+  }
+  notifyDebugProgress() {
+    this.debugProgressCallback?.([...this.traceEntries]);
+  }
+  async awaitClockDelay(ms, sessionKey) {
+    if (ms <= 0) return;
+    const step = 50;
+    let elapsed = 0;
+    while (elapsed < ms) {
+      if (sessionKey && isClockSessionAborted(sessionKey)) return;
+      const chunk = Math.min(step, ms - elapsed);
+      await new Promise((resolve) => setTimeout(resolve, chunk));
+      elapsed += chunk;
+    }
+  }
+  buildTraceInputsForNode(nodeId, nodeType) {
+    const def = getNodeDefinition(nodeType);
+    const inputs = {};
+    for (const port of def.inputs) {
+      inputs[port.name] = serializeTraceValue(
+        this.resolvePortInputValue(nodeId, port.name)
+      );
+    }
+    return inputs;
+  }
+  appendDebugTraceEntry(token, nodeLabelById, startedAt, options) {
+    const def = getNodeDefinition(token.nodeType);
+    const outputs = {};
+    for (const port of def.outputs) {
+      outputs[port.name] = serializeTraceValue(
+        this.getNodeOutput(token.nodeId, port.name)
+      );
+    }
+    const entry = {
+      id: createTraceEntryId(),
+      nodeId: token.nodeId,
+      nodeLabel: options?.tickLabel ?? nodeLabelById?.[token.nodeId],
+      nodeType: token.nodeType,
+      startedAt,
+      finishedAt: Date.now(),
+      isoTime: new Date(startedAt).toISOString(),
+      inputs: options?.inputs ?? this.buildTraceInputsForNode(token.nodeId, token.nodeType),
+      outputs,
+      error: options?.error,
+      clockTickIndex: options?.clockTickIndex,
+      clockTickTotal: options?.clockTickTotal
+    };
+    this.traceEntries.push(entry);
+    this.notifyDebugProgress();
+    return entry;
+  }
+  enqueueDebugTargets(sourceNodeId, outPort, scope) {
+    return this.findSignalTargets(sourceNodeId, outPort).map((target) => ({
+      tokenId: createTokenId(),
+      nodeId: target.nodeId,
+      nodeType: target.nodeType,
+      inPort: target.inPort,
+      scope: cloneScope(scope)
+    }));
+  }
+  async runDebugTokenSubqueue(queue, nodeLabelById, abortSessionKey) {
+    const executor = this.createExecutor(queue);
+    while (queue.length > 0) {
+      if (abortSessionKey && isClockSessionAborted(abortSessionKey)) {
+        queue.length = 0;
+        return false;
+      }
+      const token = queue.shift();
+      if (token.nodeType === CLOCK_NODE_TYPE) {
+        const node = this.requireNode(token.nodeId);
+        const config = normalizeClockConfig({
+          ...DEFAULT_CLOCK_NODE_CONFIG,
+          ...node.clockConfig
+        });
+        const halted = await this.executeClockScheduleForDebug(
+          token,
+          config,
+          nodeLabelById
+        );
+        if (halted) return true;
+        continue;
+      }
+      await this.executeDebugToken(token, nodeLabelById, executor, queue);
+      if (abortSessionKey && isClockSessionAborted(abortSessionKey)) {
+        queue.length = 0;
+        return false;
+      }
+      if (this.isDebugHaltedByFalseOutput(token.nodeId)) {
+        return true;
+      }
+      this.pushDebugSnapshot();
+    }
+    return false;
+  }
+  async executeDebugToken(token, nodeLabelById, executor, emitQueue) {
+    const startedAt = Date.now();
+    let error;
+    const runExecutor = executor ?? this.debugExecutor ?? this.createExecutor(this.debugQueue ?? []);
+    if (!this.syncTokenFromGraph(token)) {
+      return this.appendDebugTraceEntry(token, nodeLabelById, startedAt, {
+        error: "\u8282\u70B9\u5DF2\u4ECE\u84DD\u56FE\u4E2D\u79FB\u9664"
+      });
+    }
+    try {
+      await runExecutor.executeToken(token);
+    } catch (err) {
+      error = err instanceof Error ? err.message : String(err);
+      this.setNodeOutput(
+        token.nodeId,
+        "out",
+        createFalseSignal(error)
+      );
+      const targets = emitQueue ?? this.debugQueue;
+      if (targets) {
+        for (const next of this.enqueueDebugTargets(
+          token.nodeId,
+          "out",
+          token.scope
+        )) {
+          targets.push(next);
+        }
+      }
+    }
+    return this.appendDebugTraceEntry(token, nodeLabelById, startedAt, {
+      error
+    });
+  }
+  /**
+   * 调试模式下执行完整时钟序列：等待 n 次输出（含间隔），
+   * 每次更新 trace / 画布高亮，并同步跑完当次下游链。
+   */
+  async executeClockScheduleForDebug(token, config, nodeLabelById) {
+    const sessionKey = buildClockSessionKey(this.clockScopeId(), token.nodeId);
+    clearClockSessionAbort(sessionKey);
+    markClockNodeActive(token.nodeId);
+    try {
+      const normalized = normalizeClockConfig(config);
+      const baseInputs = this.buildTraceInputsForNode(
+        token.nodeId,
+        token.nodeType
+      );
+      const input = this.resolvePortInputValue(token.nodeId, "in");
+      const finishWithOutput = async (output, tickLabel) => {
+        this.setNodeOutput(token.nodeId, "out", output);
+        this.appendDebugTraceEntry(token, nodeLabelById, Date.now(), {
+          tickLabel,
+          inputs: baseInputs
+        });
+        this.pushDebugSnapshot();
+        const subQueue = this.enqueueDebugTargets(
+          token.nodeId,
+          "out",
+          token.scope
+        );
+        return this.runDebugTokenSubqueue(subQueue, nodeLabelById, sessionKey);
+      };
+      if (isFalseSignal(input)) {
+        return finishWithOutput(input);
+      }
+      if (!isTrueSignal(input)) {
+        return finishWithOutput(
+          createFalseSignal("\u65F6\u949F\u8282\u70B9\u9700\u8981\u6536\u5230\u771F\u4FE1\u53F7\u540E\u624D\u4F1A\u542F\u52A8")
+        );
+      }
+      const validation = validateClockScheduleConfig(normalized);
+      if (!validation.ok) {
+        return finishWithOutput(createFalseSignal(validation.error));
+      }
+      const baseLabel = nodeLabelById?.[token.nodeId] ?? token.nodeId;
+      const scheduleStartMs = Date.now();
+      for (let i = 0; i < normalized.outputCount; i++) {
+        if (isClockSessionAborted(sessionKey)) return false;
+        const waitMs = getClockTickWaitMs(normalized, i, scheduleStartMs);
+        if (waitMs > 0) {
+          await this.awaitClockDelay(waitMs, sessionKey);
+        }
+        if (isClockSessionAborted(sessionKey)) return false;
+        const tickStarted = Date.now();
+        const value = buildClockSignalValue(normalized);
+        this.setNodeOutput(token.nodeId, "out", createTrueSignal(value));
+        const tickLabel = normalized.outputCount > 1 ? `${baseLabel} (${i + 1}/${normalized.outputCount})` : baseLabel;
+        this.appendDebugTraceEntry(token, nodeLabelById, tickStarted, {
+          tickLabel,
+          inputs: baseInputs,
+          clockTickIndex: i + 1,
+          clockTickTotal: normalized.outputCount
+        });
+        this.pushDebugSnapshot();
+        const subQueue = this.enqueueDebugTargets(
+          token.nodeId,
+          "out",
+          token.scope
+        );
+        const halted = await this.runDebugTokenSubqueue(
+          subQueue,
+          nodeLabelById,
+          sessionKey
+        );
+        if (halted || isClockSessionAborted(sessionKey)) return halted;
+      }
+      return false;
+    } finally {
+      markClockNodeInactive(token.nodeId);
+    }
+  }
+  isDebugHaltedByFalseOutput(nodeId) {
+    if (this.graph.allowFalseSignalPropagation) return false;
+    const targetId = nodeId ?? this.traceEntries[this.traceEntries.length - 1]?.nodeId;
+    if (!targetId) return false;
+    return this.isFalseOutputNode(targetId);
+  }
+  isFalseOutputNode(nodeId) {
+    const out = this.getNodeOutput(nodeId, "out");
+    return out !== void 0 && isFalseSignal(out);
+  }
+  haltDebugQueueOnFalseOutput(nodeId) {
+    if (!this.debugQueue || this.graph.allowFalseSignalPropagation) return;
+    if (this.isFalseOutputNode(nodeId)) {
+      this.debugQueue = [];
+    }
+  }
+  async debugRunAll(nodeLabelById, onProgress) {
+    while (this.debugQueue && this.debugQueue.length > 0) {
+      await this.debugStep(nodeLabelById, onProgress);
+    }
+    return this.getTraceEntries();
+  }
+  registerBlueprintRefBehavior() {
+    const runner = this;
+    this.behaviors.registerJS("blueprint-ref-run", async ({ token, io }) => {
+      const node = runner.requireNode(token.nodeId);
+      try {
+        const input = await io.getInput("in");
+        if (!isTrueSignal(input)) {
+          io.setOutput(
+            "out",
+            createFalseSignal("\u84DD\u56FE\u8282\u70B9\u9700\u8981\u6536\u5230\u771F\u4FE1\u53F7\u540E\u624D\u4F1A\u6267\u884C")
+          );
+          io.emitFlow("out");
+          return;
+        }
+        const libraryId = node.libraryBlueprintId;
+        if (!libraryId) {
+          io.setOutput("out", createFalseSignal("\u672A\u9009\u62E9\u84DD\u56FE\u5E93\u4E2D\u7684\u84DD\u56FE"));
+          io.emitFlow("out");
+          return;
+        }
+        if (!runner.resolveLibraryBlueprint) {
+          io.setOutput("out", createFalseSignal("\u84DD\u56FE\u5E93\u89E3\u6790\u5668\u672A\u914D\u7F6E"));
+          io.emitFlow("out");
+          return;
+        }
+        const scopeStack = token.scope.vars.get(BLUEPRINT_CALL_STACK_KEY);
+        const callStack = resolveBlueprintCallStack(
+          scopeStack,
+          runner.rootLibraryBlueprintId
+        );
+        const runtimeCycle = detectRuntimeBlueprintCycle(
+          callStack,
+          libraryId,
+          runner.resolveBlueprintName
+        );
+        if (!runtimeCycle.ok) {
+          io.setOutput("out", createFalseSignal(runtimeCycle.message));
+          io.emitFlow("out");
+          return;
+        }
+        const nestedGraph = await runner.resolveLibraryBlueprint(libraryId);
+        if (!nestedGraph) {
+          io.setOutput(
+            "out",
+            createFalseSignal(`\u84DD\u56FE\u5E93\u8BB0\u5F55\u4E0D\u5B58\u5728: ${libraryId}`)
+          );
+          io.emitFlow("out");
+          return;
+        }
+        const nestedScope = cloneScope(token.scope);
+        nestedScope.vars.set(BLUEPRINT_CALL_STACK_KEY, [...callStack, libraryId]);
+        const subRunner = new _BlueprintGraphRunner(nestedGraph, {
+          resolveLibraryBlueprint: runner.resolveLibraryBlueprint,
+          rootLibraryBlueprintId: libraryId,
+          resolveBlueprintName: runner.resolveBlueprintName,
+          onViewScopeUpdate: runner.onViewScopeUpdate
+        });
+        await subRunner.emitBlueprintActivated(input.value, nestedScope);
+        const nestedOutputs = await subRunner.runFromFlowEntries(nestedScope, {
+          preserveOutputs: true
+        });
+        const payload = {
+          nodeId: token.nodeId,
+          nodeType: node.nodeType,
+          libraryBlueprintId: libraryId,
+          blueprintName: node.blueprintName ?? nestedGraph.nodes[0]?.blueprintName,
+          nestedOutputs
+        };
+        io.setOutput("out", createTrueSignal(payload));
+      } catch (error) {
+        io.setOutput(
+          "out",
+          createFalseSignal(
+            error instanceof Error ? error.message : String(error)
+          )
+        );
+      }
+      io.emitFlow("out");
+    });
+  }
+  registerFetchBehavior() {
+    const runner = this;
+    this.behaviors.registerJS("fetch-run", async ({ token, io }) => {
+      const node = runner.requireNode(token.nodeId);
+      try {
+        const inputPort = token.inPort || "in";
+        const input = await io.getInput(inputPort);
+        if (isFalseSignal(input)) {
+          io.setOutput("out", input);
+          io.emitFlow("out");
+          return;
+        }
+        if (!isTrueSignal(input)) {
+          io.setOutput(
+            "out",
+            createFalseSignal(
+              input === void 0 ? "\u6570\u636E\u6E90\u8282\u70B9\u672A\u6536\u5230\u4E0A\u6E38\u8F93\u51FA\uFF0C\u8BF7\u786E\u8BA4\u8FDE\u7EBF\u4E0E\u4E0A\u6E38\u8282\u70B9\u5DF2\u6267\u884C" : "\u6570\u636E\u6E90\u8282\u70B9\u9700\u8981\u6536\u5230\u771F\u4FE1\u53F7\u540E\u624D\u4F1A\u53D1\u8D77\u8BF7\u6C42"
+            )
+          );
+          io.emitFlow("out");
+          return;
+        }
+        const incomingScope = runner.buildFetchIncomingScope(
+          token.nodeId,
+          inputPort,
+          input
+        );
+        const config = applyFetchConfigScope(
+          normalizeFetchRequestConfig(node.fetchConfig),
+          incomingScope
+        );
+        const headersError = getFetchHeadersValidationError(config, incomingScope);
+        if (headersError) {
+          throw new Error(headersError);
+        }
+        const bodyError = getFetchBodyValidationError(config.body, config.body);
+        if (bodyError) {
+          throw new Error(`\u8BF7\u6C42\u4F53\u4E0D\u662F\u6709\u6548 JSON\uFF1A${bodyError}`);
+        }
+        resolveFetchRequestUrl(config);
+        const result = await executeFetch(config, {
+          allowHttpError: runner.isDebugSessionActive()
+        });
+        io.setOutput("out", createTrueSignal(result));
+      } catch (error) {
+        io.setOutput(
+          "out",
+          createFalseSignal(
+            error instanceof Error ? error.message : String(error)
+          )
+        );
+      }
+      io.emitFlow("out");
+    });
+  }
+  registerLogicBehavior() {
+    const runner = this;
+    this.behaviors.registerJS("logic-run", async ({ token, io }) => {
+      const node = runner.requireNode(token.nodeId);
+      try {
+        const input = await io.getInput("in");
+        if (isFalseSignal(input)) {
+          io.setOutput("out", input);
+          io.emitFlow("out");
+          return;
+        }
+        const inputValue = isTrueSignal(input) ? input.value : void 0;
+        const config = {
+          ...DEFAULT_LOGIC_NODE_CONFIG,
+          ...node.logicConfig
+        };
+        const result = executeLogicConfig(config, inputValue);
+        io.setOutput("out", createTrueSignal(result));
+      } catch (error) {
+        io.setOutput(
+          "out",
+          createFalseSignal(
+            error instanceof Error ? error.message : String(error)
+          )
+        );
+      }
+      io.emitFlow("out");
+    });
+  }
+  registerJsonBehavior() {
+    const runner = this;
+    this.behaviors.registerJS("json-parse-run", async ({ token, io }) => {
+      const node = runner.requireNode(token.nodeId);
+      try {
+        const input = await io.getInput("in");
+        if (!isTrueSignal(input)) {
+          io.setOutput(
+            "out",
+            createFalseSignal("JSON \u8282\u70B9\u9700\u8981\u6536\u5230\u771F\u4FE1\u53F7\u540E\u624D\u4F1A\u89E3\u6790")
+          );
+          io.emitFlow("out");
+          return;
+        }
+        const config = {
+          ...DEFAULT_JSON_NODE_CONFIG,
+          ...node.jsonConfig
+        };
+        const value = parseJsonConfig(config);
+        io.setOutput("out", createTrueSignal(value));
+      } catch (error) {
+        io.setOutput(
+          "out",
+          createFalseSignal(
+            error instanceof Error ? error.message : String(error)
+          )
+        );
+      }
+      io.emitFlow("out");
+    });
+  }
+  registerStorageBehavior() {
+    const runner = this;
+    this.behaviors.registerJS("storage-run", async ({ token, io }) => {
+      const node = runner.requireNode(token.nodeId);
+      try {
+        const inputPort = token.inPort || "in";
+        const input = await io.getInput(inputPort);
+        if (isFalseSignal(input)) {
+          io.setOutput("out", input);
+          io.emitFlow("out");
+          return;
+        }
+        if (!isTrueSignal(input)) {
+          io.setOutput(
+            "out",
+            createFalseSignal("\u5B58\u50A8\u8282\u70B9\u9700\u8981\u6536\u5230\u771F\u4FE1\u53F7\u540E\u624D\u4F1A\u8BFB\u5199\u7F13\u5B58")
+          );
+          io.emitFlow("out");
+          return;
+        }
+        const incomingScope = runner.buildFetchIncomingScope(
+          token.nodeId,
+          inputPort,
+          input
+        );
+        const config = normalizeStorageConfig({
+          ...DEFAULT_STORAGE_NODE_CONFIG,
+          ...node.storageConfig
+        });
+        const value = executeStorageConfig(config, incomingScope);
+        io.setOutput("out", createTrueSignal(value));
+      } catch (error) {
+        io.setOutput(
+          "out",
+          createFalseSignal(
+            error instanceof Error ? error.message : String(error)
+          )
+        );
+      }
+      io.emitFlow("out");
+    });
+  }
+  registerClockBehavior() {
+    const runner = this;
+    this.behaviors.registerJS("clock-run", async ({ token, io }) => {
+      const node = runner.requireNode(token.nodeId);
+      const config = normalizeClockConfig({
+        ...DEFAULT_CLOCK_NODE_CONFIG,
+        ...node.clockConfig
+      });
+      try {
+        const input = await io.getInput("in");
+        if (isFalseSignal(input)) {
+          io.setOutput("out", input);
+          io.emitFlow("out");
+          return;
+        }
+        if (!isTrueSignal(input)) {
+          io.setOutput(
+            "out",
+            createFalseSignal("\u65F6\u949F\u8282\u70B9\u9700\u8981\u6536\u5230\u771F\u4FE1\u53F7\u540E\u624D\u4F1A\u542F\u52A8")
+          );
+          io.emitFlow("out");
+          return;
+        }
+        const validation = validateClockScheduleConfig(config);
+        if (!validation.ok) {
+          io.setOutput("out", createFalseSignal(validation.error));
+          io.emitFlow("out");
+          return;
+        }
+        if (runner.isDebugSessionActive()) {
+          return;
+        }
+        runner.startClockSchedule(token.nodeId, config, token.scope);
+      } catch (error) {
+        io.setOutput(
+          "out",
+          createFalseSignal(
+            error instanceof Error ? error.message : String(error)
+          )
+        );
+        io.emitFlow("out");
+      }
+    });
+  }
+  registerAndBehavior() {
+    this.behaviors.registerJS("and-run", async ({ io }) => {
+      const inA = await io.getInput("inA");
+      const inB = await io.getInput("inB");
+      if (isTrueSignal(inA) && isTrueSignal(inB)) {
+        io.setOutput(
+          "out",
+          createTrueSignal({ inA: inA.value, inB: inB.value })
+        );
+      } else {
+        io.setOutput(
+          "out",
+          createFalseSignal("\u5E76\u8FD0\u7B97\uFF1A\u4E24\u4E2A\u8F93\u5165\u987B\u5747\u4E3A\u771F\u4FE1\u53F7")
+        );
+      }
+      io.emitFlow("out");
+    });
+  }
+  registerViewBindBehavior() {
+    const runner = this;
+    this.behaviors.registerJS("view-bind-run", async ({ token, io }) => {
+      const node = runner.requireNode(token.nodeId);
+      const input = await io.getInput("in");
+      if (isTrueSignal(input) && node.viewElementIds?.length) {
+        runner.onViewScopeUpdate?.(node.viewElementIds, input.value);
+      }
+      if (isFalseSignal(input)) {
+        io.setOutput("out", input);
+      } else if (isTrueSignal(input)) {
+        io.setOutput("out", createTrueSignal(input.value));
+      } else {
+        io.setOutput("out", createTrueSignal(void 0));
+      }
+      io.emitFlow("out");
+    });
+  }
+  async runFromNode(nodeId, lifecycleSignal, parentScope, activationInput, viewEvent) {
+    const queue = [
+      {
+        tokenId: createTokenId(),
+        nodeId,
+        nodeType: this.requireNode(nodeId).nodeType,
+        inPort: "in",
+        scope: cloneScope(parentScope)
+      }
+    ];
+    if (lifecycleSignal) {
+      queue[0].scope.vars.set(LIFECYCLE_SIGNAL_KEY, lifecycleSignal);
+    }
+    if (lifecycleSignal?.phase === "blueprintActivated") {
+      queue[0].scope.vars.set(
+        BLUEPRINT_ACTIVATION_INPUT_KEY,
+        activationInput
+      );
+    }
+    if (viewEvent) {
+      queue[0].scope.vars.set(VIEW_EVENT_SIGNAL_KEY, viewEvent);
+      queue[0].scope.vars.set(UI_EVENT_PAYLOAD_KEY, viewEvent);
+    }
+    const executor = this.createExecutor(queue);
+    while (queue.length > 0) {
+      const token = queue.shift();
+      if (!this.syncTokenFromGraph(token)) continue;
+      try {
+        await executor.executeToken(token);
+      } catch (error) {
+        this.setNodeOutput(
+          token.nodeId,
+          "out",
+          createFalseSignal(
+            error instanceof Error ? error.message : String(error)
+          )
+        );
+        const nextNodes = this.findSignalTargets(token.nodeId, "out");
+        for (const target of nextNodes) {
+          queue.push({
+            tokenId: createTokenId(),
+            nodeId: target.nodeId,
+            nodeType: target.nodeType,
+            inPort: target.inPort,
+            scope: token.scope,
+            correlationId: token.correlationId ?? token.tokenId
+          });
+        }
+      }
+    }
+  }
+  createExecutor(queue, options) {
+    return new Executor({
+      getNodeDefinition,
+      behaviors: this.behaviors,
+      runBlueprint: async () => {
+      },
+      getInputValue: async (token, port) => {
+        const resolvedPort = port || token.inPort || "in";
+        return this.resolvePortInputValue(token.nodeId, resolvedPort);
+      },
+      setNodeOutput: (token, port, value) => {
+        this.setNodeOutput(token.nodeId, port, value);
+      },
+      emitFlow: (token, outPort) => {
+        const targetQueue = options?.emitToActiveDebugQueue && this.debugQueue ? this.debugQueue : queue;
+        const nextNodes = this.findSignalTargets(token.nodeId, outPort);
+        for (const target of nextNodes) {
+          targetQueue.push({
+            tokenId: createTokenId(),
+            nodeId: target.nodeId,
+            nodeType: target.nodeType,
+            inPort: target.inPort,
+            scope: token.scope,
+            correlationId: token.correlationId ?? token.tokenId
+          });
+        }
+      }
+    });
+  }
+  findSignalEntryNodes() {
+    const hasIncoming = /* @__PURE__ */ new Set();
+    for (const edge of this.graph.edges) {
+      hasIncoming.add(edge.target);
+    }
+    return this.graph.nodes.filter(
+      (node) => node.nodeType !== LIFECYCLE_NODE_TYPE && node.nodeType !== EVENT_NODE_TYPE && !hasIncoming.has(node.id)
+    );
+  }
+  collectOutputs() {
+    const result = {};
+    for (const [nodeId, ports] of this.outputs.entries()) {
+      result[nodeId] = Object.fromEntries(ports.entries());
+    }
+    return result;
+  }
+  requireNode(nodeId) {
+    const node = this.graph.nodes.find((n) => n.id === nodeId);
+    if (!node) {
+      throw new Error(`Graph node not found: ${nodeId}`);
+    }
+    return node;
+  }
+  /** 队列中的 token 可能是在节点改类型（如视图绑定）之前入队的，执行前与最新图对齐 */
+  syncTokenFromGraph(token) {
+    const node = this.graph.nodes.find((n) => n.id === token.nodeId);
+    if (!node) return false;
+    token.nodeType = node.nodeType;
+    return true;
+  }
+  syncDebugQueueWithLatestGraph() {
+    if (!this.debugQueue) return;
+    this.debugQueue = this.debugQueue.filter(
+      (token) => this.syncTokenFromGraph(token)
+    );
+  }
+  findSignalTargets(nodeId, outPort) {
+    return this.graph.edges.filter(
+      (edge) => edge.source === nodeId && (edge.sourceHandle ?? "out") === outPort
+    ).map((edge) => {
+      const target = this.requireNode(edge.target);
+      return {
+        nodeId: target.id,
+        nodeType: target.nodeType,
+        inPort: edge.targetHandle ?? "in"
+      };
+    });
+  }
+  findInboundSignalEdges(nodeId, port) {
+    return this.graph.edges.filter(
+      (edge) => edge.target === nodeId && (edge.targetHandle ?? "in") === port
+    );
+  }
+  buildFetchIncomingScope(nodeId, port, fallbackInput) {
+    return resolveFetchIncomingScope({
+      fetchNodeId: nodeId,
+      inputPort: port,
+      nodes: this.graph.nodes.map((node) => ({
+        id: node.id,
+        label: node.label,
+        nodeType: node.nodeType,
+        role: node.role
+      })),
+      edges: this.graph.edges,
+      getOutput: (sourceId, sourcePort) => this.getNodeOutput(sourceId, sourcePort),
+      fallbackInput
+    });
+  }
+  /** 单端口多连线：任一为真则视为真（或语义）；支持 triggerNode 注入的入口信号 */
+  resolvePortInputValue(nodeId, port) {
+    const injected = this.injectedInputs.get(`${nodeId}:${port}`);
+    if (injected !== void 0) return injected;
+    const inboundEdges = this.findInboundSignalEdges(nodeId, port);
+    if (inboundEdges.length === 0) return void 0;
+    const values = inboundEdges.map(
+      (edge) => this.getNodeOutput(edge.source, edge.sourceHandle ?? "out")
+    );
+    return combinePortSignalsOr(values);
+  }
+  findInboundSignalEdge(nodeId, port) {
+    return this.findInboundSignalEdges(nodeId, port)[0];
+  }
+  getNodeOutput(nodeId, port) {
+    return this.outputs.get(nodeId)?.get(port);
+  }
+  setNodeOutput(nodeId, port, value) {
+    let nodeOutputs = this.outputs.get(nodeId);
+    if (!nodeOutputs) {
+      nodeOutputs = /* @__PURE__ */ new Map();
+      this.outputs.set(nodeId, nodeOutputs);
+    }
+    nodeOutputs.set(port, value);
+  }
+};
+
+exports.AND_NODE_TYPE = AND_NODE_TYPE;
+exports.BLUEPRINT_ACTIVATION_INPUT_KEY = BLUEPRINT_ACTIVATION_INPUT_KEY;
+exports.BLUEPRINT_CALL_STACK_KEY = BLUEPRINT_CALL_STACK_KEY;
+exports.BLUEPRINT_NODE_TYPE = BLUEPRINT_NODE_TYPE;
+exports.BehaviorRegistry = BehaviorRegistry;
+exports.BlueprintCycleError = BlueprintCycleError;
+exports.BlueprintGraphRunner = BlueprintGraphRunner;
+exports.CLOCK_NODE_TYPE = CLOCK_NODE_TYPE;
+exports.DEFAULT_CLOCK_NODE_CONFIG = DEFAULT_CLOCK_NODE_CONFIG;
+exports.DEFAULT_FETCH_REQUEST_CONFIG = DEFAULT_FETCH_REQUEST_CONFIG;
+exports.DEFAULT_JSON_NODE_CONFIG = DEFAULT_JSON_NODE_CONFIG;
+exports.DEFAULT_LOGIC_NODE_CONFIG = DEFAULT_LOGIC_NODE_CONFIG;
+exports.DEFAULT_LOGIC_NODE_TYPE = DEFAULT_LOGIC_NODE_TYPE;
+exports.DEFAULT_STORAGE_NODE_CONFIG = DEFAULT_STORAGE_NODE_CONFIG;
+exports.DEFAULT_VIEW_EVENT_NODE_CONFIG = DEFAULT_VIEW_EVENT_NODE_CONFIG;
+exports.EVENT_NODE_TYPE = EVENT_NODE_TYPE;
+exports.Executor = Executor;
+exports.FETCH_CACHES = FETCH_CACHES;
+exports.FETCH_CREDENTIALS = FETCH_CREDENTIALS;
+exports.FETCH_HTTP_METHODS = FETCH_HTTP_METHODS;
+exports.FETCH_MODES = FETCH_MODES;
+exports.FETCH_NODE_TYPE = FETCH_NODE_TYPE;
+exports.FETCH_REDIRECTS = FETCH_REDIRECTS;
+exports.FETCH_RESPONSE_TYPES = FETCH_RESPONSE_TYPES;
+exports.FETCH_SCOPE_AUTOCOMPLETE_FALLBACK = FETCH_SCOPE_AUTOCOMPLETE_FALLBACK;
+exports.JSON_NODE_TYPE = JSON_NODE_TYPE;
+exports.LIFECYCLE_NODE_TYPE = LIFECYCLE_NODE_TYPE;
+exports.LIFECYCLE_SIGNAL_KEY = LIFECYCLE_SIGNAL_KEY;
+exports.PAGE_LIFECYCLE_LABELS = PAGE_LIFECYCLE_LABELS;
+exports.PAGE_LIFECYCLE_PHASES = PAGE_LIFECYCLE_PHASES;
+exports.STORAGE_KINDS = STORAGE_KINDS;
+exports.STORAGE_NODE_TYPE = STORAGE_NODE_TYPE;
+exports.UI_EVENT_PAYLOAD_KEY = UI_EVENT_PAYLOAD_KEY;
+exports.VIEW_EVENT_SIGNAL_KEY = VIEW_EVENT_SIGNAL_KEY;
+exports.VIEW_EVENT_TYPES = VIEW_EVENT_TYPES;
+exports.VIEW_NODE_TYPE = VIEW_NODE_TYPE;
+exports.abortClockNode = abortClockNode;
+exports.abortClockSession = abortClockSession;
+exports.andLogicNodeDefinition = andLogicNodeDefinition;
+exports.applyFetchConfigScope = applyFetchConfigScope;
+exports.applyScopeAutocompleteSelection = applyScopeAutocompleteSelection;
+exports.assertNoBlueprintReferenceCycle = assertNoBlueprintReferenceCycle;
+exports.blueprintNodeDefinition = blueprintNodeDefinition;
+exports.buildClockSessionKey = buildClockSessionKey;
+exports.buildClockSignalValue = buildClockSignalValue;
+exports.buildEndpointFullUrl = buildEndpointFullUrl;
+exports.buildEndpointSuggestions = buildEndpointSuggestions;
+exports.buildIncomingNodeScope = buildIncomingNodeScope;
+exports.buildScopeExpression = buildScopeExpression;
+exports.clearClockSessionAbort = clearClockSessionAbort;
+exports.clockNodeDefinition = clockNodeDefinition;
+exports.collectArmedViewEventBindings = collectArmedViewEventBindings;
+exports.collectArmedViewEventNodeIds = collectArmedViewEventNodeIds;
+exports.collectBlueprintLibraryRefs = collectBlueprintLibraryRefs;
+exports.collectIncomingNodeScopeEntries = collectIncomingNodeScopeEntries;
+exports.collectViewEventBindings = collectViewEventBindings;
+exports.combinePortSignalsOr = combinePortSignalsOr;
+exports.createClockOutputValue = createClockOutputValue;
+exports.createFalseSignal = createFalseSignal;
+exports.createIncomingNodeScopeEntry = createIncomingNodeScopeEntry;
+exports.createLifecycleSignal = createLifecycleSignal;
+exports.createTraceEntryId = createTraceEntryId;
+exports.createTrueSignal = createTrueSignal;
+exports.createViewEventSignal = createViewEventSignal;
+exports.defaultLogicNodeDefinition = defaultLogicNodeDefinition;
+exports.deserializeStorageValue = deserializeStorageValue;
+exports.detectBlueprintReferenceCycle = detectBlueprintReferenceCycle;
+exports.detectRuntimeBlueprintCycle = detectRuntimeBlueprintCycle;
+exports.draftFetchHeadersText = draftFetchHeadersText;
+exports.evaluateScopeExpression = evaluateScopeExpression;
+exports.evaluateScopeTemplate = evaluateScopeTemplate;
+exports.evaluateScopeTemplateInJson = evaluateScopeTemplateInJson;
+exports.executeFetch = executeFetch;
+exports.executeLogicConfig = executeLogicConfig;
+exports.executeStorageConfig = executeStorageConfig;
+exports.fetchConfigHasScopeTemplate = fetchConfigHasScopeTemplate;
+exports.fetchNodeDefinition = fetchNodeDefinition;
+exports.filterEndpointSuggestions = filterEndpointSuggestions;
+exports.formatBlueprintCycleMessage = formatBlueprintCycleMessage;
+exports.formatClockTime = formatClockTime;
+exports.getActiveClockNodeIds = getActiveClockNodeIds;
+exports.getClockTickDelayOffsetMs = getClockTickDelayOffsetMs;
+exports.getClockTickWaitMs = getClockTickWaitMs;
+exports.getFetchBodyValidationError = getFetchBodyValidationError;
+exports.getFetchHeadersValidationError = getFetchHeadersValidationError;
+exports.getNodeDefinition = getNodeDefinition;
+exports.getScopeAutocompleteSuggestions = getScopeAutocompleteSuggestions;
+exports.hasScopeTemplate = hasScopeTemplate;
+exports.isClockNodeActive = isClockNodeActive;
+exports.isClockScheduleActive = isClockScheduleActive;
+exports.isClockSessionAborted = isClockSessionAborted;
+exports.isFalseSignal = isFalseSignal;
+exports.isStorageReadConfigured = isStorageReadConfigured;
+exports.isStorageSetConfigured = isStorageSetConfigured;
+exports.isTrueSignal = isTrueSignal;
+exports.isViewEventType = isViewEventType;
+exports.isWholeScopeExpression = isWholeScopeExpression;
+exports.jsonNodeDefinition = jsonNodeDefinition;
+exports.latestTraceOutputsByNode = latestTraceOutputsByNode;
+exports.lifecycleNodeDefinition = lifecycleNodeDefinition;
+exports.looksLikeJsonText = looksLikeJsonText;
+exports.nodeDefinitionRegistry = nodeDefinitionRegistry;
+exports.normalizeClockConfig = normalizeClockConfig;
+exports.normalizeFetchRequestConfig = normalizeFetchRequestConfig;
+exports.normalizeStorageConfig = normalizeStorageConfig;
+exports.normalizeViewEventConfig = normalizeViewEventConfig;
+exports.parseFetchHeadersJson = parseFetchHeadersJson;
+exports.parseJsonConfig = parseJsonConfig;
+exports.parseJsonText = parseJsonText;
+exports.parseScopeAutocomplete = parseScopeAutocomplete;
+exports.parseSwaggerDocument = parseSwaggerDocument;
+exports.registerDefaultBehaviors = registerDefaultBehaviors;
+exports.resolveBlueprintCallStack = resolveBlueprintCallStack;
+exports.resolveFetchBody = resolveFetchBody;
+exports.resolveFetchHeaders = resolveFetchHeaders;
+exports.resolveFetchIncomingScope = resolveFetchIncomingScope;
+exports.resolveFetchRequestUrl = resolveFetchRequestUrl;
+exports.resolveFetchScopeAutocompleteRoot = resolveFetchScopeAutocompleteRoot;
+exports.resolveStorageWriteValue = resolveStorageWriteValue;
+exports.scheduleClockOutputs = scheduleClockOutputs;
+exports.serializeStorageValue = serializeStorageValue;
+exports.serializeTraceValue = serializeTraceValue;
+exports.snapshotDomEvent = snapshotDomEvent;
+exports.snapshotViewEventNode = snapshotViewEventNode;
+exports.startClockSchedule = startClockSchedule;
+exports.stopAllClockSchedules = stopAllClockSchedules;
+exports.stopClockSchedule = stopClockSchedule;
+exports.storageNodeDefinition = storageNodeDefinition;
+exports.stringifyScopeValue = stringifyScopeValue;
+exports.subscribeActiveClockNodes = subscribeActiveClockNodes;
+exports.uniqueStorageKinds = uniqueStorageKinds;
+exports.validateClockScheduleConfig = validateClockScheduleConfig;
+exports.validateFetchJsonText = validateFetchJsonText;
+exports.validateJsonString = validateJsonString;
+exports.validateLogicSourceCode = validateLogicSourceCode;
+exports.viewBindNodeDefinition = viewBindNodeDefinition;
+exports.viewEventNodeDefinition = viewEventNodeDefinition;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map