@spaceteams/weft 0.0.1

package/dist/index.mjs

@@ -0,0 +1,956 @@
+import { createHash } from "node:crypto";
+//#region src/draft/index.ts
+function createDraft(draftId, base, overlay) {
+	return {
+		draftId,
+		base,
+		overlay
+	};
+}
+function isEmptyDraft(draft) {
+	return Object.keys(draft.overlay).length === 0;
+}
+//#endregion
+//#region src/evaluate/index.ts
+const defaultEvaluateMode = "strict";
+function evaluate(model, provided, mode = defaultEvaluateMode) {
+	const values = /* @__PURE__ */ new Map();
+	const missing = /* @__PURE__ */ new Map();
+	const trace = [];
+	for (const input of model.inputs) {
+		if (!(input.key.id in provided)) if (mode === "strict") throw new Error(`Missing input: ${input.key.id}`);
+		else {
+			missing.set(input.key.id, {
+				kind: "missing-input",
+				key: input.key.id
+			});
+			continue;
+		}
+		values.set(input.key.id, provided[input.key.id]);
+	}
+	for (const target of model.orderedRuleTargets) {
+		const rule = model.ruleByTarget.get(target);
+		if (!rule) throw new Error(`Missing compiled rule: ${target}`);
+		const inputs = {};
+		const missingDeps = [];
+		for (const dep of rule.deps) {
+			if (!values.has(dep.id)) if (mode === "strict") throw new Error(`Missing value: ${dep.id}`);
+			else {
+				missingDeps.push(dep);
+				continue;
+			}
+			inputs[dep.id] = values.get(dep.id);
+		}
+		if (missingDeps.length > 0) {
+			missing.set(target, {
+				kind: "rule-not-run",
+				key: target,
+				because: missingDeps.map((d) => d.id)
+			});
+			continue;
+		}
+		const get = (key) => {
+			if (!values.has(key.id)) throw new Error(`Invariant violation: missing dependency reached rule eval: ${key.id}`);
+			return values.get(key.id);
+		};
+		const { output, detail } = rule.eval(get);
+		values.set(target, output);
+		const deps = model.depsByTarget.get(target) ?? [];
+		const ruleMeta = model.ruleMeta.get(target);
+		const keyMeta = model.keyMeta.get(target);
+		trace.push({
+			target,
+			deps,
+			ruleSpec: rule.spec,
+			ruleMeta,
+			keyMeta,
+			detail: detail ?? {},
+			inputs,
+			output
+		});
+	}
+	return {
+		values,
+		missing,
+		order: model.orderedRuleTargets,
+		trace
+	};
+}
+//#endregion
+//#region src/facts.ts
+function mapToFactBag(map) {
+	return Object.fromEntries([...map.entries()].sort(([a], [b]) => a.localeCompare(b)));
+}
+//#endregion
+//#region src/model/snapshot-model.ts
+function snapshotModel(model) {
+	return {
+		inputKeys: [...model.inputKeys],
+		rules: model.rules.map((r) => ({
+			target: r.target.id,
+			spec: r.spec
+		}))
+	};
+}
+//#endregion
+//#region src/overlay/diff-group.ts
+function groupDiffByOrigin(result, deltas) {
+	const overlayInputs = [];
+	const derivedValues = [];
+	const other = [];
+	for (const delta of deltas) {
+		const origin = result.origins.get(delta.key);
+		if (origin?.kind === "overlay") overlayInputs.push(delta);
+		else if (origin?.kind === "derived") derivedValues.push(delta);
+		else other.push(delta);
+	}
+	const groups = [];
+	if (overlayInputs.length) groups.push({
+		label: "Overlay inputs",
+		deltas: overlayInputs
+	});
+	if (derivedValues.length) groups.push({
+		label: "Derived values",
+		deltas: derivedValues
+	});
+	if (other.length) groups.push({
+		label: "Other",
+		deltas: other
+	});
+	return groups;
+}
+//#endregion
+//#region src/overlay/explain-diff.ts
+function explainDiffs(result, deltas) {
+	const changedKeys = new Set(deltas.map((d) => d.key));
+	const traceByTarget = new Map(result.trace.map((step) => [step.target, step]));
+	return deltas.map((delta) => {
+		const step = traceByTarget.get(delta.key);
+		if (!step) return { delta };
+		return {
+			delta,
+			dependencies: step.deps.map((depKey) => ({
+				key: depKey,
+				changed: changedKeys.has(depKey)
+			}))
+		};
+	});
+}
+//#endregion
+//#region src/snapshot/canonicalize.ts
+function canonicalize(value) {
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (Array.isArray(value)) return value.map(canonicalize);
+	if (typeof value === "object" && value !== null) {
+		if (value instanceof Date) return value.toISOString();
+		const sortedKeys = Object.keys(value).sort();
+		const obj = value;
+		const out = {};
+		for (const key of sortedKeys) out[key] = canonicalize(obj[key]);
+		return out;
+	}
+	throw new Error(`Unsupported value for canonicalization: ${JSON.stringify(value)}`);
+}
+//#endregion
+//#region src/snapshot/canonicalizeValue.ts
+function canonicalizeValue(model, key, value) {
+	const semantics = model.semantics.get(key);
+	if (semantics?.encode) return semantics.encode(value);
+	else return canonicalize(value);
+}
+//#endregion
+//#region src/snapshot/canonicalizeDelta.ts
+function canonicalizeDelta(model, delta) {
+	switch (delta.kind) {
+		case "added": return {
+			key: delta.key,
+			kind: "added",
+			after: canonicalizeValue(model, delta.key, delta.after)
+		};
+		case "removed": return {
+			key: delta.key,
+			kind: "removed",
+			before: canonicalizeValue(model, delta.key, delta.before)
+		};
+		case "changed": return {
+			key: delta.key,
+			kind: "changed",
+			before: canonicalizeValue(model, delta.key, delta.before),
+			after: canonicalizeValue(model, delta.key, delta.after)
+		};
+	}
+}
+//#endregion
+//#region src/snapshot/canonicalizeFacts.ts
+function canonicalizeFacts(model, facts) {
+	const result = {};
+	for (const [key, value] of Object.entries(facts)) result[key] = canonicalizeValue(model, key, value);
+	return result;
+}
+//#endregion
+//#region src/snapshot/fingerprint.ts
+function fingerprintCanonical(value) {
+	return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+function fingerprintValue(value) {
+	return fingerprintCanonical(canonicalize(value));
+}
+//#endregion
+//#region src/model/model.ts
+function getDependencies(model, key) {
+	return model.depsByTarget.get(key.id) ?? [];
+}
+function getDependents(model, key) {
+	return model.dependentsByKey.get(key.id) ?? [];
+}
+function getDeclaredKeys(model) {
+	return [...model.inputKeys, ...model.orderedRuleTargets];
+}
+function upstreamOf(model, key) {
+	const visited = /* @__PURE__ */ new Set();
+	const stack = [...model.depsByTarget.get(key.id) ?? []];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (visited.has(current)) continue;
+		visited.add(current);
+		const deps = model.depsByTarget.get(current);
+		if (deps) {
+			for (const dep of deps) if (!visited.has(dep)) stack.push(dep);
+		}
+	}
+	return sortKeysByModelOrder(model, visited);
+}
+function downstreamOf(model, key) {
+	const visited = /* @__PURE__ */ new Set();
+	const stack = [...model.dependentsByKey.get(key.id) ?? []];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (visited.has(current)) continue;
+		visited.add(current);
+		const dependents = model.dependentsByKey.get(current);
+		if (dependents) {
+			for (const dependent of dependents) if (!visited.has(dependent)) stack.push(dependent);
+		}
+	}
+	return sortKeysByModelOrder(model, visited);
+}
+function sortKeysByModelOrder(model, keys) {
+	const keySet = new Set(keys);
+	return [...model.inputKeys.filter((k) => keySet.has(k)), ...model.orderedRuleTargets.filter((k) => keySet.has(k))];
+}
+//#endregion
+//#region src/overlay/diff-results.ts
+function diffResults(model, before, after) {
+	const deltas = [];
+	for (const key of getDeclaredKeys(model)) {
+		const hasBefore = before.values.has(key);
+		const hasAfter = after.values.has(key);
+		if (!hasBefore && !hasAfter) continue;
+		if (hasBefore !== hasAfter) {
+			deltas.push(hasBefore ? {
+				key,
+				kind: "removed",
+				before: before.values.get(key)
+			} : {
+				key,
+				kind: "added",
+				after: after.values.get(key)
+			});
+			continue;
+		}
+		const beforeValue = before.values.get(key);
+		const afterValue = after.values.get(key);
+		if (!(model.semantics.get(key)?.eq ?? Object.is)(beforeValue, afterValue)) deltas.push({
+			key,
+			kind: "changed",
+			before: beforeValue,
+			after: afterValue
+		});
+	}
+	return { deltas };
+}
+//#endregion
+//#region src/overlay/apply-overlay.ts
+function applyOverlay(base, overlay) {
+	return {
+		base,
+		overlay,
+		effective: {
+			...base,
+			...overlay
+		}
+	};
+}
+//#endregion
+//#region src/overlay/evaluate-overlay.ts
+function evaluateOverlay(model, base, overlay, mode = defaultEvaluateMode) {
+	const facts = applyOverlay(base, overlay);
+	const evaluated = evaluate(model, facts.effective, mode);
+	const origins = /* @__PURE__ */ new Map();
+	for (const input of model.inputs) {
+		const key = input.key.id;
+		if (key in overlay) origins.set(key, { kind: "overlay" });
+		else if (key in base) origins.set(key, { kind: "base" });
+	}
+	for (const rule of model.rules) origins.set(rule.target.id, { kind: "derived" });
+	return {
+		...evaluated,
+		overlayedFacts: facts,
+		origins
+	};
+}
+//#endregion
+//#region src/draft/evaluate-draft.ts
+function evaluateDraft(model, draft, mode = defaultEvaluateMode) {
+	const baseResult = evaluate(model, draft.base, mode);
+	const result = evaluateOverlay(model, draft.base, draft.overlay, mode);
+	const { deltas } = diffResults(model, baseResult, result);
+	return {
+		draft,
+		result,
+		deltas
+	};
+}
+//#endregion
+//#region src/draft/analyze-draft.ts
+function analyzeDraft(model, draft, mode = defaultEvaluateMode) {
+	const normalized = normalizeDraft(model, draft);
+	const evaluated = evaluateDraft(model, normalized.draft, mode);
+	const impact = analyzeImpact(model, evaluated);
+	return {
+		evaluated,
+		groupedDiffs: groupDiffByOrigin(evaluated.result, evaluated.deltas),
+		changes: explainDiffs(evaluated.result, evaluated.deltas),
+		impact,
+		normalizationIssues: normalized.issues
+	};
+}
+function normalizeDraft(model, draft) {
+	const normalized = {
+		draftId: draft.draftId,
+		base: draft.base,
+		overlay: {},
+		meta: draft.meta
+	};
+	const issues = [];
+	for (const key of Object.keys(draft.overlay)) {
+		if (!model.inputKeys.includes(key)) {
+			issues.push({
+				level: "warning",
+				key,
+				message: `Key "${key}" is not an input key and will be ignored`
+			});
+			continue;
+		}
+		const base = draft.base[key];
+		let overlay = draft.overlay[key];
+		const semantics = model.semantics.get(key);
+		const normalize = semantics?.normalize;
+		if (normalize) overlay = normalize(overlay);
+		if ((semantics?.eq ?? Object.is)(base, overlay)) continue;
+		normalized.overlay[key] = overlay;
+	}
+	return {
+		draft: normalized,
+		issues
+	};
+}
+function analyzeImpact(model, evaluated) {
+	const changed = new Set(evaluated.deltas.map((d) => d.key));
+	const direct = [];
+	const affected = [];
+	const terminal = [];
+	for (const key of changed) {
+		const origin = evaluated.result.origins.get(key);
+		if (origin?.kind === "overlay") direct.push(key);
+		else if (origin?.kind === "derived") affected.push(key);
+	}
+	for (const key of changed) if (!model.dependentsByKey.get(key)?.some((d) => changed.has(d))) terminal.push(key);
+	return {
+		direct,
+		affected,
+		terminal
+	};
+}
+function freezeDraftAnalysis(model, analysis) {
+	const modelShape = snapshotModel(model);
+	const draft = analysis.evaluated.draft;
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const snapshot = {
+		modelFingerprint: fingerprintValue(modelShape),
+		baseFingerprint: fingerprintValue(draft.base),
+		overlayFingerprint: fingerprintValue(draft.overlay),
+		analysisFingerprint: fingerprintValue({
+			model: modelShape,
+			base: draft.base,
+			overlay: draft.overlay
+		}),
+		createdAt: now
+	};
+	return {
+		draftId: draft.draftId,
+		snapshot,
+		base: canonicalizeFacts(model, draft.base),
+		overlay: canonicalizeFacts(model, draft.overlay),
+		effective: canonicalizeFacts(model, analysis.evaluated.result.overlayedFacts.effective),
+		values: canonicalizeFacts(model, mapToFactBag(analysis.evaluated.result.values)),
+		deltas: analysis.evaluated.deltas.map((delta) => canonicalizeDelta(model, delta)),
+		groupedDiffs: analysis.groupedDiffs.map((group) => ({
+			label: group.label,
+			deltas: group.deltas.map((delta) => canonicalizeDelta(model, delta))
+		})),
+		changes: analysis.changes.map((change) => ({
+			delta: canonicalizeDelta(model, change.delta),
+			dependencies: change.dependencies
+		})),
+		impact: analysis.impact,
+		normalizationIssues: analysis.normalizationIssues,
+		frozenAt: now
+	};
+}
+//#endregion
+//#region src/inspect/inspect-diff-target.ts
+function inspectDiffTarget(model, result, changes, target) {
+	const changeByKey = new Map(changes.map((change) => [change.delta.key, change]));
+	const stepByTarget = new Map(result.trace.map((step) => [step.target, step]));
+	function build(key, parentStep) {
+		const step = stepByTarget.get(key);
+		const change = changeByKey.get(key);
+		if (!step) {
+			const keyMeta = model.keyMeta.get(key);
+			return {
+				key,
+				kind: "input",
+				meta: { key: keyMeta },
+				execution: { value: parentStep?.inputs[key] },
+				change,
+				label: keyMeta?.label ?? key,
+				children: []
+			};
+		}
+		return {
+			key,
+			kind: step?.ruleSpec?.op ?? "rule",
+			meta: {
+				key: step?.keyMeta,
+				rule: step?.ruleMeta
+			},
+			structure: { ruleSpec: step?.ruleSpec },
+			execution: {
+				value: step?.output,
+				trace: step
+			},
+			change,
+			label: step?.keyMeta?.label ?? key,
+			children: step?.deps.map((dep) => build(dep, step)) ?? []
+		};
+	}
+	return build(target);
+}
+//#endregion
+//#region src/inspect/inspect-model-target.ts
+function inspectModelTarget(model, target) {
+	function build(key) {
+		const rule = model.ruleByTarget.get(key);
+		const keyMeta = model.keyMeta.get(key);
+		const ruleMeta = model.ruleMeta.get(key);
+		return {
+			key,
+			kind: rule ? rule?.spec?.op ?? "rule" : "input",
+			meta: {
+				key: keyMeta,
+				rule: ruleMeta
+			},
+			structure: { ruleSpec: rule?.spec },
+			label: keyMeta?.label ?? key,
+			children: rule?.deps.map((dep) => build(dep.id)) ?? []
+		};
+	}
+	return build(target);
+}
+//#endregion
+//#region src/inspect/inspect-trace-target.ts
+function inspectTraceTarget(model, trace, target) {
+	const stepByTarget = new Map(trace.map((s) => [s.target, s]));
+	function build(key, parentStep) {
+		const step = stepByTarget.get(key);
+		if (!step) {
+			const keyMeta = model.keyMeta.get(key);
+			return {
+				key,
+				kind: "input",
+				meta: { key: keyMeta },
+				execution: { value: parentStep?.inputs[key] },
+				label: keyMeta?.label ?? key,
+				children: []
+			};
+		}
+		return {
+			key,
+			kind: step?.ruleSpec?.op ?? "rule",
+			meta: {
+				key: step?.keyMeta,
+				rule: step?.ruleMeta
+			},
+			structure: { ruleSpec: step?.ruleSpec },
+			execution: {
+				value: step?.output,
+				trace: step
+			},
+			label: step?.keyMeta?.label ?? key,
+			children: step?.deps.map((dep) => build(dep, step)) ?? []
+		};
+	}
+	return build(target);
+}
+//#endregion
+//#region src/inspect/inspection-node-to-ascii.ts
+const formatLabel = (node, { showMeta, showChange }) => {
+	let label = node.meta?.rule?.label ?? node.label;
+	if (showMeta) label += ` [${node.kind}]`;
+	if (node.change && showChange) {
+		const delta = node.change.delta;
+		switch (delta.kind) {
+			case "added":
+				label += ` = ${String(delta.after)} (addded)`;
+				break;
+			case "changed":
+				label += ` = ${String(delta.before)} -> ${delta.after} (changed)`;
+				break;
+			case "removed":
+				label += ` = ${String(delta.before)} (removed)`;
+				break;
+		}
+	} else if (node.execution?.value !== void 0) label += ` = ${String(node.execution?.value)}`;
+	const detail = node.execution?.trace?.detail;
+	if (detail) switch (detail.op) {
+		case "decision": {
+			const tableDetail = detail;
+			label += tableDetail.usedDefault ? " :: default" : ` :: ${tableDetail.matchedRowLabel ?? tableDetail.matchedRowId}`;
+		}
+	}
+	return label;
+};
+const inspectionNodeToAscii = (root, options) => {
+	const toAscii = (node, prefix = "", isLast = true) => {
+		const lines = [`${prefix}${isLast ? "└── " : "├── "}${formatLabel(node, options)}`];
+		const childPrefix = prefix + (isLast ? "    " : "│   ");
+		const children = node.children.map((dep, index) => toAscii(dep, childPrefix, index === node.children.length - 1));
+		return [...lines, ...children].join("\n");
+	};
+	return toAscii(root);
+};
+//#endregion
+//#region src/key.ts
+function key(id) {
+	return {
+		__kind: "key",
+		id
+	};
+}
+//#endregion
+//#region src/model/compile-model.ts
+function compileModel(model) {
+	const issues = [];
+	const inputKeys = /* @__PURE__ */ new Set();
+	for (const input of model.inputs) {
+		const id = input.key.id;
+		if (inputKeys.has(id)) issues.push({
+			level: "error",
+			code: "DUPLICATE_INPUT",
+			message: `Input "${id}" is declared more than once.`,
+			keys: [id]
+		});
+		inputKeys.add(id);
+	}
+	const ruleByTarget = /* @__PURE__ */ new Map();
+	for (const rule of model.rules) {
+		const targetId = rule.target.id;
+		if (ruleByTarget.has(targetId)) {
+			issues.push({
+				level: "error",
+				code: "DUPLICATE_RULE_TARGET",
+				message: `Rule target "${targetId}" is declared more than once.`,
+				keys: [targetId]
+			});
+			continue;
+		}
+		ruleByTarget.set(targetId, rule);
+	}
+	for (const inputId of inputKeys) if (ruleByTarget.has(inputId)) issues.push({
+		level: "error",
+		code: "INPUT_RULE_CONFLICT",
+		message: `Key "${inputId}" is declared as both input and rule target.`,
+		keys: [inputId]
+	});
+	const knownKeys = new Set([...inputKeys, ...ruleByTarget.keys()]);
+	const depsByTarget = /* @__PURE__ */ new Map();
+	const dependentsByKeyMutable = /* @__PURE__ */ new Map();
+	for (const rule of model.rules) {
+		const targetId = rule.target.id;
+		const depIds = rule.deps.map((dep) => dep.id);
+		depsByTarget.set(targetId, depIds);
+		for (const depId of depIds) {
+			if (!knownKeys.has(depId)) {
+				issues.push({
+					level: "error",
+					code: "MISSING_DEPENDENCY",
+					message: `Rule "${targetId}" depends on unkown key "${depId}".`,
+					keys: [targetId, depId]
+				});
+				continue;
+			}
+			const dependents = dependentsByKeyMutable.get(depId);
+			if (dependents) dependents.push(targetId);
+			else dependentsByKeyMutable.set(depId, [targetId]);
+		}
+	}
+	if (issues.some((issue) => issue.level === "error")) return {
+		ok: false,
+		issues
+	};
+	const inDegree = /* @__PURE__ */ new Map();
+	for (const targetId of ruleByTarget.keys()) inDegree.set(targetId, 0);
+	for (const [targetId, depIds] of depsByTarget) {
+		let count = 0;
+		for (const depId of depIds) if (ruleByTarget.has(depId)) count += 1;
+		inDegree.set(targetId, count);
+	}
+	const queue = [];
+	for (const [targetId, degree] of inDegree) if (degree === 0) queue.push(targetId);
+	const orderedRuleTargets = [];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		orderedRuleTargets.push(current);
+		const dependents = dependentsByKeyMutable.get(current) ?? [];
+		for (const dependentTarget of dependents) {
+			if (!inDegree.has(dependentTarget)) continue;
+			const nextDegree = inDegree.get(dependentTarget) - 1;
+			inDegree.set(dependentTarget, nextDegree);
+			if (nextDegree === 0) queue.push(dependentTarget);
+		}
+	}
+	if (orderedRuleTargets.length !== ruleByTarget.size) {
+		const unresolved = [...ruleByTarget.keys()].filter((targetId) => !orderedRuleTargets.includes(targetId));
+		issues.push({
+			level: "error",
+			code: "CYCLE",
+			message: `Cycle detected among rule targets "${unresolved.join(", ")}"`,
+			keys: unresolved
+		});
+		return {
+			ok: false,
+			issues
+		};
+	}
+	const dependentsByKey = new Map([...dependentsByKeyMutable.entries()].map(([k, v]) => [k, [...v]]));
+	const declaredKeys = [...model.inputs.map((i) => [i.key.id, i.key]), ...model.rules.map((r) => [r.target.id, r.target])];
+	return {
+		ok: true,
+		issues,
+		model: {
+			keys: new Map(declaredKeys),
+			semantics: model.semantics,
+			inputs: model.inputs,
+			rules: model.rules,
+			keyMeta: model.keyMeta,
+			ruleMeta: model.ruleMeta,
+			inputKeys: [...inputKeys],
+			orderedRuleTargets,
+			ruleByTarget,
+			depsByTarget,
+			dependentsByKey
+		}
+	};
+}
+//#endregion
+//#region src/input.ts
+function input(key) {
+	return {
+		kind: "input",
+		key
+	};
+}
+//#endregion
+//#region src/model/create-model.ts
+function createModel() {
+	const inputs = [];
+	const rules = [];
+	const keyMeta = /* @__PURE__ */ new Map();
+	const ruleMeta = /* @__PURE__ */ new Map();
+	const semanticsMap = /* @__PURE__ */ new Map();
+	return {
+		input(k, meta = {}, semantics) {
+			inputs.push(input(k));
+			keyMeta.set(k.id, meta);
+			if (semantics) semanticsMap.set(k.id, semantics);
+			return k;
+		},
+		rule(r, meta = {}, semantics) {
+			rules.push(r);
+			ruleMeta.set(r.target.id, meta);
+			if (semantics) semanticsMap.set(r.target.id, semantics);
+			return r.target;
+		},
+		build() {
+			return {
+				inputs,
+				rules,
+				semantics: semanticsMap,
+				keyMeta,
+				ruleMeta
+			};
+		}
+	};
+}
+//#endregion
+//#region src/model/model-graph.ts
+function toGraph(model) {
+	return {
+		nodes: [...model.inputKeys, ...model.orderedRuleTargets],
+		edges: model.orderedRuleTargets.flatMap((to) => (model.depsByTarget.get(to) ?? []).map((from) => ({
+			from,
+			to
+		})))
+	};
+}
+function subgraph(model, includedKeys) {
+	const included = new Set(includedKeys);
+	const nodes = [...model.inputKeys.filter((k) => included.has(k)), ...model.orderedRuleTargets.filter((k) => included.has(k))];
+	const edges = [];
+	for (const target of model.orderedRuleTargets) {
+		if (!included.has(target)) continue;
+		const deps = model.depsByTarget.get(target) ?? [];
+		for (const dep of deps) if (included.has(dep)) edges.push({
+			from: dep,
+			to: target
+		});
+	}
+	return {
+		nodes,
+		edges
+	};
+}
+function upstreamGraphOf(model, key, options) {
+	const keys = new Set(upstreamOf(model, key));
+	if (options?.includeTarget ?? true) keys.add(key.id);
+	return subgraph(model, [...keys]);
+}
+function downstreamGraphOf(model, key, options) {
+	const keys = new Set(downstreamOf(model, key));
+	if (options?.includeTarget ?? true) keys.add(key.id);
+	return subgraph(model, [...keys]);
+}
+//#endregion
+//#region src/rule/index.ts
+function rule(def) {
+	return {
+		__kind: "rule",
+		spec: def.spec,
+		target: def.target,
+		deps: def.deps,
+		eval: def.eval
+	};
+}
+//#endregion
+//#region src/rule/operand.ts
+function resolveOperand(operand, get) {
+	return operand.__kind === "value" ? operand.value : get(operand);
+}
+//#endregion
+//#region src/rule/decision.ts
+function evalPredicate(p, ops, get) {
+	if (p.op === "in") return p.values.some((v) => ops.eq(get(p.source), resolveOperand(v, get)));
+	else {
+		const left = get(p.source);
+		const right = resolveOperand(p.right, get);
+		switch (p.op) {
+			case "eq": return ops.eq(get(p.source), right);
+			case "gt": return ops.compare(left, right) > 0;
+			case "gte": return ops.compare(left, right) >= 0;
+			case "lt": return ops.compare(left, right) < 0;
+			case "lte": return ops.compare(left, right) <= 0;
+		}
+	}
+}
+function predicateDependencies(p) {
+	if ("right" in p && p.right.__kind === "key") return [p.source, p.right];
+	return [p.source];
+}
+function decisionDependencies(table) {
+	const deps = /* @__PURE__ */ new Map();
+	for (const row of table.rows) for (const predicate of row.when) for (const dep of predicateDependencies(predicate)) deps.set(dep.id, dep);
+	if (table.default?.__kind === "key") deps.set(table.default.id, table.default);
+	return [...deps.values()];
+}
+function toSpec(ops, table) {
+	const spec = {
+		op: "decision",
+		opsDescriptor: {
+			family: ops.family,
+			version: ops.version
+		},
+		table: {
+			name: table.name,
+			rows: table.rows
+		}
+	};
+	if (table.default) spec.table.default = table.default;
+	return spec;
+}
+function decision(ops, target, table) {
+	return rule({
+		target,
+		spec: toSpec(ops, table),
+		deps: decisionDependencies(table),
+		eval: (get) => {
+			for (const row of table.rows) if (row.when.every((p) => evalPredicate(p, ops, get))) return {
+				output: resolveOperand(row.output, get),
+				detail: {
+					op: "decision",
+					tableName: table.name,
+					matchedRowId: row.id,
+					matchedRowLabel: row.label,
+					usedDefault: false
+				}
+			};
+			if (table.default === void 0) throw new Error(`No matching row found for decision table ${table.name}`);
+			return {
+				output: resolveOperand(table.default, get),
+				detail: {
+					op: "decision",
+					tableName: table.name,
+					usedDefault: true
+				}
+			};
+		}
+	});
+}
+//#endregion
+//#region src/rule/projection.ts
+function projection(target, source, field) {
+	return rule({
+		target,
+		spec: {
+			op: "project",
+			source: source.id,
+			field: String(field)
+		},
+		deps: [source],
+		eval: (get) => {
+			return { output: get(source)[field] };
+		}
+	});
+}
+//#endregion
+//#region src/rule/ratio.ts
+function ratio(ops, target, numerator, denominator) {
+	return rule({
+		target,
+		spec: {
+			op: "ratio",
+			opsDescriptor: {
+				family: ops.family,
+				version: ops.version
+			},
+			numerator: numerator.id,
+			denominator: denominator.id
+		},
+		deps: [numerator, denominator],
+		eval: (get) => {
+			return { output: ops.div(get(numerator), get(denominator)) };
+		}
+	});
+}
+//#endregion
+//#region src/rule/scale.ts
+function scale(ops, target, input, factor) {
+	return rule({
+		target,
+		spec: {
+			op: "scale",
+			opsDescriptor: {
+				family: ops.family,
+				version: ops.version
+			},
+			input: input.id,
+			factor: factor.id
+		},
+		deps: [input, factor],
+		eval: (get) => {
+			return { output: ops.scale(get(input), get(factor)) };
+		}
+	});
+}
+//#endregion
+//#region src/rule/sum.ts
+function sum(ops, target, deps) {
+	return rule({
+		target,
+		spec: {
+			op: "sum",
+			opsDescriptor: {
+				family: ops.family,
+				version: ops.version
+			},
+			deps: deps.map((d) => d.id)
+		},
+		deps,
+		eval: (get) => {
+			return { output: deps.reduce((acc, b) => ops.add(acc, get(b)), ops.zero()) };
+		}
+	});
+}
+//#endregion
+//#region src/rule/weighted-sum.ts
+function weightedSum(ops, target, deps) {
+	return rule({
+		target,
+		spec: {
+			op: "weighted-sum",
+			opsDescriptor: {
+				family: ops.family,
+				version: ops.version
+			},
+			deps: deps.map((d) => d.key.id),
+			weights: deps.map((d) => d.weight)
+		},
+		deps: deps.map((d) => d.key),
+		eval: (get) => {
+			return { output: deps.reduce((acc, { key, weight }) => {
+				const factor = resolveOperand(weight, get);
+				const value = get(key);
+				return ops.add(acc, ops.scale(value, factor));
+			}, ops.zero()) };
+		}
+	});
+}
+//#endregion
+//#region src/semantics/algebra.ts
+const defaultOps = {
+	family: "default/unknown",
+	version: "1",
+	eq: Object.is
+};
+const defaultNumberOps = {
+	family: "default/number",
+	version: "1",
+	eq: (a, b) => a === b,
+	compare: (a, b) => a < b ? -1 : a > b ? 1 : 0,
+	zero: () => 0,
+	add: (a, b) => a + b,
+	sub: (a, b) => a - b,
+	one: () => 1,
+	scale: (value, factor) => value * factor,
+	div: (a, b) => a / b
+};
+//#endregion
+//#region src/value.ts
+function value(value) {
+	return {
+		__kind: "value",
+		value
+	};
+}
+//#endregion
+export { analyzeDraft, compileModel, createDraft, createModel, decision, defaultEvaluateMode, defaultNumberOps, defaultOps, diffResults, downstreamGraphOf, downstreamOf, evaluate, evaluateDraft, evaluateOverlay, explainDiffs, freezeDraftAnalysis, getDeclaredKeys, getDependencies, getDependents, inspectDiffTarget, inspectModelTarget, inspectTraceTarget, inspectionNodeToAscii, isEmptyDraft, key, projection, ratio, resolveOperand, rule, scale, sortKeysByModelOrder, subgraph, sum, toGraph, upstreamGraphOf, upstreamOf, value, weightedSum };