@istar-ts/core 0.2.0 → 0.2.1

package/dist/index.cjs

@@ -0,0 +1,1486 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/metamodel.ts
+/**
+* The iStar 2.0 metamodel, ported from piStar's `tool/language/metamodel.js`.
+*
+* Kind names carry the `istar.` prefix exactly as they appear in piStar save files.
+*/
+const ISTAR_PREFIX = "istar";
+const METAMODEL_VERSION = "0.2";
+/** Containers: elements that hold inner elements (piStar `metamodel.containers`). */
+const ACTOR_KINDS = [
+	"istar.Actor",
+	"istar.Agent",
+	"istar.Role"
+];
+/** Intentional elements (piStar `metamodel.nodes`). */
+const NODE_KINDS = [
+	"istar.Goal",
+	"istar.Quality",
+	"istar.Resource",
+	"istar.Task"
+];
+const ELEMENT_KINDS = [...ACTOR_KINDS, ...NODE_KINDS];
+/** Links between two containers (piStar `metamodel.containerLinks`). */
+const ACTOR_LINK_KINDS = ["istar.IsALink", "istar.ParticipatesInLink"];
+/** Links that connect two containers through a dependum (piStar `metamodel.dependencyLinks`). */
+const DEPENDENCY_LINK_KINDS = ["istar.DependencyLink"];
+/** Links between two intentional elements (piStar `metamodel.nodeLinks`). */
+const NODE_LINK_KINDS = [
+	"istar.AndRefinementLink",
+	"istar.OrRefinementLink",
+	"istar.NeededByLink",
+	"istar.QualificationLink",
+	"istar.ContributionLink"
+];
+const LINK_KINDS = [
+	...ACTOR_LINK_KINDS,
+	...DEPENDENCY_LINK_KINDS,
+	...NODE_LINK_KINDS
+];
+/** Possible values of a Contribution link's `label`. */
+const CONTRIBUTION_LABELS = [
+	"make",
+	"help",
+	"hurt",
+	"break"
+];
+const innerNode = {
+	canBeInnerElement: true,
+	canBeDependum: true,
+	canBeOnPaper: false
+};
+const NODE_KIND_INFO = {
+	"istar.Goal": innerNode,
+	"istar.Quality": innerNode,
+	"istar.Resource": innerNode,
+	"istar.Task": innerNode
+};
+const LINK_KIND_INFO = {
+	"istar.IsALink": { label: "is-a" },
+	"istar.ParticipatesInLink": { label: "participates-in" },
+	"istar.DependencyLink": {},
+	"istar.AndRefinementLink": {},
+	"istar.OrRefinementLink": {},
+	"istar.NeededByLink": { tryReversedWhenAdding: true },
+	"istar.QualificationLink": { tryReversedWhenAdding: true },
+	"istar.ContributionLink": {
+		changeableLabel: true,
+		possibleLabels: CONTRIBUTION_LABELS
+	}
+};
+/**
+* Default sizes of each element kind, from piStar's `shapes.js`. For actors this is the
+* initial boundary size; the collapsed actor symbol is a circle of radius 40.
+*/
+const DEFAULT_ELEMENT_SIZE = {
+	"istar.Actor": {
+		width: 200,
+		height: 120
+	},
+	"istar.Agent": {
+		width: 200,
+		height: 120
+	},
+	"istar.Role": {
+		width: 200,
+		height: 120
+	},
+	"istar.Goal": {
+		width: 90,
+		height: 35
+	},
+	"istar.Quality": {
+		width: 90,
+		height: 55
+	},
+	"istar.Resource": {
+		width: 90,
+		height: 35
+	},
+	"istar.Task": {
+		width: 95,
+		height: 36
+	}
+};
+const actorKinds = new Set(ACTOR_KINDS);
+const nodeKinds = new Set(NODE_KINDS);
+const elementKinds = new Set(ELEMENT_KINDS);
+const linkKinds = new Set(LINK_KINDS);
+const actorLinkKinds = new Set(ACTOR_LINK_KINDS);
+const nodeLinkKinds = new Set(NODE_LINK_KINDS);
+function isActorKind(kind) {
+	return actorKinds.has(kind);
+}
+function isNodeKind(kind) {
+	return nodeKinds.has(kind);
+}
+function isElementKind(kind) {
+	return elementKinds.has(kind);
+}
+function isLinkKind(kind) {
+	return linkKinds.has(kind);
+}
+function isActorLinkKind(kind) {
+	return actorLinkKinds.has(kind);
+}
+function isNodeLinkKind(kind) {
+	return nodeLinkKinds.has(kind);
+}
+function isDependencyLinkKind(kind) {
+	return kind === "istar.DependencyLink";
+}
+function isContributionLabel(value) {
+	return CONTRIBUTION_LABELS.includes(value);
+}
+/** `'istar.Goal'` → `'Goal'` */
+function shortKindName(kind) {
+	return kind.slice(6);
+}
+//#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";
+const ISTAR_VERSION = "2.0";
+const DEFAULT_DIAGRAM = {
+	width: 2e3,
+	height: 1300
+};
+function createEmptyModel(diagram = DEFAULT_DIAGRAM) {
+	return {
+		elements: /* @__PURE__ */ new Map(),
+		links: /* @__PURE__ */ new Map(),
+		diagram,
+		tool: PISTAR_TOOL,
+		istar: "2.0"
+	};
+}
+function isActor(element) {
+	return element !== void 0 && isActorKind(element.kind);
+}
+function isNode(element) {
+	return element !== void 0 && !isActorKind(element.kind);
+}
+/** Inner elements of an actor, in model order. */
+function childrenOf(model, actorId) {
+	const result = [];
+	for (const element of model.elements.values()) if (element.parent === actorId) result.push(element);
+	return result;
+}
+/** Links that have the element as source or target. */
+function linksOf(model, elementId) {
+	const result = [];
+	for (const link of model.links.values()) if (link.source === elementId || link.target === elementId) result.push(link);
+	return result;
+}
+/** For a dependum, the two halves of its dependency: depender → dependum → dependee. */
+function dependencyLinksOf(model, dependumId) {
+	let inbound;
+	let outbound;
+	for (const link of model.links.values()) {
+		if (link.kind !== "istar.DependencyLink") continue;
+		if (link.target === dependumId && !inbound) inbound = link;
+		if (link.source === dependumId && !outbound) outbound = link;
+	}
+	return {
+		inbound,
+		outbound
+	};
+}
+//#endregion
+//#region src/constraints.ts
+const OK = { ok: true };
+function fail(code, reason) {
+	return {
+		ok: false,
+		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.
+*/
+function canLink(model, source, target, kind) {
+	const s = resolve(model, source);
+	const t = resolve(model, 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);
+}
+function refId(ref) {
+	return typeof ref === "string" ? ref : ref.id;
+}
+function resolve(model, ref) {
+	return model.elements.get(refId(ref));
+}
+/** The graph queries used by upstream constraints (`istar.isThereLinkBetween`, etc.). */
+var Graph = class {
+	model;
+	constructor(model) {
+		this.model = model;
+	}
+	/**
+	* True when a link (optionally of `kind`) already connects the two elements, in either
+	* direction. Mirrors `istar.isThereLinkBetween`.
+	*/
+	isThereLinkBetween(a, b, kind) {
+		for (const link of this.model.links.values()) {
+			if (kind && 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;
+		return false;
+	}
+	isTargetOfType(element, kind) {
+		for (const link of this.model.links.values()) if (link.kind === kind && link.target === element.id) return true;
+		return false;
+	}
+};
+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 (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 (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 (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;
+}
+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 (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;
+};
+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 (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)`);
+		if (graph.isThereLinkBetween(source, target)) return fail("duplicate-link", "there can only be one refinement link between the same two elements");
+		if (graph.isSourceOfType(target, "istar.DependencyLink")) return fail("depender-target", "you cannot refine a Depender Element; that is, an element that is the source of a Dependency (iStar 2.0 Guide, Page 14). Instead, you can try to move the dependency to the sub-element.");
+		if (graph.isTargetOfType(target, other)) return fail("mixed-refinement", label === "AND" ? "you cannot mix AND-refinements with OR-refinements targeting the same element (iStar 2.0 Guide, Page 10)." : "you cannot mix OR-refinements with AND-refinements targeting the same element (iStar 2.0 Guide, Page 10).");
+		return OK;
+	};
+}
+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 (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)");
+	if (graph.isThereLinkBetween(source, target)) return fail("duplicate-link", "there can only be one Needed-By link between the same two elements");
+	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 (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)");
+	if (graph.isThereLinkBetween(source, target, "istar.ContributionLink")) return fail("duplicate-link", "there can only be one Contribution link between the same two elements");
+	if (graph.isThereLinkBetween(source, target, "istar.QualificationLink")) return fail("contribution-and-qualification", "you cannot have Contribution and Qualification links between the same two elements (iStar 2.0 Guide, Page 15)");
+	if (graph.isSourceOfType(target, "istar.DependencyLink")) return fail("depender-target", "you cannot contribute to a Depender Element; that is, an element that is the source of a Dependency (iStar 2.0 Guide, Page 14). Instead, you can try to move the dependency to the sub-quality.");
+	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 (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)");
+	if (graph.isThereLinkBetween(source, target, "istar.QualificationLink")) return fail("duplicate-link", "there can only be one Qualification link between the same two elements");
+	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;
+};
+const CHECKS = {
+	"istar.IsALink": isALink,
+	"istar.ParticipatesInLink": participatesInLink,
+	"istar.DependencyLink": dependencyLink,
+	"istar.AndRefinementLink": refinementLink("AND"),
+	"istar.OrRefinementLink": refinementLink("OR"),
+	"istar.NeededByLink": neededByLink,
+	"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) {
+	const issues = [];
+	const accepted = /* @__PURE__ */ new Map();
+	const view = () => ({
+		...model,
+		links: accepted
+	});
+	const report = (linkId, kind, source, target, check) => {
+		if (!check.ok) issues.push({
+			linkId,
+			kind,
+			source,
+			target,
+			code: check.code,
+			message: check.reason
+		});
+	};
+	const dependencyLinks = [...model.links.values()].filter((l) => l.kind === "istar.DependencyLink");
+	for (const dependum of model.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"));
+		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));
+		else report(link.id, link.kind, link.source, link.target, {
+			ok: false,
+			code: "unknown-element",
+			reason: "the link refers to an element that does not exist"
+		});
+		accepted.set(link.id, link);
+	}
+	return issues;
+}
+//#endregion
+//#region src/serialization.ts
+var PistarParseError = class extends Error {
+	name = "PistarParseError";
+};
+const layouts = /* @__PURE__ */ new WeakMap();
+/** The key order recorded when `model` was parsed, if it came from `parsePistar`. */
+function getSourceLayout(model) {
+	return layouts.get(model);
+}
+/**
+* Carries the recorded key order over to a model derived from `from` (the store does this for
+* every edit, so saving an edited file keeps a stable diff).
+*/
+function inheritSourceLayout(from, to) {
+	const layout = layouts.get(from);
+	if (layout && from !== to) layouts.set(to, layout);
+	return to;
+}
+const ELEMENT_KEYS = /* @__PURE__ */ new Set([
+	"id",
+	"text",
+	"type",
+	"x",
+	"y",
+	"customProperties"
+]);
+const ACTOR_KEYS = /* @__PURE__ */ new Set([...ELEMENT_KEYS, "nodes"]);
+const DEPENDENCY_KEYS = /* @__PURE__ */ new Set([
+	...ELEMENT_KEYS,
+	"source",
+	"target"
+]);
+const LINK_KEYS = /* @__PURE__ */ new Set([
+	"id",
+	"type",
+	"source",
+	"target",
+	"name",
+	"customProperties",
+	"label"
+]);
+const DIAGRAM_KEYS = /* @__PURE__ */ new Set([
+	"width",
+	"height",
+	"name",
+	"customProperties"
+]);
+const TOP_LEVEL_KEYS = [
+	"actors",
+	"orphans",
+	"dependencies",
+	"links",
+	"display",
+	"tool",
+	"istar",
+	"saveDate",
+	"diagram"
+];
+const TOP_LEVEL_KEY_SET = new Set(TOP_LEVEL_KEYS);
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extraOf(json, known) {
+	let extra;
+	for (const key of Object.keys(json)) if (!known.has(key)) (extra ??= {})[key] = json[key];
+	return extra;
+}
+function asArray(value, where) {
+	if (value === void 0) return [];
+	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) {
+	let json;
+	if (typeof input === "string") try {
+		json = JSON.parse(input);
+	} catch (error) {
+		throw new PistarParseError(`invalid JSON: ${error.message}`, { cause: error });
+	}
+	else json = structuredClone(input);
+	if (!isRecord(json)) throw new PistarParseError("a piStar model must be a JSON object");
+	const display = isRecord(json.display) ? json.display : {};
+	const usedDisplay = /* @__PURE__ */ new Set();
+	const elements = /* @__PURE__ */ new Map();
+	const links = /* @__PURE__ */ new Map();
+	const displayFor = (id) => {
+		const entry = display[id];
+		if (!isRecord(entry)) return void 0;
+		usedDisplay.add(id);
+		return entry;
+	};
+	const readElement = (raw, where, known, extras) => {
+		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)}`);
+		if (elements.has(id) || links.has(id)) throw new PistarParseError(`${where}: duplicated id "${id}"`);
+		const element = {
+			id,
+			kind: type,
+			name: typeof raw.text === "string" ? raw.text : "",
+			x: typeof raw.x === "number" ? raw.x : 0,
+			y: typeof raw.y === "number" ? raw.y : 0,
+			...extras,
+			...isRecord(raw.customProperties) ? { customProperties: raw.customProperties } : {},
+			...optional("display", displayFor(id)),
+			...optional("extra", extraOf(raw, known))
+		};
+		elements.set(id, element);
+		return element;
+	};
+	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`);
+		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`);
+		});
+	});
+	asArray(json.orphans, "orphans").forEach((raw, i) => {
+		readElement(raw, `orphans[${i}]`, ELEMENT_KEYS, {});
+	});
+	asArray(json.dependencies, "dependencies").forEach((raw, i) => {
+		const r = raw;
+		const dependency = typeof r.source === "string" && typeof r.target === "string" ? { dependency: {
+			source: r.source,
+			target: r.target
+		} } : {};
+		readElement(raw, `dependencies[${i}]`, DEPENDENCY_KEYS, {
+			isDependum: true,
+			...dependency
+		});
+	});
+	asArray(json.links, "links").forEach((raw, i) => {
+		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)}`);
+		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,
+			source,
+			target,
+			...optional("name", typeof raw.name === "string" ? raw.name : void 0),
+			...isRecord(raw.customProperties) ? { customProperties: raw.customProperties } : {},
+			...optional("label", typeof raw.label === "string" ? raw.label : void 0),
+			...optional("display", displayFor(id)),
+			...optional("extra", extraOf(raw, LINK_KEYS))
+		});
+	});
+	let extraDisplay;
+	for (const [id, value] of Object.entries(display)) if (!usedDisplay.has(id)) (extraDisplay ??= {})[id] = value;
+	let diagram;
+	if (isRecord(json.diagram)) {
+		const d = json.diagram;
+		diagram = {
+			...optional("width", typeof d.width === "number" ? d.width : void 0),
+			...optional("height", typeof d.height === "number" ? d.height : void 0),
+			...optional("name", typeof d.name === "string" ? d.name : void 0),
+			...isRecord(d.customProperties) ? { customProperties: d.customProperties } : {},
+			...optional("extra", extraOf(d, DIAGRAM_KEYS))
+		};
+	}
+	const model = {
+		elements,
+		links,
+		...optional("diagram", diagram),
+		...optional("tool", typeof json.tool === "string" ? json.tool : void 0),
+		...optional("istar", typeof json.istar === "string" ? json.istar : void 0),
+		...optional("saveDate", typeof json.saveDate === "string" ? json.saveDate : void 0),
+		...optional("extraDisplay", extraDisplay),
+		...optional("extra", extraOf(json, TOP_LEVEL_KEY_SET))
+	};
+	layouts.set(model, {
+		keys: Object.keys(json),
+		display: Object.keys(display)
+	});
+	return model;
+}
+function optional(key, value) {
+	return value === void 0 ? {} : { [key]: value };
+}
+function formatDate(date) {
+	return date.toUTCString();
+}
+function elementJson(element) {
+	return {
+		id: element.id,
+		text: element.name,
+		type: element.kind,
+		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 = {}) {
+	const actors = [];
+	const orphans = [];
+	const dependencies = [];
+	const children = /* @__PURE__ */ new Map();
+	for (const element of model.elements.values()) if (element.parent !== void 0 && !isActorKind(element.kind)) {
+		let list = children.get(element.parent);
+		if (!list) children.set(element.parent, list = []);
+		list.push({
+			...elementJson(element),
+			...element.extra
+		});
+	}
+	for (const element of model.elements.values()) if (isActorKind(element.kind)) actors.push({
+		...elementJson(element),
+		nodes: children.get(element.id) ?? [],
+		...element.extra
+	});
+	else if (element.isDependum) {
+		const { inbound, outbound } = dependencyLinksOf(model, element.id);
+		dependencies.push({
+			...elementJson(element),
+			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),
+		...element.extra
+	});
+	const links = [];
+	for (const link of model.links.values()) links.push({
+		id: link.id,
+		type: link.kind,
+		source: link.source,
+		target: link.target,
+		...link.name !== void 0 ? { name: link.name } : {},
+		...link.customProperties ? { customProperties: { ...link.customProperties } } : {},
+		...link.label !== void 0 ? { label: link.label } : {},
+		...link.extra
+	});
+	const layout = layouts.get(model);
+	const display = {};
+	const displayOf = (id) => {
+		const owner = model.elements.get(id) ?? model.links.get(id);
+		if (owner) return owner.display;
+		return model.extraDisplay?.[id];
+	};
+	for (const id of layout?.display ?? []) {
+		const entry = displayOf(id);
+		if (entry !== void 0) display[id] = { ...entry };
+	}
+	for (const owner of [...model.elements.values(), ...model.links.values()]) if (owner.display && !(owner.id in display)) display[owner.id] = { ...owner.display };
+	for (const [id, entry] of Object.entries(model.extraDisplay ?? {})) if (!(id in display)) display[id] = entry;
+	let saveDate;
+	if (options.saveDate instanceof Date) saveDate = formatDate(options.saveDate);
+	else saveDate = options.saveDate ?? model.saveDate ?? formatDate(/* @__PURE__ */ new Date());
+	const d = model.diagram;
+	const diagram = d && {
+		...d.width !== void 0 ? { width: d.width } : {},
+		...d.height !== void 0 ? { height: d.height } : {},
+		...d.name !== void 0 ? { name: d.name } : {},
+		...d.customProperties ? { customProperties: { ...d.customProperties } } : {},
+		...d.extra
+	};
+	const values = {
+		...model.extra,
+		actors,
+		orphans,
+		dependencies,
+		links,
+		display,
+		tool: model.tool,
+		istar: model.istar,
+		saveDate,
+		diagram
+	};
+	if (layout) for (const key of [
+		"actors",
+		"orphans",
+		"dependencies",
+		"links",
+		"display"
+	]) {
+		const value = values[key];
+		if ((Array.isArray(value) ? value.length === 0 : Object.keys(value).length === 0) && !layout.keys.includes(key)) values[key] = void 0;
+	}
+	const order = [
+		...layout?.keys ?? [],
+		...TOP_LEVEL_KEYS,
+		...Object.keys(model.extra ?? {})
+	];
+	const file = {};
+	for (const key of order) if (!(key in file) && values[key] !== void 0) file[key] = values[key];
+	return file;
+}
+/** Serializes a model to piStar's JSON text (2-space indentation, no trailing newline). */
+function toPistar(model, options) {
+	return JSON.stringify(toPistarObject(model, options), null, 2);
+}
+//#endregion
+//#region src/operations.ts
+var ModelOperationError = class extends Error {
+	name = "ModelOperationError";
+};
+const defaultIdGenerator = () => {
+	const c = globalThis.crypto;
+	if (c?.randomUUID) return c.randomUUID();
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (ch) => {
+		const r = Math.random() * 16 | 0;
+		return (ch === "x" ? r : r & 3 | 8).toString(16);
+	});
+};
+function derive(from, changes) {
+	return inheritSourceLayout(from, {
+		...from,
+		...changes
+	});
+}
+function requireElement(model, id) {
+	const element = model.elements.get(id);
+	if (!element) throw new ModelOperationError(`unknown element "${id}"`);
+	return element;
+}
+function requireLink(model, id) {
+	const link = model.links.get(id);
+	if (!link) throw new ModelOperationError(`unknown link "${id}"`);
+	return link;
+}
+function withoutUndefined(value) {
+	const out = {};
+	for (const [k, v] of Object.entries(value)) if (v !== void 0) out[k] = v;
+	return out;
+}
+function addElement(model, input, ctx = {}) {
+	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 (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`);
+	}
+	const element = withoutUndefined({
+		id,
+		kind: input.kind,
+		name: input.name ?? shortKindName(input.kind),
+		x: input.x,
+		y: input.y,
+		parent: input.parent,
+		customProperties: input.customProperties,
+		display: input.display
+	});
+	return {
+		model: derive(model, { elements: new Map(model.elements).set(id, element) }),
+		element
+	};
+}
+function mergeDisplay(current, patch) {
+	if (patch === void 0) return current;
+	if (patch === null) return void 0;
+	const merged = { ...current };
+	for (const [key, value] of Object.entries(patch)) if (value === void 0) delete merged[key];
+	else merged[key] = value;
+	return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function updateElement(model, id, patch) {
+	const current = requireElement(model, 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) });
+}
+/**
+* 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 dx = x - current.x;
+	const dy = y - current.y;
+	if (dx === 0 && dy === 0) return model;
+	const elements = new Map(model.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, {
+			...child,
+			x: child.x + dx,
+			y: child.y + dy
+		});
+	}
+	return derive(model, { elements });
+}
+/**
+* Moves an inner element into another actor (or out of any actor with `null`). The element
+* becomes the actor's last child. Links that become invalid are kept; `validateModel` reports
+* them.
+*/
+function nestElement(model, id, parent) {
+	const current = requireElement(model, id);
+	if (isActorKind(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);
+	elements.delete(id);
+	const { parent: _old, ...rest } = current;
+	elements.set(id, parent === null ? rest : {
+		...rest,
+		parent
+	});
+	return derive(model, { 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());
+}
+function removeElement(model, id) {
+	requireElement(model, id);
+	return removeElements(model, [id]);
+}
+function removeCascade(model, elementIds, linkIds) {
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const element of model.elements.values()) {
+			if (elementIds.has(element.id)) continue;
+			if (element.parent !== void 0 && elementIds.has(element.parent)) {
+				elementIds.add(element.id);
+				changed = true;
+			}
+		}
+		for (const link of model.links.values()) {
+			if (linkIds.has(link.id)) continue;
+			if (elementIds.has(link.source) || elementIds.has(link.target)) {
+				linkIds.add(link.id);
+				changed = true;
+			}
+		}
+		for (const link of model.links.values()) {
+			if (!linkIds.has(link.id) || link.kind !== "istar.DependencyLink") continue;
+			for (const end of [link.source, link.target]) if (model.elements.get(end)?.isDependum && !elementIds.has(end)) {
+				elementIds.add(end);
+				changed = true;
+			}
+		}
+	}
+	if (elementIds.size === 0 && linkIds.size === 0) return model;
+	const elements = new Map(model.elements);
+	for (const id of elementIds) elements.delete(id);
+	const links = new Map(model.links);
+	for (const id of linkIds) links.delete(id);
+	return derive(model, {
+		elements,
+		links
+	});
+}
+/** 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");
+	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;
+		if (!check.ok && tryReversed) {
+			const swapped = canLink(model, target, source, input.kind);
+			if (swapped.ok) {
+				[source, target] = [target, source];
+				reversed = true;
+				check = swapped;
+			}
+		}
+		if (!check.ok) return check;
+	} else {
+		requireElement(model, source);
+		requireElement(model, 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`);
+	const link = withoutUndefined({
+		id,
+		kind: input.kind,
+		source,
+		target,
+		label: input.label,
+		name: input.name,
+		customProperties: input.customProperties
+	});
+	return {
+		ok: true,
+		model: derive(model, { links: new Map(model.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`);
+	if (!options.force) {
+		const check = canLink(model, input.depender, input.dependee, "istar.DependencyLink");
+		if (!check.ok) return check;
+	}
+	const depender = requireElement(model, input.depender);
+	const dependee = requireElement(model, input.dependee);
+	const createId = options.createId ?? defaultIdGenerator;
+	const added = addElement(model, {
+		kind: input.dependum.kind,
+		id: input.dependum.id,
+		name: input.dependum.name,
+		x: input.dependum.x ?? (depender.x + dependee.x) / 2,
+		y: input.dependum.y ?? (depender.y + dependee.y) / 2,
+		customProperties: input.dependum.customProperties
+	}, { createId });
+	const dependum = {
+		...added.element,
+		isDependum: true
+	};
+	const [id1, id2] = input.linkIds ?? [createId(), createId()];
+	const first = {
+		id: id1,
+		kind: "istar.DependencyLink",
+		source: depender.id,
+		target: dependum.id
+	};
+	const second = {
+		id: id2,
+		kind: "istar.DependencyLink",
+		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, {
+			elements: new Map(added.model.elements).set(dependum.id, dependum),
+			links: new Map(model.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]));
+}
+function pick(value, fallback) {
+	return value === void 0 ? fallback : value ?? void 0;
+}
+function updateLink(model, id, patch) {
+	const current = requireLink(model, id);
+	const next = withoutUndefined({
+		...current,
+		label: pick(patch.label, current.label),
+		name: pick(patch.name, current.name),
+		customProperties: pick(patch.customProperties, current.customProperties),
+		display: mergeDisplay(current.display, patch.display)
+	});
+	return derive(model, { links: new Map(model.links).set(id, next) });
+}
+function updateDiagram(model, patch) {
+	return derive(model, { diagram: withoutUndefined({
+		...model.diagram,
+		...patch
+	}) });
+}
+/** Where dependency depender/dependee currently point (see `dependencyLinksOf`). */
+function dependencyEnds(model, dependumId) {
+	const { inbound, outbound } = dependencyLinksOf(model, dependumId);
+	const fallback = model.elements.get(dependumId)?.dependency;
+	return {
+		depender: inbound?.source ?? fallback?.source,
+		dependee: outbound?.target ?? fallback?.target
+	};
+}
+//#endregion
+//#region src/store.ts
+function createModelStore(initial = createEmptyModel(), options = {}) {
+	const limit = options.historyLimit ?? 100;
+	const ctx = { createId: options.createId ?? defaultIdGenerator };
+	const listeners = /* @__PURE__ */ new Set();
+	let model = initial;
+	let past = [];
+	let future = [];
+	let tx;
+	const emit = (event) => {
+		for (const listener of listeners) listener(event);
+	};
+	const commit = (next, change) => {
+		if (next === model) return;
+		if (tx) {
+			model = next;
+			tx.changes.push(change);
+			return;
+		}
+		const previous = model;
+		past.push(previous);
+		if (past.length > limit) past = past.slice(past.length - limit);
+		future = [];
+		model = next;
+		emit({
+			model,
+			previous,
+			changes: [change],
+			source: "edit"
+		});
+	};
+	return {
+		getModel: () => model,
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		canLink: (source, target, kind) => canLink(model, source, target, kind),
+		addElement(input) {
+			const result = addElement(model, input, ctx);
+			commit(result.model, {
+				type: "addElement",
+				id: result.element.id
+			});
+			return result.element;
+		},
+		updateElement(id, patch) {
+			commit(updateElement(model, id, patch), {
+				type: "updateElement",
+				id,
+				patch
+			});
+		},
+		moveElement(id, x, y) {
+			commit(moveElement(model, id, x, y), {
+				type: "moveElement",
+				id,
+				x,
+				y
+			});
+		},
+		nestElement(id, parent) {
+			commit(nestElement(model, id, parent), {
+				type: "nestElement",
+				id,
+				parent
+			});
+		},
+		removeElement(id) {
+			commit(removeElement(model, id), {
+				type: "removeElements",
+				ids: [id]
+			});
+		},
+		removeElements(ids) {
+			const list = [...ids];
+			commit(removeElements(model, list), {
+				type: "removeElements",
+				ids: list
+			});
+		},
+		setCollapsed(actorId, collapsed) {
+			const patch = { display: { collapsed: collapsed ? true : void 0 } };
+			commit(updateElement(model, actorId, patch), {
+				type: "updateElement",
+				id: actorId,
+				patch
+			});
+		},
+		connect(input, connectOptions) {
+			const result = connect(model, input, {
+				...connectOptions,
+				...ctx
+			});
+			if (result.ok) commit(result.model, {
+				type: "connect",
+				id: result.link.id
+			});
+			return result;
+		},
+		addDependency(input, dependencyOptions) {
+			const result = addDependency(model, input, {
+				...dependencyOptions,
+				...ctx
+			});
+			if (result.ok) commit(result.model, {
+				type: "addDependency",
+				dependumId: result.dependum.id,
+				linkIds: [result.links[0].id, result.links[1].id]
+			});
+			return result;
+		},
+		updateLink(id, patch) {
+			commit(updateLink(model, id, patch), {
+				type: "updateLink",
+				id,
+				patch
+			});
+		},
+		disconnect(id) {
+			commit(disconnect(model, id), {
+				type: "disconnect",
+				id
+			});
+		},
+		updateDiagram(patch) {
+			commit(updateDiagram(model, patch), {
+				type: "updateDiagram",
+				patch
+			});
+		},
+		replace(next) {
+			commit(next, { type: "replace" });
+		},
+		load(next) {
+			if (tx) throw new ModelOperationError("cannot load inside a transaction");
+			const previous = model;
+			model = next;
+			past = [];
+			future = [];
+			emit({
+				model,
+				previous,
+				changes: [],
+				source: "load"
+			});
+		},
+		transaction(fn) {
+			if (tx) {
+				tx.depth++;
+				try {
+					return fn();
+				} finally {
+					tx.depth--;
+				}
+			}
+			tx = {
+				start: model,
+				changes: [],
+				depth: 1
+			};
+			let result;
+			try {
+				result = fn();
+			} catch (error) {
+				model = tx.start;
+				tx = void 0;
+				throw error;
+			}
+			const { start, changes } = tx;
+			tx = void 0;
+			if (model !== start) {
+				past.push(start);
+				if (past.length > limit) past = past.slice(past.length - limit);
+				future = [];
+				emit({
+					model,
+					previous: start,
+					changes,
+					source: "edit"
+				});
+			}
+			return result;
+		},
+		undo() {
+			const previous = past.pop();
+			if (!previous || tx) return false;
+			future.push(model);
+			const current = model;
+			model = previous;
+			emit({
+				model,
+				previous: current,
+				changes: [],
+				source: "undo"
+			});
+			return true;
+		},
+		redo() {
+			const next = future.pop();
+			if (!next || tx) return false;
+			past.push(model);
+			const current = model;
+			model = next;
+			emit({
+				model,
+				previous: current,
+				changes: [],
+				source: "redo"
+			});
+			return true;
+		},
+		canUndo: () => past.length > 0,
+		canRedo: () => future.length > 0,
+		clearHistory() {
+			past = [];
+			future = [];
+		}
+	};
+}
+//#endregion
+//#region src/properties.ts
+function string(options) {
+	return {
+		type: "string",
+		options: options ?? {},
+		parse(raw) {
+			return {
+				ok: true,
+				value: raw
+			};
+		},
+		serialize(value) {
+			return value;
+		}
+	};
+}
+function number(options) {
+	const opts = options ?? {};
+	const integer = options?.integer;
+	const min = options?.min;
+	const max = options?.max;
+	return {
+		type: "number",
+		options: opts,
+		integer,
+		min,
+		max,
+		parse(raw) {
+			const value = Number(raw);
+			if (!Number.isFinite(value)) return {
+				ok: false,
+				error: "must be a finite number"
+			};
+			if (integer && !Number.isInteger(value)) return {
+				ok: false,
+				error: "must be an integer"
+			};
+			if (min !== void 0 && value < min) return {
+				ok: false,
+				error: `must be at least ${min}`
+			};
+			if (max !== void 0 && value > max) return {
+				ok: false,
+				error: `must be at most ${max}`
+			};
+			return {
+				ok: true,
+				value
+			};
+		},
+		serialize(value) {
+			return String(value);
+		}
+	};
+}
+function boolean(options) {
+	return {
+		type: "boolean",
+		options: options ?? {},
+		parse(raw) {
+			if (raw === "true") return {
+				ok: true,
+				value: true
+			};
+			if (raw === "false") return {
+				ok: true,
+				value: false
+			};
+			return {
+				ok: false,
+				error: "must be true or false"
+			};
+		},
+		serialize(value) {
+			return value ? "true" : "false";
+		}
+	};
+}
+function enumOf(values, options) {
+	return {
+		type: "enum",
+		options: options ?? {},
+		values,
+		parse(raw) {
+			if (values.includes(raw)) return {
+				ok: true,
+				value: raw
+			};
+			return {
+				ok: false,
+				error: `must be one of: ${values.join(", ")}`
+			};
+		},
+		serialize(value) {
+			return value;
+		}
+	};
+}
+const prop = {
+	string,
+	number,
+	boolean,
+	enum: enumOf
+};
+function isCustomPropertiesRecord(source) {
+	if ("customProperties" in source) return false;
+	const owner = source;
+	return !(typeof owner.kind === "string" && owner.kind.startsWith("istar.") && (typeof owner.x === "number" || owner.source !== void 0 && owner.target !== void 0));
+}
+function resolveCustomProperties(source) {
+	if (source === void 0) return void 0;
+	if (isCustomPropertiesRecord(source)) return source;
+	return source.customProperties;
+}
+function isRequired(options) {
+	return options.optional !== true && options.default === void 0;
+}
+function emptyMeansAbsent(type, optional) {
+	return type !== "string" && optional === true;
+}
+function readShape(shape, source) {
+	const custom = resolveCustomProperties(source);
+	const values = {};
+	const issues = [];
+	for (const key of Object.keys(shape)) {
+		const field = shape[key];
+		if (!field) continue;
+		const opts = field.options;
+		const raw = custom !== void 0 && Object.prototype.hasOwnProperty.call(custom, key) ? custom[key] : void 0;
+		if (raw === void 0) {
+			if (opts.default !== void 0) values[key] = opts.default;
+			else if (isRequired(opts)) issues.push({
+				key,
+				message: "is required"
+			});
+			continue;
+		}
+		if (raw === "" && field.type !== "string") {
+			if (emptyMeansAbsent(field.type, opts.optional)) {
+				if (opts.default !== void 0) values[key] = opts.default;
+				continue;
+			}
+			issues.push({
+				key,
+				message: field.type === "boolean" ? "must be true or false" : field.type === "enum" ? `must be one of: ${field.values?.join(", ") ?? ""}` : "must be a finite number"
+			});
+			continue;
+		}
+		const parsed = field.parse(raw);
+		if (!parsed.ok) {
+			issues.push({
+				key,
+				message: parsed.error
+			});
+			continue;
+		}
+		values[key] = parsed.value;
+	}
+	return {
+		values,
+		issues
+	};
+}
+function defineProperties(kind, shape, options) {
+	const crossValidate = options?.validate;
+	return {
+		kind,
+		shape,
+		read(source) {
+			return readShape(shape, source);
+		},
+		validate(source) {
+			const { values, issues } = readShape(shape, source);
+			const cross = crossValidate ? crossValidate(values) : [];
+			return [...issues, ...cross];
+		},
+		write(current, patch) {
+			const result = {};
+			const seen = /* @__PURE__ */ new Set();
+			if (current) for (const [key, value] of Object.entries(current)) {
+				if (Object.prototype.hasOwnProperty.call(patch, key)) {
+					const patched = patch[key];
+					if (patched === void 0) continue;
+					const field = shape[key];
+					if (field) result[key] = field.serialize(patched);
+				} else result[key] = value;
+				seen.add(key);
+			}
+			for (const key of Object.keys(shape)) {
+				if (seen.has(key)) continue;
+				if (!Object.prototype.hasOwnProperty.call(patch, key)) continue;
+				const patched = patch[key];
+				if (patched === void 0) continue;
+				const field = shape[key];
+				if (field) result[key] = field.serialize(patched);
+			}
+			return result;
+		},
+		defaults() {
+			const result = {};
+			for (const key of Object.keys(shape)) {
+				const field = shape[key];
+				if (!field) continue;
+				const def = field.options.default;
+				if (def !== void 0) result[key] = field.serialize(def);
+			}
+			return result;
+		}
+	};
+}
+function validateModelProperties(model, schemas) {
+	const byKind = /* @__PURE__ */ new Map();
+	for (const schema of schemas) {
+		const list = byKind.get(schema.kind) ?? [];
+		list.push(schema);
+		byKind.set(schema.kind, list);
+	}
+	const issues = [];
+	for (const element of model.elements.values()) {
+		const kindSchemas = byKind.get(element.kind);
+		if (!kindSchemas) continue;
+		for (const schema of kindSchemas) for (const issue of schema.validate(element)) issues.push({
+			...issue,
+			id: element.id
+		});
+	}
+	for (const link of model.links.values()) {
+		const kindSchemas = byKind.get(link.kind);
+		if (!kindSchemas) continue;
+		for (const schema of kindSchemas) for (const issue of schema.validate(link)) issues.push({
+			...issue,
+			id: link.id
+		});
+	}
+	return issues;
+}
+//#endregion
+exports.ACTOR_KINDS = ACTOR_KINDS;
+exports.ACTOR_LINK_KINDS = ACTOR_LINK_KINDS;
+exports.CONTRIBUTION_LABELS = CONTRIBUTION_LABELS;
+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_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.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.addDependency = addDependency;
+exports.addElement = addElement;
+exports.boolean = boolean;
+exports.canLink = canLink;
+exports.childrenOf = childrenOf;
+exports.connect = connect;
+exports.createEmptyModel = createEmptyModel;
+exports.createModelStore = createModelStore;
+exports.defaultIdGenerator = defaultIdGenerator;
+exports.defineProperties = defineProperties;
+exports.dependencyEnds = dependencyEnds;
+exports.dependencyLinksOf = dependencyLinksOf;
+exports.disconnect = disconnect;
+exports.enumOf = enumOf;
+exports.getSourceLayout = getSourceLayout;
+exports.inheritSourceLayout = inheritSourceLayout;
+exports.isActor = isActor;
+exports.isActorKind = isActorKind;
+exports.isActorLinkKind = isActorLinkKind;
+exports.isContributionLabel = isContributionLabel;
+exports.isDependencyLinkKind = isDependencyLinkKind;
+exports.isElementKind = isElementKind;
+exports.isLinkKind = isLinkKind;
+exports.isNode = isNode;
+exports.isNodeKind = isNodeKind;
+exports.isNodeLinkKind = isNodeLinkKind;
+exports.linksOf = linksOf;
+exports.moveElement = moveElement;
+exports.nestElement = nestElement;
+exports.number = number;
+exports.parsePistar = parsePistar;
+exports.prop = prop;
+exports.removeElement = removeElement;
+exports.removeElements = removeElements;
+exports.shortKindName = shortKindName;
+exports.string = string;
+exports.toPistar = toPistar;
+exports.toPistarObject = toPistarObject;
+exports.updateDiagram = updateDiagram;
+exports.updateElement = updateElement;
+exports.updateLink = updateLink;
+exports.validateModel = validateModel;
+exports.validateModelProperties = validateModelProperties;
+
+//# sourceMappingURL=index.cjs.map