@diagc/core 0.1.0

package/dist/fishbone.js

@@ -0,0 +1,95 @@
+/** The notation id a plane (or the model) declares to be drawn as a fish. */
+export const FISHBONE_NOTATION = 'fishbone';
+export const FB_EFFECT_TYPE = 'fb-effect';
+export const FB_CATEGORY_TYPE = 'fb-category';
+/** A cause and a sub-cause are ONE type: which it is comes from where it hangs
+ * (see fishboneTree), so promoting a sub-cause is a relation edit, not a type
+ * change, and nothing about a node can disagree with its place on the fish. */
+export const FB_CAUSE_TYPE = 'fb-cause';
+export const FISHBONE_TYPES = [FB_EFFECT_TYPE, FB_CATEGORY_TYPE, FB_CAUSE_TYPE];
+/** The kind the builder and the studio create — from the cause TO what it
+ * explains. The derivation below does NOT filter by it (see fishboneTree). */
+export const FB_CAUSE_OF_KIND = 'cause-of';
+export const isFishboneNode = (n) => n.type !== undefined && FISHBONE_TYPES.includes(n.type);
+/** Category sets an author can start from. Software first: it is what this
+ * tool is mostly used for; the classic manufacturing (6M) and service (4S) sets
+ * follow. The order of names is the order of bones. */
+export const FISHBONE_PRESETS = {
+    Software: ['People', 'Process', 'Requirements', 'Code', 'Infrastructure', 'Dependencies'],
+    '6M': ['Man', 'Machine', 'Method', 'Material', 'Measurement', 'Environment'],
+    '4S': ['Surroundings', 'Suppliers', 'Systems', 'Skills'],
+};
+export const FISHBONE_PRESET_NAMES = ['Software', '6M', '4S'];
+/** node id for a preset category name: 'Infrastructure' → 'infrastructure' */
+export const presetId = (name) => name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+/**
+ * The one definition of "hangs on": a fishbone node's parent is the `to` of
+ * its FIRST relation (declaration order) whose other end is also a fishbone
+ * node — any kind, so restyling an arrow can never drop a cause off its bone.
+ * Self-loops are skipped, and a relation whose ends aren't both fishbone
+ * nodes doesn't count as a parent pick. Shared by fishboneTree and
+ * validateFishbone (validate.ts) so the rule is defined exactly once.
+ */
+export function fishboneParents(model) {
+    const typeOf = new Map(model.nodes.filter(isFishboneNode).map((n) => [n.id, n.type]));
+    const parentOf = new Map();
+    for (const r of model.relations) {
+        if (r.from === r.to || !typeOf.has(r.from) || !typeOf.has(r.to) || parentOf.has(r.from))
+            continue;
+        parentOf.set(r.from, r.to);
+    }
+    return parentOf;
+}
+/**
+ * What hangs where. This is the ONE place that answers it, so the layout, the
+ * colour hooks, the studio panel and validation cannot disagree.
+ *
+ * Reads a node's parent via fishboneParents, then reads the fish top-down from
+ * the effect with the types checked at each level: only a category hangs on
+ * the effect, only a cause on a category, only a cause on a cause, and a
+ * sub-cause has no children.
+ *
+ * Reads the MODEL's relations, never drawn edges: toggling a layer must not
+ * move a box. Never throws.
+ */
+export function fishboneTree(model) {
+    const nodes = model.nodes.filter(isFishboneNode);
+    const typeOf = new Map(nodes.map((n) => [n.id, n.type]));
+    const effect = nodes.find((n) => n.type === FB_EFFECT_TYPE)?.id;
+    const parentOf = fishboneParents(model);
+    // Map iteration is insertion order, so each child list is in relation order.
+    const childrenOf = new Map();
+    for (const [child, parent] of parentOf) {
+        const list = childrenOf.get(parent);
+        if (list === undefined)
+            childrenOf.set(parent, [child]);
+        else
+            list.push(child);
+    }
+    const kids = (id, type) => (childrenOf.get(id) ?? []).filter((c) => typeOf.get(c) === type);
+    const placed = new Set();
+    const categories = [];
+    if (effect !== undefined) {
+        placed.add(effect);
+        for (const c of kids(effect, FB_CATEGORY_TYPE)) {
+            placed.add(c);
+            const causes = [];
+            for (const cause of kids(c, FB_CAUSE_TYPE)) {
+                placed.add(cause);
+                const subs = kids(cause, FB_CAUSE_TYPE);
+                for (const s of subs)
+                    placed.add(s);
+                causes.push({ id: cause, subs });
+            }
+            categories.push({ id: c, causes });
+        }
+    }
+    return {
+        ...(effect !== undefined ? { effect } : {}),
+        categories,
+        unattached: nodes.map((n) => n.id).filter((id) => !placed.has(id)),
+    };
+}

package/dist/git.d.ts

@@ -0,0 +1,65 @@
+import type { DiagramModel, DiagramNode } from './types.js';
+/** The notation id a plane declares to be drawn as a git graph. */
+export declare const GIT_NOTATION: "git-graph";
+/** The three link kinds the layout understands. Any other kind between commits
+ * is drawn as a plain edge and never moves a circle. */
+export declare const GIT_KINDS: readonly ["commit", "branch", "merge"];
+export type GitKind = (typeof GIT_KINDS)[number];
+export declare const isGitKind: (k: string) => k is GitKind;
+/** A stage: a named frame drawn across EVERY lane, from one commit's column to
+ * another's — "Development", "Release candidates", "Hotfix". It is a node of
+ * this type whose span lives in its metadata (`from`, and optionally `to`, each
+ * a commit id) rather than in containment: a commit already belongs to its lane,
+ * and a stage cuts across lanes. */
+export declare const GIT_STAGE_TYPE: "git-stage";
+export interface GitStage {
+    id: string;
+    node: DiagramNode;
+    /** first and last column the frame covers, inclusive (from ≤ to) */
+    fromCol: number;
+    toCol: number;
+}
+/** the commit id a stage names under `key`, if it names one at all */
+export declare function stageCommit(n: DiagramNode, key: 'from' | 'to'): string | undefined;
+export interface GitLane {
+    id: string;
+    node: DiagramNode;
+    /** this lane's commits in declaration order */
+    commits: DiagramNode[];
+}
+export interface GitGraph {
+    /** `type: 'branch'` nodes in declaration order — top-to-bottom lane order */
+    lanes: GitLane[];
+    /** commit id → lane id */
+    laneOf: Map<string, string>;
+    /** commit id → column, every commit including strays */
+    columns: Map<string, number>;
+    /** `type: 'commit'` nodes no lane contains on this plane */
+    strays: DiagramNode[];
+    /** relation ids ignored to break cycles; empty for a valid graph */
+    cycleEdges: string[];
+    /** `type: 'git-stage'` nodes whose span resolves to columns, in declaration
+     * order. One that names no known commit is left out (validation reports it). */
+    stages: GitStage[];
+}
+/** `metadata.gap` as a count of empty columns: a non-negative integer, or a
+ * string of digits (the studio's generic metadata editor stores strings). */
+export declare function gapOf(n: DiagramNode): number;
+/** true when the commit's segment ended in a merge (it has an outgoing `merge`). */
+export declare function mergedAway(model: DiagramModel, commitId: string): boolean;
+/**
+ * Lanes, membership and columns for one plane. This is the ONE place that
+ * answers "which lane is this commit on" and "which column does it take", so
+ * the renderer's layout, the studio's panel and validation cannot disagree.
+ * Containment is read the way the view reads it: the plane's own edges, or its
+ * donor's when it borrows (`containmentOf`); untagged edges belong to the
+ * default (first-declared) plane. Never throws — a cycle is cut, not reported
+ * as an error here (validation does that from `cycleEdges`).
+ */
+export declare function gitGraph(model: DiagramModel, plane?: string): GitGraph;
+/** `${lane}-${n}` with the smallest n not yet taken — the DSL's naming, kept
+ * unique even after deletions. Shared by the Git panel and the canvas `+` so
+ * a commit is named the same whichever created it. */
+export declare function nextCommitId(model: DiagramModel, laneId: string): string;
+/** The lane's rightmost commit (max column; ties go to the later declared). */
+export declare function latestCommit(g: GitGraph, laneId: string): DiagramNode | undefined;

package/dist/git.js

@@ -0,0 +1,159 @@
+import { containmentPlaneOf } from './view/hierarchy.js';
+/** The notation id a plane declares to be drawn as a git graph. */
+export const GIT_NOTATION = 'git-graph';
+/** The three link kinds the layout understands. Any other kind between commits
+ * is drawn as a plain edge and never moves a circle. */
+export const GIT_KINDS = ['commit', 'branch', 'merge'];
+export const isGitKind = (k) => GIT_KINDS.includes(k);
+/** A stage: a named frame drawn across EVERY lane, from one commit's column to
+ * another's — "Development", "Release candidates", "Hotfix". It is a node of
+ * this type whose span lives in its metadata (`from`, and optionally `to`, each
+ * a commit id) rather than in containment: a commit already belongs to its lane,
+ * and a stage cuts across lanes. */
+export const GIT_STAGE_TYPE = 'git-stage';
+/** the commit id a stage names under `key`, if it names one at all */
+export function stageCommit(n, key) {
+    const raw = n.metadata?.[key];
+    return typeof raw === 'string' && raw !== '' ? raw : undefined;
+}
+/** `metadata.gap` as a count of empty columns: a non-negative integer, or a
+ * string of digits (the studio's generic metadata editor stores strings). */
+export function gapOf(n) {
+    const raw = n.metadata?.['gap'];
+    if (typeof raw === 'number')
+        return Number.isInteger(raw) && raw >= 0 ? raw : 0;
+    if (typeof raw === 'string' && /^\d+$/.test(raw))
+        return Number(raw);
+    return 0;
+}
+/** true when the commit's segment ended in a merge (it has an outgoing `merge`). */
+export function mergedAway(model, commitId) {
+    return model.relations.some((r) => r.kind === 'merge' && r.from === commitId);
+}
+/**
+ * Lanes, membership and columns for one plane. This is the ONE place that
+ * answers "which lane is this commit on" and "which column does it take", so
+ * the renderer's layout, the studio's panel and validation cannot disagree.
+ * Containment is read the way the view reads it: the plane's own edges, or its
+ * donor's when it borrows (`containmentOf`); untagged edges belong to the
+ * default (first-declared) plane. Never throws — a cycle is cut, not reported
+ * as an error here (validation does that from `cycleEdges`).
+ */
+export function gitGraph(model, plane) {
+    const planes = model.planes ?? [];
+    const defaultPlane = planes[0]?.id;
+    const active = containmentPlaneOf(model, plane) ?? plane ?? defaultPlane;
+    const edges = model.containment.filter((e) => (e.plane ?? defaultPlane) === active);
+    const byId = new Map(model.nodes.map((n) => [n.id, n]));
+    const index = new Map(model.nodes.map((n, i) => [n.id, i]));
+    const declared = (a, b) => index.get(a.id) - index.get(b.id);
+    const laneOf = new Map();
+    const lanes = [];
+    for (const n of model.nodes) {
+        if (n.type !== 'branch')
+            continue;
+        const members = edges
+            .filter((e) => e.parent === n.id)
+            .map((e) => byId.get(e.child))
+            .filter((c) => c !== undefined && c.type === 'commit')
+            .sort(declared);
+        // Containment is a DAG; a commit two lanes claim belongs to the first one
+        // declared, so every commit has exactly one row.
+        const own = members.filter((c) => !laneOf.has(c.id));
+        for (const c of own)
+            laneOf.set(c.id, n.id);
+        lanes.push({ id: n.id, node: n, commits: own });
+    }
+    const commits = model.nodes.filter((n) => n.type === 'commit');
+    const strays = commits.filter((c) => !laneOf.has(c.id));
+    const { columns, cycleEdges } = computeColumns(model.relations, commits, byId, index);
+    const stages = [];
+    for (const n of model.nodes) {
+        if (n.type !== GIT_STAGE_TYPE)
+            continue;
+        const from = stageCommit(n, 'from');
+        const a = from !== undefined ? columns.get(from) : undefined;
+        const b = columns.get(stageCommit(n, 'to') ?? from ?? '');
+        if (a === undefined || b === undefined)
+            continue;
+        stages.push({ id: n.id, node: n, fromCol: Math.min(a, b), toCol: Math.max(a, b) });
+    }
+    return { lanes, laneOf, columns, strays, cycleEdges, stages };
+}
+/** `${lane}-${n}` with the smallest n not yet taken — the DSL's naming, kept
+ * unique even after deletions. Shared by the Git panel and the canvas `+` so
+ * a commit is named the same whichever created it. */
+export function nextCommitId(model, laneId) {
+    const taken = new Set(model.nodes.map((n) => n.id));
+    for (let n = 1;; n++) {
+        const id = `${laneId}-${n}`;
+        if (!taken.has(id))
+            return id;
+    }
+}
+/** The lane's rightmost commit (max column; ties go to the later declared). */
+export function latestCommit(g, laneId) {
+    const lane = g.lanes.find((l) => l.id === laneId);
+    let best;
+    for (const c of lane?.commits ?? []) {
+        if (best === undefined || (g.columns.get(c.id) ?? 0) >= (g.columns.get(best.id) ?? 0))
+            best = c;
+    }
+    return best;
+}
+/**
+ * Longest-path columns over the git links: Kahn's algorithm, ready nodes taken
+ * in declaration order so the result is stable under re-serialisation. When
+ * nothing is ready but commits remain, the links form a cycle: the
+ * earliest-declared remaining commit gives up its incoming links from other
+ * remaining commits (recorded in `cycleEdges`) and the walk goes on.
+ */
+function computeColumns(relations, commits, byId, index) {
+    const ids = new Set(commits.map((c) => c.id));
+    const links = relations.filter((r) => isGitKind(r.kind) && ids.has(r.from) && ids.has(r.to) && r.from !== r.to);
+    const incoming = new Map();
+    const outgoing = new Map();
+    const indeg = new Map(commits.map((c) => [c.id, 0]));
+    for (const l of links) {
+        incoming.set(l.to, [...(incoming.get(l.to) ?? []), l]);
+        outgoing.set(l.from, [...(outgoing.get(l.from) ?? []), l]);
+        indeg.set(l.to, indeg.get(l.to) + 1);
+    }
+    const order = [...commits].sort((a, b) => index.get(a.id) - index.get(b.id));
+    const remaining = new Set(order.map((c) => c.id));
+    const ready = order.filter((c) => indeg.get(c.id) === 0).map((c) => c.id);
+    const dropped = new Set();
+    const cycleEdges = [];
+    const columns = new Map();
+    while (remaining.size > 0) {
+        if (ready.length === 0) {
+            const victim = order.find((c) => remaining.has(c.id));
+            for (const l of incoming.get(victim.id) ?? []) {
+                if (!remaining.has(l.from) || dropped.has(l.id))
+                    continue;
+                dropped.add(l.id);
+                cycleEdges.push(l.id);
+                indeg.set(victim.id, indeg.get(victim.id) - 1);
+            }
+            ready.push(victim.id);
+        }
+        ready.sort((a, b) => index.get(a) - index.get(b));
+        const id = ready.shift();
+        remaining.delete(id);
+        let col = 0;
+        for (const l of incoming.get(id) ?? []) {
+            if (!dropped.has(l.id))
+                col = Math.max(col, (columns.get(l.from) ?? 0) + 1);
+        }
+        columns.set(id, col + gapOf(byId.get(id)));
+        for (const l of outgoing.get(id) ?? []) {
+            if (dropped.has(l.id))
+                continue;
+            const d = indeg.get(l.to) - 1;
+            indeg.set(l.to, d);
+            if (d === 0)
+                ready.push(l.to);
+        }
+    }
+    return { columns, cycleEdges };
+}

package/dist/guards.d.ts

@@ -0,0 +1,10 @@
+import { type Drawings, type LayoutOverlay } from './types.js';
+/** Structural guard for a LayoutOverlay, shared by the studio server (before
+ * persisting a layout) and the client (before trusting a loaded one). Checks
+ * shape only — not referential integrity against a model. */
+export declare function isLayoutOverlay(u: unknown): u is LayoutOverlay;
+/** Structural guard for a drawings sidecar — the same contract as
+ * isLayoutOverlay: shape only, shared by the save route and the client loader.
+ * Every rule here is one the renderer relies on without re-checking (even point
+ * count, finite numbers, positive width). */
+export declare function isDrawings(u: unknown): u is Drawings;

package/dist/guards.js

@@ -0,0 +1,98 @@
+import { EDGE_LABEL_SIDES } from './types.js';
+/** Structural guard for a LayoutOverlay, shared by the studio server (before
+ * persisting a layout) and the client (before trusting a loaded one). Checks
+ * shape only — not referential integrity against a model. */
+export function isLayoutOverlay(u) {
+    if (typeof u !== 'object' || u === null)
+        return false;
+    const layout = u;
+    if (layout.version !== 1 || typeof layout.planes !== 'object' || layout.planes === null)
+        return false;
+    const planesOk = Object.values(layout.planes).every((plane) => typeof plane === 'object' &&
+        plane !== null &&
+        Object.values(plane).every((p) => typeof p === 'object' &&
+            p !== null &&
+            typeof p.x === 'number' &&
+            typeof p.y === 'number'));
+    if (!planesOk)
+        return false;
+    const dim = (v) => typeof v === 'number' && Number.isFinite(v) && v > 0;
+    const sizesOk = layout.sizes === undefined ||
+        (typeof layout.sizes === 'object' &&
+            layout.sizes !== null &&
+            Object.values(layout.sizes).every((s) => typeof s === 'object' && s !== null && dim(s.w) && dim(s.h)));
+    if (!sizesOk)
+        return false;
+    const unfolded = u.unfolded;
+    const unfoldedOk = unfolded === undefined ||
+        (typeof unfolded === 'object' &&
+            unfolded !== null &&
+            !Array.isArray(unfolded) &&
+            Object.values(unfolded).every((ids) => Array.isArray(ids) && ids.every((id) => typeof id === 'string')));
+    if (!unfoldedOk)
+        return false;
+    const edgeLabels = u.edgeLabels;
+    const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+    const placementOk = (v) => isRecord(v) &&
+        typeof v['t'] === 'number' &&
+        Number.isFinite(v['t']) &&
+        (v['side'] === undefined || EDGE_LABEL_SIDES.includes(v['side']));
+    const edgeLabelsOk = edgeLabels === undefined ||
+        (isRecord(edgeLabels) &&
+            Object.values(edgeLabels).every((plane) => isRecord(plane) && Object.values(plane).every((rel) => isRecord(rel) && Object.values(rel).every(placementOk))));
+    if (!edgeLabelsOk)
+        return false;
+    // A note offset is drawn straight into a transform, so a NaN or an Infinity
+    // here is a note the reader can never find again — finiteness is checked, not
+    // just the type.
+    const finiteNum = (v) => typeof v === 'number' && Number.isFinite(v);
+    const notes = u.notes;
+    const notesOk = notes === undefined ||
+        (isRecord(notes) &&
+            Object.values(notes).every((plane) => isRecord(plane) &&
+                Object.values(plane).every((o) => isRecord(o) &&
+                    finiteNum(o['dx']) &&
+                    finiteNum(o['dy']) &&
+                    // `true` or absent: a stored `false` would be a second spelling of "closed"
+                    (o['open'] === undefined || o['open'] === true))));
+    if (!notesOk)
+        return false;
+    // `export` is export-only presentation (see LayoutOverlay): an object whose
+    // only field today is a list of node ids. Validate it structurally so a typo
+    // is a 400 from the studio's save endpoint rather than a silently ignored
+    // block — an unreadable PNG is a hard defect to trace back to a layout file.
+    const exp = u.export;
+    if (exp === undefined)
+        return true;
+    if (typeof exp !== 'object' || exp === null || Array.isArray(exp))
+        return false;
+    const collapsed = exp.collapsed;
+    return (collapsed === undefined || (Array.isArray(collapsed) && collapsed.every((id) => typeof id === 'string')));
+}
+/** Structural guard for a drawings sidecar — the same contract as
+ * isLayoutOverlay: shape only, shared by the save route and the client loader.
+ * Every rule here is one the renderer relies on without re-checking (even point
+ * count, finite numbers, positive width). */
+export function isDrawings(u) {
+    if (typeof u !== 'object' || u === null)
+        return false;
+    const d = u;
+    if (d.version !== 1 || typeof d.planes !== 'object' || d.planes === null)
+        return false;
+    const finite = (n) => typeof n === 'number' && Number.isFinite(n);
+    return Object.values(d.planes).every((bucket) => Array.isArray(bucket) &&
+        bucket.every((s) => {
+            if (typeof s !== 'object' || s === null)
+                return false;
+            const st = s;
+            if (typeof st.id !== 'string')
+                return false;
+            if (!Array.isArray(st.points) || st.points.length < 2 || st.points.length % 2 !== 0)
+                return false;
+            if (!st.points.every(finite))
+                return false;
+            if (st.color !== undefined && typeof st.color !== 'string')
+                return false;
+            return st.width === undefined || (finite(st.width) && st.width > 0);
+        }));
+}

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+export declare const CORE_VERSION = 1;
+export { ejectSource } from './eject.js';
+export * from './types.js';
+export * from './mutate.js';
+export { normalizeRuns, runsToPlainText } from './text.js';
+export { relationLabels } from './labels.js';
+export { defaultLayoutDirection, type LayoutDirection } from './layout-defaults.js';
+export { model, ModelBuilder, NodeRef, BranchRef, CommitRef, GitGraphBuilder, ActivityBuilder, ActivityScope, LaneRef, RegionRef, ConsequenceRef, SecondOrderBuilder, FishboneBuilder, CategoryRef, CauseRef, ThreatModelBuilder, FlowRef, type NodeOpts, type RelateOpts, type CommitOpts, type StageOpts, type MergeOpts, type ActivityElementOpts, type ConsequenceOpts, type FishboneOpts, type ThreatOpts, type ElementOpts, } from './builder.js';
+export { validate, DiagramValidationError, IMAGE_REF, LIBRARY_IMAGE_REF, type ValidationIssue } from './validate.js';
+export { isDrawings, isLayoutOverlay } from './guards.js';
+export { addStroke, deleteStroke, emptyDrawings, pruneDrawingsPlane, uniqueStrokeId } from './drawings.js';
+export { errMessage, SOURCE_URL } from './util.js';
+export { childrenOf, countAnchored } from './children.js';
+export { activeNotation, compileView, presetLayers, resolveContainmentPlane } from './view/compile.js';
+export { buildHierarchy, type HierarchyIndex } from './view/hierarchy.js';
+export { relationLayer } from './view/layers.js';
+export { scopeToRoot, EXTERNAL_STUB_PREFIX, type ScopedModel } from './view/scope.js';
+export { estimateSizes, LEAF_SIZE, CONTAINER_PADDING, CONTAINER_HEADER } from './view/size.js';
+export type { CompiledView, LodState, NodeViewState, Size, ViewEdge, ViewNode, ViewportState, } from './view/types.js';
+export { applyCommand, applyCommandWithResult, emptyLayout, layoutPlaneKey, openingPins, withEdgeLabelPlacements, withUnfolded, type EditorCommand, type EditorState, } from './commands.js';
+export { composeIncludes, IncludeError, MAX_INCLUDE_DEPTH, type IncludeResolver, type IncludeSource, } from './compose.js';
+export { GIT_KINDS, GIT_NOTATION, GIT_STAGE_TYPE, gapOf, gitGraph, isGitKind, latestCommit, mergedAway, nextCommitId, stageCommit, type GitGraph, type GitKind, type GitLane, type GitStage, } from './git.js';
+export { SECOND_ORDER_NOTATION, SO_CONSEQUENCE_TYPES, SO_DECISION_TYPE, SO_LEADS_TO_KIND, consequenceOrders, consequenceTypeOf, isSecondOrderNode, valenceOf, type ConsequenceOrders, type Valence, } from './second-order.js';
+export { FB_CATEGORY_TYPE, FB_CAUSE_OF_KIND, FB_CAUSE_TYPE, FB_EFFECT_TYPE, FISHBONE_NOTATION, FISHBONE_PRESET_NAMES, FISHBONE_PRESETS, FISHBONE_TYPES, fishboneParents, fishboneTree, isFishboneNode, presetId, type FishboneCategory, type FishboneCause, type FishbonePreset, type FishboneTree, } from './fishbone.js';
+export { TM_NOTATION, TM_ENTITY_TYPE, TM_PROCESS_TYPE, TM_STORE_TYPE, TM_BOUNDARY_TYPE, TM_FLOW_KIND, TM_TYPES, STRIDE_NAMES, NEW_THREAT_TITLE, isThreatModelNode, isOpen, strideFor, boundaryOf, boundaryName, crossings, crossingLabel, threatRegister, threatSummary, threatTargetKey, threatsOf, nextThreatId, nextThreatStatus, allNotesOpen, type ThreatTarget, type Crossing, type ThreatRow, } from './threat-model.js';

package/dist/index.js

@@ -0,0 +1,45 @@
+/*
+ * @diagc/core — diagram model, validator, builder DSL, and view compiler.
+ * Copyright (C) 2026 Bogdan Frankovskyi
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License version 3 as
+ * published by the Free Software Foundation, with the additional permissions
+ * granted under section 7 that are set out in the LICENSE file alongside this
+ * package. Those permissions let you license diagram sources you author, and
+ * the output produced from them, under terms of your choosing.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+export const CORE_VERSION = 1;
+export { ejectSource } from './eject.js';
+export * from './types.js';
+export * from './mutate.js';
+export { normalizeRuns, runsToPlainText } from './text.js';
+export { relationLabels } from './labels.js';
+export { defaultLayoutDirection } from './layout-defaults.js';
+export { model, ModelBuilder, NodeRef, BranchRef, CommitRef, GitGraphBuilder, ActivityBuilder, ActivityScope, LaneRef, RegionRef, ConsequenceRef, SecondOrderBuilder, FishboneBuilder, CategoryRef, CauseRef, ThreatModelBuilder, FlowRef, } from './builder.js';
+export { validate, DiagramValidationError, IMAGE_REF, LIBRARY_IMAGE_REF } from './validate.js';
+export { isDrawings, isLayoutOverlay } from './guards.js';
+export { addStroke, deleteStroke, emptyDrawings, pruneDrawingsPlane, uniqueStrokeId } from './drawings.js';
+export { errMessage, SOURCE_URL } from './util.js';
+export { childrenOf, countAnchored } from './children.js';
+export { activeNotation, compileView, presetLayers, resolveContainmentPlane } from './view/compile.js';
+export { buildHierarchy } from './view/hierarchy.js';
+export { relationLayer } from './view/layers.js';
+export { scopeToRoot, EXTERNAL_STUB_PREFIX } from './view/scope.js';
+export { estimateSizes, LEAF_SIZE, CONTAINER_PADDING, CONTAINER_HEADER } from './view/size.js';
+export { applyCommand, applyCommandWithResult, emptyLayout, layoutPlaneKey, openingPins, withEdgeLabelPlacements, withUnfolded, } from './commands.js';
+export { composeIncludes, IncludeError, MAX_INCLUDE_DEPTH, } from './compose.js';
+export { GIT_KINDS, GIT_NOTATION, GIT_STAGE_TYPE, gapOf, gitGraph, isGitKind, latestCommit, mergedAway, nextCommitId, stageCommit, } from './git.js';
+export { SECOND_ORDER_NOTATION, SO_CONSEQUENCE_TYPES, SO_DECISION_TYPE, SO_LEADS_TO_KIND, consequenceOrders, consequenceTypeOf, isSecondOrderNode, valenceOf, } from './second-order.js';
+export { FB_CATEGORY_TYPE, FB_CAUSE_OF_KIND, FB_CAUSE_TYPE, FB_EFFECT_TYPE, FISHBONE_NOTATION, FISHBONE_PRESET_NAMES, FISHBONE_PRESETS, FISHBONE_TYPES, fishboneParents, fishboneTree, isFishboneNode, presetId, } from './fishbone.js';
+export { TM_NOTATION, TM_ENTITY_TYPE, TM_PROCESS_TYPE, TM_STORE_TYPE, TM_BOUNDARY_TYPE, TM_FLOW_KIND, TM_TYPES, STRIDE_NAMES, NEW_THREAT_TITLE, isThreatModelNode, isOpen, strideFor, boundaryOf, boundaryName, crossings, crossingLabel, threatRegister, threatSummary, threatTargetKey, threatsOf, nextThreatId, nextThreatStatus, allNotesOpen, } from './threat-model.js';

package/dist/labels.d.ts

@@ -0,0 +1,5 @@
+import type { DiagramRelation, EdgeLabel } from './types.js';
+/** Effective labels for a relation, bridging the legacy single `label` string.
+ * `labels` (when present) is authoritative; otherwise a non-empty legacy
+ * `label` becomes one centered label; otherwise none. */
+export declare function relationLabels(r: DiagramRelation): EdgeLabel[];

package/dist/labels.js

@@ -0,0 +1,10 @@
+/** Effective labels for a relation, bridging the legacy single `label` string.
+ * `labels` (when present) is authoritative; otherwise a non-empty legacy
+ * `label` becomes one centered label; otherwise none. */
+export function relationLabels(r) {
+    if (r.labels !== undefined)
+        return r.labels;
+    if (r.label !== undefined && r.label !== '')
+        return [{ id: 'legacy', text: r.label, t: 0.5, side: 'center' }];
+    return [];
+}

package/dist/layout-defaults.d.ts

@@ -0,0 +1,20 @@
+import type { DiagramModel } from './types.js';
+export type LayoutDirection = 'DOWN' | 'RIGHT' | 'LEFT' | 'UP';
+/**
+ * The flow direction an automatically laid-out plane takes when its settings
+ * name none.
+ *
+ * Down. A diagram is read on a page and embedded in documents, where height
+ * scrolls and width does not: a left-to-right chain of a dozen boxes becomes a
+ * ribbon that has to be shrunk until its labels are unreadable, the same chain
+ * top-to-bottom is a column read at full size. Boxes are also wide and short, so
+ * stacking them wastes far less room than queueing them.
+ *
+ * The exception is a model that draws activity frames: their lanes are
+ * horizontal bands (vertical lanes are a recorded deferral), and a flow that ran
+ * ACROSS the bands would make every lane as tall as the whole activity.
+ *
+ * In core so the renderer (which lays out) and the studio (whose direction
+ * picker shows the default as selected) cannot drift.
+ */
+export declare function defaultLayoutDirection(model: Pick<DiagramModel, 'nodes'>): LayoutDirection;

package/dist/layout-defaults.js

@@ -0,0 +1,20 @@
+/**
+ * The flow direction an automatically laid-out plane takes when its settings
+ * name none.
+ *
+ * Down. A diagram is read on a page and embedded in documents, where height
+ * scrolls and width does not: a left-to-right chain of a dozen boxes becomes a
+ * ribbon that has to be shrunk until its labels are unreadable, the same chain
+ * top-to-bottom is a column read at full size. Boxes are also wide and short, so
+ * stacking them wastes far less room than queueing them.
+ *
+ * The exception is a model that draws activity frames: their lanes are
+ * horizontal bands (vertical lanes are a recorded deferral), and a flow that ran
+ * ACROSS the bands would make every lane as tall as the whole activity.
+ *
+ * In core so the renderer (which lays out) and the studio (whose direction
+ * picker shows the default as selected) cannot drift.
+ */
+export function defaultLayoutDirection(model) {
+    return model.nodes.some((n) => n.type === 'activity-frame') ? 'RIGHT' : 'DOWN';
+}