@memoarchitect/tools 0.6.6 → 0.7.2

package/packages/tools/lib/model/config.js

@@ -1,14 +1,16 @@
-// ─── MEMO Configuration Types ─────────────────────────────────────────────────
+// ─── MEMO Application Settings ────────────────────────────────────────────────
 //
-// Domain packages (e.g. @memoarchitect/medical-modeling-profile) implement MEMOConfig as config.yaml.
-// Projects inherit from domain configs via the `extends` field.
-// The CLI merges the inheritance chain at startup.
+// How the tools operate on a project — never what the project's model contains.
 //
-// Four project types:
-//   - "ontology" — shared type system (kinds + relationships)
-//   - "profile"  — viewpoints, templates (extends an ontology)
-//   - "library"  — reusable model elements (instances, not types)
-//   - "device"   — specific medical device model referencing an ontology
+// `MEMOConfig` used to be the project's semantic description: it selected the
+// methodology, the ontologies, the modules, the viewpoints, the layers, the
+// kinds, and the relationship types. None of that is here now. Those facts are
+// SysML, resolved by `native-project.ts` and `methodology-resolver.ts`, and a
+// settings file that still declares them is rejected by `settings-boundary.ts`.
+//
+// What remains is the section 5.3 list: which external compiler and packager to
+// run, and where their executables and config files are. Changing any of it
+// changes how a command behaves, not what the model means.
 // ─────────────────────────────────────────────────────────────────────────────
 export {};
 //# sourceMappingURL=config.js.map

package/packages/tools/lib/model/config.js.map

@@ -1 +1 @@
-{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/model/config.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,EAAE;AACF,sGAAsG;AACtG,gEAAgE;AAChE,mDAAmD;AACnD,EAAE;AACF,sBAAsB;AACtB,8DAA8D;AAC9D,+DAA+D;AAC/D,kEAAkE;AAClE,yEAAyE;AACzE,gFAAgF"}
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/model/config.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,EAAE;AACF,gFAAgF;AAChF,EAAE;AACF,8EAA8E;AAC9E,4EAA4E;AAC5E,+EAA+E;AAC/E,8EAA8E;AAC9E,gFAAgF;AAChF,EAAE;AACF,gFAAgF;AAChF,4EAA4E;AAC5E,2DAA2D;AAC3D,gFAAgF"}

package/packages/tools/lib/model/effective-scope.d.ts

@@ -0,0 +1,74 @@
+import type { EffectiveMethodology, RuleCandidate } from './methodology-resolver.js';
+import type { CompiledConstraint } from '../validator/constraint-eval.js';
+/**
+ * The part of a kind this module needs.
+ *
+ * `layer` is optional here even though the registry always fills it: a caller
+ * may be asking about a kind that did not resolve, and "unplaced" has to be a
+ * representable answer rather than a cast.
+ */
+export interface ScopedKind {
+    layer?: string;
+}
+export type ScopeDimension = 'layer' | 'module' | 'standard' | 'artifactKind' | 'viewpoint';
+/** The resolved answer to "what is in scope", ready to be asked questions. */
+export interface EffectiveScope {
+    mode: 'allAvailable' | 'explicit';
+    layers: ReadonlySet<string>;
+    modules: ReadonlySet<string>;
+    standards: ReadonlySet<string>;
+    artifactKinds: ReadonlySet<string>;
+    viewpoints: ReadonlySet<string>;
+}
+export declare function buildEffectiveScope(methodology: EffectiveMethodology): EffectiveScope;
+/** A scope that selects everything — the shape callers get before a binding resolves. */
+export declare const UNRESTRICTED_SCOPE: EffectiveScope;
+/**
+ * Is one value in scope for a dimension?
+ *
+ * Under `allAvailable` everything the project resolved is in scope, and the
+ * lists are required to be empty. Under `explicit` only what is listed is in
+ * scope — including when the list is empty, which selects nothing.
+ */
+export declare function isInScope(scope: EffectiveScope, dimension: ScopeDimension, value: string | undefined): boolean;
+/**
+ * Is a kind in scope?
+ *
+ * A kind belongs to exactly one axis position, so it is in scope when its layer
+ * is selected. A kind with no layer is only in scope under `allAvailable`: an
+ * unplaced kind cannot be shown to satisfy an explicit selection.
+ */
+export declare function isKindInScope(scope: EffectiveScope, kind: ScopedKind): boolean;
+/** Filter kinds to those in scope. Used by palettes and creation dialogs alike. */
+export declare function filterKindsInScope<T extends ScopedKind>(kinds: readonly T[], scope: EffectiveScope): T[];
+/**
+ * Is a package in scope?
+ *
+ * `includedLayer` and `includedModule` both name packages; a methodology splits
+ * them for readability, not because the resolver treats them differently.
+ */
+export declare function isPackageInScope(scope: EffectiveScope, packageName: string): boolean;
+/**
+ * Is a rule active under this scope?
+ *
+ * A rule is scoped by the package that declares it. Disposition is a separate
+ * question answered by `resolveEffectiveRules`: a rule can be in scope and
+ * disabled, and the audit needs to show both facts rather than one.
+ */
+export declare function isRulePackageInScope(scope: EffectiveScope, declaringPackage: string | undefined): boolean;
+/**
+ * The rules a project's methodology actually activates.
+ *
+ * A rule is active when BOTH its declaring package and its subject kind are in
+ * scope. A rule whose subject the methodology never selected can only report on
+ * content the project did not agree to model — which is how the GPCA prototype
+ * used to accumulate cybersecurity violations for a discipline it had excluded.
+ *
+ * This lives here, shared, because `memo validate` and `memo rules list` are
+ * two views of one answer. They computed it separately, and inevitably
+ * disagreed: `validate` scope-filtered and `rules list` did not, so the same
+ * project reported 20 rules and 38 rules depending on which command you asked.
+ * A number that changes with the question is not an audit.
+ */
+export declare function activeRuleCandidates(constraints: readonly CompiledConstraint[], scope: EffectiveScope, filePackages: ReadonlyMap<string, string>, kindSourceFile: (kindName: string) => string | undefined): RuleCandidate[];
+//# sourceMappingURL=effective-scope.d.ts.map

package/packages/tools/lib/model/effective-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effective-scope.d.ts","sourceRoot":"","sources":["../../src/model/effective-scope.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAErF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAE1E;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,QAAQ,GAAG,UAAU,GAAG,cAAc,GAAG,WAAW,CAAC;AAE5F,8EAA8E;AAC9E,MAAM,WAAW,cAAc;IAC3B,IAAI,EAAE,cAAc,GAAG,UAAU,CAAC;IAClC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC5B,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC7B,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC/B,aAAa,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACnC,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACnC;AAED,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,oBAAoB,GAAG,cAAc,CASrF;AAED,yFAAyF;AACzF,eAAO,MAAM,kBAAkB,EAAE,cAOhC,CAAC;AAYF;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAI9G;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAE9E;AAED,mFAAmF;AACnF,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,UAAU,EACnD,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,KAAK,EAAE,cAAc,GACtB,CAAC,EAAE,CAGL;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAGpF;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAIzG;AAKD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAChC,WAAW,EAAE,SAAS,kBAAkB,EAAE,EAC1C,KAAK,EAAE,cAAc,EACrB,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACzC,cAAc,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,GACzD,aAAa,EAAE,CAoBjB"}

package/packages/tools/lib/model/effective-scope.js

@@ -0,0 +1,133 @@
+// ─── Effective Scope ──────────────────────────────────────────────────────────
+//
+// What the project's methodology actually selects, and the single place that
+// answers "is this in scope?" for model visibility, rule activation,
+// completeness, palettes, and allowed creation kinds.
+//
+// The behaviour this replaces is the reason the module exists. `dimension-filter`
+// treated an empty inclusion list as "the methodology does not restrict", so a
+// methodology that selected nothing and a methodology that selected everything
+// produced identical results, and nobody could tell which one had been authored.
+// Scope is now explicit: `scopeMode` says which it is, and under `explicit` an
+// empty list selects nothing.
+//
+// Design reference: sections 9.2 and 18.3 deliverable 3.
+// ─────────────────────────────────────────────────────────────────────────────
+import { ruleCandidatesFromConstraints } from './methodology-resolver.js';
+export function buildEffectiveScope(methodology) {
+    return {
+        mode: methodology.scopeMode,
+        layers: new Set(methodology.includedLayers),
+        modules: new Set(methodology.includedModules),
+        standards: new Set(methodology.includedStandards),
+        artifactKinds: new Set(methodology.includedArtifactKinds),
+        viewpoints: new Set(methodology.includedViewpoints),
+    };
+}
+/** A scope that selects everything — the shape callers get before a binding resolves. */
+export const UNRESTRICTED_SCOPE = {
+    mode: 'allAvailable',
+    layers: new Set(),
+    modules: new Set(),
+    standards: new Set(),
+    artifactKinds: new Set(),
+    viewpoints: new Set(),
+};
+function setFor(scope, dimension) {
+    switch (dimension) {
+        case 'layer': return scope.layers;
+        case 'module': return scope.modules;
+        case 'standard': return scope.standards;
+        case 'artifactKind': return scope.artifactKinds;
+        case 'viewpoint': return scope.viewpoints;
+    }
+}
+/**
+ * Is one value in scope for a dimension?
+ *
+ * Under `allAvailable` everything the project resolved is in scope, and the
+ * lists are required to be empty. Under `explicit` only what is listed is in
+ * scope — including when the list is empty, which selects nothing.
+ */
+export function isInScope(scope, dimension, value) {
+    if (scope.mode === 'allAvailable')
+        return true;
+    if (value === undefined)
+        return false;
+    return setFor(scope, dimension).has(value);
+}
+/**
+ * Is a kind in scope?
+ *
+ * A kind belongs to exactly one axis position, so it is in scope when its layer
+ * is selected. A kind with no layer is only in scope under `allAvailable`: an
+ * unplaced kind cannot be shown to satisfy an explicit selection.
+ */
+export function isKindInScope(scope, kind) {
+    return isInScope(scope, 'layer', kind.layer);
+}
+/** Filter kinds to those in scope. Used by palettes and creation dialogs alike. */
+export function filterKindsInScope(kinds, scope) {
+    if (scope.mode === 'allAvailable')
+        return [...kinds];
+    return kinds.filter(kind => isKindInScope(scope, kind));
+}
+/**
+ * Is a package in scope?
+ *
+ * `includedLayer` and `includedModule` both name packages; a methodology splits
+ * them for readability, not because the resolver treats them differently.
+ */
+export function isPackageInScope(scope, packageName) {
+    if (scope.mode === 'allAvailable')
+        return true;
+    return scope.layers.has(packageName) || scope.modules.has(packageName);
+}
+/**
+ * Is a rule active under this scope?
+ *
+ * A rule is scoped by the package that declares it. Disposition is a separate
+ * question answered by `resolveEffectiveRules`: a rule can be in scope and
+ * disabled, and the audit needs to show both facts rather than one.
+ */
+export function isRulePackageInScope(scope, declaringPackage) {
+    if (scope.mode === 'allAvailable')
+        return true;
+    if (!declaringPackage)
+        return false;
+    return isPackageInScope(scope, declaringPackage);
+}
+// ─── Rule activation ─────────────────────────────────────────────────────────
+/**
+ * The rules a project's methodology actually activates.
+ *
+ * A rule is active when BOTH its declaring package and its subject kind are in
+ * scope. A rule whose subject the methodology never selected can only report on
+ * content the project did not agree to model — which is how the GPCA prototype
+ * used to accumulate cybersecurity violations for a discipline it had excluded.
+ *
+ * This lives here, shared, because `memo validate` and `memo rules list` are
+ * two views of one answer. They computed it separately, and inevitably
+ * disagreed: `validate` scope-filtered and `rules list` did not, so the same
+ * project reported 20 rules and 38 rules depending on which command you asked.
+ * A number that changes with the question is not an audit.
+ */
+export function activeRuleCandidates(constraints, scope, filePackages, kindSourceFile) {
+    const packageOf = (file) => file ? filePackages.get(file) : undefined;
+    const subjectInScope = (appliesTo) => {
+        if (scope.mode === 'allAvailable')
+            return true;
+        // A model-level rule has no single subject kind to place.
+        if (!appliesTo || appliesTo === 'Model')
+            return true;
+        const kindName = appliesTo.split('[')[0];
+        // A methodology's inclusion lists name packages, so a kind is placed by
+        // the package that declares it — not by the `layer` string, which is a
+        // display grouping in a different namespace.
+        return isRulePackageInScope(scope, packageOf(kindSourceFile(kindName)));
+    };
+    return ruleCandidatesFromConstraints(constraints
+        .filter(c => isRulePackageInScope(scope, packageOf(c.sourceFile)))
+        .filter(c => subjectInScope(c.appliesToKind)));
+}
+//# sourceMappingURL=effective-scope.js.map

package/packages/tools/lib/model/effective-scope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effective-scope.js","sourceRoot":"","sources":["../../src/model/effective-scope.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,EAAE;AACF,6EAA6E;AAC7E,qEAAqE;AACrE,sDAAsD;AACtD,EAAE;AACF,kFAAkF;AAClF,+EAA+E;AAC/E,+EAA+E;AAC/E,iFAAiF;AACjF,+EAA+E;AAC/E,8BAA8B;AAC9B,EAAE;AACF,yDAAyD;AACzD,gFAAgF;AAGhF,OAAO,EAAE,6BAA6B,EAAE,MAAM,2BAA2B,CAAC;AA0B1E,MAAM,UAAU,mBAAmB,CAAC,WAAiC;IACjE,OAAO;QACH,IAAI,EAAE,WAAW,CAAC,SAAS;QAC3B,MAAM,EAAE,IAAI,GAAG,CAAC,WAAW,CAAC,cAAc,CAAC;QAC3C,OAAO,EAAE,IAAI,GAAG,CAAC,WAAW,CAAC,eAAe,CAAC;QAC7C,SAAS,EAAE,IAAI,GAAG,CAAC,WAAW,CAAC,iBAAiB,CAAC;QACjD,aAAa,EAAE,IAAI,GAAG,CAAC,WAAW,CAAC,qBAAqB,CAAC;QACzD,UAAU,EAAE,IAAI,GAAG,CAAC,WAAW,CAAC,kBAAkB,CAAC;KACtD,CAAC;AACN,CAAC;AAED,yFAAyF;AACzF,MAAM,CAAC,MAAM,kBAAkB,GAAmB;IAC9C,IAAI,EAAE,cAAc;IACpB,MAAM,EAAE,IAAI,GAAG,EAAE;IACjB,OAAO,EAAE,IAAI,GAAG,EAAE;IAClB,SAAS,EAAE,IAAI,GAAG,EAAE;IACpB,aAAa,EAAE,IAAI,GAAG,EAAE;IACxB,UAAU,EAAE,IAAI,GAAG,EAAE;CACxB,CAAC;AAEF,SAAS,MAAM,CAAC,KAAqB,EAAE,SAAyB;IAC5D,QAAQ,SAAS,EAAE,CAAC;QAChB,KAAK,OAAO,CAAC,CAAC,OAAO,KAAK,CAAC,MAAM,CAAC;QAClC,KAAK,QAAQ,CAAC,CAAC,OAAO,KAAK,CAAC,OAAO,CAAC;QACpC,KAAK,UAAU,CAAC,CAAC,OAAO,KAAK,CAAC,SAAS,CAAC;QACxC,KAAK,cAAc,CAAC,CAAC,OAAO,KAAK,CAAC,aAAa,CAAC;QAChD,KAAK,WAAW,CAAC,CAAC,OAAO,KAAK,CAAC,UAAU,CAAC;IAC9C,CAAC;AACL,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CAAC,KAAqB,EAAE,SAAyB,EAAE,KAAyB;IACjG,IAAI,KAAK,CAAC,IAAI,KAAK,cAAc;QAAE,OAAO,IAAI,CAAC;IAC/C,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IACtC,OAAO,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,KAAqB,EAAE,IAAgB;IACjE,OAAO,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;AACjD,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,kBAAkB,CAC9B,KAAmB,EACnB,KAAqB;IAErB,IAAI,KAAK,CAAC,IAAI,KAAK,cAAc;QAAE,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC;IACrD,OAAO,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,aAAa,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;AAC5D,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAqB,EAAE,WAAmB;IACvE,IAAI,KAAK,CAAC,IAAI,KAAK,cAAc;QAAE,OAAO,IAAI,CAAC;IAC/C,OAAO,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;AAC3E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAqB,EAAE,gBAAoC;IAC5F,IAAI,KAAK,CAAC,IAAI,KAAK,cAAc;QAAE,OAAO,IAAI,CAAC;IAC/C,IAAI,CAAC,gBAAgB;QAAE,OAAO,KAAK,CAAC;IACpC,OAAO,gBAAgB,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC;AACrD,CAAC;AAGD,gFAAgF;AAEhF;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,oBAAoB,CAChC,WAA0C,EAC1C,KAAqB,EACrB,YAAyC,EACzC,cAAwD;IAExD,MAAM,SAAS,GAAG,CAAC,IAAwB,EAAE,EAAE,CAC3C,IAAI,CAAC,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAE9C,MAAM,cAAc,GAAG,CAAC,SAA6B,EAAW,EAAE;QAC9D,IAAI,KAAK,CAAC,IAAI,KAAK,cAAc;YAAE,OAAO,IAAI,CAAC;QAC/C,0DAA0D;QAC1D,IAAI,CAAC,SAAS,IAAI,SAAS,KAAK,OAAO;YAAE,OAAO,IAAI,CAAC;QACrD,MAAM,QAAQ,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACzC,wEAAwE;QACxE,uEAAuE;QACvE,6CAA6C;QAC7C,OAAO,oBAAoB,CAAC,KAAK,EAAE,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC5E,CAAC,CAAC;IAEF,OAAO,6BAA6B,CAChC,WAAW;SACN,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,oBAAoB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;SACjE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CACpD,CAAC;AACN,CAAC"}

package/packages/tools/lib/model/ir-identity.d.ts

@@ -0,0 +1,94 @@
+import type { SysmlIdentity, SysmlIR } from '../sysml-ir/index.js';
+/**
+ * A write was made against an identity the current IR does not have.
+ *
+ * Loud on purpose. The alternative — falling back to a name lookup — is how a
+ * write ends up editing the wrong element, which is the failure this whole
+ * module exists to make impossible.
+ */
+export declare class StaleIrIdentityError extends Error {
+    readonly identityId: string;
+    constructor(identityId: string, detail: string);
+}
+/** The wire form: what a client needs to name an element in a later write. */
+export type IrIdentityTable = Record<string, string>;
+/** What an index knows about one addressable declaration. */
+export interface IrIdentityEntry {
+    identity: SysmlIdentity;
+    /** The Memo element it projects to, when the projection mapped it. */
+    memoElementId?: string;
+}
+export interface IrIdentityIndex {
+    /** Memo element ID → IR identity ID, for elements the projection mapped. */
+    readonly byMemoElement: IrIdentityTable;
+    /** IR identity ID → the declaration it names. */
+    readonly byIdentity: ReadonlyMap<string, IrIdentityEntry>;
+}
+/**
+ * Index one IR for identity resolution.
+ *
+ * Both directions are needed and neither is derivable cheaply from the other:
+ * the client holds Memo element IDs and has to mint an identity from one, and
+ * the server holds an identity and has to find what it names.
+ */
+export declare function buildIrIdentityIndex(ir: SysmlIR | undefined): IrIdentityIndex;
+/**
+ * Rebuild an index from the compact table alone.
+ *
+ * The whole IR is not shipped with a model update — `standardProperties` carry
+ * every declared property of every node, and a surface that only needs to
+ * *address* an element does not need its contents. The identity ID is a
+ * self-describing string, so the table is enough to reconstruct everything the
+ * resolver uses.
+ */
+export declare function indexFromIdentityTable(table: IrIdentityTable | undefined): IrIdentityIndex;
+/**
+ * Read an identity ID back into its parts.
+ *
+ * `file:///…/model/a.sysml#members[0]/members[2]:PartUsage`. The file URI may
+ * itself contain `#` only if percent-encoded, and the metaclass never contains
+ * `:`, so splitting at the first `#` and the last `:` is unambiguous.
+ */
+export declare function parseSysmlIdentityId(id: string): SysmlIdentity | undefined;
+/**
+ * The compact table shipped with a model update.
+ *
+ * The whole IR is not sent: its `standardProperties` carry every declared
+ * property of every node, and a client that only needs to address an element
+ * does not need its contents.
+ */
+export declare function irIdentityTable(ir: SysmlIR | undefined): IrIdentityTable;
+/**
+ * Resolve an identity ID against the current IR, or fail loudly.
+ *
+ * `expectedMemoElementId`, when given, is checked too: an identity that still
+ * exists but now names a different element is exactly as stale as one that has
+ * disappeared, and it is the more dangerous of the two.
+ */
+export declare function requireIrIdentity(index: IrIdentityIndex, identityId: string, expectedMemoElementId?: string): IrIdentityEntry;
+/** The identity a client should quote when it writes to this element. */
+export declare function identityForMemoElement(index: IrIdentityIndex, memoElementId: string): string | undefined;
+/** `members[3]/members[1]` → `[3, 1]`. Any other shape is not a path we minted. */
+export declare function parseDeclarationPath(declarationPath: string): number[] | undefined;
+/** The project-relative file an identity's URI names, given the project root. */
+export declare function identityFile(identity: SysmlIdentity, projectRoot: string): string | undefined;
+/** True when this identity was minted for that project-relative file. */
+export declare function identityNamesFile(identity: SysmlIdentity, projectRoot: string, relativePath: string): boolean;
+/**
+ * Walk a parsed document to the declaration an identity addresses.
+ *
+ * The metaclass is verified, not assumed: a path that still resolves but to a
+ * different kind of declaration means the file was edited underneath this
+ * identity, and continuing would rewrite the wrong lines.
+ */
+export declare function resolveDeclarationByIdentity(root: {
+    members?: unknown[];
+}, identity: SysmlIdentity): {
+    $type?: string;
+    name?: string;
+    $cstNode?: {
+        offset: number;
+        length: number;
+    };
+};
+//# sourceMappingURL=ir-identity.d.ts.map

package/packages/tools/lib/model/ir-identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir-identity.d.ts","sourceRoot":"","sources":["../../src/model/ir-identity.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEnE;;;;;;GAMG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAO1D;AAED,8EAA8E;AAC9E,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAErD,6DAA6D;AAC7D,MAAM,WAAW,eAAe;IAC5B,QAAQ,EAAE,aAAa,CAAC;IACxB,sEAAsE;IACtE,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,eAAe;IAC5B,4EAA4E;IAC5E,QAAQ,CAAC,aAAa,EAAE,eAAe,CAAC;IACxC,iDAAiD;IACjD,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CAC7D;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,OAAO,GAAG,SAAS,GAAG,eAAe,CAS7E;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,eAAe,GAAG,SAAS,GAAG,eAAe,CAU1F;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAS1E;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,OAAO,GAAG,SAAS,GAAG,eAAe,CAExE;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC7B,KAAK,EAAE,eAAe,EACtB,UAAU,EAAE,MAAM,EAClB,qBAAqB,CAAC,EAAE,MAAM,GAC/B,eAAe,CAajB;AAED,yEAAyE;AACzE,wBAAgB,sBAAsB,CAClC,KAAK,EAAE,eAAe,EACtB,aAAa,EAAE,MAAM,GACtB,MAAM,GAAG,SAAS,CAEpB;AAID,mFAAmF;AACnF,wBAAgB,oBAAoB,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAUlF;AAED,iFAAiF;AACjF,wBAAgB,YAAY,CAAC,QAAQ,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAI7F;AAED,yEAAyE;AACzE,wBAAgB,iBAAiB,CAC7B,QAAQ,EAAE,aAAa,EACvB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,GACrB,OAAO,CAET;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CACxC,IAAI,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,EAAE,CAAA;CAAE,EAC7B,QAAQ,EAAE,aAAa,GACxB;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAuBlF"}

package/packages/tools/lib/model/ir-identity.js

@@ -0,0 +1,178 @@
+// ─── IR identity: the address every authoring write is made against ──────────
+//
+// Session 3 made the canonical IR the ingestion boundary. Authoring still
+// addressed elements the old way — by authored name, matched with a regular
+// expression over the source text — so two declarations with the same name in
+// different namespaces were the same target as far as a write was concerned,
+// and a rename made the write silently miss.
+//
+// An IR identity is `file-URI + declaration path + metaclass`. It is positional
+// by construction, which is the point: inserting a declaration ahead of another
+// changes the second one's address, so an identity minted against an older
+// revision is *detectably* old rather than quietly pointing at a neighbour.
+// Every write therefore either resolves its identity against the current IR or
+// fails loudly — `StaleIrIdentityError`, naming the identity and what it found.
+//
+// Nothing here reads the filesystem or spawns anything: it is a resolver over
+// an IR that some lowering provider already produced.
+// ─────────────────────────────────────────────────────────────────────────────
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+/**
+ * A write was made against an identity the current IR does not have.
+ *
+ * Loud on purpose. The alternative — falling back to a name lookup — is how a
+ * write ends up editing the wrong element, which is the failure this whole
+ * module exists to make impossible.
+ */
+export class StaleIrIdentityError extends Error {
+    identityId;
+    constructor(identityId, detail) {
+        super(`The edit targets "${identityId}", which is not in the current model revision: ${detail}. `
+            + 'Reload the element and repeat the edit; no file was written.');
+        this.identityId = identityId;
+        this.name = 'StaleIrIdentityError';
+    }
+}
+/**
+ * Index one IR for identity resolution.
+ *
+ * Both directions are needed and neither is derivable cheaply from the other:
+ * the client holds Memo element IDs and has to mint an identity from one, and
+ * the server holds an identity and has to find what it names.
+ */
+export function buildIrIdentityIndex(ir) {
+    const byMemoElement = {};
+    const byIdentity = new Map();
+    for (const element of ir?.elements ?? []) {
+        const memoElementId = element.kind === 'mapped' ? element.memoElementId : undefined;
+        byIdentity.set(element.identity.id, { identity: element.identity, memoElementId });
+        if (memoElementId)
+            byMemoElement[memoElementId] = element.identity.id;
+    }
+    return { byMemoElement, byIdentity };
+}
+/**
+ * Rebuild an index from the compact table alone.
+ *
+ * The whole IR is not shipped with a model update — `standardProperties` carry
+ * every declared property of every node, and a surface that only needs to
+ * *address* an element does not need its contents. The identity ID is a
+ * self-describing string, so the table is enough to reconstruct everything the
+ * resolver uses.
+ */
+export function indexFromIdentityTable(table) {
+    const byMemoElement = {};
+    const byIdentity = new Map();
+    for (const [memoElementId, identityId] of Object.entries(table ?? {})) {
+        const identity = parseSysmlIdentityId(identityId);
+        if (!identity)
+            continue;
+        byMemoElement[memoElementId] = identityId;
+        byIdentity.set(identityId, { identity, memoElementId });
+    }
+    return { byMemoElement, byIdentity };
+}
+/**
+ * Read an identity ID back into its parts.
+ *
+ * `file:///…/model/a.sysml#members[0]/members[2]:PartUsage`. The file URI may
+ * itself contain `#` only if percent-encoded, and the metaclass never contains
+ * `:`, so splitting at the first `#` and the last `:` is unambiguous.
+ */
+export function parseSysmlIdentityId(id) {
+    const hash = id.indexOf('#');
+    const colon = id.lastIndexOf(':');
+    if (hash < 0 || colon < hash)
+        return undefined;
+    const fileUri = id.slice(0, hash);
+    const declarationPath = id.slice(hash + 1, colon);
+    const metaclass = id.slice(colon + 1);
+    if (!fileUri || !declarationPath || !metaclass)
+        return undefined;
+    return { fileUri, declarationPath, metaclass, id };
+}
+/**
+ * The compact table shipped with a model update.
+ *
+ * The whole IR is not sent: its `standardProperties` carry every declared
+ * property of every node, and a client that only needs to address an element
+ * does not need its contents.
+ */
+export function irIdentityTable(ir) {
+    return buildIrIdentityIndex(ir).byMemoElement;
+}
+/**
+ * Resolve an identity ID against the current IR, or fail loudly.
+ *
+ * `expectedMemoElementId`, when given, is checked too: an identity that still
+ * exists but now names a different element is exactly as stale as one that has
+ * disappeared, and it is the more dangerous of the two.
+ */
+export function requireIrIdentity(index, identityId, expectedMemoElementId) {
+    const found = index.byIdentity.get(identityId);
+    if (!found) {
+        throw new StaleIrIdentityError(identityId, 'no declaration in the current IR has that identity');
+    }
+    if (expectedMemoElementId !== undefined && found.memoElementId !== expectedMemoElementId) {
+        throw new StaleIrIdentityError(identityId, `it now names ${found.memoElementId ? `element "${found.memoElementId}"` : 'a declaration Memo does not project'}, `
+            + `not "${expectedMemoElementId}"`);
+    }
+    return found;
+}
+/** The identity a client should quote when it writes to this element. */
+export function identityForMemoElement(index, memoElementId) {
+    return index.byMemoElement[memoElementId];
+}
+// ─── Locating the declaration an identity names ─────────────────────────────
+/** `members[3]/members[1]` → `[3, 1]`. Any other shape is not a path we minted. */
+export function parseDeclarationPath(declarationPath) {
+    const segments = declarationPath.split('/').filter(Boolean);
+    if (segments.length === 0)
+        return undefined;
+    const indexes = [];
+    for (const segment of segments) {
+        const match = /^members\[(\d+)\]$/.exec(segment);
+        if (!match)
+            return undefined;
+        indexes.push(Number(match[1]));
+    }
+    return indexes;
+}
+/** The project-relative file an identity's URI names, given the project root. */
+export function identityFile(identity, projectRoot) {
+    const roots = pathToFileURL(resolve(projectRoot)).href.replace(/\/$/, '');
+    if (!identity.fileUri.startsWith(`${roots}/`))
+        return undefined;
+    return decodeURIComponent(identity.fileUri.slice(roots.length + 1));
+}
+/** True when this identity was minted for that project-relative file. */
+export function identityNamesFile(identity, projectRoot, relativePath) {
+    return identityFile(identity, projectRoot) === relativePath.replaceAll('\\', '/');
+}
+/**
+ * Walk a parsed document to the declaration an identity addresses.
+ *
+ * The metaclass is verified, not assumed: a path that still resolves but to a
+ * different kind of declaration means the file was edited underneath this
+ * identity, and continuing would rewrite the wrong lines.
+ */
+export function resolveDeclarationByIdentity(root, identity) {
+    const path = parseDeclarationPath(identity.declarationPath);
+    if (!path) {
+        throw new StaleIrIdentityError(identity.id, `"${identity.declarationPath}" is not a declaration path`);
+    }
+    let node = root;
+    for (const [depth, index] of path.entries()) {
+        const members = node?.members;
+        if (!Array.isArray(members) || index >= members.length) {
+            throw new StaleIrIdentityError(identity.id, `the source no longer has a declaration at ${path.slice(0, depth + 1).map(i => `members[${i}]`).join('/')}`);
+        }
+        node = members[index];
+    }
+    if (node?.$type !== identity.metaclass) {
+        throw new StaleIrIdentityError(identity.id, `that position now holds a ${node?.$type ?? 'nothing'}, not a ${identity.metaclass}`);
+    }
+    return node;
+}
+//# sourceMappingURL=ir-identity.js.map

package/packages/tools/lib/model/ir-identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir-identity.js","sourceRoot":"","sources":["../../src/model/ir-identity.ts"],"names":[],"mappings":"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"}