@riemannre3/dsh-roleplay 0.1.3

package/lib/variable-runtime.js

@@ -0,0 +1,618 @@
+export class CommittedReplyVariableGate {
+    #pending = new Map();
+    capture(sessionId, body) {
+        this.#pending.set(sessionId, body);
+    }
+    async commit(sessionId, apply) {
+        const body = this.#pending.get(sessionId);
+        if (body === undefined)
+            return false;
+        await apply(body);
+        this.#pending.delete(sessionId);
+        return true;
+    }
+    discard(sessionId) {
+        this.#pending.delete(sessionId);
+    }
+}
+class VariableRuntimeError extends Error {
+    code;
+    operation;
+    path;
+    constructor(code, message, operation, path) {
+        super(message);
+        this.code = code;
+        this.operation = operation;
+        this.path = path;
+    }
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isVariableValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.every(isVariableValue);
+    if (!isObject(value))
+        return false;
+    return Object.entries(value).every(([key, child]) => !forbiddenSegment(key) && isVariableValue(child));
+}
+function cloneValue(value) {
+    if (Array.isArray(value))
+        return value.map((item) => cloneValue(item));
+    if (isObject(value))
+        return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, cloneValue(child)]));
+    return value;
+}
+function mergeObject(target, source) {
+    const result = cloneValue(target);
+    for (const [key, value] of Object.entries(source)) {
+        if (forbiddenSegment(key))
+            throw new VariableRuntimeError("INVALID_PATH", `变量对象包含不安全的键：${key}`);
+        const current = result[key];
+        result[key] = isObject(current) && isObject(value) ? mergeObject(current, value) : cloneValue(value);
+    }
+    return result;
+}
+export function mergeVariableScopes(scopes) {
+    return [scopes.global, scopes.character, scopes.script, scopes.chat, scopes.messageSelectedVariant]
+        .reduce((state, scope) => scope === undefined ? state : mergeObject(state, scope), {});
+}
+function stripFence(value) {
+    const trimmed = value.trim();
+    const match = /^```(?:json|yaml|yml|xml)?\s*\n([\s\S]*?)\n```$/iu.exec(trimmed);
+    return match?.[1].trim() ?? trimmed;
+}
+function initvarPayloads(content) {
+    const matches = Array.from(content.matchAll(/<initvar\b[^>]*>([\s\S]*?)<\/initvar>/giu), (match) => match[1]);
+    return matches.length > 0 ? matches : [content];
+}
+export function classifyInitvarSyntax(content) {
+    const payload = stripFence(initvarPayloads(content)[0] ?? "");
+    if (/^[{[]/u.test(payload))
+        return "json";
+    if (/^<[/a-z_][\s\S]*>$/iu.test(payload))
+        return "xml";
+    if (/^[^\n:#]+:\s*.+(?:\n|$)/u.test(payload))
+        return "yaml";
+    return "unknown";
+}
+function parseJsonObject(payload) {
+    let value;
+    try {
+        value = JSON.parse(withoutTrailingJsonCommas(payload));
+    }
+    catch {
+        throw new VariableRuntimeError("INVALID_INITVAR", "initvar JSON 无法解析");
+    }
+    if (!isObject(value) || !isVariableValue(value))
+        throw new VariableRuntimeError("INVALID_INITVAR", "initvar 必须是安全的 JSON 对象");
+    return cloneValue(value);
+}
+function withoutTrailingJsonCommas(payload) {
+    let result = "";
+    let quote = "";
+    let escaped = false;
+    for (let index = 0; index < payload.length; index += 1) {
+        const character = payload[index];
+        if (quote.length > 0) {
+            result += character;
+            if (escaped)
+                escaped = false;
+            else if (character === "\\")
+                escaped = true;
+            else if (character === quote)
+                quote = "";
+            continue;
+        }
+        if (character === '"') {
+            quote = character;
+            result += character;
+            continue;
+        }
+        if (character !== ",") {
+            result += character;
+            continue;
+        }
+        let cursor = index + 1;
+        while (cursor < payload.length && /\s/u.test(payload[cursor]))
+            cursor += 1;
+        if (payload[cursor] !== "}" && payload[cursor] !== "]")
+            result += character;
+    }
+    return result;
+}
+function scalarFromYaml(value) {
+    const trimmed = value.trim();
+    if (trimmed === "null" || trimmed === "~")
+        return null;
+    if (/^(?:true|false)$/iu.test(trimmed))
+        return trimmed.toLocaleLowerCase() === "true";
+    if (/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/u.test(trimmed))
+        return Number(trimmed);
+    if (/^["']/.test(trimmed))
+        return parseLiteral(trimmed);
+    if (/^[{[]/u.test(trimmed))
+        return parseLiteral(trimmed);
+    return trimmed;
+}
+function parseSimpleYamlObject(payload) {
+    const root = {};
+    const lines = payload.split(/\r?\n/u).flatMap((rawLine) => {
+        if (rawLine.trim().length === 0 || rawLine.trimStart().startsWith("#"))
+            return [];
+        return [{ indent: rawLine.length - rawLine.trimStart().length, text: rawLine.trim() }];
+    });
+    const stack = [{ indent: -1, value: root }];
+    for (const [lineIndex, line] of lines.entries()) {
+        const { indent } = line;
+        while (stack.length > 1 && indent <= stack[stack.length - 1].indent)
+            stack.pop();
+        const parent = stack[stack.length - 1].value;
+        if (line.text.startsWith("- ")) {
+            if (!Array.isArray(parent))
+                throw new VariableRuntimeError("INVALID_INITVAR", "initvar YAML 列表缺少父级键");
+            parent.push(scalarFromYaml(line.text.slice(2)));
+            continue;
+        }
+        if (Array.isArray(parent))
+            throw new VariableRuntimeError("INVALID_INITVAR", "initvar YAML 暂不支持对象列表项");
+        const match = /^([^:#][^:]*):(?:\s*(.*))?$/u.exec(line.text);
+        if (match === null)
+            throw new VariableRuntimeError("INVALID_INITVAR", "initvar YAML 只支持确定性的对象映射");
+        const key = match[1].trim();
+        if (key.length === 0 || forbiddenSegment(key))
+            throw new VariableRuntimeError("INVALID_INITVAR", "initvar YAML 包含不安全的键");
+        const rawValue = match[2] ?? "";
+        if (rawValue.length === 0) {
+            const next = lines[lineIndex + 1];
+            const child = next !== undefined && next.indent > indent && next.text.startsWith("- ") ? [] : {};
+            parent[key] = child;
+            stack.push({ indent, value: child });
+        }
+        else
+            parent[key] = scalarFromYaml(rawValue);
+    }
+    return root;
+}
+function parseInitvarObject(content) {
+    let combined = {};
+    let syntax = "unknown";
+    for (const rawPayload of initvarPayloads(content)) {
+        const payload = stripFence(rawPayload);
+        const current = classifyInitvarSyntax(payload);
+        if (current === "json")
+            combined = mergeObject(combined, parseJsonObject(payload));
+        else if (current === "yaml")
+            combined = mergeObject(combined, parseSimpleYamlObject(payload));
+        else
+            throw new VariableRuntimeError("INVALID_INITVAR", `暂不支持 ${current === "xml" ? "XML" : "未知"} initvar 格式`);
+        syntax = current;
+    }
+    return { value: combined, syntax };
+}
+export function initializeVariableRuntime(scopes, sources) {
+    const before = mergeVariableScopes(scopes);
+    let next = cloneValue(before);
+    const events = [{ type: "VARIABLE_INITIALIZATION_STARTED" }];
+    const diagnostics = [];
+    try {
+        for (const source of sources) {
+            const parsed = parseInitvarObject(source.content);
+            next = mergeObject(next, parsed.value);
+            events.push({ type: "COMMAND_PARSED", sourceId: source.id, syntax: parsed.syntax, operation: "merge-initvar" });
+        }
+        events.push({ type: "VARIABLE_INITIALIZED" });
+        return { status: "initialized", state: next, events, diagnostics };
+    }
+    catch (error) {
+        const diagnostic = toDiagnostic(error);
+        diagnostics.push(diagnostic);
+        events.push({ type: "VARIABLE_INITIALIZATION_FAILED", diagnostic });
+        return { status: "failed", state: before, events, diagnostics };
+    }
+}
+function forbiddenSegment(value) {
+    return value === "__proto__" || value === "prototype" || value === "constructor";
+}
+function validateSegments(segments, path) {
+    if (segments.length === 0 || segments.some((segment) => typeof segment === "string" && (segment.length === 0 || forbiddenSegment(segment)))) {
+        throw new VariableRuntimeError("INVALID_PATH", `变量路径不安全：${path}`, undefined, path);
+    }
+    return [...segments];
+}
+function legacyPath(path) {
+    const segments = [];
+    const normalized = path.replace(/\[(\d+)\]/gu, ".$1");
+    for (const item of normalized.split("."))
+        segments.push(/^\d+$/u.test(item) ? Number(item) : item);
+    return validateSegments(segments, path);
+}
+function pointerPath(path) {
+    if (!path.startsWith("/"))
+        throw new VariableRuntimeError("INVALID_PATH", `JSON Pointer 必须以 / 开头：${path}`, undefined, path);
+    return validateSegments(path.slice(1).split("/").map((item) => item.replace(/~1/gu, "/").replace(/~0/gu, "~")).map((item) => /^\d+$/u.test(item) ? Number(item) : item), path);
+}
+function parentAt(root, segments, path, create) {
+    let cursor = root;
+    for (const [index, segment] of segments.slice(0, -1).entries()) {
+        const child = cursor[segment];
+        if (child === undefined && create) {
+            const created = typeof segments[index + 1] === "number" ? [] : {};
+            cursor[segment] = created;
+            cursor = created;
+            continue;
+        }
+        if (!isObject(child) && !Array.isArray(child))
+            throw new VariableRuntimeError(child === undefined ? "PATH_NOT_FOUND" : "TYPE_MISMATCH", `变量路径不存在或不是容器：${path}`, undefined, path);
+        cursor = child;
+    }
+    return { parent: cursor, key: segments[segments.length - 1] };
+}
+function valueAt(root, segments, path) {
+    let cursor = root;
+    for (const segment of segments) {
+        if ((!isObject(cursor) && !Array.isArray(cursor)) || !(segment in cursor))
+            throw new VariableRuntimeError("PATH_NOT_FOUND", `变量路径不存在：${path}`, undefined, path);
+        cursor = cursor[segment];
+    }
+    return cursor;
+}
+function hasAt(root, segments) {
+    try {
+        valueAt(root, segments, segments.join("."));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function setAt(root, segments, path, value, create) {
+    const { parent, key } = parentAt(root, segments, path, create);
+    if (!create && !(key in parent))
+        throw new VariableRuntimeError("PATH_NOT_FOUND", `变量路径不存在：${path}`, undefined, path);
+    if (Array.isArray(parent) && typeof key !== "number")
+        throw new VariableRuntimeError("TYPE_MISMATCH", `数组路径必须使用数字下标：${path}`, undefined, path);
+    parent[key] = cloneValue(value);
+}
+function replaceLeafAt(root, segments, path, value) {
+    const { parent, key } = parentAt(root, segments, path, false);
+    if (Array.isArray(parent)) {
+        if (typeof key !== "number")
+            throw new VariableRuntimeError("TYPE_MISMATCH", `数组路径必须使用数字下标：${path}`, undefined, path);
+        if (!(key in parent))
+            throw new VariableRuntimeError("PATH_NOT_FOUND", `变量路径不存在：${path}`, undefined, path);
+    }
+    else if (typeof key !== "string")
+        throw new VariableRuntimeError("TYPE_MISMATCH", `对象路径不能使用数字键：${path}`, undefined, path);
+    parent[key] = cloneValue(value);
+}
+function deleteAt(root, segments, path) {
+    const { parent, key } = parentAt(root, segments, path, false);
+    if (!(key in parent))
+        throw new VariableRuntimeError("PATH_NOT_FOUND", `变量路径不存在：${path}`, undefined, path);
+    if (Array.isArray(parent)) {
+        if (typeof key !== "number")
+            throw new VariableRuntimeError("TYPE_MISMATCH", `数组路径必须使用数字下标：${path}`, undefined, path);
+        parent.splice(key, 1);
+    }
+    else
+        delete parent[key];
+}
+function parseQuotedString(value) {
+    const quote = value[0];
+    if ((quote !== "'" && quote !== '"') || value.at(-1) !== quote)
+        throw new VariableRuntimeError("INVALID_ARGUMENT", "字符串参数缺少配对引号");
+    if (quote === '"') {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            throw new VariableRuntimeError("INVALID_ARGUMENT", "字符串参数无法解析");
+        }
+    }
+    let result = "";
+    for (let index = 1; index < value.length - 1; index += 1) {
+        const character = value[index];
+        if (character !== "\\") {
+            result += character;
+            continue;
+        }
+        index += 1;
+        const escaped = value[index];
+        if (escaped === "n")
+            result += "\n";
+        else if (escaped === "r")
+            result += "\r";
+        else if (escaped === "t")
+            result += "\t";
+        else if (escaped === "\\" || escaped === "'")
+            result += escaped;
+        else
+            throw new VariableRuntimeError("INVALID_ARGUMENT", `不支持的字符串转义：\\${escaped}`);
+    }
+    return result;
+}
+function parseLiteral(value) {
+    const trimmed = value.trim();
+    let parsed;
+    if (trimmed.startsWith("'") || trimmed.startsWith('"'))
+        parsed = parseQuotedString(trimmed);
+    else {
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            throw new VariableRuntimeError("INVALID_ARGUMENT", `命令参数不是安全的 JSON 字面量：${trimmed.slice(0, 48)}`);
+        }
+    }
+    if (!isVariableValue(parsed))
+        throw new VariableRuntimeError("INVALID_ARGUMENT", "命令参数不是安全的变量值");
+    return cloneValue(parsed);
+}
+function splitArguments(value) {
+    const parts = [];
+    let start = 0;
+    let quote = "";
+    let escaped = false;
+    let depth = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        const character = value[index];
+        if (quote.length > 0) {
+            if (escaped)
+                escaped = false;
+            else if (character === "\\")
+                escaped = true;
+            else if (character === quote)
+                quote = "";
+            continue;
+        }
+        if (character === "'" || character === '"')
+            quote = character;
+        else if (character === "{" || character === "[")
+            depth += 1;
+        else if (character === "}" || character === "]")
+            depth -= 1;
+        else if (character === "," && depth === 0) {
+            parts.push(value.slice(start, index).trim());
+            start = index + 1;
+        }
+    }
+    if (quote.length > 0 || depth !== 0)
+        throw new VariableRuntimeError("INVALID_COMMAND", "命令参数括号或引号不完整");
+    const last = value.slice(start).trim();
+    if (last.length > 0)
+        parts.push(last);
+    return parts;
+}
+function scanLegacyCommands(payload) {
+    const operations = [];
+    const consumed = [];
+    const head = /_\.(set|add|insert|assign|remove|delete|unset|move|replace|delta)\s*\(/giu;
+    let match;
+    while ((match = head.exec(payload)) !== null) {
+        const open = head.lastIndex - 1;
+        let quote = "";
+        let escaped = false;
+        let depth = 1;
+        let close = -1;
+        for (let index = open + 1; index < payload.length; index += 1) {
+            const character = payload[index];
+            if (quote.length > 0) {
+                if (escaped)
+                    escaped = false;
+                else if (character === "\\")
+                    escaped = true;
+                else if (character === quote)
+                    quote = "";
+            }
+            else if (character === "'" || character === '"')
+                quote = character;
+            else if (character === "(")
+                depth += 1;
+            else if (character === ")" && --depth === 0) {
+                close = index;
+                break;
+            }
+        }
+        if (close < 0)
+            throw new VariableRuntimeError("INVALID_COMMAND", "更新命令缺少右括号", match[1]);
+        const args = splitArguments(payload.slice(open + 1, close));
+        const operation = match[1].toLocaleLowerCase();
+        if (operation === "move") {
+            if (args.length !== 2)
+                throw new VariableRuntimeError("INVALID_ARGUMENT", "move 需要来源和目标两个路径", operation);
+            operations.push({ operation, from: parseQuotedString(args[0]), path: parseQuotedString(args[1]) });
+        }
+        else {
+            if (args.length < 1 || args.length > 3)
+                throw new VariableRuntimeError("INVALID_ARGUMENT", `${operation} 参数数量不正确`, operation);
+            const path = parseQuotedString(args[0]);
+            operations.push({ operation, path, ...(args[1] === undefined ? {} : { value: parseLiteral(args[1]) }), ...(args[2] === undefined ? {} : { index: Number(parseLiteral(args[2])) }) });
+        }
+        consumed.push({ start: match.index, end: close + 1 });
+        head.lastIndex = close + 1;
+    }
+    if (operations.length > 0) {
+        let cursor = 0;
+        let residue = "";
+        for (const range of consumed) {
+            residue += payload.slice(cursor, range.start);
+            cursor = range.end;
+        }
+        residue += payload.slice(cursor);
+        if (residue.replace(/[\s;]+/gu, "").length > 0)
+            throw new VariableRuntimeError("UNKNOWN_FORMAT", "UpdateVariable 混入了不可识别的命令文本");
+    }
+    return operations;
+}
+function jsonPatchOperations(payload) {
+    let parsed;
+    try {
+        parsed = JSON.parse(payload);
+    }
+    catch {
+        throw new VariableRuntimeError("INVALID_JSON_PATCH", "JSON Patch 无法解析");
+    }
+    if (!Array.isArray(parsed) || parsed.length === 0)
+        throw new VariableRuntimeError("INVALID_JSON_PATCH", "JSON Patch 必须是非空数组");
+    return parsed.map((item) => {
+        if (!isObject(item) || typeof item.op !== "string" || typeof item.path !== "string")
+            throw new VariableRuntimeError("INVALID_JSON_PATCH", "JSON Patch 项缺少 op 或 path");
+        const operation = item.op.toLocaleLowerCase();
+        if (!isVariableValue(item.value) && item.value !== undefined)
+            throw new VariableRuntimeError("INVALID_JSON_PATCH", "JSON Patch value 不是安全变量值", operation, item.path);
+        return { operation, path: item.path, ...(typeof item.from === "string" ? { from: item.from } : {}), ...(item.value === undefined ? {} : { value: cloneValue(item.value) }) };
+    });
+}
+function parseUpdateOperations(body) {
+    const blocks = Array.from(body.matchAll(/<UpdateVariable\b[^>]*>([\s\S]*?)<\/UpdateVariable>/giu), (match) => match[1]);
+    if (blocks.length === 0)
+        return undefined;
+    const operations = [];
+    let syntax = "unknown";
+    for (const rawBlock of blocks) {
+        const patch = /<JSON_?Patch\b[^>]*>([\s\S]*?)<\/JSON_?Patch>/iu.exec(rawBlock);
+        if (patch !== null) {
+            operations.push(...jsonPatchOperations(stripFence(patch[1])));
+            syntax = "json-patch";
+            continue;
+        }
+        const commands = scanLegacyCommands(rawBlock);
+        if (commands.length === 0)
+            throw new VariableRuntimeError("UNKNOWN_FORMAT", "UpdateVariable 中没有可识别的 pinned MVU 更新格式");
+        operations.push(...commands);
+        syntax = syntax === "json-patch" ? syntax : "legacy";
+    }
+    return { operations, syntax };
+}
+function operationPath(operation) {
+    const path = operation.path ?? "";
+    return { segments: path.startsWith("/") ? pointerPath(path) : legacyPath(path), label: path };
+}
+function requireValue(operation) {
+    if (operation.value === undefined)
+        throw new VariableRuntimeError("INVALID_ARGUMENT", `${operation.operation} 缺少 value`, operation.operation, operation.path);
+    return operation.value;
+}
+function applyOperation(state, operation) {
+    const name = operation.operation;
+    const { segments, label } = operationPath(operation);
+    try {
+        if ((name === "add" || name === "insert") && label.startsWith("/")) {
+            const value = requireValue(operation);
+            const { parent, key } = parentAt(state, segments, label, name === "insert");
+            if (Array.isArray(parent)) {
+                const index = key === "-" ? parent.length : key;
+                if (typeof index !== "number" || index < 0 || index > parent.length)
+                    throw new VariableRuntimeError("INVALID_ARGUMENT", `${name} 数组下标越界`, name, label);
+                parent.splice(index, 0, cloneValue(value));
+            }
+            else {
+                if (typeof key !== "string")
+                    throw new VariableRuntimeError("TYPE_MISMATCH", `${name} 对象路径不能使用数字键`, name, label);
+                parent[key] = cloneValue(value);
+            }
+        }
+        else if (name === "set")
+            setAt(state, segments, label, requireValue(operation), true);
+        else if (name === "replace")
+            replaceLeafAt(state, segments, label, requireValue(operation));
+        else if (name === "remove" || name === "delete" || name === "unset")
+            deleteAt(state, segments, label);
+        else if (name === "assign") {
+            const source = requireValue(operation);
+            if (!isObject(source))
+                throw new VariableRuntimeError("TYPE_MISMATCH", "assign value 必须是对象", name, label);
+            const current = valueAt(state, segments, label);
+            if (!isObject(current))
+                throw new VariableRuntimeError("TYPE_MISMATCH", "assign 目标必须是对象", name, label);
+            setAt(state, segments, label, { ...current, ...cloneValue(source) }, false);
+        }
+        else if (name === "add" || name === "delta") {
+            const delta = requireValue(operation);
+            const current = hasAt(state, segments) ? valueAt(state, segments, label) : undefined;
+            if (current === undefined && name === "add")
+                setAt(state, segments, label, delta, true);
+            else if (typeof current === "number" && typeof delta === "number")
+                setAt(state, segments, label, current + delta, false);
+            else if (name === "add" && Array.isArray(current)) {
+                current.push(cloneValue(delta));
+            }
+            else
+                throw new VariableRuntimeError("TYPE_MISMATCH", `${name} 需要数字目标${name === "add" ? "或数组目标" : ""}`, name, label);
+        }
+        else if (name === "insert") {
+            const target = valueAt(state, segments, label);
+            if (!Array.isArray(target))
+                throw new VariableRuntimeError("TYPE_MISMATCH", "insert 目标必须是数组", name, label);
+            const index = operation.index ?? target.length;
+            if (!Number.isInteger(index) || index < 0 || index > target.length)
+                throw new VariableRuntimeError("INVALID_ARGUMENT", "insert 下标越界", name, label);
+            target.splice(index, 0, cloneValue(requireValue(operation)));
+        }
+        else if (name === "move") {
+            if (operation.from === undefined)
+                throw new VariableRuntimeError("INVALID_ARGUMENT", "move 缺少来源路径", name, label);
+            const from = operation.from.startsWith("/") ? pointerPath(operation.from) : legacyPath(operation.from);
+            const value = cloneValue(valueAt(state, from, operation.from));
+            deleteAt(state, from, operation.from);
+            setAt(state, segments, label, value, true);
+        }
+        else
+            throw new VariableRuntimeError("UNSUPPORTED_OPERATION", `不支持的更新操作：${name}`, name, label);
+    }
+    catch (error) {
+        if (error instanceof VariableRuntimeError && error.operation === undefined)
+            throw new VariableRuntimeError(error.code, error.message, name, error.path ?? label);
+        throw error;
+    }
+}
+function toDiagnostic(error) {
+    if (error instanceof VariableRuntimeError)
+        return { code: error.code, message: error.message, ...(error.operation === undefined ? {} : { operation: error.operation }), ...(error.path === undefined ? {} : { path: error.path }) };
+    return { code: "INVALID_COMMAND", message: error instanceof Error ? error.message : "变量更新失败" };
+}
+export function applyVariableUpdate(before, body) {
+    const original = cloneValue(before);
+    let parsed;
+    try {
+        parsed = parseUpdateOperations(body);
+    }
+    catch (error) {
+        const diagnostic = toDiagnostic(error);
+        return { status: "failed", state: original, operationCount: 0, diagnostics: [diagnostic], events: [{ type: "VARIABLE_UPDATE_STARTED" }, { type: "VARIABLE_UPDATE_FAILED", diagnostic }] };
+    }
+    if (parsed === undefined)
+        return { status: "ignored", state: original, operationCount: 0, diagnostics: [], events: [] };
+    const events = [{ type: "VARIABLE_UPDATE_STARTED", syntax: parsed.syntax }];
+    const next = cloneValue(original);
+    try {
+        for (const operation of parsed.operations) {
+            applyOperation(next, operation);
+            events.push({ type: "COMMAND_PARSED", syntax: parsed.syntax, operation: operation.operation, path: operation.path });
+        }
+        events.push({ type: "VARIABLE_UPDATE_ENDED", syntax: parsed.syntax });
+        return { status: "committed", state: next, operationCount: parsed.operations.length, diagnostics: [], events };
+    }
+    catch (error) {
+        const diagnostic = toDiagnostic(error);
+        events.push({ type: "VARIABLE_UPDATE_FAILED", syntax: parsed.syntax, diagnostic });
+        return { status: "failed", state: original, operationCount: parsed.operations.length, diagnostics: [diagnostic], events };
+    }
+}
+function canonical(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(",")}]`;
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+}
+export async function variableStateDigest(state) {
+    const bytes = new TextEncoder().encode(canonical(state));
+    const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes));
+    return Array.from(digest, (value) => value.toString(16).padStart(2, "0")).join("");
+}