@world-engines/authoring-ui 0.1.0-alpha.0

package/dist/ladybug/graph-groups.js

@@ -0,0 +1,245 @@
+import { PHYSICS_GRID_SIZE } from "./graph-physics.js";
+export const GRAPH_GROUP_MIN_SIZE = 96;
+export const GRAPH_GROUP_LABEL_MAX_LENGTH = 40;
+/** 不持久化第二份颜色 authority；相同 group id 在 npm/editor 中得到相同实色。 */
+export const graphGroupColor = (id) => {
+    let hash = 2166136261;
+    for (let index = 0; index < id.length; index += 1) {
+        hash ^= id.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return `hsl(${(hash >>> 0) % 360} 64% 54%)`;
+};
+export const normalizeGraphGroupLabel = (value) => {
+    const normalized = value.trim().slice(0, GRAPH_GROUP_LABEL_MAX_LENGTH);
+    return normalized.length === 0 ? null : normalized;
+};
+const isFiniteNumber = (value) => Number.isFinite(value);
+export const isGraphGroupBoundsFinite = (bounds) => isFiniteNumber(bounds.x)
+    && isFiniteNumber(bounds.y)
+    && isFiniteNumber(bounds.width)
+    && isFiniteNumber(bounds.height)
+    && bounds.width >= 0
+    && bounds.height >= 0;
+const assertBounds = (bounds, label) => {
+    if (!isGraphGroupBoundsFinite(bounds)) {
+        throw new TypeError(`${label} 必须使用有限坐标和非负尺寸`);
+    }
+};
+const assertPoint = (point, label) => {
+    if (!isFiniteNumber(point.x) || !isFiniteNumber(point.y)) {
+        throw new TypeError(`${label} 必须使用有限坐标`);
+    }
+};
+const assertGroups = (groups) => {
+    for (const group of groups)
+        assertBounds(group, `分组 ${group.id}`);
+};
+export const snapGraphGroupCoordinate = (value) => {
+    if (!isFiniteNumber(value))
+        throw new TypeError("网格坐标必须是有限数");
+    const snapped = Math.round(value / PHYSICS_GRID_SIZE) * PHYSICS_GRID_SIZE;
+    return Object.is(snapped, -0) ? 0 : snapped;
+};
+export const snapGraphGroupPoint = (point) => {
+    assertPoint(point, "网格点");
+    return {
+        x: snapGraphGroupCoordinate(point.x),
+        y: snapGraphGroupCoordinate(point.y)
+    };
+};
+/** 同时吸附两角，避免 position 与 size 使用不同网格 authority。 */
+export const snapGraphGroupBounds = (bounds) => {
+    assertBounds(bounds, "分组矩形");
+    const start = snapGraphGroupPoint(bounds);
+    const end = snapGraphGroupPoint({
+        x: bounds.x + bounds.width,
+        y: bounds.y + bounds.height
+    });
+    return {
+        x: start.x,
+        y: start.y,
+        width: Math.max(0, end.x - start.x),
+        height: Math.max(0, end.y - start.y)
+    };
+};
+/** 画框可向任意方向进行；返回归一化且已吸附的非负矩形。 */
+export const graphGroupBoundsFromPoints = (start, end) => {
+    const snappedStart = snapGraphGroupPoint(start);
+    const snappedEnd = snapGraphGroupPoint(end);
+    return {
+        x: Math.min(snappedStart.x, snappedEnd.x),
+        y: Math.min(snappedStart.y, snappedEnd.y),
+        width: Math.abs(snappedEnd.x - snappedStart.x),
+        height: Math.abs(snappedEnd.y - snappedStart.y)
+    };
+};
+export const graphGroupsOverlap = (left, right) => {
+    assertBounds(left, "左侧分组");
+    assertBounds(right, "右侧分组");
+    return left.x < right.x + right.width
+        && left.x + left.width > right.x
+        && left.y < right.y + right.height
+        && left.y + left.height > right.y;
+};
+export const isGraphGroupBoundsValid = (candidate, groups, excludeId) => {
+    if (!isGraphGroupBoundsFinite(candidate)
+        || candidate.width < GRAPH_GROUP_MIN_SIZE
+        || candidate.height < GRAPH_GROUP_MIN_SIZE)
+        return false;
+    if (groups.some((group) => !isGraphGroupBoundsFinite(group)))
+        return false;
+    return groups.every((group) => group.id === excludeId || !graphGroupsOverlap(candidate, group));
+};
+/** 所有矩形必须有效，且任何两个矩形只能分离或边界相贴。 */
+export const validateGraphGroups = (groups) => {
+    const ids = new Set();
+    for (let left = 0; left < groups.length; left += 1) {
+        const group = groups[left];
+        if (group.id.length === 0 || ids.has(group.id)
+            || !isGraphGroupBoundsValid(group, groups, group.id))
+            return false;
+        ids.add(group.id);
+        for (let right = left + 1; right < groups.length; right += 1) {
+            if (graphGroupsOverlap(group, groups[right]))
+                return false;
+        }
+    }
+    return true;
+};
+export const nodesInsideGraphGroup = (group, centers) => {
+    assertBounds(group, "成员分组");
+    for (const [id, center] of Object.entries(centers))
+        assertPoint(center, `节点 ${id}`);
+    return Object.entries(centers)
+        .filter(([, center]) => center.x >= group.x
+        && center.x < group.x + group.width
+        && center.y >= group.y
+        && center.y < group.y + group.height)
+        .map(([id]) => id);
+};
+const sweepAxis = (movingMin, movingMax, obstacleMin, obstacleMax, delta) => {
+    if (delta > 0)
+        return {
+            entry: (obstacleMin - movingMax) / delta,
+            exit: (obstacleMax - movingMin) / delta
+        };
+    if (delta < 0)
+        return {
+            entry: (obstacleMax - movingMin) / delta,
+            exit: (obstacleMin - movingMax) / delta
+        };
+    return movingMin < obstacleMax && movingMax > obstacleMin
+        ? { entry: Number.NEGATIVE_INFINITY, exit: Number.POSITIVE_INFINITY }
+        : null;
+};
+/** 返回从 source 到 obstacle 首次产生正面积相交的比例；终点穿过障碍也会截停。 */
+const sweptCollisionTime = (source, delta, obstacle) => {
+    const x = sweepAxis(source.x, source.x + source.width, obstacle.x, obstacle.x + obstacle.width, delta.x);
+    const y = sweepAxis(source.y, source.y + source.height, obstacle.y, obstacle.y + obstacle.height, delta.y);
+    if (x === null || y === null)
+        return null;
+    const entry = Math.max(x.entry, y.entry, 0);
+    const exit = Math.min(x.exit, y.exit, 1);
+    return entry < exit && entry <= 1 && exit >= 0 ? entry : null;
+};
+const snapTowardSource = (value, delta) => {
+    const scaled = value / PHYSICS_GRID_SIZE;
+    if (delta > 0)
+        return Math.floor(scaled + 1e-9) * PHYSICS_GRID_SIZE;
+    if (delta < 0)
+        return Math.ceil(scaled - 1e-9) * PHYSICS_GRID_SIZE;
+    return value;
+};
+export const clampGraphGroupTranslation = (source, requestedDelta, groups, excludeId) => {
+    assertBounds(source, "待移动分组");
+    assertPoint(requestedDelta, "移动距离");
+    assertGroups(groups);
+    const snappedTarget = snapGraphGroupPoint({
+        x: source.x + requestedDelta.x,
+        y: source.y + requestedDelta.y
+    });
+    const delta = { x: snappedTarget.x - source.x, y: snappedTarget.y - source.y };
+    let movementRatio = 1;
+    for (const group of groups) {
+        if (group.id === excludeId)
+            continue;
+        const collisionTime = sweptCollisionTime(source, delta, group);
+        if (collisionTime !== null)
+            movementRatio = Math.min(movementRatio, collisionTime);
+    }
+    // 碰撞发生在两次网格采样之间时，沿移动方向向 source 一侧吸附，避免
+    // 最近舍入把矩形送进障碍；成员套用同一 delta 后也继续位于节点网格。
+    const actualDelta = movementRatio < 1
+        ? {
+            x: snapTowardSource(source.x + delta.x * movementRatio, delta.x) - source.x,
+            y: snapTowardSource(source.y + delta.y * movementRatio, delta.y) - source.y
+        }
+        : delta;
+    return {
+        bounds: {
+            x: source.x + actualDelta.x,
+            y: source.y + actualDelta.y,
+            width: source.width,
+            height: source.height
+        },
+        delta: actualDelta
+    };
+};
+const overlapsOnAxis = (leftStart, leftEnd, rightStart, rightEnd) => leftStart < rightEnd && leftEnd > rightStart;
+export const resizeGraphGroupSide = (source, side, requestedCoordinate, groups, excludeId) => {
+    assertBounds(source, "待缩放分组");
+    assertGroups(groups);
+    const coordinate = snapGraphGroupCoordinate(requestedCoordinate);
+    const right = source.x + source.width;
+    const bottom = source.y + source.height;
+    let edge = side === "left"
+        ? Math.min(coordinate, right - GRAPH_GROUP_MIN_SIZE)
+        : side === "right"
+            ? Math.max(coordinate, source.x + GRAPH_GROUP_MIN_SIZE)
+            : side === "top"
+                ? Math.min(coordinate, bottom - GRAPH_GROUP_MIN_SIZE)
+                : Math.max(coordinate, source.y + GRAPH_GROUP_MIN_SIZE);
+    for (const group of groups) {
+        if (group.id === excludeId)
+            continue;
+        const groupRight = group.x + group.width;
+        const groupBottom = group.y + group.height;
+        if ((side === "left" || side === "right")
+            && !overlapsOnAxis(source.y, bottom, group.y, groupBottom))
+            continue;
+        if ((side === "top" || side === "bottom")
+            && !overlapsOnAxis(source.x, right, group.x, groupRight))
+            continue;
+        if (side === "left" && edge < source.x && groupRight <= source.x && groupRight > edge) {
+            edge = groupRight;
+        }
+        else if (side === "right" && edge > right && group.x >= right && group.x < edge) {
+            edge = group.x;
+        }
+        else if (side === "top" && edge < source.y && groupBottom <= source.y && groupBottom > edge) {
+            edge = groupBottom;
+        }
+        else if (side === "bottom" && edge > bottom && group.y >= bottom && group.y < edge) {
+            edge = group.y;
+        }
+    }
+    if (side === "left")
+        return { x: edge, y: source.y, width: right - edge, height: source.height };
+    if (side === "right")
+        return { x: source.x, y: source.y, width: edge - source.x, height: source.height };
+    if (side === "top")
+        return { x: source.x, y: edge, width: source.width, height: bottom - edge };
+    return { x: source.x, y: source.y, width: source.width, height: edge - source.y };
+};
+/** 使用 clamp 返回的同一 delta 更新成员，成员之间的相对偏移不会改变。 */
+export const translateGraphGroupMembers = (centers, memberIds, delta) => {
+    assertPoint(delta, "成员移动距离");
+    const memberSet = new Set(memberIds);
+    return Object.fromEntries(Object.entries(centers).map(([id, center]) => {
+        assertPoint(center, `节点 ${id}`);
+        return [id, memberSet.has(id)
+                ? { x: center.x + delta.x, y: center.y + delta.y }
+                : center];
+    }));
+};

package/dist/ladybug/graph-layout-contract.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 物理模块统一使用节点圆心坐标；GraphCanvas 的 canonical 48px 左上角换算只留在调用 seam。
+ */
+export interface GraphLayoutPosition {
+    readonly x: number;
+    readonly y: number;
+}
+export interface GraphLayoutNode extends GraphLayoutPosition {
+    readonly id: string;
+    readonly radius: number;
+}
+export interface GraphLayoutEdge {
+    readonly from: string;
+    readonly to: string;
+}
+export interface GraphLayoutRequest {
+    readonly nodes: readonly GraphLayoutNode[];
+    readonly edges: readonly GraphLayoutEdge[];
+    /** 被拖节点保持 request 中的圆心坐标，其他节点绕它退让。 */
+    readonly fixedNodeId?: string;
+}
+export type GraphLayoutSolver = (request: GraphLayoutRequest, signal?: AbortSignal) => Promise<Readonly<Record<string, GraphLayoutPosition>>>;
+/** 每个 Canvas 宿主持有一个 handle，并在 unmount/场景切换时释放 Worker。 */
+export type GraphLayoutSolverHandle = GraphLayoutSolver & {
+    dispose(): void;
+};
+export interface PackedGraphLayoutRequest {
+    readonly nodeIds: readonly string[];
+    readonly nodes: Float64Array;
+    readonly edges: Uint32Array;
+    readonly fixedIndex: number;
+}
+export declare const packGraphLayoutRequest: (request: GraphLayoutRequest) => PackedGraphLayoutRequest;
+export declare const unpackGraphLayoutPositions: (nodeIds: readonly string[], packed: Float64Array) => Readonly<Record<string, GraphLayoutPosition>>;

package/dist/ladybug/graph-layout-contract.js

@@ -0,0 +1,55 @@
+export const packGraphLayoutRequest = (request) => {
+    const nodeIds = [];
+    const indexById = new Map();
+    const nodes = new Float64Array(request.nodes.length * 3);
+    request.nodes.forEach((node, index) => {
+        if (node.id.length === 0 || indexById.has(node.id)) {
+            throw new TypeError(`图布局节点 id 必须非空且唯一: ${node.id}`);
+        }
+        if (!Number.isFinite(node.x) || !Number.isFinite(node.y)) {
+            throw new TypeError(`图布局节点坐标必须是有限数: ${node.id}`);
+        }
+        if (!Number.isFinite(node.radius) || node.radius <= 0) {
+            throw new TypeError(`图布局节点半径必须是正有限数: ${node.id}`);
+        }
+        nodeIds.push(node.id);
+        indexById.set(node.id, index);
+        const offset = index * 3;
+        nodes[offset] = node.x;
+        nodes[offset + 1] = node.y;
+        nodes[offset + 2] = node.radius;
+    });
+    const edges = new Uint32Array(request.edges.length * 2);
+    request.edges.forEach((edge, index) => {
+        const from = indexById.get(edge.from);
+        const to = indexById.get(edge.to);
+        if (from === undefined || to === undefined) {
+            throw new TypeError(`图布局关系引用了未知节点: ${edge.from} -> ${edge.to}`);
+        }
+        edges[index * 2] = from;
+        edges[index * 2 + 1] = to;
+    });
+    let fixedIndex = -1;
+    if (request.fixedNodeId !== undefined) {
+        fixedIndex = indexById.get(request.fixedNodeId) ?? -1;
+        if (fixedIndex < 0) {
+            throw new TypeError(`图布局 fixedNodeId 引用了未知节点: ${request.fixedNodeId}`);
+        }
+    }
+    return { nodeIds, nodes, edges, fixedIndex };
+};
+export const unpackGraphLayoutPositions = (nodeIds, packed) => {
+    if (packed.length !== nodeIds.length * 2) {
+        throw new Error("WASM 图布局返回的 position 长度不匹配");
+    }
+    const positions = {};
+    nodeIds.forEach((id, index) => {
+        const x = packed[index * 2];
+        const y = packed[index * 2 + 1];
+        if (x === undefined || y === undefined || !Number.isFinite(x) || !Number.isFinite(y)) {
+            throw new Error(`WASM 图布局返回了非法坐标: ${id}`);
+        }
+        positions[id] = { x, y };
+    });
+    return positions;
+};

package/dist/ladybug/graph-layout-solver.d.ts

@@ -0,0 +1,16 @@
+import { type GraphLayoutSolverHandle } from "./graph-layout-contract.js";
+import type { GraphLayoutWorkerResponse, GraphLayoutWorkerSolveMessage } from "./graph-layout-worker-protocol.js";
+interface WorkerLike {
+    onmessage: ((event: MessageEvent<GraphLayoutWorkerResponse>) => void) | null;
+    onerror: ((event: ErrorEvent) => void) | null;
+    postMessage(message: GraphLayoutWorkerSolveMessage, transfer: Transferable[]): void;
+    terminate(): void;
+}
+type GraphLayoutWorkerFactory = () => WorkerLike;
+/**
+ * 两个宿主共用的唯一 factory。每次新调用都会 supersede 尚未完成的旧帧；
+ * worker 和主线程各自检查 generation，旧结果永远不会写回 UI。
+ */
+export declare const createGraphLayoutSolverWithWorker: (workerFactory: GraphLayoutWorkerFactory) => GraphLayoutSolverHandle;
+export declare const createGraphLayoutSolver: () => GraphLayoutSolverHandle;
+export {};

package/dist/ladybug/graph-layout-solver.js

@@ -0,0 +1,96 @@
+import { packGraphLayoutRequest, unpackGraphLayoutPositions } from "./graph-layout-contract.js";
+const abortError = (message) => Object.assign(new Error(message), { name: "AbortError" });
+const defaultWorkerFactory = () => new Worker(new URL("./graph-layout-worker.js", import.meta.url), { name: "worldengine-graph-layout", type: "module" });
+/**
+ * 两个宿主共用的唯一 factory。每次新调用都会 supersede 尚未完成的旧帧；
+ * worker 和主线程各自检查 generation，旧结果永远不会写回 UI。
+ */
+export const createGraphLayoutSolverWithWorker = (workerFactory) => {
+    const worker = workerFactory();
+    let generation = 0;
+    let pending;
+    let disposed = false;
+    const rejectPending = (reason) => {
+        const current = pending;
+        pending = undefined;
+        if (current === undefined)
+            return;
+        current.removeAbortListener();
+        current.reject(reason);
+    };
+    worker.onmessage = (event) => {
+        if (disposed)
+            return;
+        const response = event.data;
+        const current = pending;
+        if (current === undefined || response.generation !== current.generation || response.generation !== generation) {
+            return;
+        }
+        pending = undefined;
+        current.removeAbortListener();
+        if (response.kind === "error") {
+            current.reject(new Error(response.message));
+            return;
+        }
+        try {
+            current.resolve(unpackGraphLayoutPositions(current.nodeIds, new Float64Array(response.positions)));
+        }
+        catch (error) {
+            current.reject(error);
+        }
+    };
+    worker.onerror = (event) => {
+        if (disposed)
+            return;
+        rejectPending(new Error(event.message || "图布局 worker 执行失败"));
+    };
+    const solve = ((request, signal) => {
+        if (disposed)
+            return Promise.reject(new Error("图布局 solver 已释放"));
+        if (signal?.aborted === true)
+            return Promise.reject(abortError("图布局请求已取消"));
+        const packed = packGraphLayoutRequest(request);
+        rejectPending(abortError("图布局请求已被更新帧取代"));
+        generation += 1;
+        const requestGeneration = generation;
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                if (pending?.generation !== requestGeneration)
+                    return;
+                rejectPending(abortError("图布局请求已取消"));
+            };
+            signal?.addEventListener("abort", onAbort, { once: true });
+            pending = {
+                generation: requestGeneration,
+                nodeIds: packed.nodeIds,
+                resolve,
+                reject,
+                removeAbortListener: () => signal?.removeEventListener("abort", onAbort)
+            };
+            const message = {
+                kind: "solve",
+                generation: requestGeneration,
+                nodes: packed.nodes.buffer,
+                edges: packed.edges.buffer,
+                fixedIndex: packed.fixedIndex
+            };
+            try {
+                worker.postMessage(message, [packed.nodes.buffer, packed.edges.buffer]);
+            }
+            catch (error) {
+                rejectPending(error);
+            }
+        });
+    });
+    solve.dispose = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        rejectPending(abortError("图布局 solver 已释放"));
+        worker.onmessage = null;
+        worker.onerror = null;
+        worker.terminate();
+    };
+    return solve;
+};
+export const createGraphLayoutSolver = () => createGraphLayoutSolverWithWorker(defaultWorkerFactory);

package/dist/ladybug/graph-layout-wasm.d.ts

@@ -0,0 +1,9 @@
+import { type GraphLayoutRequest, type GraphLayoutPosition, type PackedGraphLayoutRequest } from "./graph-layout-contract.js";
+export declare class GraphLayoutWasm {
+    #private;
+    constructor(exports: WebAssembly.Exports);
+    solvePacked(request: PackedGraphLayoutRequest): Float64Array;
+    solve(request: GraphLayoutRequest): Readonly<Record<string, GraphLayoutPosition>>;
+}
+export declare const instantiateGraphLayoutWasm: (bytes: BufferSource) => Promise<GraphLayoutWasm>;
+export declare const loadDefaultGraphLayoutWasm: () => Promise<GraphLayoutWasm>;

package/dist/ladybug/graph-layout-wasm.js

@@ -0,0 +1,88 @@
+import { packGraphLayoutRequest, unpackGraphLayoutPositions } from "./graph-layout-contract.js";
+const MAGIC = 0x5745_474c;
+const VERSION = 1;
+const HEADER_BYTES = 24;
+const NODE_BYTES = 24;
+const EDGE_BYTES = 8;
+const NO_FIXED_NODE = 0xffff_ffff;
+const assertExports = (exports) => {
+    const candidate = exports;
+    if (!(candidate.memory instanceof WebAssembly.Memory)
+        || typeof candidate.graph_layout_alloc !== "function"
+        || typeof candidate.graph_layout_dealloc !== "function"
+        || typeof candidate.graph_layout_solve !== "function") {
+        throw new Error("图布局 WASM 导出不完整");
+    }
+    return candidate;
+};
+export class GraphLayoutWasm {
+    #exports;
+    constructor(exports) {
+        this.#exports = assertExports(exports);
+    }
+    solvePacked(request) {
+        const nodeCount = request.nodes.length / 3;
+        const edgeCount = request.edges.length / 2;
+        if (!Number.isInteger(nodeCount) || !Number.isInteger(edgeCount)) {
+            throw new TypeError("图布局 packed request 长度非法");
+        }
+        if (nodeCount === 0)
+            return new Float64Array();
+        const byteLength = HEADER_BYTES + nodeCount * NODE_BYTES + edgeCount * EDGE_BYTES;
+        const pointer = this.#exports.graph_layout_alloc(byteLength);
+        if (pointer === 0)
+            throw new Error("图布局 WASM 内存分配失败");
+        try {
+            const view = new DataView(this.#exports.memory.buffer, pointer, byteLength);
+            view.setUint32(0, MAGIC, true);
+            view.setUint32(4, VERSION, true);
+            view.setUint32(8, nodeCount, true);
+            view.setUint32(12, edgeCount, true);
+            view.setUint32(16, request.fixedIndex < 0 ? NO_FIXED_NODE : request.fixedIndex, true);
+            view.setUint32(20, 0, true);
+            for (let index = 0; index < nodeCount; index += 1) {
+                const packedOffset = index * 3;
+                const wasmOffset = HEADER_BYTES + index * NODE_BYTES;
+                view.setFloat64(wasmOffset, request.nodes[packedOffset], true);
+                view.setFloat64(wasmOffset + 8, request.nodes[packedOffset + 1], true);
+                view.setFloat64(wasmOffset + 16, request.nodes[packedOffset + 2], true);
+            }
+            const edgeOffset = HEADER_BYTES + nodeCount * NODE_BYTES;
+            for (let index = 0; index < request.edges.length; index += 1) {
+                view.setUint32(edgeOffset + index * 4, request.edges[index], true);
+            }
+            const status = this.#exports.graph_layout_solve(pointer, byteLength);
+            if (status !== 0)
+                throw new Error(`图布局 WASM 求解失败，状态码 ${status}`);
+            // solve 可能触发 memory.grow，必须重新取得 buffer。
+            const resultView = new DataView(this.#exports.memory.buffer, pointer, byteLength);
+            const result = new Float64Array(nodeCount * 2);
+            for (let index = 0; index < nodeCount; index += 1) {
+                const wasmOffset = HEADER_BYTES + index * NODE_BYTES;
+                result[index * 2] = resultView.getFloat64(wasmOffset, true);
+                result[index * 2 + 1] = resultView.getFloat64(wasmOffset + 8, true);
+            }
+            return result;
+        }
+        finally {
+            this.#exports.graph_layout_dealloc(pointer, byteLength);
+        }
+    }
+    solve(request) {
+        const packed = packGraphLayoutRequest(request);
+        return unpackGraphLayoutPositions(packed.nodeIds, this.solvePacked(packed));
+    }
+}
+export const instantiateGraphLayoutWasm = async (bytes) => {
+    const result = await WebAssembly.instantiate(bytes, {});
+    const instance = result instanceof WebAssembly.Instance ? result : result.instance;
+    return new GraphLayoutWasm(instance.exports);
+};
+export const loadDefaultGraphLayoutWasm = async () => {
+    const url = new URL("./graph-layout.wasm", import.meta.url);
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`无法加载图布局 WASM (${response.status})`);
+    }
+    return instantiateGraphLayoutWasm(await response.arrayBuffer());
+};

package/dist/ladybug/graph-layout-worker-protocol.d.ts

@@ -0,0 +1,18 @@
+export interface GraphLayoutWorkerSolveMessage {
+    readonly kind: "solve";
+    readonly generation: number;
+    readonly nodes: ArrayBuffer;
+    readonly edges: ArrayBuffer;
+    readonly fixedIndex: number;
+}
+export interface GraphLayoutWorkerResultMessage {
+    readonly kind: "result";
+    readonly generation: number;
+    readonly positions: ArrayBuffer;
+}
+export interface GraphLayoutWorkerErrorMessage {
+    readonly kind: "error";
+    readonly generation: number;
+    readonly message: string;
+}
+export type GraphLayoutWorkerResponse = GraphLayoutWorkerResultMessage | GraphLayoutWorkerErrorMessage;

package/dist/ladybug/graph-layout-worker-protocol.js

@@ -0,0 +1 @@
+export {};

package/dist/ladybug/graph-layout-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ladybug/graph-layout-worker.js

@@ -0,0 +1,66 @@
+/// <reference lib="webworker" />
+import { loadDefaultGraphLayoutWasm } from "./graph-layout-wasm.js";
+const workerScope = self;
+let runtimePromise;
+let newestGeneration = 0;
+let pending;
+let scheduled = false;
+const scheduleLatest = () => {
+    if (scheduled)
+        return;
+    scheduled = true;
+    setTimeout(() => { void solveLatest(); }, 0);
+};
+const solveLatest = async () => {
+    scheduled = false;
+    const request = pending;
+    pending = undefined;
+    if (request === undefined)
+        return;
+    try {
+        runtimePromise ??= loadDefaultGraphLayoutWasm();
+        const runtime = await runtimePromise;
+        // WASM 下载期间到达的新帧会直接取代本帧，本帧不再消耗求解时间。
+        if (request.generation !== newestGeneration) {
+            scheduleLatest();
+            return;
+        }
+        const packed = {
+            nodeIds: [],
+            nodes: new Float64Array(request.nodes),
+            edges: new Uint32Array(request.edges),
+            fixedIndex: request.fixedIndex
+        };
+        const positions = runtime.solvePacked(packed);
+        if (request.generation === newestGeneration) {
+            const response = {
+                kind: "result",
+                generation: request.generation,
+                positions: positions.buffer
+            };
+            workerScope.postMessage(response, [positions.buffer]);
+        }
+    }
+    catch (error) {
+        if (request.generation === newestGeneration) {
+            const response = {
+                kind: "error",
+                generation: request.generation,
+                message: error instanceof Error ? error.message : String(error)
+            };
+            workerScope.postMessage(response);
+        }
+    }
+    finally {
+        if (pending !== undefined)
+            scheduleLatest();
+    }
+};
+workerScope.onmessage = (event) => {
+    const request = event.data;
+    if (request.kind !== "solve" || !Number.isSafeInteger(request.generation))
+        return;
+    newestGeneration = Math.max(newestGeneration, request.generation);
+    pending = request;
+    scheduleLatest();
+};

package/dist/ladybug/graph-layout.d.ts

@@ -0,0 +1,2 @@
+export { createGraphLayoutSolver } from "./graph-layout-solver.js";
+export type { GraphLayoutEdge, GraphLayoutNode, GraphLayoutPosition, GraphLayoutRequest, GraphLayoutSolver, GraphLayoutSolverHandle } from "./graph-layout-contract.js";

package/dist/ladybug/graph-layout.js

@@ -0,0 +1 @@
+export { createGraphLayoutSolver } from "./graph-layout-solver.js";