@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/runtime/automations/definition-input.js

@@ -0,0 +1,283 @@
+import { Buffer } from "node:buffer";
+import { isAutomationRunFileName } from "./run-file-binding.js";
+import { AUTOMATION_GRAPH_LIMITS } from "./limits.js";
+const MAX_DEFINITION_BYTES = 128 * 1024;
+const MAX_TEXT = 8_192;
+const MAX_BINDINGS = 64;
+const NODE_ID = /^[A-Za-z][A-Za-z0-9._-]{0,63}$/u;
+const RECORD_ID = /^[\p{L}\p{N}][\p{L}\p{N}._:-]{0,63}$/u;
+function invalid(path) {
+    throw new Error(`automation_graph_invalid: ${path}`);
+}
+function object(value, path) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        invalid(path);
+    return value;
+}
+function onlyKeys(value, allowed, path) {
+    if (Object.keys(value).some((key) => !allowed.includes(key)))
+        invalid(path);
+}
+function text(value, path, maximum = MAX_TEXT) {
+    if (typeof value !== "string" || value.length > maximum)
+        invalid(path);
+}
+function identifier(value, path) {
+    if (typeof value !== "string" || !NODE_ID.test(value))
+        invalid(path);
+}
+function recordId(value, path) {
+    if (typeof value !== "string" || !RECORD_ID.test(value))
+        invalid(path);
+}
+function positiveInteger(value, path) {
+    if (!Number.isSafeInteger(value) || Number(value) < 1)
+        invalid(path);
+}
+function jsonValue(value, path, depth = 0) {
+    if (depth > 12)
+        invalid(path);
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return;
+    if (typeof value === "number" && Number.isFinite(value))
+        return;
+    if (Array.isArray(value)) {
+        if (value.length > 1_000)
+            invalid(path);
+        value.forEach((part, index) => jsonValue(part, `${path}.${index}`, depth + 1));
+        return;
+    }
+    const record = object(value, path);
+    if (Object.keys(record).length > MAX_BINDINGS)
+        invalid(path);
+    for (const [key, part] of Object.entries(record)) {
+        if (key === "__proto__" || key === "prototype" || key === "constructor")
+            invalid(path);
+        jsonValue(part, `${path}.${key}`, depth + 1);
+    }
+}
+function binding(value, path) {
+    const input = object(value, path);
+    switch (input.kind) {
+        case "literal":
+            onlyKeys(input, ["kind", "value"], path);
+            jsonValue(input.value, `${path}.value`);
+            return;
+        case "run_input":
+            onlyKeys(input, ["kind", "input"], path);
+            identifier(input.input, `${path}.input`);
+            return;
+        case "run_file":
+            onlyKeys(input, ["kind", "fileName"], path);
+            if (!isAutomationRunFileName(input.fileName))
+                invalid(`${path}.fileName`);
+            return;
+        case "source_files":
+            onlyKeys(input, ["kind"], path);
+            return;
+        case "source_file":
+            onlyKeys(input, ["kind", "index", "field"], path);
+            if (!Number.isSafeInteger(input.index) || Number(input.index) < 0)
+                invalid(`${path}.index`);
+            if (!["snapshot_path", "original_path", "version"].includes(String(input.field)))
+                invalid(`${path}.field`);
+            return;
+        case "node_result":
+            onlyKeys(input, ["kind", "nodeId", "select", "pointer"], path);
+            identifier(input.nodeId, `${path}.nodeId`);
+            if (input.select !== "text" && input.select !== "data")
+                invalid(`${path}.select`);
+            if (input.pointer !== undefined)
+                text(input.pointer, `${path}.pointer`, 512);
+            return;
+        case "branch_results":
+            onlyKeys(input, ["kind", "parallelNodeId"], path);
+            identifier(input.parallelNodeId, `${path}.parallelNodeId`);
+            return;
+        default:
+            invalid(`${path}.kind`);
+    }
+}
+function bindings(value, path) {
+    const entries = Object.entries(object(value, path));
+    if (entries.length > MAX_BINDINGS)
+        invalid(path);
+    for (const [name, entry] of entries) {
+        identifier(name, `${path}.name`);
+        binding(entry, `${path}.${name}`);
+    }
+}
+function operation(value, path) {
+    const input = object(value, path);
+    onlyKeys(input, ["toolName", "operationId", "contractVersion"], path);
+    text(input.toolName, `${path}.toolName`, 64);
+    text(input.operationId, `${path}.operationId`, 64);
+    positiveInteger(input.contractVersion, `${path}.contractVersion`);
+}
+function node(value, path, depth) {
+    if (depth > AUTOMATION_GRAPH_LIMITS.nestingDepth * 2 + 1)
+        invalid(path);
+    const input = object(value, path);
+    identifier(input.id, `${path}.id`);
+    if (input.kind === "sequence") {
+        onlyKeys(input, ["kind", "id", "children"], path);
+        if (!Array.isArray(input.children) || input.children.length > AUTOMATION_GRAPH_LIMITS.executableNodes)
+            invalid(`${path}.children`);
+        input.children.forEach((child, index) => node(child, `${path}.children.${index}`, depth + 1));
+        return;
+    }
+    if (input.kind === "parallel") {
+        onlyKeys(input, ["kind", "id", "branches"], path);
+        if (!Array.isArray(input.branches) || input.branches.length > AUTOMATION_GRAPH_LIMITS.branchesPerGroup)
+            invalid(`${path}.branches`);
+        input.branches.forEach((branch, index) => {
+            if (object(branch, `${path}.branches.${index}`).kind !== "sequence")
+                invalid(`${path}.branches.${index}`);
+            node(branch, `${path}.branches.${index}`, depth + 1);
+        });
+        return;
+    }
+    text(input.title, `${path}.title`, 160);
+    if (input.onFailure !== "stop" && input.onFailure !== "skip")
+        invalid(`${path}.onFailure`);
+    if (input.kind === "tool") {
+        onlyKeys(input, ["kind", "id", "title", "onFailure", "operation", "controls", "payload"], path);
+        operation(input.operation, `${path}.operation`);
+        bindings(input.controls, `${path}.controls`);
+        if (input.payload !== undefined)
+            binding(input.payload, `${path}.payload`);
+        return;
+    }
+    if (input.kind !== "agent")
+        invalid(`${path}.kind`);
+    onlyKeys(input, ["kind", "id", "title", "onFailure", "modelProfileId", "agentMode", "roleInstructions", "prompt", "inputs", "tools", "result", "acceptance", "savedAgentOrigin"], path);
+    text(input.modelProfileId, `${path}.modelProfileId`, 128);
+    if (!["fast", "reasoning", "deep"].includes(String(input.agentMode)))
+        invalid(`${path}.agentMode`);
+    text(input.roleInstructions, `${path}.roleInstructions`);
+    text(input.prompt, `${path}.prompt`);
+    bindings(input.inputs, `${path}.inputs`);
+    if (!Array.isArray(input.tools) || input.tools.length > MAX_BINDINGS)
+        invalid(`${path}.tools`);
+    input.tools.forEach((entry, index) => {
+        const selected = object(entry, `${path}.tools.${index}`);
+        onlyKeys(selected, ["operation", "usage"], `${path}.tools.${index}`);
+        operation(selected.operation, `${path}.tools.${index}.operation`);
+        if (selected.usage !== "available" && selected.usage !== "required")
+            invalid(`${path}.tools.${index}.usage`);
+    });
+    const result = object(input.result, `${path}.result`);
+    if (result.kind === "text")
+        onlyKeys(result, ["kind"], `${path}.result`);
+    else if (result.kind === "json") {
+        onlyKeys(result, ["kind", "schema"], `${path}.result`);
+        const schema = object(result.schema, `${path}.result.schema`);
+        onlyKeys(schema, ["type", "additionalProperties", "properties", "required"], `${path}.result.schema`);
+        if (schema.type !== "object" || schema.additionalProperties !== false)
+            invalid(`${path}.result.schema`);
+        if (!Array.isArray(schema.required) || !schema.required.every((name) => typeof name === "string"))
+            invalid(`${path}.result.schema.required`);
+        const properties = object(schema.properties, `${path}.result.schema.properties`);
+        if (Object.keys(properties).length > MAX_BINDINGS)
+            invalid(`${path}.result.schema.properties`);
+        for (const [name, property] of Object.entries(properties)) {
+            identifier(name, `${path}.result.schema.properties`);
+            object(property, `${path}.result.schema.properties.${name}`);
+        }
+    }
+    else
+        invalid(`${path}.result.kind`);
+    if (input.acceptance !== undefined) {
+        if (!Array.isArray(input.acceptance) || input.acceptance.length > MAX_BINDINGS)
+            invalid(`${path}.acceptance`);
+        input.acceptance.forEach((entry, index) => {
+            const check = object(entry, `${path}.acceptance.${index}`);
+            onlyKeys(check, ["field", "equals"], `${path}.acceptance.${index}`);
+            identifier(check.field, `${path}.acceptance.${index}.field`);
+            if (!["string", "number", "boolean"].includes(typeof check.equals))
+                invalid(`${path}.acceptance.${index}.equals`);
+        });
+    }
+    if (input.savedAgentOrigin !== undefined) {
+        const origin = object(input.savedAgentOrigin, `${path}.savedAgentOrigin`);
+        onlyKeys(origin, ["agentId", "revision"], `${path}.savedAgentOrigin`);
+        recordId(origin.agentId, `${path}.savedAgentOrigin.agentId`);
+        positiveInteger(origin.revision, `${path}.savedAgentOrigin.revision`);
+    }
+}
+function trigger(value) {
+    const input = object(value, "trigger");
+    if (input.kind === "manual") {
+        onlyKeys(input, ["kind"], "trigger");
+        return;
+    }
+    if (input.kind === "schedule") {
+        onlyKeys(input, ["kind", "schedule"], "trigger");
+        object(input.schedule, "trigger.schedule");
+        return;
+    }
+    if (input.kind !== "folder")
+        invalid("trigger.kind");
+    onlyKeys(input, ["kind", "checkEveryMs", "minimumEligibleFiles"], "trigger");
+    positiveInteger(input.checkEveryMs, "trigger.checkEveryMs");
+    positiveInteger(input.minimumEligibleFiles, "trigger.minimumEligibleFiles");
+}
+function source(value) {
+    const input = object(value, "source");
+    onlyKeys(input, ["sourceId", "location", "includePatterns", "excludePatterns", "recursive", "includeExisting", "mode", "maxBatchFiles"], "source");
+    recordId(input.sourceId, "source.sourceId");
+    const location = object(input.location, "source.location");
+    onlyKeys(location, ["kind", "path"], "source.location");
+    if (location.kind !== "runtime_path")
+        invalid("source.location.kind");
+    text(location.path, "source.location.path", 1_024);
+    for (const name of ["includePatterns", "excludePatterns"]) {
+        const patterns = input[name];
+        if (!Array.isArray(patterns) || patterns.length > 64)
+            invalid(`source.${name}`);
+        patterns.forEach((pattern, index) => text(pattern, `source.${name}.${index}`, 256));
+    }
+    if (typeof input.recursive !== "boolean" || typeof input.includeExisting !== "boolean")
+        invalid("source.flags");
+    if (input.mode !== "per_file" && input.mode !== "batch")
+        invalid("source.mode");
+    positiveInteger(input.maxBatchFiles, "source.maxBatchFiles");
+}
+/** Parse untrusted editor/authoring JSON before the graph walker touches it. */
+export function parseAutomationDefinition(value) {
+    const input = object(value, "definition");
+    let serialized;
+    try {
+        serialized = JSON.stringify(input);
+    }
+    catch {
+        invalid("definition");
+    }
+    if (Buffer.byteLength(serialized, "utf8") > MAX_DEFINITION_BYTES)
+        invalid("definition.size");
+    onlyKeys(input, ["schemaVersion", "automationId", "revision", "title", "objective", "workingDirectory", "trigger", "source", "inputs", "body", "limits"], "definition");
+    if (input.schemaVersion !== 1)
+        invalid("schemaVersion");
+    recordId(input.automationId, "automationId");
+    positiveInteger(input.revision, "revision");
+    text(input.title, "title", 160);
+    text(input.objective, "objective");
+    if (input.workingDirectory !== undefined)
+        text(input.workingDirectory, "workingDirectory", 1_024);
+    trigger(input.trigger);
+    if (input.source !== undefined)
+        source(input.source);
+    jsonValue(input.inputs, "inputs");
+    if (Array.isArray(input.inputs) || input.inputs === null || typeof input.inputs !== "object")
+        invalid("inputs");
+    node(input.body, "body", 0);
+    if (object(input.body, "body").kind !== "sequence")
+        invalid("body.kind");
+    const limits = object(input.limits, "limits");
+    onlyKeys(limits, ["maxConcurrentNodes", "maxModelCallsPerRun", "maxToolCallsPerRun", "maxRunDurationMs", "maxRunsPerDay", "maxStoredArtifactBytes", "stopReportDeadlineMs"], "limits");
+    for (const value of Object.values(limits))
+        positiveInteger(value, "limits");
+    if (Object.keys(limits).length !== 7)
+        invalid("limits");
+    return JSON.parse(serialized);
+}

package/dist/src/runtime/automations/dependency-fingerprint.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeConfig } from "../ports.js";
+import type { AutomationCatalogOperation } from "./catalog.js";
+import type { AutomationRevision } from "./definition-contracts.js";
+/** A published Run must never silently switch its model or tool contract. */
+export declare function fingerprintAutomationDependencies(input: {
+    definition: AutomationRevision;
+    config: RuntimeConfig;
+    operations: readonly AutomationCatalogOperation[];
+}): string;

package/dist/src/runtime/automations/dependency-fingerprint.js

@@ -0,0 +1,55 @@
+import { createHash } from "node:crypto";
+import { compileAutomationGraph } from "./graph-validation.js";
+import { projectAutomationModelDependencies } from "./model-dependency-projection.js";
+function stableJson(value) {
+    return JSON.stringify(value, (_key, item) => item && typeof item === "object" && !Array.isArray(item)
+        ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b)))
+        : item);
+}
+function operationKey(operation) {
+    return JSON.stringify([operation.toolName, operation.operationId, operation.contractVersion]);
+}
+function executionContract(operation) {
+    if (!operation)
+        return null;
+    const hasFixedExecutionParameters = operation.fixedParams !== undefined
+        && Object.keys(operation.fixedParams).length > 0;
+    return {
+        toolName: operation.toolName,
+        operationId: operation.operationId,
+        contractVersion: operation.contractVersion,
+        permissionMode: operation.permissionMode,
+        effect: operation.effect,
+        approval: operation.approval,
+        input: operation.input,
+        ...(hasFixedExecutionParameters ? { fixedParams: operation.fixedParams } : {}),
+        payload: operation.payload ?? null,
+        attachmentInput: operation.attachmentInput ?? null,
+        selectionControlIds: operation.selectionControlIds ?? null,
+    };
+}
+/** A published Run must never silently switch its model or tool contract. */
+export function fingerprintAutomationDependencies(input) {
+    const compiled = compileAutomationGraph(input.definition);
+    if (!compiled.ok)
+        throw new Error("automation_graph_invalid");
+    const selected = [];
+    const agents = [];
+    for (const step of compiled.graph.steps) {
+        if (step.node.kind === "tool")
+            selected.push(step.node.operation);
+        else {
+            agents.push(step.node);
+            selected.push(...step.node.tools.map((item) => item.operation));
+        }
+    }
+    const byKey = new Map(input.operations.map((operation) => [operationKey(operation), operation]));
+    const contracts = [...new Set(selected.map(operationKey))].sort().map((key) => ({
+        key,
+        contract: executionContract(byKey.get(key)),
+    }));
+    return createHash("sha256").update(stableJson({
+        contracts,
+        models: projectAutomationModelDependencies(input.config, agents),
+    })).digest("hex");
+}

package/dist/src/runtime/automations/draft-batch-aliases.d.ts

@@ -0,0 +1,12 @@
+import type { AutomationRevision } from "./definition-contracts.js";
+import type { DraftMutation } from "./draft-mutations.js";
+export declare class AutomationDraftBatchError extends Error {
+    readonly code: string;
+    readonly path: string;
+    readonly commandPath?: string;
+    constructor(code: string, path: string, commandPath?: string);
+}
+/** Only canonical identity slots participate; literal contents remain exact. */
+export declare function resolveDraftBatchMutation(mutation: DraftMutation, aliases: ReadonlyMap<string, string>, path: string): DraftMutation;
+export declare function projectDraftBatchAliases(definition: AutomationRevision, aliases: ReadonlyMap<string, string>): Readonly<Record<string, string>>;
+export declare function registerDraftBatchAlias(alias: string, mutation: DraftMutation, before: AutomationRevision, after: AutomationRevision, aliases: Map<string, string>, path: string): void;

package/dist/src/runtime/automations/draft-batch-aliases.js

@@ -0,0 +1,94 @@
+export class AutomationDraftBatchError extends Error {
+    code;
+    path;
+    commandPath;
+    constructor(code, path, commandPath) {
+        const boundedPath = path.length <= 240 ? path : `${path.slice(0, 240)}…`;
+        super(`${code}:${boundedPath}`);
+        this.code = code;
+        this.path = boundedPath;
+        if (commandPath !== undefined)
+            this.commandPath = commandPath.length <= 240 ? commandPath : `${commandPath.slice(0, 240)}…`;
+        this.name = "AutomationDraftBatchError";
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function resolveIdentity(value, aliases, path) {
+    if (typeof value !== "string" || !value.startsWith("$"))
+        return value;
+    const resolved = aliases.get(value.slice(1));
+    if (!resolved)
+        throw new AutomationDraftBatchError("automation_batch_alias_unknown", path);
+    return resolved;
+}
+function resolveBinding(value, aliases, path) {
+    if (!isRecord(value))
+        return value;
+    if (value.kind === "node_result")
+        return { ...value, nodeId: resolveIdentity(value.nodeId, aliases, `${path}.nodeId`) };
+    if (value.kind === "branch_results")
+        return { ...value, parallelNodeId: resolveIdentity(value.parallelNodeId, aliases, `${path}.parallelNodeId`) };
+    return value;
+}
+function resolveNodeBindings(node, aliases, path) {
+    const resolved = { ...node };
+    for (const key of ["controls", "inputs"]) {
+        const bindings = node[key];
+        if (!isRecord(bindings))
+            continue;
+        resolved[key] = Object.fromEntries(Object.entries(bindings).map(([name, binding]) => [name, resolveBinding(binding, aliases, `${path}.${key}.${name}`)]));
+    }
+    if (Object.hasOwn(node, "payload"))
+        resolved.payload = resolveBinding(node.payload, aliases, `${path}.payload`);
+    return resolved;
+}
+/** Only canonical identity slots participate; literal contents remain exact. */
+export function resolveDraftBatchMutation(mutation, aliases, path) {
+    const id = (value, field) => resolveIdentity(value, aliases, `${path}.${field}`);
+    switch (mutation.kind) {
+        case "add_node":
+            return { ...mutation, parentSequenceId: id(mutation.parentSequenceId, "parentSequenceId"),
+                nodeWithoutId: resolveNodeBindings(mutation.nodeWithoutId, aliases, `${path}.nodeWithoutId`) };
+        case "update_node":
+            return { ...mutation, nodeId: id(mutation.nodeId, "nodeId"),
+                patch: resolveNodeBindings(mutation.patch, aliases, `${path}.patch`) };
+        case "remove_node":
+            return { ...mutation, nodeId: id(mutation.nodeId, "nodeId") };
+        case "move_node":
+            return { ...mutation, nodeId: id(mutation.nodeId, "nodeId"),
+                parentSequenceId: id(mutation.parentSequenceId, "parentSequenceId") };
+        case "wrap_parallel":
+            return { ...mutation, nodeIds: mutation.nodeIds.map((nodeId, index) => id(nodeId, `nodeIds.${index}`)) };
+        case "update_definition":
+            return mutation;
+    }
+}
+function graphNodes(node) {
+    if (node.kind === "sequence")
+        return [node, ...node.children.flatMap(graphNodes)];
+    if (node.kind === "parallel")
+        return [node, ...node.branches.flatMap(graphNodes)];
+    return [node];
+}
+export function projectDraftBatchAliases(definition, aliases) {
+    const existingIds = new Set(graphNodes(definition.body).map(({ id }) => id));
+    return Object.fromEntries([...aliases].filter(([, id]) => existingIds.has(id)));
+}
+export function registerDraftBatchAlias(alias, mutation, before, after, aliases, path) {
+    const createsAliasTarget = mutation.kind === "add_node" || mutation.kind === "wrap_parallel";
+    if (!createsAliasTarget)
+        throw new AutomationDraftBatchError("automation_batch_alias_target_invalid", path);
+    const previous = new Set(graphNodes(before.body).map(({ id }) => id));
+    const added = graphNodes(after.body).filter(({ id }) => !previous.has(id));
+    const targetKind = mutation.kind === "wrap_parallel" ? "parallel" : mutation.nodeWithoutId.kind;
+    const target = added.find((node) => node.kind === targetKind);
+    if (!target)
+        throw new AutomationDraftBatchError("automation_batch_alias_target_missing", path);
+    aliases.set(alias, target.id);
+    if (target.kind !== "parallel")
+        return;
+    for (const [index, branch] of target.branches.entries())
+        aliases.set(`${alias}.branch${index + 1}`, branch.id);
+}

package/dist/src/runtime/automations/draft-batch.d.ts

@@ -0,0 +1,29 @@
+import type { AutomationRevision } from "./definition-contracts.js";
+import { type DraftMutation } from "./draft-mutations.js";
+import { type AutomationGraphIssue } from "./graph-validation.js";
+import { AutomationDraftBatchError } from "./draft-batch-aliases.js";
+export { AutomationDraftBatchError } from "./draft-batch-aliases.js";
+export declare const AUTOMATION_DRAFT_BATCH_LIMITS: Readonly<{
+    commands: 32;
+    bytes: number;
+}>;
+type DraftBatchCommand = Readonly<{
+    as?: string;
+    mutation: DraftMutation;
+}>;
+export type AutomationDraftBatch = Readonly<{
+    version: 1;
+    commands: readonly DraftBatchCommand[];
+}>;
+export type AutomationDraftBatchResult = Readonly<{
+    definition: AutomationRevision;
+    aliases: Readonly<Record<string, string>>;
+}>;
+export declare class AutomationDraftBatchGraphError extends AutomationDraftBatchError {
+    readonly issues: readonly AutomationGraphIssue[];
+    readonly omittedIssueCount: number;
+    constructor(issues: readonly AutomationGraphIssue[]);
+}
+export declare function parseAutomationDraftBatch(value: unknown): AutomationDraftBatch;
+/** No journal writes occur here; empty roots remain editable drafts, never executable graphs. */
+export declare function applyAutomationDraftBatch(current: AutomationRevision, plan: AutomationDraftBatch, revision: number): AutomationDraftBatchResult;

package/dist/src/runtime/automations/draft-batch.js

@@ -0,0 +1,147 @@
+import { parseAutomationDefinition } from "./definition-input.js";
+import { applyDraftMutation, parseDraftMutation } from "./draft-mutations.js";
+import { compileAutomationGraph } from "./graph-validation.js";
+import { AutomationDraftBatchError, projectDraftBatchAliases, registerDraftBatchAlias, resolveDraftBatchMutation } from "./draft-batch-aliases.js";
+export { AutomationDraftBatchError } from "./draft-batch-aliases.js";
+export const AUTOMATION_DRAFT_BATCH_LIMITS = Object.freeze({ commands: 32, bytes: 32 * 1024 });
+export class AutomationDraftBatchGraphError extends AutomationDraftBatchError {
+    issues;
+    omittedIssueCount;
+    constructor(issues) {
+        super(issues[0].code, issues[0].path);
+        this.issues = issues.slice(0, 8);
+        this.omittedIssueCount = Math.max(0, issues.length - this.issues.length);
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function requireRecord(value, path) {
+    if (!isRecord(value))
+        throw new AutomationDraftBatchError("automation_batch_invalid", path);
+    return value;
+}
+function requireKnownFields(record, fields, path) {
+    const unknown = Object.keys(record).find((key) => !fields.includes(key));
+    if (unknown !== undefined)
+        throw new AutomationDraftBatchError("automation_batch_field_unknown", `${path}.${unknown}`);
+}
+const MUTATION_FIELDS = {
+    add_node: ["kind", "parentSequenceId", "index", "nodeWithoutId"],
+    update_node: ["kind", "nodeId", "patch"],
+    remove_node: ["kind", "nodeId"],
+    move_node: ["kind", "nodeId", "parentSequenceId", "index"],
+    wrap_parallel: ["kind", "nodeIds"],
+    update_definition: ["kind", "patch"],
+};
+function isKnownMutationKind(value) {
+    if (typeof value !== "string")
+        return false;
+    return Object.hasOwn(MUTATION_FIELDS, value);
+}
+function requireMutationFields(input, fields, path) {
+    const missing = fields.find((field) => !Object.hasOwn(input, field));
+    if (missing !== undefined)
+        throw new AutomationDraftBatchError("automation_batch_field_required", `${path}.${missing}`);
+}
+function parseBatchMutation(value, path) {
+    const input = requireRecord(value, path);
+    requireMutationFields(input, ["kind"], path);
+    if (!isKnownMutationKind(input.kind))
+        throw new AutomationDraftBatchError("automation_batch_mutation_kind_invalid", `${path}.kind`);
+    const fields = MUTATION_FIELDS[input.kind];
+    requireMutationFields(input, fields, path);
+    requireKnownFields(input, fields, path);
+    return withMutationPath(path, () => parseDraftMutation(input));
+}
+function snapshotBatchInput(value) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(value);
+    }
+    catch {
+        throw new AutomationDraftBatchError("automation_batch_invalid", "plan");
+    }
+    if (serialized === undefined)
+        throw new AutomationDraftBatchError("automation_batch_invalid", "plan");
+    if (Buffer.byteLength(serialized, "utf8") > AUTOMATION_DRAFT_BATCH_LIMITS.bytes)
+        throw new AutomationDraftBatchError("automation_batch_too_large", "plan");
+    return JSON.parse(serialized);
+}
+function requireAlias(value, mutation, path, seen) {
+    const isValidAlias = typeof value === "string" && /^[A-Za-z][A-Za-z0-9_-]{0,47}$/u.test(value);
+    if (!isValidAlias || value === "root")
+        throw new AutomationDraftBatchError("automation_batch_alias_invalid", path);
+    if (seen.has(value))
+        throw new AutomationDraftBatchError("automation_batch_alias_duplicate", path);
+    const createsAliasTarget = mutation.kind === "add_node" || mutation.kind === "wrap_parallel";
+    if (!createsAliasTarget)
+        throw new AutomationDraftBatchError("automation_batch_alias_target_invalid", path);
+    seen.add(value);
+    return value;
+}
+function withMutationPath(path, execute) {
+    try {
+        return execute();
+    }
+    catch (error) {
+        if (error instanceof AutomationDraftBatchError)
+            throw error;
+        const definitionIssuePath = error instanceof Error
+            ? /^automation_graph_invalid: (.+)$/u.exec(error.message)?.[1] : undefined;
+        if (definitionIssuePath)
+            throw new AutomationDraftBatchError("automation_graph_invalid", definitionIssuePath, path);
+        const code = error instanceof Error && /^automation_[a-z_]+$/u.test(error.message)
+            ? error.message : "automation_batch_invalid";
+        throw new AutomationDraftBatchError(code, path);
+    }
+}
+export function parseAutomationDraftBatch(value) {
+    const input = requireRecord(snapshotBatchInput(value), "plan");
+    requireKnownFields(input, ["version", "commands"], "plan");
+    if (input.version !== 1)
+        throw new AutomationDraftBatchError("automation_batch_version_invalid", "plan.version");
+    const hasBoundedCommands = Array.isArray(input.commands) && input.commands.length >= 1 &&
+        input.commands.length <= AUTOMATION_DRAFT_BATCH_LIMITS.commands;
+    if (!hasBoundedCommands)
+        throw new AutomationDraftBatchError("automation_batch_commands_invalid", "plan.commands");
+    const aliases = new Set();
+    const commands = input.commands.map((value, index) => {
+        const path = `plan.commands.${index}`;
+        const command = requireRecord(value, path);
+        requireKnownFields(command, ["as", "mutation"], path);
+        const mutation = parseBatchMutation(command.mutation, `${path}.mutation`);
+        if (!Object.hasOwn(command, "as"))
+            return { mutation };
+        return { mutation, as: requireAlias(command.as, mutation, `${path}.as`, aliases) };
+    });
+    return { version: 1, commands };
+}
+function isPermittedEmptyDraft(definition, issues) {
+    if (definition.body.children.length !== 0)
+        return false;
+    if (issues.length !== 1)
+        return false;
+    return issues[0].code === "automation_graph_empty";
+}
+/** No journal writes occur here; empty roots remain editable drafts, never executable graphs. */
+export function applyAutomationDraftBatch(current, plan, revision) {
+    const aliases = new Map([["root", current.body.id]]);
+    let definition = current;
+    for (const [index, command] of plan.commands.entries()) {
+        const path = `plan.commands.${index}`;
+        const mutation = resolveDraftBatchMutation(command.mutation, aliases, `${path}.mutation`);
+        const previous = definition;
+        definition = withMutationPath(`${path}.mutation`, () => applyDraftMutation({ ...definition, revision: current.revision }, mutation));
+        if (command.as)
+            registerDraftBatchAlias(command.as, mutation, previous, definition, aliases, `${path}.as`);
+    }
+    definition = withMutationPath("plan", () => parseAutomationDefinition({ ...definition, revision }));
+    const compiled = compileAutomationGraph(definition);
+    const result = { definition, aliases: projectDraftBatchAliases(definition, aliases) };
+    if (compiled.ok)
+        return result;
+    if (isPermittedEmptyDraft(definition, compiled.issues))
+        return result;
+    throw new AutomationDraftBatchGraphError(compiled.issues);
+}