@istar-ts/core 0.7.0 → 0.8.1

package/dist/index.cjs

@@ -138,6 +138,236 @@ function shortKindName(kind) {
 	return kind.slice(6);
 }
 //#endregion
+//#region src/metamodels.ts
+function shortName(kind) {
+	const dot = kind.indexOf(".");
+	return dot === -1 ? kind : kind.slice(dot + 1);
+}
+function buildIstar() {
+	const elements = /* @__PURE__ */ new Map();
+	for (const kind of ACTOR_KINDS) elements.set(kind, {
+		kind,
+		category: "actor",
+		label: shortName(kind),
+		size: DEFAULT_ELEMENT_SIZE[kind],
+		pistarType: kind
+	});
+	for (const kind of NODE_KINDS) elements.set(kind, {
+		kind,
+		category: "node",
+		label: shortName(kind),
+		size: DEFAULT_ELEMENT_SIZE[kind],
+		info: NODE_KIND_INFO[kind],
+		pistarType: kind
+	});
+	const links = /* @__PURE__ */ new Map();
+	const labels = {
+		"istar.IsALink": "Is-A",
+		"istar.ParticipatesInLink": "Participates-In",
+		"istar.DependencyLink": "Dependency",
+		"istar.AndRefinementLink": "And-Refinement",
+		"istar.OrRefinementLink": "Or-Refinement",
+		"istar.NeededByLink": "Needed-By",
+		"istar.QualificationLink": "Qualification",
+		"istar.ContributionLink": "Contribution"
+	};
+	const add = (kinds, category) => {
+		for (const kind of kinds) links.set(kind, {
+			kind,
+			category,
+			label: labels[kind],
+			info: LINK_KIND_INFO[kind],
+			pistarType: kind
+		});
+	};
+	add(ACTOR_LINK_KINDS, "actor");
+	add(DEPENDENCY_LINK_KINDS, "dependency");
+	add(NODE_LINK_KINDS, "node");
+	return {
+		name: "istar-2.0",
+		extensions: [],
+		elements,
+		links,
+		elementsByPistarType: new Map([...elements.keys()].map((k) => [k, k])),
+		linksByPistarType: new Map([...links.keys()].map((k) => [k, k]))
+	};
+}
+/** iStar 2.0, as the piStar tool implements it. The default metamodel everywhere. */
+const ISTAR_2_0 = buildIstar();
+var MetamodelError = class extends Error {
+	name = "MetamodelError";
+};
+/**
+* Declares an extension, keeping its kind names as literal types (so `extendMetamodel` can
+* type the result). Identity at runtime.
+*/
+function defineMetamodelExtension(extension) {
+	return extension;
+}
+const KIND_NAME = /^[A-Za-z_][\w-]*\.[A-Za-z_][\w-]*$/;
+const CATEGORY_SELECTORS = /* @__PURE__ */ new Set([
+	"node",
+	"actor",
+	"*"
+]);
+/**
+* Returns a new metamodel with the extension's kinds added. `base` is not modified.
+*
+* Throws `MetamodelError` when a kind name isn't namespaced, uses the reserved `istar.`
+* prefix, collides with an existing kind or piStar type, or refers to an unknown kind.
+*/
+function extendMetamodel(base, extension) {
+	const where = `extension "${extension.name}"`;
+	if (!extension.name || typeof extension.name !== "string") throw new MetamodelError("an extension needs a name");
+	if (base.extensions.includes(extension.name)) throw new MetamodelError(`${where} is already applied`);
+	const elements = new Map(base.elements);
+	const links = new Map(base.links);
+	const elementsByType = new Map(base.elementsByPistarType);
+	const linksByType = new Map(base.linksByPistarType);
+	const claimName = (kind, what) => {
+		if (typeof kind !== "string" || !KIND_NAME.test(kind)) throw new MetamodelError(`${where}: ${what} kind ${JSON.stringify(kind)} must be namespaced, e.g. "${extension.name}.Name"`);
+		if (kind.startsWith(`istar.`)) throw new MetamodelError(`${where}: ${what} kind "${kind}" uses the reserved "${ISTAR_PREFIX}." prefix; name it "${extension.name}.${shortName(kind)}" and set pistarType: "${kind}" to read files that use it`);
+		if (elements.has(kind) || links.has(kind)) throw new MetamodelError(`${where}: kind "${kind}" already exists`);
+	};
+	const claimType = (type, kind) => {
+		if (typeof type !== "string" || type === "") throw new MetamodelError(`${where}: kind "${kind}" has an empty pistarType`);
+		if (elementsByType.has(type) || linksByType.has(type) || elements.has(type) || links.has(type)) throw new MetamodelError(`${where}: pistarType "${type}" of kind "${kind}" is already used by another kind`);
+	};
+	for (const declaration of extension.elements ?? []) {
+		const { kind } = declaration;
+		claimName(kind, "element");
+		let parent;
+		if (declaration.behavesLike !== void 0) {
+			parent = elements.get(declaration.behavesLike);
+			if (!parent) throw new MetamodelError(`${where}: "${kind}" behaves like unknown element kind "${declaration.behavesLike}"`);
+		}
+		const category = declaration.category ?? parent?.category;
+		if (category !== "actor" && category !== "node") throw new MetamodelError(`${where}: element kind "${kind}" needs a category ("node" or "actor") or behavesLike`);
+		if (parent && parent.category !== category) throw new MetamodelError(`${where}: "${kind}" is a ${category} but behaves like "${parent.kind}", a ${parent.category}`);
+		const type = declaration.pistarType ?? kind;
+		claimType(type, kind);
+		const baseInfo = parent?.info ?? {
+			canBeInnerElement: true,
+			canBeDependum: true,
+			canBeOnPaper: false
+		};
+		const definition = {
+			kind,
+			category,
+			label: declaration.label ?? shortName(kind),
+			size: declaration.size ?? parent?.size ?? (category === "actor" ? {
+				width: 200,
+				height: 120
+			} : {
+				width: 90,
+				height: 55
+			}),
+			...category === "node" ? { info: {
+				...baseInfo,
+				...declaration.info
+			} } : {},
+			...parent ? { behavesLike: parent.kind } : {},
+			pistarType: type,
+			extension: extension.name
+		};
+		elements.set(kind, definition);
+		elementsByType.set(type, kind);
+	}
+	for (const declaration of extension.links ?? []) {
+		const { kind } = declaration;
+		claimName(kind, "link");
+		if (declaration.behavesLike === void 0 === (declaration.rules === void 0)) throw new MetamodelError(`${where}: link kind "${kind}" needs exactly one of behavesLike or rules`);
+		let parent;
+		if (declaration.behavesLike !== void 0) {
+			parent = links.get(declaration.behavesLike);
+			if (!parent) throw new MetamodelError(`${where}: "${kind}" behaves like unknown link kind "${declaration.behavesLike}"`);
+		}
+		const category = declaration.category ?? parent?.category ?? "node";
+		if (category !== "node" && category !== "actor" && category !== "dependency") throw new MetamodelError(`${where}: link kind "${kind}" has an unknown category "${category}"`);
+		if (parent && parent.category !== category) throw new MetamodelError(`${where}: "${kind}" is a ${category} link but behaves like "${parent.kind}", a ${parent.category} link`);
+		if (category === "dependency" && !parent) throw new MetamodelError(`${where}: dependency link kind "${kind}" must behave like a dependency link (its dependum makes declarative rules ambiguous)`);
+		if (declaration.rules) for (const [side, selectors] of [["sources", declaration.rules.sources], ["targets", declaration.rules.targets]]) {
+			if (!Array.isArray(selectors) || selectors.length === 0) throw new MetamodelError(`${where}: link kind "${kind}" needs at least one of ${side}`);
+			for (const selector of selectors) if (!CATEGORY_SELECTORS.has(selector) && !elements.has(selector)) throw new MetamodelError(`${where}: ${side} of "${kind}" names unknown element kind "${selector}"`);
+		}
+		const type = declaration.pistarType ?? kind;
+		claimType(type, kind);
+		const definition = {
+			kind,
+			category,
+			label: declaration.label ?? shortName(kind),
+			info: declaration.info ?? parent?.info ?? {},
+			...parent ? { behavesLike: parent.kind } : {},
+			...declaration.rules ? { rules: declaration.rules } : {},
+			...declaration.check ? { check: declaration.check } : {},
+			pistarType: type,
+			extension: extension.name
+		};
+		links.set(kind, definition);
+		linksByType.set(type, kind);
+	}
+	return {
+		name: `${base.name}+${extension.name}`,
+		extensions: [...base.extensions, extension.name],
+		elements,
+		links,
+		elementsByPistarType: elementsByType,
+		linksByPistarType: linksByType
+	};
+}
+function elementKindDefinition(metamodel, kind) {
+	return metamodel.elements.get(kind);
+}
+function linkKindDefinition(metamodel, kind) {
+	return metamodel.links.get(kind);
+}
+/** True for actor-category kinds (Actor, Agent, Role and extensions behaving like them). */
+function isActorKindIn(metamodel, kind) {
+	return metamodel.elements.get(kind)?.category === "actor";
+}
+/** True for node-category kinds (intentional elements, built-in or extended). */
+function isNodeKindIn(metamodel, kind) {
+	return metamodel.elements.get(kind)?.category === "node";
+}
+/**
+* The built-in (or rule-carrying) kind an element kind ultimately behaves like: `istar.Task`
+* for a Planning that behaves like a Task; the kind itself when it behaves like nothing.
+*/
+function effectiveElementKind(metamodel, kind) {
+	let current = metamodel.elements.get(kind);
+	const seen = /* @__PURE__ */ new Set();
+	while (current?.behavesLike !== void 0 && !seen.has(current.kind)) {
+		seen.add(current.kind);
+		const next = metamodel.elements.get(current.behavesLike);
+		if (!next) break;
+		current = next;
+	}
+	return current?.kind ?? kind;
+}
+/** Like `effectiveElementKind`, for link kinds. */
+function effectiveLinkKind(metamodel, kind) {
+	let current = metamodel.links.get(kind);
+	const seen = /* @__PURE__ */ new Set();
+	while (current?.behavesLike !== void 0 && !seen.has(current.kind)) {
+		seen.add(current.kind);
+		const next = metamodel.links.get(current.behavesLike);
+		if (!next) break;
+		current = next;
+	}
+	return current?.kind ?? kind;
+}
+/** True when `kind` is `ancestor` or (transitively) behaves like it. */
+function elementBehavesLike(metamodel, kind, ancestor) {
+	let current = kind;
+	const seen = /* @__PURE__ */ new Set();
+	while (current !== void 0 && !seen.has(current)) {
+		if (current === ancestor) return true;
+		seen.add(current);
+		current = metamodel.elements.get(current)?.behavesLike;
+	}
+	return false;
+}
+//#endregion
 //#region src/model.ts
 /** Tool identifier written by piStar 2.1.0, whose file format this library emulates. */
 const PISTAR_TOOL = "pistar.2.1.0";
@@ -146,20 +376,66 @@ const DEFAULT_DIAGRAM = {
 	width: 2e3,
 	height: 1300
 };
-function createEmptyModel(diagram = DEFAULT_DIAGRAM) {
-	return {
+/**
+* The metamodel of each model that isn't iStar 2.0. Kept beside the model rather than in it,
+* so a model's shape (and `JSON.stringify`, deep equality, snapshots) is the same as before
+* metamodels existed. Operations and the store carry it to every model they derive.
+*/
+const metamodels = /* @__PURE__ */ new WeakMap();
+/**
+* Associates `metamodel` with `model` and returns the same model, typed for it. Use when a
+* model was built without the library's operations (e.g. with an object spread), which loses
+* the association.
+*/
+function withMetamodel(model, metamodel) {
+	if (metamodel === ISTAR_2_0) metamodels.delete(model);
+	else metamodels.set(model, metamodel);
+	return model;
+}
+/** Gives `to` the metamodel of `from` (used for every model an operation derives). */
+function inheritMetamodel(from, to) {
+	const metamodel = metamodels.get(from);
+	if (metamodel && from !== to) metamodels.set(to, metamodel);
+	return to;
+}
+function createEmptyModel(diagram = DEFAULT_DIAGRAM, options = {}) {
+	const model = {
 		elements: /* @__PURE__ */ new Map(),
 		links: /* @__PURE__ */ new Map(),
 		diagram,
 		tool: PISTAR_TOOL,
 		istar: "2.0"
 	};
+	return options.metamodel ? withMetamodel(model, options.metamodel) : model;
+}
+/**
+* The metamodel a model was read or created with (see `parsePistar`, `createEmptyModel`), or
+* iStar 2.0. Constraints, operations and serialization use it unless given another one.
+*/
+function metamodelOf(model) {
+	return metamodels.get(model) ?? ISTAR_2_0;
 }
+/**
+* True for iStar 2.0 actors (Actor, Agent, Role). One argument, so it is safe as an array
+* callback (`elements.filter(isActor)`). For extended actor kinds use `isActorIn(metamodel)`.
+*/
 function isActor(element) {
-	return element !== void 0 && isActorKind(element.kind);
+	return element !== void 0 && isActorKindIn(ISTAR_2_0, element.kind);
 }
+/** True for iStar 2.0 intentional elements. For extended kinds use `isNodeIn(metamodel)`. */
 function isNode(element) {
-	return element !== void 0 && !isActorKind(element.kind);
+	return element !== void 0 && !isActorKindIn(ISTAR_2_0, element.kind);
+}
+/**
+* A predicate for actor-category elements of `metamodel`, extended actor kinds included:
+* `elements.filter(isActorIn(metamodelOf(model)))`.
+*/
+function isActorIn(metamodel) {
+	return (element) => element !== void 0 && isActorKindIn(metamodel, element.kind);
+}
+/** A predicate for node-category elements of `metamodel`, extended node kinds included. */
+function isNodeIn(metamodel) {
+	return (element) => element !== void 0 && metamodel.elements.get(element.kind)?.category === "node";
 }
 /** Inner elements of an actor, in model order. */
 function childrenOf(model, actorId) {
@@ -175,10 +451,11 @@ function linksOf(model, elementId) {
 }
 /** For a dependum, the two halves of its dependency: depender → dependum → dependee. */
 function dependencyLinksOf(model, dependumId) {
+	const metamodel = metamodelOf(model);
 	let inbound;
 	let outbound;
 	for (const link of model.links.values()) {
-		if (link.kind !== "istar.DependencyLink") continue;
+		if (metamodel.links.get(link.kind)?.category !== "dependency") continue;
 		if (link.target === dependumId && !inbound) inbound = link;
 		if (link.source === dependumId && !outbound) outbound = link;
 	}
@@ -200,17 +477,41 @@ function fail(code, reason) {
 /**
 * Checks whether a link of `kind` may be added from `source` to `target` in `model`.
 *
-* For `istar.DependencyLink`, `source` is the depender and `target` the dependee (an actor or
-* one of its inner elements); the dependum sits between them and is not part of the check.
+* For dependency links, `source` is the depender and `target` the dependee (an actor or one of
+* its inner elements); the dependum sits between them and is not part of the check.
+*
+* Extended kinds (see `extendMetamodel`) are checked with the rules of the kind they behave
+* like, or with their declarative rules, then with their extra predicate.
 */
-function canLink(model, source, target, kind) {
-	const s = resolve(model, source);
-	const t = resolve(model, target);
+function canLink(model, source, target, kind, options = {}) {
+	const any = model;
+	const metamodel = options.metamodel ?? metamodelOf(model);
+	const s = resolve(any, source);
+	const t = resolve(any, target);
 	if (!s) return fail("unknown-element", `unknown source element "${refId(source)}"`);
 	if (!t) return fail("unknown-element", `unknown target element "${refId(target)}"`);
-	const check = CHECKS[kind];
-	if (!check) return fail("unknown-link-kind", `unknown link kind "${String(kind)}"`);
-	return check(new Graph(model), s, t);
+	const definition = metamodel.links.get(kind);
+	if (!definition) return fail("unknown-link-kind", `unknown link kind "${String(kind)}"`);
+	return checkWith(new Graph(any, metamodel), definition, s, t);
+}
+/** Runs the rule a link kind resolves to, then every extra predicate along its chain. */
+function checkWith(graph, definition, source, target) {
+	const chain = [];
+	for (let current = definition; current && !chain.includes(current); current = current.behavesLike ? graph.metamodel.links.get(current.behavesLike) : void 0) chain.push(current);
+	const root = chain[chain.length - 1];
+	const builtIn = CHECKS[root.kind];
+	let result;
+	if (root.rules) result = declarativeCheck(graph, definition, root.rules, root.kind, source, target);
+	else if (builtIn) result = builtIn(graph, source, target);
+	else result = fail("unknown-link-kind", `link kind "${definition.kind}" has no rules`);
+	if (!result.ok) return result;
+	const context = graph.context(definition.kind, source, target);
+	for (const step of chain.toReversed()) {
+		if (!step.check) continue;
+		const extra = step.check(context);
+		if (!extra.ok) return extra;
+	}
+	return OK;
 }
 function refId(ref) {
 	return typeof ref === "string" ? ref : ref.id;
@@ -218,11 +519,20 @@ function refId(ref) {
 function resolve(model, ref) {
 	return model.elements.get(refId(ref));
 }
-/** The graph queries used by upstream constraints (`istar.isThereLinkBetween`, etc.). */
+/**
+* The graph queries used by upstream constraints (`istar.isThereLinkBetween`, etc.). Link kinds
+* are compared by what they behave like, so an extension link behaving like an OR-refinement
+* counts as one for the iStar 2.0 rules (no mixing with AND, no refining a depender…).
+*/
 var Graph = class {
 	model;
-	constructor(model) {
+	metamodel;
+	constructor(model, metamodel) {
 		this.model = model;
+		this.metamodel = metamodel;
+	}
+	matches(link, kind) {
+		return link.kind === kind || effectiveLinkKind(this.metamodel, link.kind) === kind;
 	}
 	/**
 	* True when a link (optionally of `kind`) already connects the two elements, in either
@@ -230,47 +540,76 @@ var Graph = class {
 	*/
 	isThereLinkBetween(a, b, kind) {
 		for (const link of this.model.links.values()) {
-			if (kind && link.kind !== kind) continue;
+			if (kind && !this.matches(link, kind)) continue;
+			if (link.source === a.id && link.target === b.id || link.source === b.id && link.target === a.id) return true;
+		}
+		return false;
+	}
+	/** Like `isThereLinkBetween`, counting only links of exactly `kind`. */
+	isThereLinkOfKindBetween(a, b, kind) {
+		for (const link of this.model.links.values()) {
+			if (link.kind !== kind) continue;
 			if (link.source === a.id && link.target === b.id || link.source === b.id && link.target === a.id) return true;
 		}
 		return false;
 	}
 	isSourceOfType(element, kind) {
-		for (const link of this.model.links.values()) if (link.kind === kind && link.source === element.id) return true;
+		for (const link of this.model.links.values()) if (link.source === element.id && this.matches(link, kind)) return true;
 		return false;
 	}
 	isTargetOfType(element, kind) {
-		for (const link of this.model.links.values()) if (link.kind === kind && link.target === element.id) return true;
+		for (const link of this.model.links.values()) if (link.target === element.id && this.matches(link, kind)) return true;
 		return false;
 	}
+	/** The kind the iStar 2.0 rules see: built-in kinds as they are, extensions as what they behave like. */
+	kindOf(element) {
+		return effectiveElementKind(this.metamodel, element.kind);
+	}
+	isActor(element) {
+		return this.metamodel.elements.get(element.kind)?.category === "actor";
+	}
+	context(kind, source, target) {
+		return {
+			model: this.model,
+			metamodel: this.metamodel,
+			kind,
+			source,
+			target,
+			isThereLinkBetween: (a, b, k) => this.isThereLinkBetween(a, b, k),
+			isSourceOfType: (e, k) => this.isSourceOfType(e, k),
+			isTargetOfType: (e, k) => this.isTargetOfType(e, k)
+		};
+	}
+};
+const is = (graph, element, ...shortNames) => {
+	const kind = graph.kindOf(element);
+	return shortNames.some((name) => kind === `istar.${name}`);
 };
-const is = (element, ...shortNames) => shortNames.some((name) => element.kind === `istar.${name}`);
-const isKindOfActor = (element) => isActorKind(element.kind);
 const isDependum = (element) => element.isDependum === true;
 const isALink = (graph, source, target) => {
-	if (!is(source, "Actor", "Role")) return fail("invalid-source", "the source of Is-A links must be a Role or a general Actor (iStar 2.0 Guide, Page 6).");
+	if (!is(graph, source, "Actor", "Role")) return fail("invalid-source", "the source of Is-A links must be a Role or a general Actor (iStar 2.0 Guide, Page 6).");
 	if (source.kind !== target.kind) return fail("actor-types-differ", "the source and target of Is-A links must be of the same type - Actor and Actor, or Role and Role (iStar 2.0 Guide, Page 6).");
-	if (!is(target, "Actor", "Role")) return fail("invalid-target", "the target of Is-A links must be a Role or a general Actor (iStar 2.0 Guide, Page 6).");
+	if (!is(graph, target, "Actor", "Role")) return fail("invalid-target", "the target of Is-A links must be a Role or a general Actor (iStar 2.0 Guide, Page 6).");
 	if (source.id === target.id) return fail("self-link", "you cannot make Is-A links from an actor onto itself.");
 	if (graph.isThereLinkBetween(source, target)) return fail("duplicate-link", "there can only be one Actor link between the same two actors (iStar 2.0 Guide, Page 14).");
 	return OK;
 };
 const participatesInLink = (graph, source, target) => {
-	if (!isKindOfActor(source)) return fail("invalid-source", "the source of a Participates-In link must be some kind of actor (iStar 2.0 Guide, Page 6)");
-	if (!isKindOfActor(target)) return fail("invalid-target", "the target of a Participates-In link must be some kind of actor (iStar 2.0 Guide, Page 6)");
+	if (!graph.isActor(source)) return fail("invalid-source", "the source of a Participates-In link must be some kind of actor (iStar 2.0 Guide, Page 6)");
+	if (!graph.isActor(target)) return fail("invalid-target", "the target of a Participates-In link must be some kind of actor (iStar 2.0 Guide, Page 6)");
 	if (source.id === target.id) return fail("self-link", "you cannot make a Participates-In link from an actor onto itself.");
 	if (graph.isThereLinkBetween(source, target)) return fail("duplicate-link", "there can only be one Actor link between the same two actors (iStar 2.0 Guide, Page 14).");
 	return OK;
 };
 /** The actor an element belongs to: itself for actors, its parent for inner elements. */
-function owningActorId(element) {
-	return isKindOfActor(element) ? element.id : element.parent;
+function owningActorId(graph, element) {
+	return graph.isActor(element) ? element.id : element.parent;
 }
 const dependencyLink = (graph, source, target) => {
 	if (source.id === target.id) return fail("self-link", "a Dependency link cannot link an element onto itself");
 	if (isDependum(source)) return fail("dependum-endpoint", "a Dependency link cannot start from a dependum");
 	if (isDependum(target)) return fail("dependum-endpoint", "a Dependency link cannot end in a dependum");
-	if (owningActorId(source) === owningActorId(target)) return fail("same-actor", "a Dependency link must involve two different actors (iStar 2.0 Guide, Page 14)");
+	if (owningActorId(graph, source) === owningActorId(graph, target)) return fail("same-actor", "a Dependency link must involve two different actors (iStar 2.0 Guide, Page 14)");
 	if (graph.isTargetOfType(source, "istar.OrRefinementLink") || graph.isTargetOfType(source, "istar.AndRefinementLink")) return fail("refined-depender", "a refined element cannot be the Depender Element in a Dependency link (iStar 2.0 Guide, Page 14). Instead, you can try to add the Dependency originating from a child.");
 	if (graph.isTargetOfType(source, "istar.ContributionLink")) return fail("contributed-depender", "a contributed element cannot be the Depender Element in a Dependency link (iStar 2.0 Guide, Page 14). Instead, you can try to add the Dependency originating from a child.");
 	return OK;
@@ -278,8 +617,8 @@ const dependencyLink = (graph, source, target) => {
 function refinementLink(label) {
 	const other = label === "AND" ? "istar.OrRefinementLink" : "istar.AndRefinementLink";
 	return (graph, source, target) => {
-		if (!is(source, "Task", "Goal")) return fail("invalid-source", `the source of an ${label}-refinement link must be a Goal or a Task (iStar 2.0 Guide, Table 1)`);
-		if (!is(target, "Task", "Goal")) return fail("invalid-target", `the target of an ${label}-refinement link must be a Goal or a Task (iStar 2.0 Guide, Table 1)`);
+		if (!is(graph, source, "Task", "Goal")) return fail("invalid-source", `the source of an ${label}-refinement link must be a Goal or a Task (iStar 2.0 Guide, Table 1)`);
+		if (!is(graph, target, "Task", "Goal")) return fail("invalid-target", `the target of an ${label}-refinement link must be a Goal or a Task (iStar 2.0 Guide, Table 1)`);
 		if (source.id === target.id) return fail("self-link", `you cannot make an ${label}-refinement link from an element onto itself`);
 		if (isDependum(source) || isDependum(target)) return fail("dependum-endpoint", `you cannot make an ${label}-refinement link with a dependum (iStar 2.0 Guide, Page 14)`);
 		if (source.parent !== target.parent) return fail("different-actors", `the source and target of an ${label}-refinement link must pertain to the same actor (iStar 2.0 Guide, Page 14)`);
@@ -290,8 +629,8 @@ function refinementLink(label) {
 	};
 }
 const neededByLink = (graph, source, target) => {
-	if (!is(source, "Resource")) return fail("invalid-source", "the source of a Needed-By link must be a Resource (iStar 2.0 Guide, Table 1)");
-	if (!is(target, "Task")) return fail("invalid-target", "the target of a Needed-By link must be a Task (iStar 2.0 Guide, Table 1)");
+	if (!is(graph, source, "Resource")) return fail("invalid-source", "the source of a Needed-By link must be a Resource (iStar 2.0 Guide, Table 1)");
+	if (!is(graph, target, "Task")) return fail("invalid-target", "the target of a Needed-By link must be a Task (iStar 2.0 Guide, Table 1)");
 	if (source.id === target.id) return fail("self-link", "you cannot make a Needed-By link from an element onto itself");
 	if (isDependum(source) || isDependum(target)) return fail("dependum-endpoint", "you cannot make a Needed-By link with a dependum (iStar 2.0 Guide, Page 14)");
 	if (source.parent !== target.parent) return fail("different-actors", "the source and target of a Needed-By link must pertain to the same actor (iStar 2.0 Guide, Page 14)");
@@ -299,8 +638,8 @@ const neededByLink = (graph, source, target) => {
 	return OK;
 };
 const contributionLink = (graph, source, target) => {
-	if (!is(source, "Goal", "Quality", "Task", "Resource")) return fail("invalid-source", "the source of a Contribution link must be a Goal, a Quality, a Task or a Resource (iStar 2.0 Guide, Table 1)");
-	if (!is(target, "Quality")) return fail("invalid-target", "the target of a Contribution link must be a Quality (iStar 2.0 Guide, Table 1)");
+	if (!is(graph, source, "Goal", "Quality", "Task", "Resource")) return fail("invalid-source", "the source of a Contribution link must be a Goal, a Quality, a Task or a Resource (iStar 2.0 Guide, Table 1)");
+	if (!is(graph, target, "Quality")) return fail("invalid-target", "the target of a Contribution link must be a Quality (iStar 2.0 Guide, Table 1)");
 	if (source.id === target.id) return fail("self-link", "you cannot make a Contribution link from an element onto itself (iStar 2.0 Guide, Page 15)");
 	if (isDependum(source) || isDependum(target)) return fail("dependum-endpoint", "you cannot make a Contribution link with a dependum (iStar 2.0 Guide, Page 14)");
 	if (source.parent !== target.parent) return fail("different-actors", "the source and target of a Contribution link must pertain to the same actor (iStar 2.0 Guide, Page 14)");
@@ -310,8 +649,8 @@ const contributionLink = (graph, source, target) => {
 	return OK;
 };
 const qualificationLink = (graph, source, target) => {
-	if (!is(source, "Quality")) return fail("invalid-source", "the source of a Qualification link must be a Quality (iStar 2.0 Guide, Table 1)");
-	if (!is(target, "Goal", "Task", "Resource")) return fail("invalid-target", "the target of a Qualification link must be a Goal, a Task or a Resource (iStar 2.0 Guide, Table 1)");
+	if (!is(graph, source, "Quality")) return fail("invalid-source", "the source of a Qualification link must be a Quality (iStar 2.0 Guide, Table 1)");
+	if (!is(graph, target, "Goal", "Task", "Resource")) return fail("invalid-target", "the target of a Qualification link must be a Goal, a Task or a Resource (iStar 2.0 Guide, Table 1)");
 	if (source.id === target.id) return fail("self-link", "you cannot make a Qualification link from an element onto itself");
 	if (isDependum(source) || isDependum(target)) return fail("dependum-endpoint", "you cannot make a Qualification link with a dependum (iStar 2.0 Guide, Page 14)");
 	if (source.parent !== target.parent) return fail("different-actors", "the source and target of a Qualification link must pertain to the same actor (iStar 2.0 Guide, Page 14)");
@@ -319,6 +658,42 @@ const qualificationLink = (graph, source, target) => {
 	if (graph.isThereLinkBetween(source, target, "istar.ContributionLink")) return fail("contribution-and-qualification", "you cannot have Qualification and Contribution links between the same two elements (iStar 2.0 Guide, Page 15)");
 	return OK;
 };
+/** The words used for a list of kind selectors in messages: "a Goal or a Task". */
+function describe(graph, selectors) {
+	const names = selectors.map((selector) => {
+		if (selector === "*") return "any element";
+		if (selector === "node") return "an intentional element";
+		if (selector === "actor") return "an actor";
+		const label = graph.metamodel.elements.get(selector)?.label ?? selector;
+		return /^[aeiou]/i.test(label) ? `an ${label}` : `a ${label}`;
+	});
+	return names.length <= 2 ? names.join(" or ") : `${names.slice(0, -1).join(", ")} or ${names[names.length - 1]}`;
+}
+function matchesSelector(graph, element, selector) {
+	if (selector === "*") return true;
+	const category = graph.metamodel.elements.get(element.kind)?.category;
+	if (selector === "node" || selector === "actor") return category === selector;
+	return elementBehavesLike(graph.metamodel, element.kind, selector);
+}
+/**
+* Declarative rules of an extension link kind, checked in the order of the iStar 2.0 node-link
+* rules (and of piStar-ext's generated `isValid`): source kind, target kind, self link,
+* dependum, same actor, duplicates.
+*/
+function declarativeCheck(graph, definition, rules, rulesKind, source, target) {
+	const name = definition.label;
+	const article = /^[aeiou]/i.test(name) ? "an" : "a";
+	if (!rules.sources.some((selector) => matchesSelector(graph, source, selector))) return fail("invalid-source", `the source of ${article} ${name} link must be ${describe(graph, rules.sources)}`);
+	if (!rules.targets.some((selector) => matchesSelector(graph, target, selector))) return fail("invalid-target", `the target of ${article} ${name} link must be ${describe(graph, rules.targets)}`);
+	if (!rules.allowSelf && source.id === target.id) return fail("self-link", `you cannot make ${article} ${name} link from an element onto itself`);
+	if (definition.category === "node") {
+		if (!rules.allowDependum && (isDependum(source) || isDependum(target))) return fail("dependum-endpoint", `you cannot make ${article} ${name} link with a dependum`);
+		if (rules.sameActor !== false && source.parent !== target.parent) return fail("different-actors", `the source and target of ${article} ${name} link must pertain to the same actor (iStar 2.0 Guide, Page 14)`);
+	}
+	const unique = rules.unique ?? "kind";
+	if (unique === "any" && graph.isThereLinkBetween(source, target) || unique === "kind" && graph.isThereLinkOfKindBetween(source, target, definition.kind) || unique === "kind" && rulesKind !== definition.kind && graph.isThereLinkOfKindBetween(source, target, rulesKind)) return fail("duplicate-link", `there can only be one ${name} link between the same two elements`);
+	return OK;
+}
 const CHECKS = {
 	"istar.IsALink": isALink,
 	"istar.ParticipatesInLink": participatesInLink,
@@ -329,42 +704,42 @@ const CHECKS = {
 	"istar.ContributionLink": contributionLink,
 	"istar.QualificationLink": qualificationLink
 };
-/**
-* Re-validates every link of a model, the way piStar does when loading a file: dependencies
-* first (each checked before its own links are added), then the remaining links in file
-* order, each against the graph built so far. Invalid links are reported, not removed.
-*/
-function validateModel(model) {
+function validateModel(model, options) {
+	const metamodel = (typeof options === "object" && options !== null ? options.metamodel : void 0) ?? metamodelOf(model);
+	const any = model;
 	const issues = [];
 	const accepted = /* @__PURE__ */ new Map();
 	const view = () => ({
-		...model,
+		...any,
 		links: accepted
 	});
-	const report = (linkId, kind, source, target, check) => {
-		if (!check.ok) issues.push({
+	const check = (source, target, kind) => canLink(view(), source, target, kind, { metamodel });
+	const isDependency = (link) => metamodel.links.get(link.kind)?.category === "dependency";
+	const report = (linkId, kind, source, target, result) => {
+		if (!result.ok) issues.push({
 			linkId,
 			kind,
 			source,
 			target,
-			code: check.code,
-			message: check.reason
+			code: result.code,
+			message: result.reason
 		});
 	};
-	const dependencyLinks = [...model.links.values()].filter((l) => l.kind === "istar.DependencyLink");
-	for (const dependum of model.elements.values()) {
+	const dependencyLinks = [...any.links.values()].filter(isDependency);
+	for (const dependum of any.elements.values()) {
 		if (!dependum.isDependum) continue;
 		const inbound = dependencyLinks.find((l) => l.target === dependum.id);
 		const outbound = dependencyLinks.find((l) => l.source === dependum.id);
 		const depender = inbound?.source ?? dependum.dependency?.source;
 		const dependee = outbound?.target ?? dependum.dependency?.target;
-		if (depender !== void 0 && dependee !== void 0) report(inbound?.id ?? dependum.id, "istar.DependencyLink", depender, dependee, canLink(view(), depender, dependee, "istar.DependencyLink"));
+		const kind = inbound?.kind ?? outbound?.kind ?? "istar.DependencyLink";
+		if (depender !== void 0 && dependee !== void 0) report(inbound?.id ?? dependum.id, kind, depender, dependee, check(depender, dependee, kind));
 		if (inbound) accepted.set(inbound.id, inbound);
 		if (outbound) accepted.set(outbound.id, outbound);
 	}
-	for (const link of model.links.values()) {
-		if (link.kind === "istar.DependencyLink") continue;
-		if (model.elements.has(link.source) && model.elements.has(link.target)) report(link.id, link.kind, link.source, link.target, canLink(view(), link.source, link.target, link.kind));
+	for (const link of any.links.values()) {
+		if (isDependency(link)) continue;
+		if (any.elements.has(link.source) && any.elements.has(link.target)) report(link.id, link.kind, link.source, link.target, check(link.source, link.target, link.kind));
 		else report(link.id, link.kind, link.source, link.target, {
 			ok: false,
 			code: "unknown-element",
@@ -379,6 +754,10 @@ function validateModel(model) {
 var PistarParseError = class extends Error {
 	name = "PistarParseError";
 };
+/** Thrown by `toPistar` for a kind its metamodel doesn't know (rather than writing it wrong). */
+var PistarWriteError = class extends Error {
+	name = "PistarWriteError";
+};
 const layouts = /* @__PURE__ */ new WeakMap();
 /** The key order recorded when `model` was parsed, if it came from `parsePistar`. */
 function getSourceLayout(model) {
@@ -447,13 +826,9 @@ function asArray(value, where) {
 	if (!Array.isArray(value)) throw new PistarParseError(`"${where}" must be an array`);
 	return value;
 }
-/**
-* Parses a piStar save file (JSON text or an already-parsed object). The input is not mutated.
-*
-* Unlike the piStar tool, elements with `x` or `y` equal to 0 are kept: upstream's
-* `if (element.x && element.y)` silently drops them, which looks unintended.
-*/
-function parsePistar(input) {
+function parsePistar(input, options = {}) {
+	const metamodel = options.metamodel ?? ISTAR_2_0;
+	const categoryOf = (kind) => metamodel.elements.get(kind)?.category;
 	let json;
 	if (typeof input === "string") try {
 		json = JSON.parse(input);
@@ -476,11 +851,12 @@ function parsePistar(input) {
 		if (!isRecord(raw)) throw new PistarParseError(`${where}: expected an object`);
 		const { id, type } = raw;
 		if (typeof id !== "string" || id === "") throw new PistarParseError(`${where}: missing "id"`);
-		if (typeof type !== "string" || !isElementKind(type)) throw new PistarParseError(`${where} (${id}): unknown element type ${JSON.stringify(type)}`);
+		const kind = typeof type === "string" ? metamodel.elementsByPistarType.get(type) : void 0;
+		if (kind === void 0) throw new PistarParseError(`${where} (${id}): unknown element type ${JSON.stringify(type)}`);
 		if (elements.has(id) || links.has(id)) throw new PistarParseError(`${where}: duplicated id "${id}"`);
 		const element = {
 			id,
-			kind: type,
+			kind,
 			name: typeof raw.text === "string" ? raw.text : "",
 			x: typeof raw.x === "number" ? raw.x : 0,
 			y: typeof raw.y === "number" ? raw.y : 0,
@@ -494,9 +870,10 @@ function parsePistar(input) {
 	};
 	asArray(json.actors, "actors").forEach((raw, i) => {
 		const actor = readElement(raw, `actors[${i}]`, ACTOR_KEYS, {});
-		if (!isActorKind(actor.kind)) throw new PistarParseError(`actors[${i}] (${actor.id}): ${actor.kind} is not an actor kind`);
+		if (categoryOf(actor.kind) !== "actor") throw new PistarParseError(`actors[${i}] (${actor.id}): ${actor.kind} is not an actor kind`);
 		asArray(raw.nodes, `actors[${i}].nodes`).forEach((node, j) => {
-			if (isActorKind(readElement(node, `actors[${i}].nodes[${j}]`, ELEMENT_KEYS, { parent: actor.id }).kind)) throw new PistarParseError(`actors[${i}].nodes[${j}]: actors cannot be nested`);
+			const child = readElement(node, `actors[${i}].nodes[${j}]`, ELEMENT_KEYS, { parent: actor.id });
+			if (categoryOf(child.kind) === "actor") throw new PistarParseError(`actors[${i}].nodes[${j}]: actors cannot be nested`);
 		});
 	});
 	asArray(json.orphans, "orphans").forEach((raw, i) => {
@@ -517,12 +894,13 @@ function parsePistar(input) {
 		if (!isRecord(raw)) throw new PistarParseError(`links[${i}]: expected an object`);
 		const { id, type, source, target } = raw;
 		if (typeof id !== "string" || id === "") throw new PistarParseError(`links[${i}]: missing "id"`);
-		if (typeof type !== "string" || !isLinkKind(type)) throw new PistarParseError(`links[${i}] (${id}): unknown link type ${JSON.stringify(type)}`);
+		const kind = typeof type === "string" ? metamodel.linksByPistarType.get(type) : void 0;
+		if (kind === void 0) throw new PistarParseError(`links[${i}] (${id}): unknown link type ${JSON.stringify(type)}`);
 		if (typeof source !== "string" || typeof target !== "string") throw new PistarParseError(`links[${i}] (${id}): missing "source" or "target"`);
 		if (elements.has(id) || links.has(id)) throw new PistarParseError(`links[${i}]: duplicated id "${id}"`);
 		links.set(id, {
 			id,
-			kind: type,
+			kind,
 			source,
 			target,
 			...optional("name", typeof raw.name === "string" ? raw.name : void 0),
@@ -559,7 +937,7 @@ function parsePistar(input) {
 		keys: Object.keys(json),
 		display: Object.keys(display)
 	});
-	return model;
+	return withMetamodel(model, metamodel);
 }
 function optional(key, value) {
 	return value === void 0 ? {} : { [key]: value };
@@ -567,18 +945,25 @@ function optional(key, value) {
 function formatDate(date) {
 	return date.toUTCString();
 }
-function elementJson(element) {
+function pistarTypeOf(type, kind, metamodel) {
+	if (type === void 0) throw new PistarWriteError(`kind "${kind}" is not part of ${metamodel.name}; pass its metamodel (toPistar(model, { metamodel }) or withMetamodel)`);
+	return type;
+}
+function elementJson(element, metamodel) {
 	return {
 		id: element.id,
 		text: element.name,
-		type: element.kind,
+		type: pistarTypeOf(metamodel.elements.get(element.kind)?.pistarType, element.kind, metamodel),
 		x: element.x,
 		y: element.y,
 		...element.customProperties ? { customProperties: { ...element.customProperties } } : {}
 	};
 }
 /** Builds the save-file object for a model. `toPistar` is this plus `JSON.stringify`. */
-function toPistarObject(model, options = {}) {
+function toPistarObject(input, options = {}) {
+	const model = input;
+	const metamodel = options.metamodel ?? metamodelOf(input);
+	const isActorKind = (kind) => metamodel.elements.get(kind)?.category === "actor";
 	const actors = [];
 	const orphans = [];
 	const dependencies = [];
@@ -587,31 +972,31 @@ function toPistarObject(model, options = {}) {
 		let list = children.get(element.parent);
 		if (!list) children.set(element.parent, list = []);
 		list.push({
-			...elementJson(element),
+			...elementJson(element, metamodel),
 			...element.extra
 		});
 	}
 	for (const element of model.elements.values()) if (isActorKind(element.kind)) actors.push({
-		...elementJson(element),
+		...elementJson(element, metamodel),
 		nodes: children.get(element.id) ?? [],
 		...element.extra
 	});
 	else if (element.isDependum) {
 		const { inbound, outbound } = dependencyLinksOf(model, element.id);
 		dependencies.push({
-			...elementJson(element),
+			...elementJson(element, metamodel),
 			source: inbound?.source ?? element.dependency?.source ?? "",
 			target: outbound?.target ?? element.dependency?.target ?? "",
 			...element.extra
 		});
 	} else if (element.parent === void 0 || !model.elements.has(element.parent)) orphans.push({
-		...elementJson(element),
+		...elementJson(element, metamodel),
 		...element.extra
 	});
 	const links = [];
 	for (const link of model.links.values()) links.push({
 		id: link.id,
-		type: link.kind,
+		type: pistarTypeOf(metamodel.links.get(link.kind)?.pistarType, link.kind, metamodel),
 		source: link.source,
 		target: link.target,
 		...link.name !== void 0 ? { name: link.name } : {},
@@ -691,11 +1076,23 @@ const defaultIdGenerator = () => {
 		return (ch === "x" ? r : r & 3 | 8).toString(16);
 	});
 };
+function any(model) {
+	return model;
+}
+function typed(model) {
+	return model;
+}
+function metaOf(model) {
+	return metamodelOf(model);
+}
+function isActorIn$1(model, kind) {
+	return metaOf(model).elements.get(kind)?.category === "actor";
+}
 function derive(from, changes) {
-	return inheritSourceLayout(from, {
+	return inheritMetamodel(from, inheritSourceLayout(from, {
 		...from,
 		...changes
-	});
+	}));
 }
 function requireElement(model, id) {
 	const element = model.elements.get(id);
@@ -713,16 +1110,20 @@ function withoutUndefined(value) {
 	return out;
 }
 function addElement(model, input, ctx = {}) {
+	const m = any(model);
+	const metamodel = metaOf(m);
+	const definition = metamodel.elements.get(input.kind);
+	if (!definition) throw new ModelOperationError(`unknown element kind "${input.kind}" in ${metamodel.name}`);
 	const id = input.id ?? (ctx.createId ?? defaultIdGenerator)();
-	if (model.elements.has(id) || model.links.has(id)) throw new ModelOperationError(`id "${id}" is already in use`);
+	if (m.elements.has(id) || m.links.has(id)) throw new ModelOperationError(`id "${id}" is already in use`);
 	if (input.parent !== void 0) {
-		if (isActorKind(input.kind)) throw new ModelOperationError("actors cannot be nested");
-		if (!isActorKind(requireElement(model, input.parent).kind)) throw new ModelOperationError(`parent "${input.parent}" is not an actor`);
+		if (definition.category === "actor") throw new ModelOperationError("actors cannot be nested");
+		if (!isActorIn$1(m, requireElement(m, input.parent).kind)) throw new ModelOperationError(`parent "${input.parent}" is not an actor`);
 	}
 	const element = withoutUndefined({
 		id,
 		kind: input.kind,
-		name: input.name ?? shortKindName(input.kind),
+		name: input.name ?? definition.label,
 		x: input.x,
 		y: input.y,
 		parent: input.parent,
@@ -730,7 +1131,7 @@ function addElement(model, input, ctx = {}) {
 		display: input.display
 	});
 	return {
-		model: derive(model, { elements: new Map(model.elements).set(id, element) }),
+		model: typed(derive(m, { elements: new Map(m.elements).set(id, element) })),
 		element
 	};
 }
@@ -743,38 +1144,40 @@ function mergeDisplay(current, patch) {
 	return Object.keys(merged).length > 0 ? merged : void 0;
 }
 function updateElement(model, id, patch) {
-	const current = requireElement(model, id);
+	const m = any(model);
+	const current = requireElement(m, id);
 	const next = withoutUndefined({
 		...current,
 		name: patch.name ?? current.name,
 		customProperties: patch.customProperties === void 0 ? current.customProperties : patch.customProperties ?? void 0,
 		display: mergeDisplay(current.display, patch.display)
 	});
-	return derive(model, { elements: new Map(model.elements).set(id, next) });
+	return typed(derive(m, { elements: new Map(m.elements).set(id, next) }));
 }
 /**
 * Moves an element to an absolute position. Moving an actor shifts its inner elements by the
 * same offset.
 */
 function moveElement(model, id, x, y) {
-	const current = requireElement(model, id);
+	const m = any(model);
+	const current = requireElement(m, id);
 	const dx = x - current.x;
 	const dy = y - current.y;
 	if (dx === 0 && dy === 0) return model;
-	const elements = new Map(model.elements);
+	const elements = new Map(m.elements);
 	elements.set(id, {
 		...current,
 		x,
 		y
 	});
-	if (isActorKind(current.kind)) {
-		for (const child of model.elements.values()) if (child.parent === id) elements.set(child.id, {
+	if (isActorIn$1(m, current.kind)) {
+		for (const child of m.elements.values()) if (child.parent === id) elements.set(child.id, {
 			...child,
 			x: child.x + dx,
 			y: child.y + dy
 		});
 	}
-	return derive(model, { elements });
+	return typed(derive(m, { elements }));
 }
 /**
 * Moves an inner element into another actor (or out of any actor with `null`). The element
@@ -782,32 +1185,35 @@ function moveElement(model, id, x, y) {
 * them.
 */
 function nestElement(model, id, parent) {
-	const current = requireElement(model, id);
-	if (isActorKind(current.kind)) throw new ModelOperationError("actors cannot be nested");
+	const m = any(model);
+	const current = requireElement(m, id);
+	if (isActorIn$1(m, current.kind)) throw new ModelOperationError("actors cannot be nested");
 	if (current.isDependum) throw new ModelOperationError("a dependum cannot be nested");
 	if ((current.parent ?? null) === parent) return model;
-	if (parent !== null && !isActorKind(requireElement(model, parent).kind)) throw new ModelOperationError(`parent "${parent}" is not an actor`);
-	const elements = new Map(model.elements);
+	if (parent !== null && !isActorIn$1(m, requireElement(m, parent).kind)) throw new ModelOperationError(`parent "${parent}" is not an actor`);
+	const elements = new Map(m.elements);
 	elements.delete(id);
 	const { parent: _old, ...rest } = current;
 	elements.set(id, parent === null ? rest : {
 		...rest,
 		parent
 	});
-	return derive(model, { elements });
+	return typed(derive(m, { elements }));
 }
 /**
 * Removes elements and everything that depends on them: inner elements of removed actors,
 * links touching removed elements, and the rest of any dependency that loses a part.
 */
 function removeElements(model, ids) {
-	return removeCascade(model, new Set(ids), /* @__PURE__ */ new Set());
+	return typed(removeCascade(any(model), new Set(ids), /* @__PURE__ */ new Set()));
 }
 function removeElement(model, id) {
-	requireElement(model, id);
+	requireElement(any(model), id);
 	return removeElements(model, [id]);
 }
 function removeCascade(model, elementIds, linkIds) {
+	const metamodel = metaOf(model);
+	const isDependencyHalf = (link) => metamodel.links.get(link.kind)?.category === "dependency";
 	let changed = true;
 	while (changed) {
 		changed = false;
@@ -826,7 +1232,7 @@ function removeCascade(model, elementIds, linkIds) {
 			}
 		}
 		for (const link of model.links.values()) {
-			if (!linkIds.has(link.id) || link.kind !== "istar.DependencyLink") continue;
+			if (!linkIds.has(link.id) || !isDependencyHalf(link)) continue;
 			for (const end of [link.source, link.target]) if (model.elements.get(end)?.isDependum && !elementIds.has(end)) {
 				elementIds.add(end);
 				changed = true;
@@ -845,14 +1251,18 @@ function removeCascade(model, elementIds, linkIds) {
 }
 /** Adds a link between two elements if the iStar constraints allow it. */
 function connect(model, input, options = {}) {
-	if (input.kind === "istar.DependencyLink") throw new ModelOperationError("use addDependency to create dependencies");
+	const m = any(model);
+	const metamodel = metaOf(m);
+	const kind = input.kind;
+	const definition = metamodel.links.get(kind);
+	if (definition?.category === "dependency") throw new ModelOperationError("use addDependency to create dependencies");
 	let { source, target } = input;
 	let reversed = false;
 	if (!options.force) {
-		let check = canLink(model, source, target, input.kind);
-		const tryReversed = options.tryReversed ?? LINK_KIND_INFO[input.kind].tryReversedWhenAdding;
+		let check = canLink(m, source, target, kind);
+		const tryReversed = options.tryReversed ?? definition?.info.tryReversedWhenAdding;
 		if (!check.ok && tryReversed) {
-			const swapped = canLink(model, target, source, input.kind);
+			const swapped = canLink(m, target, source, kind);
 			if (swapped.ok) {
 				[source, target] = [target, source];
 				reversed = true;
@@ -861,14 +1271,15 @@ function connect(model, input, options = {}) {
 		}
 		if (!check.ok) return check;
 	} else {
-		requireElement(model, source);
-		requireElement(model, target);
+		if (!definition) throw new ModelOperationError(`unknown link kind "${kind}" in ${metamodel.name}`);
+		requireElement(m, source);
+		requireElement(m, target);
 	}
 	const id = input.id ?? (options.createId ?? defaultIdGenerator)();
-	if (model.elements.has(id) || model.links.has(id)) throw new ModelOperationError(`id "${id}" is already in use`);
+	if (m.elements.has(id) || m.links.has(id)) throw new ModelOperationError(`id "${id}" is already in use`);
 	const link = withoutUndefined({
 		id,
-		kind: input.kind,
+		kind,
 		source,
 		target,
 		label: input.label,
@@ -877,23 +1288,29 @@ function connect(model, input, options = {}) {
 	});
 	return {
 		ok: true,
-		model: derive(model, { links: new Map(model.links).set(id, link) }),
+		model: typed(derive(m, { links: new Map(m.links).set(id, link) })),
 		link,
 		reversed
 	};
 }
 /** Adds depender → dependum → dependee. */
 function addDependency(model, input, options = {}) {
-	if (!isNodeKind(input.dependum.kind)) throw new ModelOperationError(`${input.dependum.kind} cannot be a dependum`);
+	const m = any(model);
+	const metamodel = metaOf(m);
+	const dependumKind = input.dependum.kind;
+	const dependumDefinition = metamodel.elements.get(dependumKind);
+	if (dependumDefinition?.category !== "node" || dependumDefinition.info?.canBeDependum === false) throw new ModelOperationError(`${dependumKind} cannot be a dependum`);
+	const linkKind = input.linkKind ?? "istar.DependencyLink";
+	if (metamodel.links.get(linkKind)?.category !== "dependency") throw new ModelOperationError(`${linkKind} is not a dependency link kind`);
 	if (!options.force) {
-		const check = canLink(model, input.depender, input.dependee, "istar.DependencyLink");
+		const check = canLink(m, input.depender, input.dependee, linkKind);
 		if (!check.ok) return check;
 	}
-	const depender = requireElement(model, input.depender);
-	const dependee = requireElement(model, input.dependee);
+	const depender = requireElement(m, input.depender);
+	const dependee = requireElement(m, input.dependee);
 	const createId = options.createId ?? defaultIdGenerator;
-	const added = addElement(model, {
-		kind: input.dependum.kind,
+	const added = addElement(m, {
+		kind: dependumKind,
 		id: input.dependum.id,
 		name: input.dependum.name,
 		x: input.dependum.x ?? (depender.x + dependee.x) / 2,
@@ -907,37 +1324,39 @@ function addDependency(model, input, options = {}) {
 	const [id1, id2] = input.linkIds ?? [createId(), createId()];
 	const first = {
 		id: id1,
-		kind: "istar.DependencyLink",
+		kind: linkKind,
 		source: depender.id,
 		target: dependum.id
 	};
 	const second = {
 		id: id2,
-		kind: "istar.DependencyLink",
+		kind: linkKind,
 		source: dependum.id,
 		target: dependee.id
 	};
 	for (const id of [id1, id2]) if (added.model.elements.has(id) || added.model.links.has(id) || id1 === id2) throw new ModelOperationError(`id "${id}" is already in use`);
 	return {
 		ok: true,
-		model: derive(model, {
+		model: typed(derive(m, {
 			elements: new Map(added.model.elements).set(dependum.id, dependum),
-			links: new Map(model.links).set(id1, first).set(id2, second)
-		}),
+			links: new Map(m.links).set(id1, first).set(id2, second)
+		})),
 		dependum,
 		links: [first, second]
 	};
 }
 /** Removes a link. Removing either half of a dependency removes the whole dependency. */
 function disconnect(model, id) {
-	requireLink(model, id);
-	return removeCascade(model, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set([id]));
+	const m = any(model);
+	requireLink(m, id);
+	return typed(removeCascade(m, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set([id])));
 }
 function pick(value, fallback) {
 	return value === void 0 ? fallback : value ?? void 0;
 }
 function updateLink(model, id, patch) {
-	const current = requireLink(model, id);
+	const m = any(model);
+	const current = requireLink(m, id);
 	const next = withoutUndefined({
 		...current,
 		label: pick(patch.label, current.label),
@@ -945,13 +1364,14 @@ function updateLink(model, id, patch) {
 		customProperties: pick(patch.customProperties, current.customProperties),
 		display: mergeDisplay(current.display, patch.display)
 	});
-	return derive(model, { links: new Map(model.links).set(id, next) });
+	return typed(derive(m, { links: new Map(m.links).set(id, next) }));
 }
 function updateDiagram(model, patch) {
-	return derive(model, { diagram: withoutUndefined({
-		...model.diagram,
+	const m = any(model);
+	return typed(derive(m, { diagram: withoutUndefined({
+		...m.diagram,
 		...patch
-	}) });
+	}) }));
 }
 /** Where dependency depender/dependee currently point (see `dependencyLinksOf`). */
 function dependencyEnds(model, dependumId) {
@@ -964,7 +1384,8 @@ function dependencyEnds(model, dependumId) {
 }
 //#endregion
 //#region src/store.ts
-function createModelStore(initial = createEmptyModel(), options = {}) {
+function createModelStore(initial, options = {}) {
+	initial ??= options.metamodel ? createEmptyModel(void 0, { metamodel: options.metamodel }) : createEmptyModel();
 	const limit = options.historyLimit ?? 100;
 	const ctx = { createId: options.createId ?? defaultIdGenerator };
 	const listeners = /* @__PURE__ */ new Set();
@@ -1428,17 +1849,20 @@ exports.DEFAULT_DIAGRAM = DEFAULT_DIAGRAM;
 exports.DEFAULT_ELEMENT_SIZE = DEFAULT_ELEMENT_SIZE;
 exports.DEPENDENCY_LINK_KINDS = DEPENDENCY_LINK_KINDS;
 exports.ELEMENT_KINDS = ELEMENT_KINDS;
+exports.ISTAR_2_0 = ISTAR_2_0;
 exports.ISTAR_PREFIX = ISTAR_PREFIX;
 exports.ISTAR_VERSION = ISTAR_VERSION;
 exports.LINK_KINDS = LINK_KINDS;
 exports.LINK_KIND_INFO = LINK_KIND_INFO;
 exports.METAMODEL_VERSION = METAMODEL_VERSION;
+exports.MetamodelError = MetamodelError;
 exports.ModelOperationError = ModelOperationError;
 exports.NODE_KINDS = NODE_KINDS;
 exports.NODE_KIND_INFO = NODE_KIND_INFO;
 exports.NODE_LINK_KINDS = NODE_LINK_KINDS;
 exports.PISTAR_TOOL = PISTAR_TOOL;
 exports.PistarParseError = PistarParseError;
+exports.PistarWriteError = PistarWriteError;
 exports.addDependency = addDependency;
 exports.addElement = addElement;
 exports.boolean = boolean;
@@ -1448,24 +1872,37 @@ exports.connect = connect;
 exports.createEmptyModel = createEmptyModel;
 exports.createModelStore = createModelStore;
 exports.defaultIdGenerator = defaultIdGenerator;
+exports.defineMetamodelExtension = defineMetamodelExtension;
 exports.defineProperties = defineProperties;
 exports.dependencyEnds = dependencyEnds;
 exports.dependencyLinksOf = dependencyLinksOf;
 exports.disconnect = disconnect;
+exports.effectiveElementKind = effectiveElementKind;
+exports.effectiveLinkKind = effectiveLinkKind;
+exports.elementBehavesLike = elementBehavesLike;
+exports.elementKindDefinition = elementKindDefinition;
 exports.enumOf = enumOf;
+exports.extendMetamodel = extendMetamodel;
 exports.getSourceLayout = getSourceLayout;
+exports.inheritMetamodel = inheritMetamodel;
 exports.inheritSourceLayout = inheritSourceLayout;
 exports.isActor = isActor;
+exports.isActorIn = isActorIn;
 exports.isActorKind = isActorKind;
+exports.isActorKindIn = isActorKindIn;
 exports.isActorLinkKind = isActorLinkKind;
 exports.isContributionLabel = isContributionLabel;
 exports.isDependencyLinkKind = isDependencyLinkKind;
 exports.isElementKind = isElementKind;
 exports.isLinkKind = isLinkKind;
 exports.isNode = isNode;
+exports.isNodeIn = isNodeIn;
 exports.isNodeKind = isNodeKind;
+exports.isNodeKindIn = isNodeKindIn;
 exports.isNodeLinkKind = isNodeLinkKind;
+exports.linkKindDefinition = linkKindDefinition;
 exports.linksOf = linksOf;
+exports.metamodelOf = metamodelOf;
 exports.moveElement = moveElement;
 exports.nestElement = nestElement;
 exports.number = number;
@@ -1482,5 +1919,6 @@ exports.updateElement = updateElement;
 exports.updateLink = updateLink;
 exports.validateModel = validateModel;
 exports.validateModelProperties = validateModelProperties;
+exports.withMetamodel = withMetamodel;
 
 //# sourceMappingURL=index.cjs.map