@memoarchitect/tools 0.6.7 → 0.8.7

package/packages/tools/lib/model/config.d.ts

@@ -1,236 +1,65 @@
-/** Project type discriminator */
-export type ProjectType = 'ontology' | 'profile' | 'library' | 'device';
-/** An architecture visualization layer grouping related entity kinds */
-export interface ArchLayer {
-    /** Unique layer identifier, e.g. "requirements", "architecture" */
-    id: string;
-    /** Human-readable label for the layer */
-    label: string;
-    /** Hex color for layer visualization, e.g. "#4A90D9" */
-    color: string;
-}
-/** A typed relationship between entity kinds */
-export interface RelationshipType {
-    /** Relationship identifier, e.g. "mitigates" */
-    name: string;
-    /** Human-readable label, e.g. "Mitigates" */
-    label: string;
-    /** Architecture layer this relationship belongs to */
-    layer: string;
-    /** Hex color for relationship visualization */
-    color: string;
-}
 /** SysML v2 constructs supported as entity base types */
 export type SysMLConstruct = 'part def' | 'requirement def' | 'verification def' | 'state def' | 'use case def' | 'action def' | 'action usage' | 'item def' | 'port def' | 'interface def' | 'connection def' | 'attribute def' | 'enum def';
-/** Definition of an entity kind within a domain */
-export interface KindDefinition {
-    /** Human-readable label */
-    label: string;
-    /** Architecture layer this kind belongs to */
-    layer?: string;
-    /** SysML v2 construct this kind maps to */
-    sysmlConstruct: SysMLConstruct;
-    /** Icon identifier for the palette/diagram */
-    icon?: string;
-    /** Template file for new instances (relative to domain package) */
-    template?: string;
-    /** Default attributes for new instances */
-    defaultAttributes?: Record<string, string>;
-}
 /** Legacy diagram type keys — each maps to exactly one SysML v2 view kind (see view-kinds.ts) */
 export type DiagramType = 'bdd' | 'ibd' | 'req' | 'ucd' | 'act' | 'afd' | 'pkg' | 'par' | 'risk' | 'stm' | 'seq' | 'fmea' | 'alloc' | 'threat-model';
-/** Diagram definition — a named, typed view within a viewpoint */
-export interface DiagramDefinition {
-    /** Unique diagram identifier, e.g. "diag-risk-chain" */
-    id: string;
-    /** Human-readable name, e.g. "Risk Mitigation Chain" */
-    name: string;
-    /** SysML v2 diagram type */
-    diagramType: DiagramType;
-    /** Parent viewpoint ID this diagram belongs to */
-    viewpointId: string;
-    /** Additional viewpoints this reusable diagram also conforms to. */
-    viewpointIds?: string[];
-    /** Optional group shown within each viewpoint in Memo Architect. */
-    group?: string;
-    /** Whether this diagram is auto-generated from the viewpoint */
-    auto: boolean;
-    /** Description / purpose of this diagram (used in doc generation) */
-    description?: string;
-    /** Additional metadata properties (free-form, for doc generation) */
-    properties?: Record<string, string>;
-    /** Optional override: specific element IDs to include (subset of viewpoint) */
-    elementIds?: string[];
-    /** Optional override: specific relationship types to show */
-    relationshipTypes?: string[];
-}
-/** Viewpoint definition for filtered model views */
-export interface ViewpointDefinition {
-    /** Unique viewpoint identifier */
-    id: string;
-    /** Human-readable name */
-    label: string;
-    /** Optional ontology-authored grouping used by Memo Architect. */
-    group?: string;
-    /** Entity kinds visible in this viewpoint */
-    visibleKinds: string[];
-    /** Relationship types visible in this viewpoint */
-    visibleRelationships: string[];
-    /** Architecture layers visible in this viewpoint */
-    visibleLayers: string[];
-    /** SysML v2 diagram types supported by this viewpoint */
-    supportedDiagramTypes?: DiagramType[];
-    /** Auto-generated diagrams for this viewpoint */
-    diagrams?: DiagramDefinition[];
-}
-/** Guided workflow step for wizard-like interactions */
-export interface WorkflowStep {
-    /** Step identifier */
-    id: string;
-    /** Human-readable label */
-    label: string;
-    /** Entity kinds involved in this step */
-    kinds: string[];
-    /** Prompt text for the user */
-    prompt: string;
-}
-/** Guided workflow definition */
-export interface WorkflowDefinition {
-    /** Unique workflow identifier */
-    id: string;
-    /** Human-readable label */
-    label: string;
-    /** Ordered steps */
-    steps: WorkflowStep[];
-}
-/** First-run configuration for new projects */
-export interface FirstRunConfig {
-    /** Template to scaffold, e.g. "infusion-pump" */
-    template?: string;
-    /** Prompt user for project metadata */
-    promptForMetadata?: boolean;
-    /** Auto-create starter files */
-    scaffoldFiles?: string[];
-}
-export interface SysideToolConfig {
-    /** Executable name or path. Defaults to `syside` on PATH. */
-    executable?: string;
-    /** Optional syside.toml path, relative to the project directory. */
-    configFile?: string;
-    /** Treat Syside warnings as compilation errors. Defaults to true. */
-    warningsAsErrors?: boolean;
-    /** Syside validation scope. Defaults to `all`. Use `none` for syntax-only compilation. */
-    diagnose?: 'all' | 'external' | 'project' | 'none';
-}
-export interface SysandToolConfig {
-    /** Executable name or path. Defaults to `sysand` on PATH. */
-    executable?: string;
-    /** Optional sysand.toml path, relative to the project directory. */
-    configFile?: string;
-}
-/** External tool selection. Defaults preserve MEMO's built-in behavior. */
+/**
+ * Tool selection, one provider per role.
+ *
+ * Every value here is a plain `string`. A union type would re-hardcode the
+ * roster the provider registry exists to keep open: the legal values are
+ * whatever is registered, checked at resolution time against the registry, and
+ * a third-party adapter must be selectable without editing this file.
+ *
+ * Per-provider settings live under the provider's own ID (`syside`, `sysand`,
+ * …). They are typed as `unknown` here and read by that provider's adapter,
+ * which is the only module that knows the shape — see the index signature.
+ */
 export interface ToolchainConfig {
-    compiler?: 'internal' | 'syside';
-    packager?: 'internal' | 'sysand';
-    syside?: SysideToolConfig;
-    sysand?: SysandToolConfig;
-}
-/** Ontology reference in a device project */
-export interface OntologyReference {
-    /** Package name, e.g. "@memoarchitect/ontology" or "memo-ontology" on SysAnd */
-    name: string;
-    /** Semver version constraint, e.g. "^2.0.0" */
-    version: string;
-}
-/** Self-describing metadata for an ontology package */
-export interface OntologyMetadata {
-    /** Package identifier, e.g. "@memoarchitect/ontology" */
-    id: string;
-    /** Semver version */
-    version: string;
-    /** Human-readable description */
-    description: string;
-    /** Author or organization */
-    author?: string;
-    /** License identifier, e.g. "Apache-2.0" */
-    license?: string;
-    /** Searchable tags, e.g. ["medical", "ISO-14971"] */
-    tags?: string[];
-}
-/** Reference to an external ontology (OWL, JSON-LD, or SysAnd format) */
-export interface ExternalOntologyRef {
-    /** Import format */
-    source: 'owl' | 'jsonld' | 'sysand';
-    /** File path or URL to the ontology */
-    uri: string;
-    /** Namespace prefix, e.g. "fma" */
-    prefix: string;
-    /** Import only these classes/concepts (empty = import all) */
-    subset?: string[];
-}
-/** Reference to a reusable element library */
-export interface LibraryRef {
-    /** Package name, e.g. "@sysand/std-library" */
-    package: string;
-    /** Import only these categories, e.g. ["USB", "Logging"] */
-    categories?: string[];
+    /** "Is this valid SysML/KerML?" */
+    validator?: string;
+    /** "What can MEMO ingest from this revision?" */
+    lowering?: string;
+    /** How the project is packed and published. */
+    packager?: string;
+    /**
+     * @deprecated Alias that sets both `validator` and `lowering`.
+     *
+     * It predates the split of the two roles, which answer different questions
+     * and produce diagnostics in different domains. Kept so existing settings
+     * files keep working; `validator`/`lowering` win when both are present.
+     */
+    compiler?: string;
+    /** Per-provider settings, keyed by provider ID. Read only by that adapter. */
+    [providerId: string]: unknown;
 }
 /**
- * MEMOConfig — the complete project/domain configuration.
+ * MEMOConfig — application settings for one project.
  *
- * Two project types:
- *   - "ontology": defines a shareable type system (publishable as .kpar)
- *   - "device": models a specific medical device (references an ontology)
+ * Everything here changes how a command runs. Nothing here changes what the
+ * model means: no field selects a methodology, enables or disables a rule,
+ * defines a kind or relationship, or chooses the content of a portable view.
+ * `warningsAsErrors` may change a command's exit policy; it does not change the
+ * severity the model authored.
  */
 export interface MEMOConfig {
-    /** Project name (set by `memo init`) */
-    projectName: string;
-    /** Project type: "ontology", "profile", "library", or "device" */
-    projectType: ProjectType;
-    /** Parent config to inherit from. String for single parent, array for multiple. */
-    extends?: string | string[];
-    /** Ontology references (device projects only) */
-    ontologies?: OntologyReference[];
     /**
-     * Optional ontology modules to load on top of the base ontology.
-     * Modules are declared as optional in the base ontology's memo.package.yaml
-     * under `optionalModules:`. Following OWL import semantics, only modules a
-     * project explicitly opts into are loaded — disabled modules contribute
-     * no kinds/relationships, no validation rules, and no viewpoints.
+     * Display name for CLI output.
      *
-     * Each entry is a package name like "@memoarchitect/ontology-ros" or a
-     * short alias like "ros" (resolved against the base ontology's optionalModules list).
+     * The project's real name is `projectName` on its `ProjectMethodBinding`.
+     * This is a convenience copy for log lines, resolved from the binding when
+     * one is available and falling back to the directory name when it is not.
      */
-    modules?: string[];
-    /** Self-describing metadata for ontology packages */
-    ontologyMetadata?: OntologyMetadata;
-    /** External ontology imports (OWL, JSON-LD, SysAnd) */
-    externalOntologies?: ExternalOntologyRef[];
-    /** Reusable element library imports */
-    libraries?: LibraryRef[];
-    /** Architecture visualization layers */
-    architectureLayers?: ArchLayer[];
-    /** Entity kind definitions (keyed by kind identifier). Optional — prefer KindRegistry. */
-    kinds?: Record<string, KindDefinition>;
-    /** Typed relationship definitions with architecture layer mapping. Optional — prefer RelationshipRegistry. */
-    relationshipTypes?: RelationshipType[];
+    projectName: string;
     /**
      * Where authored relationships are written, per model package.
      * Keyed by package qualified name, valued by a project-relative .sysml
-     * path. A package listed here always collects its relationships in that
-     * file; anything not listed falls back to the ownership policy in
-     * server/relationship-writer.ts.
+     * path. This is an editor placement preference — it decides which file a
+     * new relationship lands in, not whether the relationship is legal.
      */
     relationshipFiles?: Record<string, string>;
     /** Project-relative .sysml file that owns relationships with no better home. */
     canonicalRelationshipFile?: string;
-    /** Viewpoint definitions for filtered views */
-    viewpoints?: ViewpointDefinition[];
-    /** Guided workflows for step-by-step modeling */
-    workflows?: WorkflowDefinition[];
-    /** First-run scaffolding configuration */
-    firstRun?: FirstRunConfig;
-    /** Compiler and KPAR packager selection. */
+    /** Validator, lowering and packager provider selection. */
     toolchain?: ToolchainConfig;
 }
 //# sourceMappingURL=config.d.ts.map

package/packages/tools/lib/model/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/model/config.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/model/config.ts"],"names":[],"mappings":"AAeA,yDAAyD;AACzD,MAAM,MAAM,cAAc,GACpB,UAAU,GACV,iBAAiB,GACjB,kBAAkB,GAClB,WAAW,GACX,cAAc,GACd,YAAY,GACZ,cAAc,GACd,UAAU,GACV,UAAU,GACV,eAAe,GACf,gBAAgB,GAChB,eAAe,GACf,UAAU,CAAC;AAEjB,iGAAiG;AACjG,MAAM,MAAM,WAAW,GACjB,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GACtE,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,GAAG,cAAc,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,eAAe;IAC5B,mCAAmC;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iDAAiD;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8EAA8E;IAC9E,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC;CACjC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,UAAU;IACvB;;;;;;OAMG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE3C,gFAAgF;IAChF,yBAAyB,CAAC,EAAE,MAAM,CAAC;IAEnC,2DAA2D;IAC3D,SAAS,CAAC,EAAE,eAAe,CAAC;CAC/B"}

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