@arronqzy/vue-blueprint 0.1.0

package/src/graph/node-summary.ts

@@ -0,0 +1,88 @@
+import {
+  PAGE_LIFECYCLE_LABELS,
+  resolveFetchRequestUrl,
+} from "@arronqzy/blueprint-dsl";
+
+import {
+  resolveBlueprintConfigSource,
+  resolveNodeClockConfig,
+  resolveNodeFetchConfig,
+  resolveNodeJsonConfig,
+  resolveNodeLogicConfig,
+  resolveViewElementIds,
+} from "./document";
+import type { BlueprintFlowNodeData } from "./vue-flow-adapter";
+
+function truncate(text: string, max: number): string {
+  const trimmed = text.trim();
+  if (trimmed.length <= max) return trimmed;
+  return `${trimmed.slice(0, Math.max(0, max - 1))}…`;
+}
+
+/** 画布节点正文区展示的配置摘要 */
+export function resolveBlueprintNodeSummary(
+  data: BlueprintFlowNodeData
+): string | undefined {
+  const configSource = resolveBlueprintConfigSource(data);
+
+  switch (configSource) {
+    case "fetch": {
+      const config = resolveNodeFetchConfig(data);
+      if (!config.url?.trim()) return "未配置 URL";
+      let url = config.url.trim();
+      try {
+        url = resolveFetchRequestUrl(config);
+      } catch {
+        /* 保留原始输入 */
+      }
+      const method = config.method ?? "GET";
+      return truncate(`${method} ${url}`, 44);
+    }
+    case "clock": {
+      const clock = resolveNodeClockConfig(data);
+      const parts = [
+        `${clock.outputCount} 次`,
+        clock.intervalSeconds > 0 ? `间隔 ${clock.intervalSeconds}s` : null,
+        clock.emitImmediately ? "立即首发" : "延迟首发",
+      ].filter(Boolean);
+      return parts.join(" · ");
+    }
+    case "json": {
+      const json = resolveNodeJsonConfig(data).jsonString?.trim();
+      if (!json) return "空 JSON";
+      return truncate(json.replace(/\s+/g, " "), 44);
+    }
+    case "logic": {
+      const code = resolveNodeLogicConfig(data).sourceCode?.trim();
+      if (!code) return "未配置脚本";
+      const firstLine =
+        code.split("\n").find((line) => line.trim())?.trim() ?? code;
+      return truncate(firstLine, 44);
+    }
+    case "blueprint": {
+      if (data.libraryBlueprintLabel) {
+        return truncate(data.libraryBlueprintLabel, 44);
+      }
+      if (data.libraryBlueprintId) {
+        return truncate(data.libraryBlueprintId, 44);
+      }
+      return "未选择蓝图";
+    }
+    case "lifecycle": {
+      const phase = data.lifecyclePhase ?? "mounted";
+      return PAGE_LIFECYCLE_LABELS[phase as keyof typeof PAGE_LIFECYCLE_LABELS] ?? phase;
+    }
+    case "view": {
+      const ids = resolveViewElementIds(data);
+      if (ids.length === 0) return "未关联视图节点";
+      if (ids.length === 1) {
+        return truncate(`视图节点 ${ids[0]}`, 44);
+      }
+      return `已关联 ${ids.length} 个视图节点`;
+    }
+    case "and":
+      return "两路输入均为真时输出";
+    default:
+      return undefined;
+  }
+}

package/src/graph/node-types.ts

@@ -0,0 +1,9 @@
+/** 与 @arronqzy/blueprint-dsl 中 NodeDefinition.type 对齐，供执行层解析 */
+export {
+  BLUEPRINT_NODE_TYPE,
+  DEFAULT_LOGIC_NODE_TYPE,
+  LIFECYCLE_NODE_TYPE,
+  JSON_NODE_TYPE,
+  CLOCK_NODE_TYPE,
+  AND_NODE_TYPE,
+} from "@arronqzy/blueprint-dsl";

package/src/graph/sync-edges.ts

@@ -0,0 +1,69 @@
+import type { Edge } from "@vue-flow/core";
+
+import type { BlueprintGraphEdge } from "./document";
+import { syncEdgesFromFlow, toVueFlowEdges } from "./vue-flow-adapter";
+import type { BlueprintGraph } from "./blueprint-graph";
+
+/** 边线描边（写入 edge.style；使用 hex 避免 SVG style 解析 hsl 异常） */
+export const BP_EDGE_STYLE = {
+  stroke: "#2563eb",
+  strokeWidth: 2.5,
+} as const;
+
+export const BP_FLOW_EDGE_TYPE = "blueprintSmooth" as const;
+
+export function flowEdgesToGraphEdges(flowEdges: Edge[]): BlueprintGraphEdge[] {
+  return syncEdgesFromFlow(
+    flowEdges.map((e) => ({
+      id: e.id,
+      source: e.source,
+      target: e.target,
+      sourceHandle: e.sourceHandle ?? "out",
+      targetHandle: e.targetHandle ?? "in",
+    }))
+  );
+}
+
+export function graphToFlowEdges(graph: BlueprintGraph): Edge[] {
+  return normalizeFlowEdges(toVueFlowEdges(graph.document) as Edge[]);
+}
+
+export function edgeListSignature(edges: { id: string }[]): string {
+  return edges
+    .map((e) => e.id)
+    .sort()
+    .join(",");
+}
+
+function edgeConnectionKey(edge: {
+  source: string;
+  target: string;
+  sourceHandle?: string | null;
+  targetHandle?: string | null;
+}): string {
+  return `${edge.source}|${edge.sourceHandle ?? "out"}|${edge.target}|${edge.targetHandle ?? "in"}`;
+}
+
+/** 避免 onConnect 与 onEdgesChange 各加一条时重复 */
+export function dedupeFlowEdges(edges: Edge[]): Edge[] {
+  const seen = new Set<string>();
+  const out: Edge[] = [];
+  for (const e of edges) {
+    const key = edgeConnectionKey(e);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(e);
+  }
+  return out;
+}
+
+export function normalizeFlowEdges(edges: Edge[]): Edge[] {
+  return dedupeFlowEdges(edges).map((e) => ({
+    ...e,
+    type: BP_FLOW_EDGE_TYPE,
+    zIndex: 1000,
+    selectable: true,
+    deletable: true,
+    style: { ...BP_EDGE_STYLE },
+  })) as Edge[];
+}

package/src/graph/sync-nodes.ts

@@ -0,0 +1,110 @@
+import type { Connection, Edge, Node } from "@vue-flow/core";
+
+import type { BlueprintGraph } from "./blueprint-graph";
+import {
+  collectPositionUpdates,
+  toVueFlowNodes,
+  type BlueprintFlowNodeData,
+} from "./vue-flow-adapter";
+
+/** 从 graph 同步节点时保留 VF 已测量的宽高，否则边无法绘制 */
+type FlowNodeWithMeasured = Node & {
+  measured?: { width?: number; height?: number };
+};
+
+export function mergeMeasuredFlowNodes<T extends FlowNodeWithMeasured>(
+  incoming: T[],
+  previous: T[]
+): T[] {
+  const prevById = new Map(previous.map((n) => [n.id, n]));
+  return incoming.map((n) => {
+    const prev = prevById.get(n.id);
+    if (!prev) return n;
+    return {
+      ...n,
+      measured: prev.measured ?? n.measured,
+      width: prev.width ?? n.width,
+      height: prev.height ?? n.height,
+    };
+  });
+}
+
+export function nodeListSignature(nodes: { id: string }[]): string {
+  return nodes
+    .map((n) => n.id)
+    .sort()
+    .join(",");
+}
+
+/** 含 role / 配置 / 名称等影响 React Flow 节点展示与端口的字段 */
+export function nodeStructureSignature(
+  nodes: Array<{
+    id: string;
+    role: string;
+    label: string;
+    configSource?: string;
+    lifecyclePhase?: string;
+    libraryBlueprintId?: string;
+    nodeType?: string;
+    viewElementId?: string;
+    viewElementIds?: string[];
+    fetchConfig?: { url?: string; method?: string; apiBaseUrl?: string; swaggerDocsUrl?: string };
+    jsonConfig?: { jsonString?: string };
+    logicConfig?: { sourceCode?: string };
+    clockConfig?: { intervalSeconds?: number; timeFormat?: string; outputCount?: number; emitImmediately?: boolean };
+  }>
+): string {
+  return nodes
+    .map(
+      (n) =>
+        `${n.id}:${n.role}:${n.label}:${n.configSource ?? ""}:${n.lifecyclePhase ?? ""}:${n.libraryBlueprintId ?? ""}:${n.nodeType ?? ""}:${(n.viewElementIds ?? (n.viewElementId ? [n.viewElementId] : [])).join(",")}:${n.fetchConfig?.url ?? ""}:${n.fetchConfig?.method ?? ""}:${n.fetchConfig?.apiBaseUrl ?? ""}:${n.fetchConfig?.swaggerDocsUrl ?? ""}:${n.jsonConfig?.jsonString ?? ""}:${n.logicConfig?.sourceCode ?? ""}:${n.clockConfig?.intervalSeconds ?? ""}:${n.clockConfig?.timeFormat ?? ""}:${n.clockConfig?.outputCount ?? ""}:${n.clockConfig?.emitImmediately ?? ""}`
+    )
+    .sort()
+    .join("|");
+}
+
+export function graphToFlowNodes(
+  graph: BlueprintGraph,
+  selectedNodeId: string | null,
+  libraryNameById?: ReadonlyMap<string, string>
+): Node<BlueprintFlowNodeData>[] {
+  const base = toVueFlowNodes(graph.document) as Node<BlueprintFlowNodeData>[];
+  return base.map((n) => ({
+    ...n,
+    selected: false,
+    data: {
+      ...n.data,
+      libraryBlueprintLabel: n.data!.libraryBlueprintId
+        ? libraryNameById?.get(n.data!.libraryBlueprintId)
+        : undefined,
+      isSelected: selectedNodeId === n.id,
+    },
+  })) as Node<BlueprintFlowNodeData>[];
+}
+
+export function resolveConnection(
+  connection: Connection,
+  rfNodes: Node<BlueprintFlowNodeData>[]
+): Connection | null {
+  const nodeIds = new Set(rfNodes.map((n) => n.id));
+  const source = connection.source ?? "";
+  const target = connection.target ?? "";
+
+  if (!source || !target || source === target) return null;
+  if (!nodeIds.has(source) || !nodeIds.has(target)) return null;
+
+  return {
+    source,
+    target,
+    sourceHandle: connection.sourceHandle ?? "out",
+    targetHandle: connection.targetHandle ?? "in",
+  };
+}
+
+export function filterEdgesWithValidNodes(edges: Edge[], nodeIds: Set<string>): Edge[] {
+  return edges.filter((e) => nodeIds.has(e.source) && nodeIds.has(e.target));
+}
+
+export function applyFlowNodePositions(graph: BlueprintGraph, rfNodes: Node[]) {
+  return graph.applyNodePositions(collectPositionUpdates(rfNodes));
+}

package/src/graph/vue-flow-adapter.ts

@@ -0,0 +1,127 @@
+import type {
+  BlueprintDocument,
+  BlueprintGraphEdge,
+  BlueprintGraphNode,
+} from "./document";
+import { createNodeId } from "./document";
+
+export type BlueprintFlowNodeData = {
+  label: string;
+  role: BlueprintGraphNode["role"];
+  nodeType: string;
+  configSource?: BlueprintGraphNode["configSource"];
+  viewElementId?: string;
+  viewElementIds?: string[];
+  parentId?: string;
+  nestedBlueprintId?: string;
+  libraryBlueprintId?: string;
+  libraryBlueprintLabel?: string;
+  lifecyclePhase?: BlueprintGraphNode["lifecyclePhase"];
+  fetchConfig?: BlueprintGraphNode["fetchConfig"];
+  jsonConfig?: BlueprintGraphNode["jsonConfig"];
+  clockConfig?: BlueprintGraphNode["clockConfig"];
+  logicConfig?: BlueprintGraphNode["logicConfig"];
+  /** 调试执行时时钟节点已发送次数 */
+  clockEmitProgress?: { current: number; total: number } | null;
+  /** 由画布注入，勿写入图数据 */
+  isSelected?: boolean;
+  /** 调试执行时高亮当前执行到的节点 */
+  isExecutionActive?: boolean;
+  /** 调试执行时当前节点主输出信号类型 */
+  executionSignalKind?: "true" | "false" | null;
+};
+
+/** 与 BlueprintNodeCard 固定宽度一致，供 RF 在 measured 前计算连线路径 */
+export const BP_FLOW_NODE_WIDTH = 168;
+export const BP_FLOW_NODE_HEIGHT = 92;
+
+export type VueFlowNodeView = {
+  id: string;
+  type: string;
+  position: { x: number; y: number };
+  width?: number;
+  height?: number;
+  dragHandle?: string;
+  data: BlueprintFlowNodeData;
+};
+
+export type VueFlowEdgeView = {
+  id: string;
+  type?: string;
+  source: string;
+  target: string;
+  sourceHandle?: string | null;
+  targetHandle?: string | null;
+};
+
+export function toVueFlowNodes(document: BlueprintDocument): VueFlowNodeView[] {
+  return document.nodes.map((n) => ({
+    id: n.id,
+    type:
+      n.role === "blueprint"
+        ? "blueprint"
+        : n.role === "lifecycle"
+          ? "lifecycle"
+          : n.role === "clock"
+            ? "clock"
+          : n.role === "and"
+            ? "and"
+        : n.role === "fetch"
+          ? "fetch"
+          : n.role === "json"
+            ? "json"
+            : "logic",
+    position: { ...n.position },
+    width: BP_FLOW_NODE_WIDTH,
+    height: BP_FLOW_NODE_HEIGHT,
+    zIndex: 0,
+    connectable: true,
+    dragHandle: ".bp-flow-drag-handle",
+    data: {
+      label: n.label,
+      role: n.role,
+      nodeType: n.nodeType,
+      configSource: n.configSource,
+      viewElementId: n.viewElementId,
+      viewElementIds: n.viewElementIds,
+      parentId: n.parentId,
+      nestedBlueprintId: n.nestedBlueprintId,
+      libraryBlueprintId: n.libraryBlueprintId,
+      lifecyclePhase: n.lifecyclePhase,
+      fetchConfig: n.fetchConfig,
+      jsonConfig: n.jsonConfig,
+      clockConfig: n.clockConfig,
+      logicConfig: n.logicConfig,
+    },
+  }));
+}
+
+export function toVueFlowEdges(document: BlueprintDocument): VueFlowEdgeView[] {
+  return document.edges.map((e) => ({
+    id: e.id,
+    type: "smoothstep",
+    source: e.source,
+    target: e.target,
+    sourceHandle: e.sourceHandle ?? "out",
+    targetHandle: e.targetHandle ?? "in",
+  }));
+}
+
+export function syncEdgesFromFlow(flowEdges: VueFlowEdgeView[]): BlueprintGraphEdge[] {
+  return flowEdges.map((e) => ({
+    id: e.id || createNodeId("edge"),
+    source: e.source,
+    target: e.target,
+    sourceHandle: e.sourceHandle ?? undefined,
+    targetHandle: e.targetHandle ?? undefined,
+  }));
+}
+
+export function collectPositionUpdates(
+  nodes: Array<{ id: string; position: { x: number; y: number } }>
+): Array<{ id: string; position: { x: number; y: number } }> {
+  return nodes.map((n) => ({
+    id: n.id,
+    position: { x: n.position.x, y: n.position.y },
+  }));
+}

package/src/index.ts

@@ -0,0 +1,37 @@
+export { BlueprintGraph } from "./graph/blueprint-graph";
+export * from "./graph";
+export { documentToRunnableGraph } from "./runtime/document-to-runnable-graph";
+export type { BlueprintExecutionOverlay } from "./runtime/execution-overlay";
+export type { BlueprintFlowNodeData } from "./types";
+export { default as BluePrintVueRoot } from "./components/BluePrintVueRoot.vue";
+export { default as BlueprintCanvas } from "./components/BlueprintCanvas.vue";
+export { default as BlueprintNodeConfigSidebar } from "./BlueprintNodeConfigSidebar.vue";
+export type {
+  BlueprintNodeConfigSidebarProps,
+  BlueprintViewElementOption,
+  BlueprintLibraryOption,
+} from "./BlueprintNodeConfigSidebar.vue";
+export { default as BlueprintExecutionLogPanel } from "./components/BlueprintExecutionLogPanel.vue";
+export type { BlueprintExecutionLogPanelProps } from "./components/BlueprintExecutionLogPanel.vue";
+export { default as BlueprintMetaDialog } from "./components/BlueprintMetaDialog.vue";
+export type { BlueprintMetaDialogProps } from "./components/BlueprintMetaDialog.vue";
+export { default as BlueprintNodeSwitchTaskDialog } from "./components/BlueprintNodeSwitchTaskDialog.vue";
+export type { BlueprintNodeSwitchTaskDialogProps } from "./components/BlueprintNodeSwitchTaskDialog.vue";
+export type { ExecutionLogSettings } from "./library/execution-log-settings";
+export type { ExecutionTraceEntry, ExecutionRunRecord } from "@arronqzy/blueprint-dsl";
+export { resolveBlueprintConfigSource, resolveBlueprintNodeTypeLabel } from "./graph/document";
+export type { BlueprintConfigSource } from "./graph/document";
+export * from "./library/blueprint-io";
+export * from "./library/blueprint-library-db";
+export type * from "./library/types";
+export { abortClockNode, stopAllClockSchedules } from "@arronqzy/blueprint-dsl";
+export { useBlueprintPageLifecycle } from "./composables/useBlueprintPageLifecycle";
+export type { UseBlueprintPageLifecycleOptions } from "./composables/useBlueprintPageLifecycle";
+export { useBlueprintDebugSession } from "./composables/useBlueprintDebugSession";
+export type {
+  LifecycleNodeOption,
+  UseBlueprintDebugSessionOptions,
+  UseBlueprintDebugSessionReturn,
+} from "./composables/useBlueprintDebugSession";
+export { useBlueprintNodeSelectionGuard } from "./composables/useBlueprintNodeSelectionGuard";
+export type { PendingBlueprintNodeSwitch } from "./composables/useBlueprintNodeSelectionGuard";

package/src/library/blueprint-io.ts

@@ -0,0 +1,108 @@
+import type { BlueprintDocument } from "../graph/document";
+import { createNodeId } from "../graph/document";
+import {
+  BLUEPRINT_EXPORT_KIND,
+  BLUEPRINT_EXPORT_VERSION,
+  type BlueprintExportPayload,
+  type BlueprintLibraryRecord,
+  type BlueprintLibrarySource,
+  type BlueprintMetaDraft,
+} from "./types";
+
+export function createLibraryBlueprintId() {
+  return createNodeId("lib_bp");
+}
+
+export function blueprintDocumentsEqual(
+  a: BlueprintDocument,
+  b: BlueprintDocument
+): boolean {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+export function buildBlueprintExportPayload(
+  document: BlueprintDocument,
+  meta: BlueprintMetaDraft
+): BlueprintExportPayload {
+  return {
+    kind: BLUEPRINT_EXPORT_KIND,
+    version: BLUEPRINT_EXPORT_VERSION,
+    name: meta.name.trim() || "未命名蓝图",
+    remark: meta.remark.trim() || undefined,
+    exportedAt: Date.now(),
+    document: {
+      ...document,
+      name: meta.name.trim() || document.name,
+    },
+  };
+}
+
+export function parseBlueprintImportFile(raw: unknown): BlueprintExportPayload {
+  if (!raw || typeof raw !== "object") {
+    throw new Error("invalid-format");
+  }
+  const data = raw as Partial<BlueprintExportPayload>;
+  if (data.kind !== BLUEPRINT_EXPORT_KIND || data.version !== BLUEPRINT_EXPORT_VERSION) {
+    throw new Error("unsupported-version");
+  }
+  if (!data.document || !Array.isArray(data.document.nodes) || !Array.isArray(data.document.edges)) {
+    throw new Error("invalid-document");
+  }
+  return {
+    kind: BLUEPRINT_EXPORT_KIND,
+    version: BLUEPRINT_EXPORT_VERSION,
+    name: typeof data.name === "string" ? data.name : "导入的蓝图",
+    remark: typeof data.remark === "string" ? data.remark : undefined,
+    exportedAt: typeof data.exportedAt === "number" ? data.exportedAt : Date.now(),
+    document: data.document,
+  };
+}
+
+export function downloadBlueprintExport(payload: BlueprintExportPayload) {
+  const blob = new Blob([JSON.stringify(payload, null, 2)], {
+    type: "application/json",
+  });
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement("a");
+  anchor.href = url;
+  const safeName = payload.name
+    .replace(/[\\/:*?"<>|]/g, "-")
+    .replace(/\s+/g, "-");
+  anchor.download = `${safeName || "blueprint"}-${Date.now()}.json`;
+  anchor.click();
+  URL.revokeObjectURL(url);
+}
+
+export function buildLibraryRecord(args: {
+  document: BlueprintDocument;
+  meta: BlueprintMetaDraft;
+  source: BlueprintLibrarySource;
+  id?: string;
+  createdAt?: number;
+}): BlueprintLibraryRecord {
+  const now = Date.now();
+  const name = args.meta.name.trim() || "未命名蓝图";
+  return {
+    id: args.id ?? createLibraryBlueprintId(),
+    name,
+    remark: args.meta.remark.trim() || undefined,
+    source: args.source,
+    createdAt: args.createdAt ?? now,
+    updatedAt: now,
+    document: {
+      ...args.document,
+      name,
+    },
+  };
+}
+
+export function libraryRecordFromImport(payload: BlueprintExportPayload): BlueprintLibraryRecord {
+  return buildLibraryRecord({
+    document: payload.document,
+    meta: {
+      name: payload.name,
+      remark: payload.remark ?? "",
+    },
+    source: "imported",
+  });
+}

package/src/library/blueprint-library-db.ts

@@ -0,0 +1,112 @@
+import type {
+  BlueprintLibraryListItem,
+  BlueprintLibraryRecord,
+} from "./types";
+
+const DB_NAME = "arronqzy-blueprint-library";
+const DB_VERSION = 1;
+const STORE_NAME = "blueprints";
+
+function openDb(): Promise<IDBDatabase> {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+    request.onerror = () => reject(request.error ?? new Error("indexeddb-open-failed"));
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        const store = db.createObjectStore(STORE_NAME, { keyPath: "id" });
+        store.createIndex("source", "source", { unique: false });
+        store.createIndex("updatedAt", "updatedAt", { unique: false });
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+  });
+}
+
+function runTransaction<T>(
+  mode: IDBTransactionMode,
+  runner: (store: IDBObjectStore) => IDBRequest<T>
+): Promise<T> {
+  return openDb().then(
+    (db) =>
+      new Promise<T>((resolve, reject) => {
+        const tx = db.transaction(STORE_NAME, mode);
+        const store = tx.objectStore(STORE_NAME);
+        const request = runner(store);
+        let result!: T;
+
+        request.onerror = () =>
+          reject(request.error ?? new Error("indexeddb-request-failed"));
+        request.onsuccess = () => {
+          result = request.result as T;
+        };
+
+        tx.oncomplete = () => {
+          db.close();
+          resolve(result);
+        };
+        tx.onerror = () => {
+          db.close();
+          reject(tx.error ?? new Error("indexeddb-transaction-failed"));
+        };
+      })
+  );
+}
+
+export async function listBlueprintLibrary(): Promise<BlueprintLibraryListItem[]> {
+  const records = await runTransaction<BlueprintLibraryRecord[]>("readonly", (store) =>
+    store.getAll()
+  );
+  return records
+    .map((record) => ({
+      id: record.id,
+      name: record.name,
+      remark: record.remark,
+      source: record.source,
+      updatedAt: record.updatedAt,
+    }))
+    .sort((a, b) => b.updatedAt - a.updatedAt);
+}
+
+export async function getBlueprintLibraryRecord(
+  id: string
+): Promise<BlueprintLibraryRecord | null> {
+  const record = await runTransaction<BlueprintLibraryRecord | undefined>("readonly", (store) =>
+    store.get(id)
+  );
+  return record ?? null;
+}
+
+export async function putBlueprintLibraryRecord(
+  record: BlueprintLibraryRecord
+): Promise<BlueprintLibraryRecord> {
+  await runTransaction<IDBValidKey>("readwrite", (store) => store.put(record));
+  return record;
+}
+
+export async function updateBlueprintLibraryMeta(
+  id: string,
+  patch: { name?: string; remark?: string }
+): Promise<BlueprintLibraryRecord | null> {
+  const existing = await getBlueprintLibraryRecord(id);
+  if (!existing) return null;
+
+  const name = patch.name?.trim() || existing.name;
+  const record: BlueprintLibraryRecord = {
+    ...existing,
+    name,
+    remark: patch.remark !== undefined ? patch.remark.trim() || undefined : existing.remark,
+    updatedAt: Date.now(),
+    document: {
+      ...existing.document,
+      name,
+    },
+  };
+
+  await putBlueprintLibraryRecord(record);
+  return record;
+}
+
+export async function deleteBlueprintLibraryRecord(id: string): Promise<void> {
+  await runTransaction<undefined>("readwrite", (store) => store.delete(id));
+}