@openmbee/opensysml 0.9.1 → 0.10.0

package/dist/core/edit.js

@@ -0,0 +1,1994 @@
+// Changing a loaded model and writing it back, with its layout intact.
+//
+// An edit is described, not typed out: an Editor collects operations naming
+// elements the way a read result names them, and `apply()` has the service
+// perform them on the source it parsed. The service edits the bytes the
+// operations reach and nothing else, so comments, blank lines and indentation
+// outside an edited span come back unchanged, and it re-parses what it edited
+// before returning it.
+import { create } from "@bufbuild/protobuf";
+import { AddCommentEditSchema, AddConnectionEditSchema, AddDocumentationEditSchema, AddImportEditSchema, AddMemberEditSchema, AddMetadataEditSchema, AddMetadataPrefixEditSchema, AddNoteEditSchema, AddRequirementConstraintEditSchema, AddSatisfyEditSchema, AddSequenceEditSchema, AddTransitionEditSchema, AddVerifyEditSchema, DeleteEditSchema, EditFailure, EditOperationSchema, MetadataFeatureValueSchema, MoveEditSchema, RenameEditSchema, SetValueEditSchema, } from "../generated/sysml_pb.js";
+import { CAPABILITY_ACTION_BODY_STATEMENT_AUTHORING, CAPABILITY_APPLY_EDITS, CAPABILITY_AUTHORING, CAPABILITY_COMMENT_AUTHORING, CAPABILITY_CONNECTION_AUTHORING, CAPABILITY_CONSTRAINT_BODY_AUTHORING, CAPABILITY_DOCUMENTATION_AUTHORING, CAPABILITY_IMPORT_AUTHORING, CAPABILITY_IMPLICIT_PARAMETERS, CAPABILITY_MEMBER_MODIFIERS, CAPABILITY_METADATA_AUTHORING, CAPABILITY_METADATA_PREFIX_AUTHORING, CAPABILITY_REQUIREMENT_CONSTRAINT_AUTHORING, CAPABILITY_SATISFY_AUTHORING, CAPABILITY_SEQUENCE_AUTHORING, CAPABILITY_STATE_ACTION_AUTHORING, CAPABILITY_TRANSITION_AUTHORING, CAPABILITY_VERIFICATION_OBJECTIVE_AUTHORING, byCodeUnit, requireCapability, upgradeRemedy, } from "./capabilities.js";
+import { Conversion, FORMAT_SYSML } from "./conversion.js";
+import { DeleteReferencedError, EditError, EditResultError, EditTargetError, IllegalMemberKindError, InvalidEditError, MemberNameTakenError, MoveReferencedError, NoEditsError, OverlappingEditsError, OwnerInsideTargetError, OwnerNotFoundError, OwnerNotNamespaceError, ReferencedElsewhereError, RenameReferencedError, Referrer, } from "./errors.js";
+import { decodeDiagnostic } from "./model.js";
+/** One byte range an operation replaced in the source it saw. */
+export class AppliedEdit {
+    /** Position of the operation in the editor. */
+    operationIndex;
+    /** Element edited, by the id it was named with. */
+    target;
+    /** Byte offset where the replacement starts. */
+    offset;
+    /** Number of bytes replaced; zero when text was only inserted. */
+    length;
+    /** The bytes that were there. */
+    oldText;
+    /** What replaced them. */
+    newText;
+    /** The document the bytes belong to, named as the parse named it. */
+    document;
+    constructor(init) {
+        this.operationIndex = init.operationIndex;
+        this.target = init.target;
+        this.offset = init.offset;
+        this.length = init.length;
+        this.oldText = init.oldText;
+        this.newText = init.newText;
+        this.document = init.document;
+    }
+    toString() {
+        return `${this.target}: ${JSON.stringify(this.oldText)} -> ${JSON.stringify(this.newText)}`;
+    }
+}
+/** The edited notation of one document of the model. */
+export class EditedDocument {
+    /** The document's name as the parse named it. */
+    name;
+    /** The edited notation, byte-identical to the source outside the edited spans. */
+    content;
+    constructor(init) {
+        this.name = init.name;
+        this.content = init.content;
+    }
+    toString() {
+        return this.content;
+    }
+}
+/** The edited notation, as a {@link Conversion}. */
+export class EditResult extends Conversion {
+    /** What each operation changed, grouped by document, in source order within one. */
+    applied;
+    /** The edited notation of every document the edits rewrote, edited document first. */
+    documents;
+    constructor(init) {
+        super(init);
+        this.applied = init.applied;
+        this.documents = init.documents;
+    }
+}
+/** Refusal kinds, as the wire enum names them, and the error each raises. */
+const FAILURE_ERRORS = new Map([
+    ["EDIT_FAILURE_NO_OPERATIONS", NoEditsError],
+    ["EDIT_FAILURE_UNKNOWN_TARGET", EditTargetError],
+    ["EDIT_FAILURE_AMBIGUOUS_TARGET", EditTargetError],
+    ["EDIT_FAILURE_NOT_VALUED", EditTargetError],
+    ["EDIT_FAILURE_NOT_NAMED", EditTargetError],
+    ["EDIT_FAILURE_INVALID_VALUE", InvalidEditError],
+    ["EDIT_FAILURE_INVALID_NAME", InvalidEditError],
+    ["EDIT_FAILURE_RENAME_REFERENCED", RenameReferencedError],
+    ["EDIT_FAILURE_OVERLAPPING_EDITS", OverlappingEditsError],
+    ["EDIT_FAILURE_RESULT_INVALID", EditResultError],
+    ["EDIT_FAILURE_OWNER_UNKNOWN", OwnerNotFoundError],
+    ["EDIT_FAILURE_OWNER_NOT_NAMESPACE", OwnerNotNamespaceError],
+    ["EDIT_FAILURE_ILLEGAL_KIND", IllegalMemberKindError],
+    ["EDIT_FAILURE_MEMBER_NAME_TAKEN", MemberNameTakenError],
+    ["EDIT_FAILURE_DELETE_REFERENCED", DeleteReferencedError],
+    ["EDIT_FAILURE_OWNER_INSIDE_TARGET", OwnerInsideTargetError],
+    ["EDIT_FAILURE_MOVE_REFERENCED", MoveReferencedError],
+    ["EDIT_FAILURE_REFERENCED_ELSEWHERE", ReferencedElsewhereError],
+]);
+const FAILURE_NAMES = new Map([
+    [EditFailure.UNSPECIFIED, "EDIT_FAILURE_UNSPECIFIED"],
+    [EditFailure.NO_OPERATIONS, "EDIT_FAILURE_NO_OPERATIONS"],
+    [EditFailure.UNKNOWN_TARGET, "EDIT_FAILURE_UNKNOWN_TARGET"],
+    [EditFailure.AMBIGUOUS_TARGET, "EDIT_FAILURE_AMBIGUOUS_TARGET"],
+    [EditFailure.NOT_VALUED, "EDIT_FAILURE_NOT_VALUED"],
+    [EditFailure.INVALID_VALUE, "EDIT_FAILURE_INVALID_VALUE"],
+    [EditFailure.INVALID_NAME, "EDIT_FAILURE_INVALID_NAME"],
+    [EditFailure.NOT_NAMED, "EDIT_FAILURE_NOT_NAMED"],
+    [EditFailure.RENAME_REFERENCED, "EDIT_FAILURE_RENAME_REFERENCED"],
+    [EditFailure.OVERLAPPING_EDITS, "EDIT_FAILURE_OVERLAPPING_EDITS"],
+    [EditFailure.RESULT_INVALID, "EDIT_FAILURE_RESULT_INVALID"],
+    [EditFailure.OWNER_UNKNOWN, "EDIT_FAILURE_OWNER_UNKNOWN"],
+    [EditFailure.OWNER_NOT_NAMESPACE, "EDIT_FAILURE_OWNER_NOT_NAMESPACE"],
+    [EditFailure.ILLEGAL_KIND, "EDIT_FAILURE_ILLEGAL_KIND"],
+    [EditFailure.MEMBER_NAME_TAKEN, "EDIT_FAILURE_MEMBER_NAME_TAKEN"],
+    [EditFailure.DELETE_REFERENCED, "EDIT_FAILURE_DELETE_REFERENCED"],
+    [EditFailure.OWNER_INSIDE_TARGET, "EDIT_FAILURE_OWNER_INSIDE_TARGET"],
+    [EditFailure.MOVE_REFERENCED, "EDIT_FAILURE_MOVE_REFERENCED"],
+    [EditFailure.REFERENCED_ELSEWHERE, "EDIT_FAILURE_REFERENCED_ELSEWHERE"],
+]);
+/** Name a refusal kind, including one this client's enum has no name for. */
+export function failureName(failure) {
+    return FAILURE_NAMES.get(failure) ?? `EDIT_FAILURE_${failure}`;
+}
+/** Build the error a refusal kind names. */
+export function errorForFailure(failure, message, options = {}) {
+    const ctor = FAILURE_ERRORS.get(failure) ?? EditError;
+    return new ctor(message, { failure, ...options });
+}
+/** The referrers of an `ApplyEditsResponse`, each with the document declaring it. */
+export function referrersOf(response) {
+    return response.referrers.map((referrer) => new Referrer(referrer.name, referrer.document));
+}
+/** Read an `ApplyEditsResponse` as an {@link EditResult}. */
+export function editResultOf(response, appliedSource = FORMAT_SYSML) {
+    return new EditResult({
+        content: response.content,
+        fromFormat: appliedSource,
+        toFormat: appliedSource,
+        diagnostics: [],
+        experimental: false,
+        experimentalNotice: "",
+        applied: response.applied.map((edit) => new AppliedEdit({
+            operationIndex: edit.operationIndex,
+            target: edit.target,
+            offset: edit.offset,
+            length: edit.length,
+            oldText: edit.oldText,
+            newText: edit.newText,
+            document: edit.document,
+        })),
+        documents: response.documents.map((document) => new EditedDocument({ name: document.name, content: document.content })),
+    });
+}
+/** The refusal an `ApplyEditsResponse` carries, as a typed error, or undefined. */
+export function editErrorOf(response) {
+    if (response.error === "") {
+        return undefined;
+    }
+    return errorForFailure(failureName(response.failure), response.error, {
+        diagnostics: response.diagnostics.map(decodeDiagnostic),
+        referringElements: response.referringElements,
+        referrers: referrersOf(response),
+    });
+}
+function nameOf(value) {
+    if (value === null) {
+        return "null";
+    }
+    return typeof value;
+}
+function sequenceText(label, value, optional = false) {
+    if (value === undefined && optional) {
+        return;
+    }
+    if (typeof value !== "string") {
+        throw new TypeError(`${label} must be notation text, not ${nameOf(value)}`);
+    }
+}
+function sequenceTuple(owner, keyword, slots, fields) {
+    const operation = [
+        "add_sequence", owner, keyword, slots.ref, slots.memberKind, slots.memberName, slots.typeName, slots.after,
+    ];
+    if (fields !== undefined && Object.keys(fields).length > 0) {
+        operation.push(fields);
+    }
+    return operation;
+}
+function sequenceOptions(after, multiplicity) {
+    sequenceText("multiplicity", multiplicity, true);
+    sequenceText("after", after, true);
+    return [after ?? "", multiplicity];
+}
+function sequenceKeywordOptions(keyword, options) {
+    if (options[1] !== undefined && keyword !== "then") {
+        throw new RangeError("multiplicity requires then=True");
+    }
+}
+function sequenceStatement(owner, keyword, memberKind = "", fields = {}, options) {
+    const rest = { ...fields };
+    const opts = options?.options ??
+        sequenceOptions((options?.after ?? rest["after"]), (options?.multiplicity ?? rest["multiplicity"]));
+    delete rest["after"];
+    delete rest["multiplicity"];
+    const [after, multiplicity] = opts;
+    if (multiplicity !== undefined) {
+        rest["multiplicity"] = multiplicity;
+    }
+    return sequenceTuple(owner, keyword, {
+        ref: options?.ref ?? "",
+        memberKind,
+        memberName: options?.memberName ?? "",
+        typeName: options?.typeName ?? "",
+        after,
+    }, rest);
+}
+/** Chainable action-body items for nested `if` and loop statements. */
+export class Body {
+    #operations = [];
+    /** The body items collected so far. */
+    get operations() {
+        return [...this.#operations];
+    }
+    #keyword(then) {
+        if (then === undefined) {
+            return this.#operations.length === 0 ? "" : "then";
+        }
+        if (typeof then !== "boolean") {
+            throw new TypeError(`then must be bool or None, not ${nameOf(then)}`);
+        }
+        return then ? "then" : "";
+    }
+    #addStatement(kind, options) {
+        const fields = { ...options };
+        delete fields.chained;
+        delete fields.typeName;
+        const opts = sequenceOptions(fields["after"], fields["multiplicity"]);
+        delete fields.after;
+        delete fields.multiplicity;
+        const keyword = this.#keyword(options.chained);
+        sequenceKeywordOptions(keyword, opts);
+        this.#operations.push(sequenceStatement("", keyword, kind, fields, {
+            typeName: options.typeName ?? "",
+            options: opts,
+        }));
+        return this;
+    }
+    /** Emit `first <ref>;`. */
+    addFirst(ref) {
+        sequenceText("ref", ref);
+        this.#operations.push(sequenceStatement("", "first", "", {}, { ref }));
+        return this;
+    }
+    /** Emit `then [m] <ref>;` or `then [m] <kind> <action> : <type>;`. */
+    addThen(ref, action, options = {}) {
+        const { type, kind = "action", multiplicity } = options;
+        for (const [label, text] of [
+            ["ref", ref],
+            ["action", action],
+            ["type", type],
+            ["kind", kind],
+            ["multiplicity", multiplicity],
+        ]) {
+            sequenceText(label, text, true);
+        }
+        const opts = ["", multiplicity];
+        if ((ref === undefined) === (action === undefined)) {
+            throw new RangeError("exactly one of ref and action is required");
+        }
+        if (ref !== undefined) {
+            if (type !== undefined || kind !== "action") {
+                throw new RangeError("a then reference takes no type or kind");
+            }
+            this.#operations.push(sequenceStatement("", "then", "", {}, { ref, options: opts }));
+        }
+        else {
+            this.#operations.push(sequenceStatement("", "then", kind, {}, {
+                memberName: action,
+                typeName: type ?? "",
+                options: opts,
+            }));
+        }
+        return this;
+    }
+    /** Emit `<kind> <name> : <type>;`. */
+    addAction(name, options = {}) {
+        const { type, kind = "action" } = options;
+        for (const [label, text] of [
+            ["name", name],
+            ["type", type],
+            ["kind", kind],
+        ]) {
+            sequenceText(label, text, true);
+        }
+        this.#operations.push(sequenceStatement("", "", kind, {}, {
+            memberName: name ?? "",
+            typeName: type ?? "",
+        }));
+        return this;
+    }
+    /** Emit `accept <payload> [: <type>] [via <via>];` or `then [m] accept ...;`. */
+    addAccept(payload, options = {}) {
+        const { type, via, then, multiplicity } = options;
+        sequenceText("payload", payload);
+        sequenceText("type", type, true);
+        sequenceText("via", via, true);
+        return this.#addStatement("accept", {
+            chained: then,
+            typeName: type ?? "",
+            parameter: payload,
+            via: via ?? "",
+            multiplicity,
+        });
+    }
+    /** Emit `send <payload> [via <via>] [to <to>];` or `then [m] send ...;`. */
+    addSend(payload, options = {}) {
+        const { to, via, then, multiplicity } = options;
+        sequenceText("payload", payload);
+        sequenceText("to", to, true);
+        sequenceText("via", via, true);
+        return this.#addStatement("send", {
+            chained: then,
+            value: payload,
+            target: to ?? "",
+            via: via ?? "",
+            multiplicity,
+        });
+    }
+    /** Emit `assign <target> := <value>;` or `then [m] assign ...;`. */
+    addAssign(target, value, options = {}) {
+        const { then, multiplicity } = options;
+        sequenceText("target", target);
+        sequenceText("value", value);
+        return this.#addStatement("assign", { chained: then, target, value, multiplicity });
+    }
+    /** Emit `if <condition> { <body> } [else { <elseBody> }]` or `then [m] if ...`. */
+    addIf(condition, body, elseBody, options = {}) {
+        const { then, multiplicity } = options;
+        sequenceText("condition", condition);
+        if (!(body instanceof Body)) {
+            throw new TypeError(`body must be Body, not ${nameOf(body)}`);
+        }
+        if (elseBody !== undefined && !(elseBody instanceof Body)) {
+            throw new TypeError(`else_body must be Body or None, not ${nameOf(elseBody)}`);
+        }
+        return this.#addStatement("if", {
+            chained: then,
+            condition,
+            body: body.operations,
+            else_body: elseBody !== undefined && elseBody.operations.length > 0 ? elseBody.operations : [],
+            multiplicity,
+        });
+    }
+    /** Emit `while <condition> { <body> } [until <until>];` or `then [m] while ...`. */
+    addWhile(condition, body, options = {}) {
+        const { until, then, multiplicity } = options;
+        sequenceText("condition", condition);
+        sequenceText("until", until, true);
+        if (!(body instanceof Body)) {
+            throw new TypeError(`body must be Body, not ${nameOf(body)}`);
+        }
+        return this.#addStatement("while", {
+            chained: then,
+            condition,
+            until: until ?? "",
+            body: body.operations,
+            multiplicity,
+        });
+    }
+    /** Emit `loop { <body> } [until <until>];` or `then [m] loop ...`. */
+    addLoop(body, options = {}) {
+        const { until, then, multiplicity } = options;
+        sequenceText("until", until, true);
+        if (!(body instanceof Body)) {
+            throw new TypeError(`body must be Body, not ${nameOf(body)}`);
+        }
+        return this.#addStatement("loop", {
+            chained: then,
+            until: until ?? "",
+            body: body.operations,
+            multiplicity,
+        });
+    }
+    /** Emit `for <variable> [: <type>] in <collection> { <body> }` or `then [m] for ...`. */
+    addFor(variable, collection, body, options = {}) {
+        const { type, then, multiplicity } = options;
+        sequenceText("variable", variable);
+        sequenceText("collection", collection);
+        sequenceText("type", type, true);
+        if (!(body instanceof Body)) {
+            throw new TypeError(`body must be Body, not ${nameOf(body)}`);
+        }
+        return this.#addStatement("for", {
+            chained: then,
+            parameter: variable,
+            value: collection,
+            typeName: type ?? "",
+            body: body.operations,
+            multiplicity,
+        });
+    }
+    /** Emit `terminate [<occurrence>];` or `then [m] terminate ...;`. */
+    addTerminate(occurrence, options = {}) {
+        const { then, multiplicity } = options;
+        sequenceText("occurrence", occurrence, true);
+        return this.#addStatement("terminate", {
+            chained: then,
+            value: occurrence ?? "",
+            multiplicity,
+        });
+    }
+    /** Emit `if <guard> then <ref>;`. */
+    addGuardedThen(guard, ref) {
+        sequenceText("guard", guard);
+        sequenceText("ref", ref);
+        this.#operations.push(sequenceStatement("", "if", "", { condition: guard }, { ref }));
+        return this;
+    }
+    /** Emit `else <ref>;`. */
+    addElse(ref) {
+        sequenceText("ref", ref);
+        this.#operations.push(sequenceStatement("", "else", "", {}, { ref }));
+        return this;
+    }
+}
+function notationReferences(label, values) {
+    if (values === undefined) {
+        return [];
+    }
+    const references = typeof values === "string" ? [values] : [...values];
+    if (!Array.isArray(references)) {
+        throw new TypeError(`${label} must be a notation string or sequence of strings`);
+    }
+    if (!references.every((reference) => typeof reference === "string")) {
+        throw new TypeError(`${label} must contain only notation strings`);
+    }
+    return references;
+}
+function parameterPairs(parameters, argument) {
+    if (parameters === undefined) {
+        return [];
+    }
+    if (!Array.isArray(parameters)) {
+        throw new TypeError(`${argument} must be a list of 2-tuples of strings, not ${nameOf(parameters)}`);
+    }
+    return parameters.map((pair, index) => {
+        if (!Array.isArray(pair) || pair.length !== 2) {
+            throw new TypeError(`${argument}[${index}] must be a 2-tuple of strings`);
+        }
+        if (!pair.every((value) => typeof value === "string")) {
+            throw new TypeError(`${argument}[${index}] name and type must be strings`);
+        }
+        return [pair[0], pair[1]];
+    });
+}
+function optionalText(value, argument) {
+    if (value !== undefined && typeof value !== "string") {
+        throw new TypeError(`${argument} must be notation text or None, not ${nameOf(value)}`);
+    }
+}
+function targetId(target) {
+    if (typeof target === "string") {
+        return target;
+    }
+    const ident = target?.id;
+    if (typeof ident === "string" && ident !== "") {
+        return ident;
+    }
+    throw new TypeError(`target must be a symbol id (FQN) or a Symbol, not ${nameOf(target)}`);
+}
+function ownerId(owner) {
+    return typeof owner === "string" ? owner : targetId(owner);
+}
+/** Operations to perform on a loaded model, and the call that performs them. */
+export class Editor {
+    #modelHash;
+    #apply;
+    #operations = [];
+    #applied = false;
+    constructor(modelHash, apply) {
+        this.#modelHash = modelHash;
+        this.#apply = apply;
+    }
+    /** The operations collected so far, in the order they were added. */
+    get operations() {
+        return [...this.#operations];
+    }
+    /** Whether this editor has been applied. */
+    get applied() {
+        return this.#applied;
+    }
+    /** How many operations are collected. */
+    get length() {
+        return this.#operations.length;
+    }
+    /** Set the value expression of one of the model's features. */
+    setValue(target, value) {
+        if (typeof value !== "string") {
+            throw new TypeError(`value must be SysML notation for an expression, not ${nameOf(value)}: ` +
+                "write it as it should read in the file");
+        }
+        this.#add(["set_value", targetId(target), value]);
+        return this;
+    }
+    /** Rename one of the model's declarations. */
+    rename(target, newName) {
+        if (typeof newName !== "string") {
+            throw new TypeError(`new_name must be a name, not ${nameOf(newName)}`);
+        }
+        this.#add(["rename", targetId(target), newName]);
+        return this;
+    }
+    /** Add one declaration, using strings for all SysML/KerML notation. */
+    addMember(owner, kind, name, options = {}) {
+        const { type, multiplicity, value, specializes, abstract = false, redefines, default: isDefault = false, direction, metadata, expression, doc, } = options;
+        if (typeof kind !== "string") {
+            throw new TypeError(`kind must be notation text, not ${nameOf(kind)}`);
+        }
+        for (const [label, text] of [
+            ["kind", kind],
+            ["type", type],
+            ["multiplicity", multiplicity],
+            ["value", value],
+            ["expression", expression],
+        ]) {
+            if (text !== undefined && typeof text !== "string") {
+                throw new TypeError(`${label} must be notation text, not ${nameOf(text)}`);
+            }
+        }
+        if (typeof name !== "string") {
+            throw new TypeError(`name must be notation text, not ${nameOf(name)}`);
+        }
+        const ownerName = ownerId(owner);
+        const specializeList = notationReferences("specializes", specializes);
+        const redefineList = notationReferences("redefines", redefines);
+        const hasMetadata = metadata !== undefined;
+        const metadataList = notationReferences("metadata", metadata);
+        if (typeof abstract !== "boolean") {
+            throw new TypeError("abstract must be bool");
+        }
+        if (typeof isDefault !== "boolean") {
+            throw new TypeError("default must be bool");
+        }
+        if (direction !== undefined && typeof direction !== "string") {
+            throw new TypeError(`direction must be notation text, not ${nameOf(direction)}`);
+        }
+        if (doc !== undefined && typeof doc !== "string") {
+            throw new TypeError(`doc must be text, not ${nameOf(doc)}`);
+        }
+        const base = [
+            "add_member", ownerName, kind, name, type ?? "", multiplicity ?? "",
+            value ?? "", [...specializeList],
+        ];
+        if (abstract ||
+            redefineList.length > 0 ||
+            isDefault ||
+            direction !== undefined ||
+            hasMetadata ||
+            kind === "ref" ||
+            kind === "return" ||
+            kind === "" ||
+            expression !== undefined ||
+            doc !== undefined) {
+            base.push(abstract, [...redefineList], isDefault, direction ?? "");
+        }
+        if (hasMetadata) {
+            base.push([...metadataList]);
+        }
+        if (expression !== undefined || doc !== undefined) {
+            base.push(expression ?? "");
+        }
+        if (doc !== undefined) {
+            base.push(doc);
+        }
+        this.#add(base);
+        return this;
+    }
+    /** Add an `objective` member, unnamed when `name` is omitted. */
+    addObjective(owner, options = {}) {
+        const { name, type } = options;
+        if (name !== undefined && typeof name !== "string") {
+            throw new TypeError(`name must be notation text, not ${nameOf(name)}`);
+        }
+        if (type !== undefined && typeof type !== "string") {
+            throw new TypeError(`type must be notation text, not ${nameOf(type)}`);
+        }
+        return this.addMember(owner, "objective", name ?? "", { type });
+    }
+    /** Add `verify <requirement>;` to a verification case or its objective. */
+    addVerify(owner, requirement) {
+        if (typeof requirement !== "string") {
+            throw new TypeError(`requirement must be notation text, not ${nameOf(requirement)}`);
+        }
+        this.#add(["add_verify", ownerId(owner), requirement]);
+        return this;
+    }
+    /** Add a `metadata` usage or `@` shorthand with optional values. */
+    addMetadata(owner, metadataType, options = {}) {
+        const { values, name, about, shorthand = false } = options;
+        if (typeof metadataType !== "string") {
+            throw new TypeError(`metadata_type must be notation text, not ${nameOf(metadataType)}`);
+        }
+        if (name !== undefined && typeof name !== "string") {
+            throw new TypeError(`name must be notation text, not ${nameOf(name)}`);
+        }
+        if (typeof shorthand !== "boolean") {
+            throw new TypeError("shorthand must be bool");
+        }
+        let bindings;
+        if (values === undefined) {
+            bindings = [];
+        }
+        else if (Array.isArray(values)) {
+            bindings = values;
+        }
+        else if (typeof values === "object") {
+            bindings = Object.entries(values);
+        }
+        else {
+            throw new TypeError("values must be a mapping or a sequence of (feature, value) pairs");
+        }
+        const normalized = bindings.map((pair, index) => {
+            if (!Array.isArray(pair) || pair.length !== 2) {
+                throw new TypeError(`values[${index}] must be a pair of strings`);
+            }
+            if (!pair.every((text) => typeof text === "string")) {
+                throw new TypeError(`values[${index}] feature and value must be strings`);
+            }
+            return [pair[0], pair[1]];
+        });
+        const aboutList = notationReferences("about", about);
+        this.#add([
+            "add_metadata", ownerId(owner), metadataType, name ?? "", aboutList, normalized, shorthand,
+        ]);
+        return this;
+    }
+    /** Add a metadata prefix to an existing declaration. */
+    addMetadataPrefix(target, metadataType) {
+        if (typeof metadataType !== "string") {
+            throw new TypeError(`metadata_type must be notation text, not ${nameOf(metadataType)}`);
+        }
+        this.#add(["add_metadata_prefix", ownerId(target), metadataType]);
+        return this;
+    }
+    /** Add `doc /* body *\/` as the first body member of a declaration. */
+    addDocumentation(target, body, options = {}) {
+        const { name, locale, replace = false } = options;
+        if (typeof body !== "string") {
+            throw new TypeError(`body must be text, not ${nameOf(body)}`);
+        }
+        for (const [label, text] of [
+            ["name", name],
+            ["locale", locale],
+        ]) {
+            if (text !== undefined && typeof text !== "string") {
+                throw new TypeError(`${label} must be text, not ${nameOf(text)}`);
+            }
+        }
+        if (typeof replace !== "boolean") {
+            throw new TypeError(`replace must be a bool, not ${nameOf(replace)}`);
+        }
+        this.#add([
+            "add_documentation", targetId(target), body, name ?? "", locale ?? "", replace,
+        ]);
+        return this;
+    }
+    /** Add `comment [name] [about a, b] [locale "..."] /* body *\/` to a body. */
+    addComment(owner, body, options = {}) {
+        const { name, about, locale } = options;
+        if (typeof body !== "string") {
+            throw new TypeError(`body must be text, not ${nameOf(body)}`);
+        }
+        for (const [label, text] of [
+            ["name", name],
+            ["locale", locale],
+        ]) {
+            if (text !== undefined && typeof text !== "string") {
+                throw new TypeError(`${label} must be text, not ${nameOf(text)}`);
+            }
+        }
+        if (typeof about === "string") {
+            throw new TypeError("about must be a sequence of names or symbols, not one name");
+        }
+        const aboutList = (about ?? []).map((element) => targetId(element));
+        this.#add(["add_comment", ownerId(owner), body, name ?? "", aboutList, locale ?? ""]);
+        return this;
+    }
+    /** Write the line note `// text` on its own line above a declaration. */
+    addNote(target, text) {
+        if (typeof text !== "string") {
+            throw new TypeError(`text must be text, not ${nameOf(text)}`);
+        }
+        if (text.includes("\n") || text.includes("\r")) {
+            throw new RangeError("a note is one line: its text may not contain a line break");
+        }
+        this.#add(["add_note", targetId(target), text]);
+        return this;
+    }
+    /** Add a `satisfy` usage to a body that admits behavior usages. */
+    addSatisfy(owner, requirement, options = {}) {
+        const { by, asserted = false, negated = false } = options;
+        if (typeof requirement !== "string") {
+            throw new TypeError(`requirement must be notation text, not ${nameOf(requirement)}`);
+        }
+        if (by !== undefined && typeof by !== "string") {
+            throw new TypeError(`by must be notation text, not ${nameOf(by)}`);
+        }
+        if (typeof asserted !== "boolean" || typeof negated !== "boolean") {
+            throw new TypeError("asserted and negated must be bool");
+        }
+        this.#add(["add_satisfy", ownerId(owner), requirement, by ?? "", asserted, negated]);
+        return this;
+    }
+    /** Add a `require` or `assume` constraint to a requirement-like body. */
+    addRequirementConstraint(owner, kind, expression, name) {
+        for (const [label, text] of [
+            ["kind", kind],
+            ["expression", expression],
+        ]) {
+            if (typeof text !== "string") {
+                throw new TypeError(`${label} must be notation text, not ${nameOf(text)}`);
+            }
+        }
+        if (name !== undefined && typeof name !== "string") {
+            throw new TypeError(`name must be notation text, not ${nameOf(name)}`);
+        }
+        this.#add(["add_requirement_constraint", ownerId(owner), kind, expression, name ?? ""]);
+        return this;
+    }
+    /** Add a transition with optional trigger, guard and effect clauses. */
+    addTransition(owner, source, target, options = {}) {
+        const { name, trigger, guard, effect } = options;
+        if (typeof source !== "string") {
+            throw new TypeError(`source must be notation text, not ${nameOf(source)}`);
+        }
+        if (typeof target !== "string") {
+            throw new TypeError(`target must be notation text, not ${nameOf(target)}`);
+        }
+        for (const [label, text] of [
+            ["name", name],
+            ["trigger", trigger],
+            ["guard", guard],
+            ["effect", effect],
+        ]) {
+            if (text !== undefined && typeof text !== "string") {
+                throw new TypeError(`${label} must be notation text, not ${nameOf(text)}`);
+            }
+        }
+        this.#add([
+            "add_transition", ownerId(owner), name ?? "", source, target,
+            trigger ?? "", guard ?? "", effect ?? "", false,
+        ]);
+        return this;
+    }
+    /** Add an entry transition to target in a state body. */
+    addEntryTransition(owner, target) {
+        if (typeof target !== "string") {
+            throw new TypeError(`target must be notation text, not ${nameOf(target)}`);
+        }
+        this.#add(["add_transition", ownerId(owner), "", "", target, "", "", "", true]);
+        return this;
+    }
+    /** Emit `first <ref>;`. */
+    addFirst(owner, ref, options = {}) {
+        const { after } = options;
+        if (typeof ref !== "string") {
+            throw new TypeError(`ref must be notation text, not ${nameOf(ref)}`);
+        }
+        if (after !== undefined && typeof after !== "string") {
+            throw new TypeError(`after must be a member name, not ${nameOf(after)}`);
+        }
+        const opts = [after ?? "", undefined];
+        this.#add(sequenceStatement(ownerId(owner), "first", "", {}, { ref, options: opts }));
+        return this;
+    }
+    /** Emit `then [m] <ref>;` or `then [m] <kind> <name> : <type>;`. */
+    addThen(owner, options = {}) {
+        const { ref, action, type, after, kind = "action", multiplicity } = options;
+        for (const [label, text] of [
+            ["ref", ref],
+            ["action", action],
+            ["type", type],
+            ["after", after],
+            ["kind", kind],
+            ["multiplicity", multiplicity],
+        ]) {
+            if (text !== undefined && typeof text !== "string") {
+                throw new TypeError(`${label} must be notation text, not ${nameOf(text)}`);
+            }
+        }
+        const opts = [after ?? "", multiplicity];
+        if ((ref === undefined) === (action === undefined)) {
+            throw new RangeError("exactly one of ref and action is required");
+        }
+        if (ref !== undefined && (type !== undefined || kind !== "action")) {
+            throw new RangeError("a then reference takes no type or kind");
+        }
+        if (ref !== undefined) {
+            this.#add(sequenceStatement(ownerId(owner), "then", "", {}, { ref, options: opts }));
+        }
+        else {
+            this.#add(sequenceStatement(ownerId(owner), "then", kind, {}, {
+                memberName: action,
+                typeName: type ?? "",
+                options: opts,
+            }));
+        }
+        return this;
+    }
+    /** Emit `then [m] accept <payload> [: <type>] [via <via>];`. */
+    addAccept(owner, payload, options = {}) {
+        const { type, via, then = true, multiplicity, after } = options;
+        sequenceText("payload", payload);
+        sequenceText("type", type, true);
+        sequenceText("via", via, true);
+        const opts = sequenceOptions(after, multiplicity);
+        if (typeof then !== "boolean") {
+            throw new TypeError(`then must be bool, not ${nameOf(then)}`);
+        }
+        sequenceKeywordOptions(then ? "then" : "", opts);
+        this.#add(sequenceStatement(ownerId(owner), then ? "then" : "", "accept", {
+            parameter: payload,
+            via: via ?? "",
+        }, {
+            typeName: type ?? "",
+            options: opts,
+        }));
+        return this;
+    }
+    /** Emit `then [m] send <payload> [via <via>] [to <to>];`. */
+    addSend(owner, payload, options = {}) {
+        const { to, via, then = true, multiplicity, after } = options;
+        sequenceText("payload", payload);
+        sequenceText("to", to, true);
+        sequenceText("via", via, true);
+        const opts = sequenceOptions(after, multiplicity);
+        if (typeof then !== "boolean") {
+            throw new TypeError(`then must be bool, not ${nameOf(then)}`);
+        }
+        sequenceKeywordOptions(then ? "then" : "", opts);
+        this.#add(sequenceStatement(ownerId(owner), then ? "then" : "", "send", {
+            value: payload,
+            target: to ?? "",
+            via: via ?? "",
+        }, {
+            options: opts,
+        }));
+        return this;
+    }
+    /** Emit `then [m] assign <target> := <value>;`. */
+    addAssign(owner, target, value, options = {}) {
+        const { then = true, multiplicity, after } = options;
+        sequenceText("target", target);
+        sequenceText("value", value);
+        const opts = sequenceOptions(after, multiplicity);
+        if (typeof then !== "boolean") {
+            throw new TypeError(`then must be bool, not ${nameOf(then)}`);
+        }
+        sequenceKeywordOptions(then ? "then" : "", opts);
+        this.#add(sequenceStatement(ownerId(owner), then ? "then" : "", "assign", {
+            target,
+            value,
+        }, {
+            options: opts,
+        }));
+        return this;
+    }
+    /** Emit `then [m] if <condition> { <body> } [else { <elseBody> }]`. */
+    addIf(owner, condition, body, elseBody, options = {}) {
+        const { then = true, multiplicity, after } = options;
+        sequenceText("condition", condition);
+        if (!(body instanceof Body)) {
+            throw new TypeError(`body must be Body, not ${nameOf(body)}`);
+        }
+        if (elseBody !== undefined && !(elseBody instanceof Body)) {
+            throw new TypeError(`else_body must be Body or None, not ${nameOf(elseBody)}`);
+        }
+        const opts = sequenceOptions(after, multiplicity);
+        if (typeof then !== "boolean") {
+            throw new TypeError(`then must be bool, not ${nameOf(then)}`);
+        }
+        sequenceKeywordOptions(then ? "then" : "", opts);
+        this.#add(sequenceStatement(ownerId(owner), then ? "then" : "", "if", {
+            condition,
+            body: body.operations,
+            else_body: elseBody !== undefined && elseBody.operations.length > 0 ? elseBody.operations : [],
+        }, {
+            options: opts,
+        }));
+        return this;
+    }
+    /** Emit `then [m] while <condition> { <body> } [until <until>];`. */
+    addWhile(owner, condition, body, options = {}) {
+        const { until, then = true, multiplicity, after } = options;
+        sequenceText("condition", condition);
+        sequenceText("until", until, true);
+        if (!(body instanceof Body)) {
+            throw new TypeError(`body must be Body, not ${nameOf(body)}`);
+        }
+        const opts = sequenceOptions(after, multiplicity);
+        if (typeof then !== "boolean") {
+            throw new TypeError(`then must be bool, not ${nameOf(then)}`);
+        }
+        sequenceKeywordOptions(then ? "then" : "", opts);
+        this.#add(sequenceStatement(ownerId(owner), then ? "then" : "", "while", {
+            condition,
+            until: until ?? "",
+            body: body.operations,
+        }, {
+            options: opts,
+        }));
+        return this;
+    }
+    /** Emit `then [m] loop { <body> } [until <until>];`. */
+    addLoop(owner, body, options = {}) {
+        const { until, then = true, multiplicity, after } = options;
+        sequenceText("until", until, true);
+        if (!(body instanceof Body)) {
+            throw new TypeError(`body must be Body, not ${nameOf(body)}`);
+        }
+        const opts = sequenceOptions(after, multiplicity);
+        if (typeof then !== "boolean") {
+            throw new TypeError(`then must be bool, not ${nameOf(then)}`);
+        }
+        sequenceKeywordOptions(then ? "then" : "", opts);
+        this.#add(sequenceStatement(ownerId(owner), then ? "then" : "", "loop", {
+            until: until ?? "",
+            body: body.operations,
+        }, {
+            options: opts,
+        }));
+        return this;
+    }
+    /** Emit `then [m] for <variable> [: <type>] in <collection> { <body> }`. */
+    addFor(owner, variable, collection, body, options = {}) {
+        const { type, then = true, multiplicity, after } = options;
+        sequenceText("variable", variable);
+        sequenceText("collection", collection);
+        sequenceText("type", type, true);
+        if (!(body instanceof Body)) {
+            throw new TypeError(`body must be Body, not ${nameOf(body)}`);
+        }
+        const opts = sequenceOptions(after, multiplicity);
+        if (typeof then !== "boolean") {
+            throw new TypeError(`then must be bool, not ${nameOf(then)}`);
+        }
+        sequenceKeywordOptions(then ? "then" : "", opts);
+        this.#add(sequenceStatement(ownerId(owner), then ? "then" : "", "for", {
+            parameter: variable,
+            value: collection,
+            body: body.operations,
+        }, {
+            typeName: type ?? "",
+            options: opts,
+        }));
+        return this;
+    }
+    /** Emit `then [m] terminate [<occurrence>];`. */
+    addTerminate(owner, occurrence, options = {}) {
+        const { then = true, multiplicity, after } = options;
+        sequenceText("occurrence", occurrence, true);
+        const opts = sequenceOptions(after, multiplicity);
+        if (typeof then !== "boolean") {
+            throw new TypeError(`then must be bool, not ${nameOf(then)}`);
+        }
+        sequenceKeywordOptions(then ? "then" : "", opts);
+        this.#add(sequenceStatement(ownerId(owner), then ? "then" : "", "terminate", {
+            value: occurrence ?? "",
+        }, {
+            options: opts,
+        }));
+        return this;
+    }
+    /** Emit `if <guard> then <ref>;`. */
+    addGuardedThen(owner, guard, ref, options = {}) {
+        const { after } = options;
+        sequenceText("guard", guard);
+        sequenceText("ref", ref);
+        const opts = sequenceOptions(after);
+        this.#add(sequenceStatement(ownerId(owner), "if", "", { condition: guard }, { ref, options: opts }));
+        return this;
+    }
+    /** Emit `else <ref>;`. */
+    addElse(owner, ref, options = {}) {
+        const { after } = options;
+        sequenceText("ref", ref);
+        const opts = sequenceOptions(after);
+        this.#add(sequenceStatement(ownerId(owner), "else", "", {}, { ref, options: opts }));
+        return this;
+    }
+    /** Add an import declaration to a namespace body or the document root. */
+    addImport(owner, target, options = {}) {
+        const { visibility, recursive = false, all = false, filter } = options;
+        if (typeof target !== "string") {
+            throw new TypeError(`target must be notation text, not ${nameOf(target)}`);
+        }
+        if (visibility !== undefined && typeof visibility !== "string") {
+            throw new TypeError(`visibility must be notation text or None, not ${nameOf(visibility)}`);
+        }
+        if (typeof recursive !== "boolean") {
+            throw new TypeError(`recursive must be a bool, not ${nameOf(recursive)}`);
+        }
+        if (typeof all !== "boolean") {
+            throw new TypeError(`all must be a bool, not ${nameOf(all)}`);
+        }
+        let filters;
+        if (filter === undefined) {
+            filters = [];
+        }
+        else if (typeof filter === "string") {
+            filters = [filter];
+        }
+        else if (Array.isArray(filter)) {
+            filters = filter;
+        }
+        else {
+            throw new TypeError(`filter must be notation text or a list of it, not ${nameOf(filter)}`);
+        }
+        for (const [index, expression] of filters.entries()) {
+            if (typeof expression !== "string") {
+                throw new TypeError(`filter[${index}] must be notation text`);
+            }
+        }
+        this.#add([
+            "add_import", ownerId(owner), visibility ?? "", target, recursive, all, filters,
+        ]);
+        return this;
+    }
+    /** Add a `require constraint` to a requirement-like body. */
+    addRequireConstraint(owner, expression, name) {
+        return this.addRequirementConstraint(owner, "require", expression, name);
+    }
+    /** Add an `assume constraint` to a requirement-like body. */
+    addAssumeConstraint(owner, expression, name) {
+        return this.addRequirementConstraint(owner, "assume", expression, name);
+    }
+    /** Add a connection-like usage between two feature references. */
+    addConnection(owner, kind, from, to, options = {}) {
+        const { name, type } = options;
+        for (const [label, text] of [
+            ["kind", kind],
+            ["from_", from],
+            ["to", to],
+        ]) {
+            if (typeof text !== "string") {
+                throw new TypeError(`${label} must be notation text, not ${nameOf(text)}`);
+            }
+        }
+        for (const [label, text] of [
+            ["name", name],
+            ["type", type],
+        ]) {
+            if (text !== undefined && typeof text !== "string") {
+                throw new TypeError(`${label} must be notation text, not ${nameOf(text)}`);
+            }
+        }
+        this.#add(["add_connection", ownerId(owner), kind, from, to, name ?? "", type ?? ""]);
+        return this;
+    }
+    /** Add an `allocation ... allocate from to` usage. */
+    addAllocation(owner, from, to, options = {}) {
+        return this.addConnection(owner, "allocation", from, to, options);
+    }
+    /** Add a `flow ... from from to` usage. */
+    addFlow(owner, from, to, options = {}) {
+        return this.addConnection(owner, "flow", from, to, options);
+    }
+    /** Add a `succession ... first from then to` usage. */
+    addSuccession(owner, from, to, options = {}) {
+        return this.addConnection(owner, "succession", from, to, options);
+    }
+    /** Delete a declaration, optionally removing declarations that refer to it. */
+    delete(target, options = {}) {
+        const { cascade = false } = options;
+        if (typeof cascade !== "boolean") {
+            throw new TypeError("cascade must be bool");
+        }
+        this.#add(["delete", targetId(target), cascade]);
+        return this;
+    }
+    /** Move a declaration into another namespace of the same document. */
+    move(target, owner) {
+        this.#add(["move", targetId(target), ownerId(owner)]);
+        return this;
+    }
+    /** Have the service perform these operations and return the edited model. */
+    async apply() {
+        if (this.#applied) {
+            throw new Error("this editor has already been applied: it describes an edit of the model it was made " +
+                "from, so build another editor from the edited model rather than applying this one twice");
+        }
+        if (this.#operations.length === 0) {
+            throw new NoEditsError("this editor has no operations: add an edit before applying it", { failure: "EDIT_FAILURE_NO_OPERATIONS" });
+        }
+        const result = await this.#apply(this.#modelHash, this.#operations);
+        this.#applied = true;
+        return result;
+    }
+    #add(operation) {
+        if (this.#applied) {
+            throw new Error("this editor has already been applied: build another editor from the edited model " +
+                "to edit further");
+        }
+        this.#operations.push(operation);
+    }
+    toString() {
+        return `Editor(modelHash=${JSON.stringify(this.#modelHash)}, operations=${this.#operations.length}, applied=${this.#applied})`;
+    }
+    addPackage(owner, name, options = {}) {
+        return this.addMember(owner, "package", name, options);
+    }
+    addPartDef(owner, name, options = {}) {
+        return this.addMember(owner, "part def", name, options);
+    }
+    addPart(owner, name, options = {}) {
+        return this.addMember(owner, "part", name, options);
+    }
+    addAttributeDef(owner, name, options = {}) {
+        return this.addMember(owner, "attribute def", name, options);
+    }
+    addAttribute(owner, name, options = {}) {
+        return this.addMember(owner, "attribute", name, options);
+    }
+    addItemDef(owner, name, options = {}) {
+        return this.addMember(owner, "item def", name, options);
+    }
+    addItem(owner, name, options = {}) {
+        return this.addMember(owner, "item", name, options);
+    }
+    addPortDef(owner, name, options = {}) {
+        return this.addMember(owner, "port def", name, options);
+    }
+    addPort(owner, name, options = {}) {
+        return this.addMember(owner, "port", name, options);
+    }
+    addClass(owner, name, options = {}) {
+        return this.addMember(owner, "class", name, options);
+    }
+    addStruct(owner, name, options = {}) {
+        return this.addMember(owner, "struct", name, options);
+    }
+    addDatatype(owner, name, options = {}) {
+        return this.addMember(owner, "datatype", name, options);
+    }
+    addClassifier(owner, name, options = {}) {
+        return this.addMember(owner, "classifier", name, options);
+    }
+    addFeature(owner, name, options = {}) {
+        return this.addMember(owner, "feature", name, options);
+    }
+    addAssoc(owner, name, options = {}) {
+        return this.addMember(owner, "assoc", name, options);
+    }
+    addBehavior(owner, name, options = {}) {
+        return this.addMember(owner, "behavior", name, options);
+    }
+    addFunction(owner, name, options = {}) {
+        return this.addMember(owner, "function", name, options);
+    }
+    addPredicate(owner, name, options = {}) {
+        return this.addMember(owner, "predicate", name, options);
+    }
+    addInteraction(owner, name, options = {}) {
+        return this.addMember(owner, "interaction", name, options);
+    }
+    addMetaclass(owner, name, options = {}) {
+        return this.addMember(owner, "metaclass", name, options);
+    }
+    /** Add a `calc def` with input parameters and an optional result. */
+    addCalcDef(owner, name, options = {}) {
+        const { inputs, returnType, returnExpression, expression, ...rest } = options;
+        const parameters = parameterPairs(inputs, "inputs");
+        optionalText(returnType, "return_type");
+        optionalText(returnExpression, "return_expression");
+        optionalText(expression, "expression");
+        if (expression !== undefined && returnExpression !== undefined) {
+            throw new RangeError("expression and return_expression both bind the result; give one");
+        }
+        if (returnExpression !== undefined && (returnType === undefined || returnType === "")) {
+            throw new RangeError("return_expression requires return_type");
+        }
+        const ownerName = ownerId(owner);
+        this.addMember(ownerName, "calc def", name, { expression, ...rest });
+        const qualifiedName = ownerName === "" ? name : `${ownerName}::${name}`;
+        for (const [parameterName, parameterType] of parameters) {
+            this.addParameter(qualifiedName, "in", parameterName, { type: parameterType });
+        }
+        if (returnType !== undefined || returnExpression !== undefined) {
+            this.addReturn(qualifiedName, { type: returnType, value: returnExpression });
+        }
+        return this;
+    }
+    /** Add a `calc` with input parameters and an optional result. */
+    addCalc(owner, name, options = {}) {
+        const { inputs, returnType, returnExpression, expression, ...rest } = options;
+        const parameters = parameterPairs(inputs, "inputs");
+        optionalText(returnType, "return_type");
+        optionalText(returnExpression, "return_expression");
+        optionalText(expression, "expression");
+        if (expression !== undefined && returnExpression !== undefined) {
+            throw new RangeError("expression and return_expression both bind the result; give one");
+        }
+        if (returnExpression !== undefined && (returnType === undefined || returnType === "")) {
+            throw new RangeError("return_expression requires return_type");
+        }
+        const ownerName = ownerId(owner);
+        this.addMember(ownerName, "calc", name, { expression, ...rest });
+        const qualifiedName = ownerName === "" ? name : `${ownerName}::${name}`;
+        for (const [parameterName, parameterType] of parameters) {
+            this.addParameter(qualifiedName, "in", parameterName, { type: parameterType });
+        }
+        if (returnType !== undefined || returnExpression !== undefined) {
+            this.addReturn(qualifiedName, { type: returnType, value: returnExpression });
+        }
+        return this;
+    }
+    /** Add a directional parameter usage. */
+    addParameter(owner, direction, name, options = {}) {
+        const { kind, ...rest } = options;
+        return this.addMember(owner, kind ?? "", name, { ...rest, direction });
+    }
+    /** Add a return parameter member. */
+    addReturn(owner, options = {}) {
+        const { name, ...rest } = options;
+        return this.addMember(owner, "return", name ?? "", rest);
+    }
+    /** Add an `action def` with input and output parameters. */
+    addActionDef(owner, name, options = {}) {
+        const { inputs, outputs, ...rest } = options;
+        const inputParameters = parameterPairs(inputs, "inputs");
+        const outputParameters = parameterPairs(outputs, "outputs");
+        const ownerName = ownerId(owner);
+        this.addMember(ownerName, "action def", name, rest);
+        const qualifiedName = ownerName === "" ? name : `${ownerName}::${name}`;
+        for (const [parameterName, parameterType] of inputParameters) {
+            this.addParameter(qualifiedName, "in", parameterName, { type: parameterType });
+        }
+        for (const [parameterName, parameterType] of outputParameters) {
+            this.addParameter(qualifiedName, "out", parameterName, { type: parameterType });
+        }
+        return this;
+    }
+    /** Add an `action` with input and output parameters. */
+    addAction(owner, name, options = {}) {
+        const { inputs, outputs, ...rest } = options;
+        const inputParameters = parameterPairs(inputs, "inputs");
+        const outputParameters = parameterPairs(outputs, "outputs");
+        const ownerName = ownerId(owner);
+        this.addMember(ownerName, "action", name, rest);
+        const qualifiedName = ownerName === "" ? name : `${ownerName}::${name}`;
+        for (const [parameterName, parameterType] of inputParameters) {
+            this.addParameter(qualifiedName, "in", parameterName, { type: parameterType });
+        }
+        for (const [parameterName, parameterType] of outputParameters) {
+            this.addParameter(qualifiedName, "out", parameterName, { type: parameterType });
+        }
+        return this;
+    }
+    /** Add a `perform action name : Type` usage. */
+    addPerformAction(owner, name, options = {}) {
+        return this.addMember(owner, "perform action", name, options);
+    }
+    /** Add a `perform <action>;` usage named by its referenced action. */
+    addPerform(owner, action, options = {}) {
+        return this.addMember(owner, "perform", action, options);
+    }
+    /** Add an `exhibit state` usage. */
+    addExhibitState(owner, name, options = {}) {
+        return this.addMember(owner, "exhibit state", name, options);
+    }
+    /** Add an `exhibit <state>;` usage named by its referenced state. */
+    addExhibit(owner, state) {
+        return this.addMember(owner, "exhibit", state);
+    }
+    /** Add an `entry`, `do` or `exit` action to a state body. */
+    addStateAction(owner, kind, name, options = {}) {
+        const { type } = options;
+        if (typeof kind !== "string") {
+            throw new TypeError(`kind must be notation text, not ${nameOf(kind)}`);
+        }
+        if (kind !== "entry" && kind !== "do" && kind !== "exit") {
+            throw new RangeError("kind must be 'entry', 'do' or 'exit'");
+        }
+        return this.addMember(owner, `${kind} action`, name, { type });
+    }
+    addStateDef(owner, name, options = {}) {
+        return this.addMember(owner, "state def", name, options);
+    }
+    addState(owner, name, options = {}) {
+        return this.addMember(owner, "state", name, options);
+    }
+    /** Add a `constraint def`; `expression` writes `{ … }`, `value` writes `= …`. */
+    addConstraintDef(owner, name, options = {}) {
+        return this.addMember(owner, "constraint def", name, options);
+    }
+    /** Add a `constraint`; `expression` writes `{ … }`, `value` writes `= …`. */
+    addConstraint(owner, name, options = {}) {
+        return this.addMember(owner, "constraint", name, options);
+    }
+    /** Add an asserted constraint usage, optionally negated. */
+    addAssertConstraint(owner, options = {}) {
+        const { name, type, expression, negated = false } = options;
+        if (typeof negated !== "boolean") {
+            throw new TypeError("negated must be bool");
+        }
+        return this.addMember(owner, negated ? "assert not constraint" : "assert constraint", name ?? "", {
+            type,
+            expression,
+        });
+    }
+    /** Add an anonymous `assert` usage; the assertion is not named by ref. */
+    addAssert(owner, ref, options = {}) {
+        const { negated = false } = options;
+        if (typeof ref !== "string") {
+            throw new TypeError(`ref must be notation text, not ${nameOf(ref)}`);
+        }
+        if (typeof negated !== "boolean") {
+            throw new TypeError("negated must be bool");
+        }
+        return this.addMember(owner, negated ? "assert not" : "assert", ref);
+    }
+    addRequirementDef(owner, name, options = {}) {
+        return this.addMember(owner, "requirement def", name, options);
+    }
+    addRequirement(owner, name, options = {}) {
+        return this.addMember(owner, "requirement", name, options);
+    }
+}
+const SEQUENCE_DETAIL_FIELDS = new Set([
+    "condition", "value", "target", "via", "until", "body", "else_body",
+    "multiplicity", "parameter",
+]);
+const ACTION_BODY_MEMBER_KINDS = new Set([
+    "accept", "send", "assign", "if", "while", "loop", "for", "terminate",
+]);
+const ASSERTED_CONSTRAINT_KINDS = new Set([
+    "assert", "assert not", "assert constraint", "assert not constraint",
+]);
+const STATE_ACTION_KINDS = new Set([
+    "exhibit state", "exhibit", "entry action", "do action", "exit action",
+]);
+const EDIT_CAPABILITY_ORDER = [
+    CAPABILITY_APPLY_EDITS,
+    CAPABILITY_AUTHORING,
+    CAPABILITY_CONNECTION_AUTHORING,
+    CAPABILITY_SATISFY_AUTHORING,
+    CAPABILITY_REQUIREMENT_CONSTRAINT_AUTHORING,
+    CAPABILITY_TRANSITION_AUTHORING,
+    CAPABILITY_VERIFICATION_OBJECTIVE_AUTHORING,
+    CAPABILITY_METADATA_AUTHORING,
+    CAPABILITY_METADATA_PREFIX_AUTHORING,
+    CAPABILITY_SEQUENCE_AUTHORING,
+    CAPABILITY_ACTION_BODY_STATEMENT_AUTHORING,
+    CAPABILITY_IMPORT_AUTHORING,
+    CAPABILITY_DOCUMENTATION_AUTHORING,
+    CAPABILITY_COMMENT_AUTHORING,
+    CAPABILITY_MEMBER_MODIFIERS,
+    CAPABILITY_IMPLICIT_PARAMETERS,
+    CAPABILITY_CONSTRAINT_BODY_AUTHORING,
+    CAPABILITY_STATE_ACTION_AUTHORING,
+];
+// Capabilities an edit request needs as a whole, checked once every operation is read.
+const EDIT_CAPABILITIES_CHECKED_LAST = [
+    CAPABILITY_ACTION_BODY_STATEMENT_AUTHORING,
+    CAPABILITY_MEMBER_MODIFIERS,
+    CAPABILITY_IMPLICIT_PARAMETERS,
+];
+function allText(values) {
+    return values.every((value) => typeof value === "string");
+}
+function memberExtras(extra) {
+    let metadata = [];
+    let bodyExpression = "";
+    let doc = "";
+    if (extra.length > 0) {
+        if (typeof extra[0] === "string") {
+            bodyExpression = extra[0];
+            if (extra.length === 2) {
+                doc = extra[1];
+            }
+        }
+        else {
+            metadata = extra[0];
+            if (extra.length > 1) {
+                bodyExpression = extra[1];
+            }
+            if (extra.length > 2) {
+                doc = extra[2];
+            }
+        }
+    }
+    if (typeof bodyExpression !== "string") {
+        throw new RangeError("malformed add_member operation: expression must be notation text");
+    }
+    if (typeof doc !== "string") {
+        throw new RangeError("malformed add_member operation: doc must be text");
+    }
+    return [metadata, bodyExpression, doc];
+}
+/** Whether a wire-form sequence member carries an action-body statement. */
+function wireSequenceExtended(add, depth = 0) {
+    if (depth > 128) {
+        throw new RangeError("nested action-body items exceed the maximum depth");
+    }
+    let extended = add.keyword === "if" ||
+        add.keyword === "else" ||
+        (add.keyword === "" && add.memberKind !== "") ||
+        ACTION_BODY_MEMBER_KINDS.has(add.memberKind);
+    extended =
+        extended ||
+            add.condition !== "" ||
+            add.value !== "" ||
+            add.target !== "" ||
+            add.via !== "" ||
+            add.until !== "" ||
+            add.multiplicity !== "" ||
+            add.parameter !== "" ||
+            add.body.length > 0 ||
+            add.elseBody.length > 0;
+    for (const child of [...add.body, ...add.elseBody]) {
+        extended = wireSequenceExtended(child, depth + 1) || extended;
+    }
+    return extended;
+}
+function addSequenceMessage(add, operationData, depth = 0) {
+    if (depth > 128) {
+        throw new RangeError("nested action-body items exceed the maximum depth");
+    }
+    if (!Array.isArray(operationData) || (operationData.length !== 8 && operationData.length !== 9)) {
+        throw new RangeError("malformed add_sequence operation: expected 8 or 9 fields");
+    }
+    const data = operationData;
+    const [, owner, keyword, ref, memberKind, memberName, typeName, after] = data;
+    if (!allText([owner, keyword, ref, memberKind, memberName, typeName, after])) {
+        throw new RangeError("malformed add_sequence operation: fields must be text");
+    }
+    const fields = data.length === 9 ? data[8] : {};
+    if (typeof fields !== "object" || fields === null || Array.isArray(fields)) {
+        throw new RangeError("malformed add_sequence operation: ninth field must be a dictionary");
+    }
+    const record = fields;
+    const unknown = Object.keys(record).filter((key) => !SEQUENCE_DETAIL_FIELDS.has(key));
+    if (unknown.length > 0) {
+        unknown.sort(byCodeUnit);
+        throw new RangeError(`malformed add_sequence operation: unknown fields ${unknown.join(", ")}`);
+    }
+    for (const [key, value] of Object.entries(record)) {
+        if (key === "body" || key === "else_body") {
+            if (!Array.isArray(value)) {
+                throw new RangeError(`malformed add_sequence operation: ${key} must be a list`);
+            }
+        }
+        else if (typeof value !== "string") {
+            throw new RangeError(`malformed add_sequence operation: ${key} must be text`);
+        }
+    }
+    add.owner = owner;
+    add.keyword = keyword;
+    add.ref = ref;
+    add.memberKind = memberKind;
+    add.memberName = memberName;
+    add.type = typeName;
+    add.after = after;
+    for (const key of ["condition", "value", "target", "via", "until", "multiplicity", "parameter"]) {
+        if (key in record) {
+            add[key] = record[key];
+        }
+    }
+    let extended = keyword === "if" ||
+        keyword === "else" ||
+        (keyword === "" && memberKind !== "") ||
+        ACTION_BODY_MEMBER_KINDS.has(memberKind);
+    extended = extended || Object.keys(record).some((key) => SEQUENCE_DETAIL_FIELDS.has(key));
+    for (const child of record["body"] ?? []) {
+        const childEdit = create(AddSequenceEditSchema);
+        add.body.push(childEdit);
+        extended = addSequenceMessage(childEdit, child, depth + 1) || extended;
+    }
+    for (const child of record["else_body"] ?? []) {
+        const childEdit = create(AddSequenceEditSchema);
+        add.elseBody.push(childEdit);
+        extended = addSequenceMessage(childEdit, child, depth + 1) || extended;
+    }
+    return extended;
+}
+/** Translates edit tuples into an `ApplyEditsRequest`'s operations, gating capabilities. */
+export class EditRequestBuilder {
+    #info;
+    #requested = new Set([CAPABILITY_APPLY_EDITS]);
+    constructor(info) {
+        this.#info = info;
+    }
+    /** The operations the tuples describe, and the capabilities they need. A
+     * wire `EditOperation` passes through as written — how a caller sends an
+     * operation the tuple form cannot write — gated on the fields it carries. */
+    build(operations) {
+        const built = operations.map((data) => this.add(data));
+        return { operations: built, capabilities: this.finish() };
+    }
+    add(operationData) {
+        if (typeof operationData === "object" && "$typeName" in operationData) {
+            return this.wire(operationData);
+        }
+        const operation = create(EditOperationSchema);
+        switch (operationData[0]) {
+            case "set_value":
+                this.#setValue(operation, operationData);
+                break;
+            case "rename":
+                this.#rename(operation, operationData);
+                break;
+            case "add_member":
+                this.#addMember(operation, operationData);
+                break;
+            case "add_connection":
+                this.#addConnection(operation, operationData);
+                break;
+            case "add_satisfy":
+                this.#addSatisfy(operation, operationData);
+                break;
+            case "add_requirement_constraint":
+                this.#addRequirementConstraint(operation, operationData);
+                break;
+            case "add_transition":
+                this.#addTransition(operation, operationData);
+                break;
+            case "add_verify":
+                this.#addVerify(operation, operationData);
+                break;
+            case "add_metadata":
+                this.#addMetadata(operation, operationData);
+                break;
+            case "add_metadata_prefix":
+                this.#addMetadataPrefix(operation, operationData);
+                break;
+            case "add_sequence":
+                this.#addSequence(operation, operationData);
+                break;
+            case "add_import":
+                this.#addImport(operation, operationData);
+                break;
+            case "add_documentation":
+                this.#addDocumentation(operation, operationData);
+                break;
+            case "add_comment":
+                this.#addComment(operation, operationData);
+                break;
+            case "add_note":
+                this.#addNote(operation, operationData);
+                break;
+            case "delete":
+                this.#delete(operation, operationData);
+                break;
+            case "move":
+                this.#move(operation, operationData);
+                break;
+            default:
+                throw new RangeError(`unknown edit operation ${JSON.stringify(operationData[0])}: expected set_value, rename, ` +
+                    "add_member, add_connection, add_satisfy, add_requirement_constraint, " +
+                    "add_transition, add_verify, add_metadata, add_metadata_prefix, add_sequence, " +
+                    "add_import, add_documentation, add_comment, add_note, delete or move");
+        }
+        return operation;
+    }
+    /** Gate an operation already in wire form on the fields it carries. */
+    wire(operation) {
+        const detail = operation.operation.value;
+        switch (operation.operation.case) {
+            case "setValue":
+            case "rename":
+                break;
+            case "addMember":
+                this.#require(CAPABILITY_AUTHORING);
+                this.#note(CAPABILITY_IMPLICIT_PARAMETERS, detail["kind"] === "");
+                if (detail["kind"] === "objective" && detail["name"] === "") {
+                    this.#require(CAPABILITY_VERIFICATION_OBJECTIVE_AUTHORING);
+                }
+                if (detail["doc"] !== undefined && detail["doc"] !== "") {
+                    this.#require(CAPABILITY_DOCUMENTATION_AUTHORING);
+                }
+                if ((detail["metadataPrefixes"] ?? []).length > 0) {
+                    this.#require(CAPABILITY_METADATA_AUTHORING);
+                }
+                if (detail["bodyExpression"] !== "" ||
+                    ASSERTED_CONSTRAINT_KINDS.has(detail["kind"])) {
+                    this.#require(CAPABILITY_CONSTRAINT_BODY_AUTHORING);
+                }
+                if (STATE_ACTION_KINDS.has(detail["kind"])) {
+                    this.#require(CAPABILITY_STATE_ACTION_AUTHORING);
+                }
+                this.#note(CAPABILITY_MEMBER_MODIFIERS, detail["isAbstract"] === true ||
+                    (detail["redefines"] ?? []).length > 0 ||
+                    detail["isDefault"] === true ||
+                    detail["direction"] !== "" ||
+                    detail["kind"] === "ref" ||
+                    detail["kind"] === "return");
+                break;
+            case "addConnection":
+                this.#require(CAPABILITY_AUTHORING, CAPABILITY_CONNECTION_AUTHORING);
+                break;
+            case "addSatisfy":
+                this.#require(CAPABILITY_AUTHORING, CAPABILITY_SATISFY_AUTHORING);
+                break;
+            case "addRequirementConstraint":
+                this.#require(CAPABILITY_AUTHORING, CAPABILITY_REQUIREMENT_CONSTRAINT_AUTHORING);
+                break;
+            case "addTransition":
+                this.#require(CAPABILITY_AUTHORING, CAPABILITY_TRANSITION_AUTHORING);
+                break;
+            case "addVerify":
+                this.#require(CAPABILITY_AUTHORING, CAPABILITY_VERIFICATION_OBJECTIVE_AUTHORING);
+                break;
+            case "addMetadata":
+                this.#require(CAPABILITY_AUTHORING, CAPABILITY_METADATA_AUTHORING);
+                break;
+            case "addMetadataPrefix":
+                this.#require(CAPABILITY_AUTHORING, CAPABILITY_METADATA_PREFIX_AUTHORING);
+                break;
+            case "addSequence":
+                this.#require(CAPABILITY_AUTHORING, CAPABILITY_SEQUENCE_AUTHORING);
+                this.#note(CAPABILITY_ACTION_BODY_STATEMENT_AUTHORING, wireSequenceExtended(detail));
+                break;
+            case "addImport":
+                this.#require(CAPABILITY_AUTHORING, CAPABILITY_IMPORT_AUTHORING);
+                break;
+            case "addDocumentation":
+                this.#require(CAPABILITY_AUTHORING, CAPABILITY_DOCUMENTATION_AUTHORING);
+                break;
+            case "addComment":
+            case "addNote":
+                this.#require(CAPABILITY_AUTHORING, CAPABILITY_COMMENT_AUTHORING);
+                break;
+            case "delete":
+            case "move":
+                this.#require(CAPABILITY_AUTHORING);
+                break;
+            default:
+                throw new RangeError(`unknown edit operation ${JSON.stringify(operation.operation.case)}`);
+        }
+        return operation;
+    }
+    finish() {
+        for (const capability of EDIT_CAPABILITIES_CHECKED_LAST) {
+            if (this.#requested.has(capability)) {
+                this.#require(capability);
+            }
+        }
+        return EDIT_CAPABILITY_ORDER.filter((capability) => this.#requested.has(capability));
+    }
+    #require(...capabilities) {
+        for (const capability of capabilities) {
+            requireCapability(this.#info, capability, upgradeRemedy(capability));
+            this.#requested.add(capability);
+        }
+    }
+    #note(capability, needed = true) {
+        if (needed) {
+            this.#requested.add(capability);
+        }
+    }
+    #setValue(operation, operationData) {
+        const [, target, text] = operationData;
+        operation.operation = {
+            case: "setValue",
+            value: create(SetValueEditSchema, {
+                target: target,
+                value: text,
+            }),
+        };
+    }
+    #rename(operation, operationData) {
+        const [, target, text] = operationData;
+        operation.operation = {
+            case: "rename",
+            value: create(RenameEditSchema, {
+                target: target,
+                newName: text,
+            }),
+        };
+    }
+    #addMember(operation, operationData) {
+        if (![8, 12, 13, 14, 15].includes(operationData.length)) {
+            throw new RangeError("malformed add_member operation: expected 8, 12, 13, 14 or 15 fields");
+        }
+        const [, owner, memberKind, name, typeName, multiplicity, value, specializes] = operationData;
+        const modifiers = operationData.length >= 12 ? operationData.slice(8, 12) : [];
+        const [metadata, bodyExpression, doc] = memberExtras(operationData.slice(12));
+        this.#require(CAPABILITY_AUTHORING);
+        this.#note(CAPABILITY_IMPLICIT_PARAMETERS, memberKind === "");
+        if (memberKind === "objective" && name === "") {
+            this.#require(CAPABILITY_VERIFICATION_OBJECTIVE_AUTHORING);
+        }
+        const add = create(AddMemberEditSchema);
+        add.owner = owner;
+        add.kind = memberKind;
+        add.name = name;
+        add.type = typeName;
+        add.multiplicity = multiplicity;
+        add.value = value;
+        add.specializes = [...specializes];
+        if (doc !== "") {
+            this.#require(CAPABILITY_DOCUMENTATION_AUTHORING);
+            add.doc = doc;
+        }
+        if (modifiers.length > 0) {
+            this.#memberModifiers(add, memberKind, modifiers);
+        }
+        if (!Array.isArray(metadata) || !allText(metadata)) {
+            throw new RangeError("malformed add_member metadata: expected a sequence of notation strings");
+        }
+        add.metadataPrefixes = [...metadata];
+        if (metadata.length > 0) {
+            this.#require(CAPABILITY_METADATA_AUTHORING);
+        }
+        add.bodyExpression = bodyExpression;
+        if (bodyExpression !== "" || ASSERTED_CONSTRAINT_KINDS.has(memberKind)) {
+            this.#require(CAPABILITY_CONSTRAINT_BODY_AUTHORING);
+        }
+        if (STATE_ACTION_KINDS.has(memberKind)) {
+            this.#require(CAPABILITY_STATE_ACTION_AUTHORING);
+        }
+        operation.operation = { case: "addMember", value: add };
+    }
+    #memberModifiers(add, memberKind, modifiers) {
+        const [abstract, redefines, isDefault, direction] = modifiers;
+        if (typeof abstract !== "boolean" || typeof isDefault !== "boolean") {
+            throw new RangeError("malformed add_member modifiers: abstract and default must be bool");
+        }
+        if (typeof redefines === "string" || !Array.isArray(redefines) || !allText(redefines)) {
+            throw new RangeError("malformed add_member modifiers: redefines must be a sequence");
+        }
+        if (typeof direction !== "string") {
+            throw new RangeError("malformed add_member modifiers: direction must be notation text");
+        }
+        add.isAbstract = abstract;
+        add.redefines = [...redefines];
+        add.isDefault = isDefault;
+        add.direction = direction;
+        this.#note(CAPABILITY_MEMBER_MODIFIERS, abstract || redefines.length > 0 || isDefault || direction !== "" ||
+            memberKind === "ref" || memberKind === "return");
+    }
+    #addConnection(operation, operationData) {
+        if (operationData.length !== 7) {
+            throw new RangeError("malformed add_connection operation: expected 7 fields");
+        }
+        const [, owner, connectionKind, fromEnd, toEnd, name, typeName] = operationData;
+        this.#require(CAPABILITY_AUTHORING, CAPABILITY_CONNECTION_AUTHORING);
+        operation.operation = {
+            case: "addConnection",
+            value: create(AddConnectionEditSchema, {
+                owner: owner,
+                kind: connectionKind,
+                fromEnd: fromEnd,
+                toEnd: toEnd,
+                name: name,
+                type: typeName,
+            }),
+        };
+    }
+    #addSatisfy(operation, operationData) {
+        if (operationData.length !== 6) {
+            throw new RangeError("malformed add_satisfy operation: expected 6 fields");
+        }
+        const [, owner, requirement, satisfyingFeature, asserted, negated] = operationData;
+        if (typeof asserted !== "boolean" || typeof negated !== "boolean") {
+            throw new RangeError("malformed add_satisfy operation: asserted and negated must be bool");
+        }
+        this.#require(CAPABILITY_AUTHORING, CAPABILITY_SATISFY_AUTHORING);
+        operation.operation = {
+            case: "addSatisfy",
+            value: create(AddSatisfyEditSchema, {
+                owner: owner,
+                requirement: requirement,
+                satisfyingFeature: satisfyingFeature,
+                isAsserted: asserted,
+                isNegated: negated,
+            }),
+        };
+    }
+    #addRequirementConstraint(operation, operationData) {
+        if (operationData.length !== 5) {
+            throw new RangeError("malformed add_requirement_constraint operation: expected 5 fields");
+        }
+        const [, owner, constraintKind, expression, name] = operationData;
+        this.#require(CAPABILITY_AUTHORING, CAPABILITY_REQUIREMENT_CONSTRAINT_AUTHORING);
+        operation.operation = {
+            case: "addRequirementConstraint",
+            value: create(AddRequirementConstraintEditSchema, {
+                owner: owner,
+                kind: constraintKind,
+                expression: expression,
+                name: name,
+            }),
+        };
+    }
+    #addTransition(operation, operationData) {
+        if (operationData.length !== 9) {
+            throw new RangeError("malformed add_transition operation: expected 9 fields");
+        }
+        const [, owner, name, source, target, trigger, guard, effect, initial] = operationData;
+        if (!allText([owner, name, source, target, trigger, guard, effect]) || typeof initial !== "boolean") {
+            throw new RangeError("malformed add_transition operation: text fields and initial must be valid");
+        }
+        this.#require(CAPABILITY_AUTHORING, CAPABILITY_TRANSITION_AUTHORING);
+        operation.operation = {
+            case: "addTransition",
+            value: create(AddTransitionEditSchema, {
+                owner: owner,
+                name: name,
+                source: source,
+                target: target,
+                trigger: trigger,
+                guard: guard,
+                effect: effect,
+                initial,
+            }),
+        };
+    }
+    #addVerify(operation, operationData) {
+        if (operationData.length !== 3) {
+            throw new RangeError("malformed add_verify operation: expected 3 fields");
+        }
+        const [, owner, requirement] = operationData;
+        if (typeof owner !== "string" || typeof requirement !== "string") {
+            throw new RangeError("malformed add_verify operation: fields must be notation text");
+        }
+        this.#require(CAPABILITY_AUTHORING, CAPABILITY_VERIFICATION_OBJECTIVE_AUTHORING);
+        operation.operation = {
+            case: "addVerify",
+            value: create(AddVerifyEditSchema, { owner, requirement }),
+        };
+    }
+    #addMetadata(operation, operationData) {
+        if (operationData.length !== 7) {
+            throw new RangeError("malformed add_metadata operation: expected 7 fields");
+        }
+        const [, owner, metadataType, name, about, values, shorthand] = operationData;
+        if (!allText([owner, metadataType, name])) {
+            throw new RangeError("malformed add_metadata operation: text fields must be strings");
+        }
+        if (typeof shorthand !== "boolean") {
+            throw new RangeError("malformed add_metadata operation: shorthand must be bool");
+        }
+        if (!Array.isArray(about) || !allText(about)) {
+            throw new RangeError("malformed add_metadata operation: about must be notation strings");
+        }
+        if (typeof values === "string" || !Array.isArray(values)) {
+            throw new RangeError("malformed add_metadata operation: values must be feature-value pairs");
+        }
+        this.#require(CAPABILITY_AUTHORING, CAPABILITY_METADATA_AUTHORING);
+        const bindings = values.map((pair, index) => {
+            if (!Array.isArray(pair) || pair.length !== 2 || !allText(pair)) {
+                throw new RangeError(`malformed add_metadata operation: values[${index}] must be a pair of strings`);
+            }
+            return create(MetadataFeatureValueSchema, {
+                feature: pair[0],
+                value: pair[1],
+            });
+        });
+        operation.operation = {
+            case: "addMetadata",
+            value: create(AddMetadataEditSchema, {
+                owner: owner,
+                metadataType: metadataType,
+                name: name,
+                about: [...about],
+                values: bindings,
+                shorthand,
+            }),
+        };
+    }
+    #addMetadataPrefix(operation, operationData) {
+        if (operationData.length !== 3) {
+            throw new RangeError("malformed add_metadata_prefix operation: expected 3 fields");
+        }
+        const [, target, metadataType] = operationData;
+        if (typeof target !== "string" || typeof metadataType !== "string") {
+            throw new RangeError("malformed add_metadata_prefix operation: fields must be notation text");
+        }
+        this.#require(CAPABILITY_AUTHORING, CAPABILITY_METADATA_PREFIX_AUTHORING);
+        operation.operation = {
+            case: "addMetadataPrefix",
+            value: create(AddMetadataPrefixEditSchema, { target, metadataType }),
+        };
+    }
+    #addSequence(operation, operationData) {
+        if (!Array.isArray(operationData) || (operationData.length !== 8 && operationData.length !== 9)) {
+            throw new RangeError("malformed add_sequence operation: expected 8 or 9 fields");
+        }
+        this.#require(CAPABILITY_AUTHORING, CAPABILITY_SEQUENCE_AUTHORING);
+        const add = create(AddSequenceEditSchema);
+        this.#note(CAPABILITY_ACTION_BODY_STATEMENT_AUTHORING, addSequenceMessage(add, operationData));
+        operation.operation = { case: "addSequence", value: add };
+    }
+    #addImport(operation, operationData) {
+        if (operationData.length !== 7) {
+            throw new RangeError("malformed add_import operation: expected 7 fields");
+        }
+        const [, owner, visibility, target, recursive, importAll, filters] = operationData;
+        if (!allText([owner, visibility, target]) ||
+            typeof recursive !== "boolean" ||
+            typeof importAll !== "boolean" ||
+            !Array.isArray(filters) ||
+            !allText(filters)) {
+            throw new RangeError("malformed add_import operation: text fields, recursive, import_all and filters must be valid");
+        }
+        this.#require(CAPABILITY_AUTHORING, CAPABILITY_IMPORT_AUTHORING);
+        operation.operation = {
+            case: "addImport",
+            value: create(AddImportEditSchema, {
+                owner: owner,
+                visibility: visibility,
+                target: target,
+                isRecursive: recursive,
+                isImportAll: importAll,
+                filters: [...filters],
+            }),
+        };
+    }
+    #addDocumentation(operation, operationData) {
+        if (operationData.length !== 6) {
+            throw new RangeError("malformed add_documentation operation: expected 6 fields");
+        }
+        const [, target, body, name, locale, replace] = operationData;
+        if (!allText([target, body, name, locale]) || typeof replace !== "boolean") {
+            throw new RangeError("malformed add_documentation operation: text fields and replace must be valid");
+        }
+        this.#require(CAPABILITY_AUTHORING, CAPABILITY_DOCUMENTATION_AUTHORING);
+        operation.operation = {
+            case: "addDocumentation",
+            value: create(AddDocumentationEditSchema, {
+                target: target,
+                body: body,
+                name: name,
+                locale: locale,
+                replace,
+            }),
+        };
+    }
+    #addComment(operation, operationData) {
+        if (operationData.length !== 6) {
+            throw new RangeError("malformed add_comment operation: expected 6 fields");
+        }
+        const [, owner, body, name, about, locale] = operationData;
+        const aboutList = Array.isArray(about) ? about : null;
+        if (!allText([owner, body, name, locale]) || aboutList === null || !allText(aboutList)) {
+            throw new RangeError("malformed add_comment operation: text fields and about must be valid");
+        }
+        this.#require(CAPABILITY_AUTHORING, CAPABILITY_COMMENT_AUTHORING);
+        operation.operation = {
+            case: "addComment",
+            value: create(AddCommentEditSchema, {
+                owner: owner,
+                body: body,
+                name: name,
+                about: [...aboutList],
+                locale: locale,
+            }),
+        };
+    }
+    #addNote(operation, operationData) {
+        if (operationData.length !== 3 || !allText(operationData.slice(1))) {
+            throw new RangeError("malformed add_note operation: expected target and text");
+        }
+        const [, target, text] = operationData;
+        this.#require(CAPABILITY_AUTHORING, CAPABILITY_COMMENT_AUTHORING);
+        operation.operation = {
+            case: "addNote",
+            value: create(AddNoteEditSchema, {
+                target: target,
+                text: text,
+            }),
+        };
+    }
+    #delete(operation, operationData) {
+        if (operationData.length !== 3 || typeof operationData[2] !== "boolean") {
+            throw new RangeError("malformed delete operation: expected target and bool cascade");
+        }
+        const [, target, cascade] = operationData;
+        this.#require(CAPABILITY_AUTHORING);
+        operation.operation = {
+            case: "delete",
+            value: create(DeleteEditSchema, {
+                target: target,
+                cascade,
+            }),
+        };
+    }
+    #move(operation, operationData) {
+        if (operationData.length !== 3) {
+            throw new RangeError("malformed move operation: expected target and owner");
+        }
+        const [, target, owner] = operationData;
+        this.#require(CAPABILITY_AUTHORING);
+        operation.operation = {
+            case: "move",
+            value: create(MoveEditSchema, {
+                target: target,
+                owner: owner,
+            }),
+        };
+    }
+}