expressir 2.4.4 → 2.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: faa2eff1343ffba0a34111f1b9c48f2ea65fc8585da64b15844e39cd413b067f
-  data.tar.gz: 34ad23a65dabd3806206cf741c4e19d468bad9f6c566b89c0af10c594e0ca99b
+  metadata.gz: d4cb3a63d16dd31f57a8050366d6b9d9d4e442d65e7df44c01f5edad8f330565
+  data.tar.gz: f234902848350d1abbca9aef98c0ca2bd562fe19463a51e395ec53688ef4e72b
 SHA512:
-  metadata.gz: 05d55fe19517184f73d6f97815be45fef28a7c8d84360ee8a83288e2d0de63671f8fd5715bd4e14c0154cc731d3531871ebeccf83a52c41d6dc1f6dc412e433f
-  data.tar.gz: fc4a6d27fde05257a4b8023ed7507caecdbbb6f79a28f32085ce17c79d1f30428bae762d70b80906f3b6e1e8a46237e7fe5a6ab2d67f407b8fc5cf0c86bf8864
+  metadata.gz: f25c7bf185356ceaea4a9ac257683ef56db6f24923baa6f00e3a566b8e923de2b18500fa8e9b20173b4a83d90a94aa92a2f3fda2dc239fc0eba900bd713ea23d
+  data.tar.gz: 0d310df7b81ada4f9a0a9c73a1e962c100af3082b9911d7c88430de01016a2566a2ff42e30f1b94b6a256c6bd50a5d05263c52e1ff667e0f3798d0958546ac0e

data/README.adoc

@@ -213,6 +213,7 @@ Commands:
   expressir clean PATH                         # Strip remarks and prettify EXPRESS schema at PATH
   expressir expand PATH                        # Concatenate the interface closure into one .exp
   expressir flatten PATH                       # Flatten the interface closure into an ISO 10303-11:1994 longform schema
+  expressir fix PATH                           # Rewrite self-schema-qualified references (#125)
   expressir format PATH                        # pretty print EXPRESS schema located at PATH
   expressir help [COMMAND]                     # Describe available commands or one specific command
   expressir validate load *PATH                # validate EXPRESS schema located at PATH
@@ -527,10 +528,18 @@ expressir expand schemas/resources/action_schema/action_schema.exp \
 |===
 | Option | Description
 | `--output PATH`, `-o PATH` | Write the artifact to PATH (defaults to stdout)
+| `--manifest PATH` | ELF schema manifest YAML defining where schemas live (primary
+  resolution mode)
+| `--stepmod DIR` | STEPmod checkout root — explicit opt-in to directory-convention
+  resolution as the fallback
 |===
 
 The closure is resolved by scanning `USE FROM` / `REFERENCE FROM` names in the
-root source and looking them up in the same directory.
+root source. Schema resolution order: `--manifest PATH` (an ELF schema
+manifest — explicit, layout-independent) first; `--stepmod DIR` (the STEPmod
+directory convention) as an explicit fallback; otherwise the file's own
+directory, with a failed lookup warning and pointing at the two explicit
+modes.
 
 === Flatten schema (SHTOLO longform)
 
@@ -551,8 +560,35 @@ expressir flatten schemas/resources/action_schema/action_schema.exp \
 | Option | Description
 | `--output PATH`, `-o PATH` | Write the longform schema to PATH (defaults to stdout)
 | `--longform_name ID` | Identifier for the resulting SCHEMA (default: `<root>_lf`)
+| `--extenders all|none` | `all` (default, the WG12 requirement): fold every extensible
+  SELECT/ENUMERATION extension in the closure into its base type — for
+  `EXTENSIBLE GENERIC_ENTITY SELECT` that means every entity the closure
+  carries. `none`: leave extensible types exactly as declared.
+| `--manifest PATH` | ELF schema manifest YAML defining where schemas live (primary
+  resolution mode)
+| `--stepmod DIR` | STEPmod checkout root — explicit opt-in to directory-convention
+  resolution as the fallback
 |===
 
+The longform output is verified against Express Engine: for
+`description_assignment`, `eengine --compare` of our longform against
+eengine's own reference artifact reports *No differences detected*
+(`spec/expressir/express/shtolo_eengine_oracle_differential_spec.rb`).
+
+=== Fix schema (self-schema references)
+
+The `fix` command rewrites string literals that qualify an item with the
+CURRENT schema's name — `'THIS_SCHEMA.ITEM'` inside THIS_SCHEMA is
+technically incorrect: the item usually comes from another schema,
+imported implicitly through a USEd supertype. Local items drop the
+prefix; foreign items gain their true defining schema
+(`'GEOMETRY_SCHEMA.B_SPLINE_SURFACE'`); unknown items are left untouched.
+
+[source, sh]
+----
+expressir fix schemas/aic_topologically_bounded_surface.exp   --output fixed.exp
+----
+
 === Validate schema
 
 The `validate load` command performs validation checks on EXPRESS schema files.
@@ -597,6 +633,10 @@ expressir validate check schemas/resources/action_schema/action_schema.exp
 # Check all .exp files under a directory
 expressir validate check schemas/resources/
 
+# Resolve the closure through an ELF schema manifest (or --stepmod DIR)
+expressir validate check modules/description_assignment/mim.exp \
+  --manifest schemas-srl.yaml
+
 # Exit 1 when any :error note fires
 expressir validate check schemas/resources/action_schema/action_schema.exp
 ----

data/TODO.parity-ee/00-overview.md

@@ -56,3 +56,21 @@ SHTOLO paper, BNFs, DTDs)
 `docs/issues/` — bug corpus incl. a shtolo old-vs-new differential;
 `docs/` — SHTOLO paper PDF, Part 11/14/21 BNFs, XML DTDs,
 interface/qualify notes; `00check.txt` — check design notes.
+
+## Phase 2 — full eengine parity (2026-09-22, user-directed)
+
+| # | plan | status |
+|---|---|---|
+| 12 | full check-p11 catalog port | planned |
+| 13 | population / Part 21 validation | planned |
+| 14 | SHTOLO completion (Annex G + corpus differential) | in progress |
+| 15 | Part 28 XML + SMRL index | planned |
+| 16 | schema compare & patch | planned |
+| 17 | official test-case incorporation | standing structure |
+
+Execution order: 14 (finish Shtolo) → 12 (checks) → 15 (XML index)
+→ 16 (compare) → 13 (population, biggest). Each slice ships a PR and
+a patch release as it lands ("release as we go"). Reference repos:
+`~/src/external/exp-engine-engine` (oracle), `~/src/mn/iso-10303-11`
+(normative text), `~/src/mn/iso-10303-detached-docs` (Parts 21/28
+sources and fixtures).

data/TODO.parity-ee/12-full-check-catalog.md

@@ -0,0 +1,67 @@
+# 12 — Full check-p11 catalog port (eeng `kernel/check.lisp`)
+
+## Goal
+
+Bring `Expressir::Express::Checker` from the current documented subset
+to the full eeng check-p11 catalog: every note eeng 5.1.0 emits over
+the SRL/SMRL corpora, with note ids and severities aligned so oracle
+differentials stay cross-referenceable.
+
+## Current subset (shipped)
+
+check-schema-interface-redundant, check-schema-iface-resource-duplicate,
+check-subtype-ref, check-subtype-cycle (path-tracked DFS),
+check-duplicate-declaration, check-where-name-pattern,
+check-unique-name-pattern, check-unresolved-ref,
+check-select-extended-type, check-enumeration-extended-type,
+check-self-schema-reference (#125), parse-failure → nonzero exit.
+
+## Sources
+
+- `~/src/external/exp-engine-engine/kernel/check.lisp` (835 lines,
+  `check-p11` generic + per-node-type methods) and
+  `kernel/check-notes.lisp` (note catalog).
+- ISO 10303-11:2004 clause text — `~/src/mn/iso-10303-11/sources/sections/`
+  (each ported check cites its clause).
+- Existing plan: `07-semantic-checks-port.md`; current impl
+  `lib/expressir/express/checker.rb`.
+
+## Design
+
+1. **Catalog extraction**: enumerate every `post-message` site in
+   check.lisp/check-notes.lisp → (note-id, severity, node type,
+   message shape). Commit as `spec/fixtures/eeng/check-catalog.md`
+   with our coverage column; CI gate diffs the catalog against the
+   oracle so new eeng notes surface.
+2. **Port order** (by eeng's own walk): schema-level (interfaces,
+   constants) → entity (supertype/subtype-of, attributes, derives,
+   inverses, uniques, wheres) → type (select/enumeration/aggregate
+   bounds) → function/procedure/rule bodies (expression typing lite:
+   arity/name resolution of called functions, built-ins from BUILTINS,
+   variable scoping via ScopeResolver) → attribute-level
+   redeclaration consistency (redispatches, `SELF\` qualifiers).
+3. **Differential gate**: run eeng `--validate` and our `validate
+   check` over the SRL corpus + module arm/mim set; every corpus file
+   must produce the SAME note-id multiset (message text may differ).
+   Land as `checker_eeng_full_catalog_differential_spec`
+   (production_scale-tagged for the big corpus; small fixtures in the
+   default suite).
+4. **Severity mapping** table: eeng `:error/:warning` → ours verbatim.
+
+## Acceptance
+
+- Catalog file lists 100% of eeng note ids with status columns.
+- SRL differential: zero unexplained note-id mismatches.
+- `validate check` docs updated (README table).
+
+## Test cases
+
+- eeng `docs/issues/` corpus inputs; qualify loops
+  (`scripts/qual-*.sh`) over resources.lst/modules.lst.
+- Per-clause unit fixtures citing ISO 10303-11 clause numbers.
+
+## Release checkpoint
+
+PR + expressir patch release once the entity/type/schema tiers land
+(expression-tier notes may follow in a second PR — keep the catalog
+honest about which tier each note belongs to).

data/TODO.parity-ee/13-population-p21.md

@@ -0,0 +1,54 @@
+# 13 — Population / Part 21 instance validation
+
+## Goal
+
+Validate STEP Part 21 instance data (.stp/.p21) against a loaded
+schema — eeng's core strength (`--validate` with population), absent
+from expressir today.
+
+## Sources
+
+- ISO 10303-21: exchange structure grammar — BNF in
+  `~/src/mn/iso-10303-detached-docs/sources/iso-10303-21*/` (and
+  eeng's copy under `plugins/p21/`, incl. its parser + validation).
+- eeng: `plugins/p21/` (p21 reader, population), `--validate`
+  (`run-op` population path), `wo-xml.lisp` instance-side references.
+- eeng banner: population validation "not fully supported" upstream —
+  our target is the supported subset, documented precisely.
+
+## Design (scope ladder; each step ships)
+
+1. **P21 reader**: parsanol grammar for the exchange structure
+   (header entities + DATA section: complex entity `(`name(...)`)`,
+   entity instances, list/set values, typed refs `#1`, enums `.T.`,
+   binary `\"..."`, redefines `/`). Emit a Population model
+   (`Model::Population`): instances with entity name + attribute
+   values keyed by explicit attribute position.
+2. **Structural validation**: every instance maps to a known entity
+   in the schema closure (complex entities → all parts); attribute
+   arity matches; value kinds match declared types (aggregate bounds,
+   select members, string/binary widths, REAL precision) — the
+   aggregate of eeng's population notes.
+3. **Constraint validation**: UNIQUE rules (per-entity + inherited),
+   WHERE rules — evaluation needs an EXPRESS expression interpreter;
+   reuse/extend the `benchmark`/expression-walk machinery, evaluate
+   over instance bindings (scope: no INVERSE/derives first).
+4. **CLI**: `expressir validate population SCHEMA -p DATA.p21`,
+   JSON/plain reports aligned with Checker notes.
+
+## Acceptance
+
+- Official Part 21 test corpora parse + validate (see tests).
+- Differential vs eeng `--validate` on shared fixtures: same
+  accept/reject decision and note ids.
+
+## Test cases
+
+- ISO 10303-21 validation suite files from detached-docs where
+  available; else eeng `tests/` + `scripts/test-tt*.sh` fixtures.
+- Hand fixtures: arity mismatch, bad enum, UNIQUE collision, WHERE
+  failure, complex-entity mismatch.
+
+## Release checkpoint
+
+Steps 1–2 = first release (structural validator); step 3 second.

data/TODO.parity-ee/14-shtolo-completion.md

@@ -0,0 +1,44 @@
+# 14 — SHTOLO completion (expressir#32, Annex G)
+
+## Goal
+
+Finish `Expressir::Express::Shtolo` to full Annex G conformance and
+close the eeng differential over the whole corpus. Current state:
+G.1 + G.2 stages implemented (522 lines), suite green (10 examples),
+`extenders:` :all/:none matches the eeng-default split.
+
+## Remaining work
+
+1. **Rule audit**: walk `spec/fixtures/shtolo/annex-g-rules.md`
+   (G.NM.1-2, G.1.1-10, G.2.1-7) and mark every rule PASS/partial/✖
+   in the file; a fixture per rule. Known-thin areas from the audit:
+   - G.1.6 dependently-instantiable rule output (function + WHERE
+     wiring) — verify against Annex G text, not eeng (eeng ✖).
+   - name-munging policy (`_dot_` and friends) — eeng ✖; standard wins.
+   - prune pass reachability (unreachable subtype branches).
+2. **Corpus differential**: for every module arm/mim in modules.lst,
+   compare our flatten output to `eengine --flat` (eeng default =
+   `extenders: :none` shape); classify divergences
+   standard-conformant vs bug. Feed the mismatch corpus into specs.
+3. **Scale**: SMRL full set flatten over the compiled-set warm model;
+   memory ceiling documented.
+4. **CLI**: `expressir shtolo MANIFEST -o longform.exp` (root schema
+   + closure resolution reuses ParityInputs).
+
+## Acceptance
+
+- Every Annex G rule has a green fixture.
+- Corpus differential: zero unexplained diffs; every explained
+  divergence documented in `parity-matrix.md`.
+- SMRL flatten completes; output parses under the 1994 profile.
+
+## Test cases
+
+- annex-g-rules.md fixtures; eeng `docs/issues/bug39` shtolo outputs
+  (old-vs-new vs stepcode exppp); `scripts/qual-*.sh` loops;
+  `pretty-test.sh` ap209/210/242 × arm/mim shape checks.
+
+## Release checkpoint
+
+One PR per coherent slice (rule audit + fixtures; differential gate;
+CLI), patch releases as each merges.

data/TODO.parity-ee/15-part28-xml.md

@@ -0,0 +1,51 @@
+# 15 — EXPRESS → XML (ISO 10303-28 / eeng --xml)
+
+## Goal
+
+Generate XML Schema output for a schema (expressir#276): eeng's
+`--xml` (`wo-xml-p11.lisp`) plus the SMRL index listing
+(`wo-smrl-xml.lisp`, feeds the SMRL document set).
+
+## Sources
+
+- ISO 10303-28:2007 ( EXPRESS-driven XML representation) — detached
+  docs `~/src/mn/iso-10303-detached-docs/sources/iso-10303-28*/`;
+  eeng `docs/` carries `express_model.dtd` + module.dtd (legacy
+  forms).
+- eeng: `plugins/p11/wo-xml-p11.lisp` (schema → XSD),
+  `wo-smrl-xml.lisp` (SMRL index XML), `--xml` run-op.
+- Consumer: iso-10303 repo's `schemas/data/*.xml` SMRL pages
+  (rendered by metanorma today) — our output must be drop-in for
+  that pipeline.
+
+## Design
+
+1. **SMRL index XML first** (small, high value for iso-10303): the
+   index of all schemas in a repository (name, file, interfaces,
+   counts) as the repo's data-layer source — replaces the
+   hand-maintained entries.
+2. **express2xsd**: schema → XSD via a declarative mapping table
+   (entity → element+complexType, type → simpleType/complexType,
+   select → choice, explicit attrs in order, supertype substitution
+   groups for SUBTYPE OF, aggregates → minOccurs/maxOccurs). Emit
+   through a Nokogiri-free XML writer (ROXML via lutaml-model where
+   it fits; hand-rolled tree otherwise — the mapping is the product,
+   not the serialization).
+3. **CLI**: `expressir xml SCHEMA -o schema.xsd`;
+   `expressir xml-index REPO -o smrl.xml`.
+
+## Acceptance
+
+- Output validates against the Part 28 reference XSDs (detached
+  docs) for the fixture set; xsd diff vs eeng --xml on SRL corpus
+  classified standard-vs-eeng.
+- iso-10303 SMRL pages render from our generated index unchanged.
+
+## Test cases
+
+- eeng `scripts/build-xml.sh` full-corpus reference outputs;
+  `test-tt{,1}.sh` (XML + Saxon HTM chain) as end-to-end smoke.
+
+## Release checkpoint
+
+SMRL index first (unblocks iso-10303 pipeline), express2xsd second.

data/TODO.parity-ee/16-compare-patch.md

@@ -0,0 +1,48 @@
+# 16 — Schema compare & patch (eeng --compare / --patch)
+
+## Goal
+
+Structural diff of two schemata with a machine-applicable patch
+output — eeng `--compare` (+ `--concat_compare`, `--patch`,
+`--patch_schema_name`), used by WG12 to track schema revisions.
+
+## Sources
+
+- eeng `plugins/p11/wo-*.lisp` compare entry (`run-op (:compare)`
+  in top-level.lisp) and patch application paths; mode args:
+  `:trial_schema :reference_schema :xml-output :patch-output`.
+- Semantics baseline: declaration-level matching by id within the
+  flattened/concatenated form (eeng compares post-concat shapes for
+  shortforms).
+
+## Design
+
+1. **Model diff** on the resolved repositories: declarations matched
+   by canonical path (`schema.item`); kinds of delta — added,
+   removed, changed (per-attribute structural diff: types,
+   attribute lists, where/unique bodies via formatted-text
+   comparison first, structural second).
+2. **Outputs**: unified-ish text report (human), XML
+   (`--xml-output` parity), and patch script (the eeng patch
+   format: rename/redefine vocabulary it defines — ported from
+   wo-patch output shapes).
+3. **CLI**: `expressir compare TRIAL.exp REFERENCE.exp [--xml|--patch]`;
+   `concat-compare` rides the Concatenator for shortform pairs.
+4. **Patch application**: apply a patch file to a model (rename
+   declarations, remap interfaces) — the write-back side eeng uses
+   for round-trip patching.
+
+## Acceptance
+
+- SRL corpus self-compare = empty diff; mutated fixtures (rename,
+  add/remove attr, retype) produce the expected delta kinds.
+- Differential vs eeng `--compare` XML on the same pairs.
+
+## Test cases
+
+- eeng `docs/issues/` pairs; hand-mutated fixture ladder; the
+  `--concat_compare` module-vs-module pairs from scripts.
+
+## Release checkpoint
+
+Text+XML diff first release; patch apply second.

data/TODO.parity-ee/17-official-tests.md

@@ -0,0 +1,42 @@
+# 17 — Official test-case incorporation
+
+## Goal
+
+One place that maps every OFFICIAL/reference test corpus to our
+specs, and CI gates that run the tractable tier on every push.
+
+## Corpora
+
+1. **eeng suite** (already imported, `spec/fixtures/eeng/`):
+   `scripts/*.sh` 14 drivers (qual-arm/mod/res loops, pretty-test.sh
+   ap209/210/242 × arm/mim × shortform/longform, ap210 giant file,
+   test-tt{,1}.sh XML chain, build-xml.sh), `docs/issues/` bug
+   corpus (bug39 shtolo old-vs-new vs stepcode exppp; bug40 pretty
+   expressions), `qualify.txt`, `interfaces.txt`, `00check.txt`.
+2. **ISO 10303-11** grammar/conformance sources:
+   `~/src/mn/iso-10303-11/sources/sections/` — Annex G rules
+   (fixtures live in `spec/fixtures/shtolo/annex-g-rules.md`),
+   syntax annexes for negative/positive grammar tests.
+3. **ISO detached docs** `~/src/mn/iso-10303-detached-docs/sources/
+   iso-10303-*`: Part 21 exchange-structure fixtures (population),
+   Part 28 reference XSDs (XML), Part 22 (SDAI vocabulary, later).
+4. **SRL/SMRL corpora** (`resources.lst`/`modules.lst` names match
+   our checkout): the differential tier.
+
+## Structure
+
+- `spec/expressir/eeng_parity/` — one spec per capability matrix
+  row; each example tags its source corpus file in a comment.
+- Tiering: `:fast` (fixtures, every push) / `:corpus`
+  (SRL differential, nightly or manual tag `production_scale`) /
+  `:smoke_eeng` (runs the local eeng oracle when the binary exists —
+  skipped otherwise).
+- `rake parity:status` prints the capability × corpus matrix with
+  green/gray cells — the single progress view.
+
+## Rules
+
+- No test is added without its provenance row in the fixture dir's
+  PROVENANCE.md (established practice, keep it).
+- Oracle outputs are regenerated, never hand-edited; the regeneration
+  command lives next to each golden.

data/expressir.gemspec

@@ -36,7 +36,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "benchmark-ips"
   spec.add_dependency "csv"
   spec.add_dependency "liquid"
-  spec.add_dependency "lutaml-model", "~> 0.8.0"
+  spec.add_dependency "lutaml-model", "~> 0.8.50"
   spec.add_dependency "moxml"
   spec.add_dependency "nokogiri"
   spec.add_dependency "paint"

data/lib/expressir/express/adoc_hyperlink_formatter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # HyperlinkFormatter variant emitting AsciiDoc xref macros instead
+    # of the legacy stepmod +{{{<<express:...>>}}}+ markup: a reference
+    # to schema.item renders as +<<schema.item,item>>+, the anchor
+    # namespace schema document pages emit (expressir #255 / iso-10303
+    # #41). With +subs="+macros"+ source blocks the links go live.
+    module AdocHyperlinkFormatter
+      # @!visibility private
+      def self.included(mod)
+        unless mod.superclass <= Expressir::Express::Formatter
+          raise Error::FormatterMethodMissingError.new("AdocHyperlinkFormatter",
+                                                       "format_references_simple_reference")
+        end
+      end
+
+      def format_references_simple_reference(node)
+        return node.id unless node.base_path
+
+        parts = node.base_path.split(".")
+        return node.id if parts.size < 2
+
+        anchor = parts[-2, 2].join(".")
+        "<<#{anchor},#{node.id}>>"
+      end
+    end
+  end
+end

data/lib/expressir/express/adoc_source_formatter.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # Pre-built Formatter subclass rendering the FULL schema with
+    # cross-references as AsciiDoc xref macros — the document-page
+    # counterpart of SourceFormatter (Schema#formatted_hyperlinked_adoc).
+    class AdocSourceFormatter < Formatter
+      include AdocHyperlinkFormatter
+    end
+  end
+end

data/lib/expressir/express/shtolo.rb

@@ -33,12 +33,21 @@ module Expressir
       #                 closure into its base type (Annex G.2.3/G.2.4);
       #                 :none leaves extensible types exactly as declared —
       #                 the shape eengine's default --flat emits.
+      # `prune`        — true (default) runs the G.1.9 prune pass;
+      #                 false keeps the artifact's full declaration set.
+      # `stage`        — :longform (default) runs the G.2 rewrites;
+      #                 :artifact stops after stage 1 — the annex's
+      #                 intermediate schema, the shape eengine's
+      #                 --concat_schema output corresponds to (copy
+      #                 pass, no prune, no 1994 rewrite).
       def initialize(root_schema, repository, longform_name: nil,
-                     extenders: :all)
+                     extenders: :all, prune: true, stage: :longform)
         @root = root_schema
         @repository = repository
         @longform_name = longform_name || @root.id
         @extenders = extenders
+        @prune = prune
+        @stage = stage
         @reference_entities = [] # G.1.6 entities
       end
 
@@ -274,6 +283,8 @@ module Expressir
 
       def build_longform
         artifact = build_artifact
+        prune!(artifact) if @prune
+        return artifact if @stage == :artifact
 
         if @extenders == :all
           resolve_extensible_enumerations!(artifact)
@@ -288,6 +299,123 @@ module Expressir
         artifact
       end
 
+      # G.1.9 prune pass: the artifact keeps only what stays visible
+      # and reachable. Runs before the stage-2 rewrites so they never
+      # see declarations the longform would drop.
+      def prune!(schema)
+        visible_ids = visible_declaration_ids(schema)
+
+        # rules whose parameter entities are not all visible
+        schema.rules = schema.rules.reject do |rule|
+          Array(rule.applies_to).any? do |ref|
+            id = ref.is_a?(String) ? ref : ref.id
+            id && !visible_ids.key?(id.safe_downcase)
+          end
+        end
+
+        # select items pointing at declarations the artifact lacks
+        schema.types.each do |type|
+          next unless type.underlying_type.is_a?(Model::DataTypes::Select)
+
+          items = Array(type.underlying_type.items)
+          kept = items.select do |item|
+            item.id.nil? || visible_ids.key?(item.id.safe_downcase)
+          end
+          # An emptied select disappears from the representation
+          # (annex G.1.9 s1/s2/s3 example).
+          type.underlying_type.items = kept unless kept.empty? && items.empty?
+          if kept.empty? && !items.empty?
+            type.underlying_type = nil
+          end
+        end
+        schema.types = schema.types.reject { |t| t.underlying_type.nil? }
+
+        # functions/procedures nothing calls, to fixpoint (a helper only
+        # a dropped function called is itself unreachable)
+        loop do
+          called = called_ids(schema)
+          drop = schema.functions.any? { |f| !called[f.id.safe_downcase] } ||
+            schema.procedures.any? { |p| !called[p.id.safe_downcase] }
+          break unless drop
+
+          schema.functions = schema.functions.select { |f| called[f.id.safe_downcase] }
+          schema.procedures = schema.procedures.select { |p| called[p.id.safe_downcase] }
+        end
+
+        prune_supertype_expressions!(schema, visible_ids)
+      end
+
+      def visible_declaration_ids(schema)
+        all_decls(schema).each_with_object({}) do |decl, hash|
+          hash[decl.id.safe_downcase] = true if decl.respond_to?(:id) && decl.id
+        end
+      end
+
+      # Every identifier a FunctionCall site names, across the
+      # artifact's surviving declarations.
+      def called_ids(schema)
+        called = {}
+        each_node(schema) do |node|
+          next unless node.is_a?(Model::Expressions::FunctionCall)
+
+          ref = node.function
+          id = ref.is_a?(String) ? ref : ref&.id
+          called[id.safe_downcase] = true if id
+        end
+        called
+      end
+
+      # Annex C reductions over supertype expressions: references to
+      # invisible entities leave ONEOF; ONEOF(a) => a; AND/OR sides
+      # that become empty collapse; a vacuous expression deletes the
+      # constraint.
+      def prune_supertype_expressions!(schema, visible_ids)
+        keep = []
+        schema.subtype_constraints.each do |constraint|
+          expr = constraint.supertype_expression
+          if expr.nil?
+            # total-over-only constraints carry no expression; stage 2
+            # turns their TOTAL_OVER into a rule.
+            keep << constraint
+            next
+          end
+          reduced = reduce_supertype_expression(expr, visible_ids)
+          # Annex C: a vacuous expression deletes the constraint.
+          next if reduced.nil?
+
+          constraint.supertype_expression = reduced
+          keep << constraint
+        end
+        schema.subtype_constraints = keep
+      end
+
+      def reduce_supertype_expression(expr, visible_ids)
+        case expr
+        when Model::SupertypeExpressions::OneofSupertypeExpression
+          refs = Array(expr.operands).select do |ref|
+            id = ref.is_a?(String) ? ref : ref.id
+            id.nil? || visible_ids.key?(id.safe_downcase)
+          end
+          return nil if refs.empty?
+
+          refs.one? ? refs.first : reset_oneof(expr, refs)
+        when Model::SupertypeExpressions::BinarySupertypeExpression
+          left = reduce_supertype_expression(expr.operands[0], visible_ids)
+          right = reduce_supertype_expression(expr.operands[1], visible_ids)
+          return nil if left.nil? && right.nil?
+
+          left || right
+        else
+          expr
+        end
+      end
+
+      def reset_oneof(expr, refs)
+        copy = deep_copy(expr)
+        copy.operands = refs
+        copy
+      end
+
       def resolve_extensible_enumerations!(schema)
         schema.types.select do |t|
           t.underlying_type.is_a?(Model::DataTypes::Enumeration) && t.underlying_type.extensible

data/lib/expressir/express.rb

@@ -10,6 +10,8 @@ module Expressir
 
     # Core classes (autoloaded for lazy loading)
     autoload :Cache, "#{__dir__}/express/cache"
+    autoload :AdocHyperlinkFormatter, "#{__dir__}/express/adoc_hyperlink_formatter"
+    autoload :AdocSourceFormatter, "#{__dir__}/express/adoc_source_formatter"
     autoload :Checker, "#{__dir__}/express/checker"
     autoload :Concatenator, "#{__dir__}/express/concatenator"
     autoload :Core, "#{__dir__}/express/core"

data/lib/expressir/model/declarations/schema.rb

@@ -59,6 +59,8 @@ module Expressir
         liquid do
           map :header, to: :header
           map :formatted, to: :formatted
+          map :formatted_hyperlinked, to: :formatted_hyperlinked
+          map :formatted_hyperlinked_adoc, to: :formatted_hyperlinked_adoc
           map :source, to: :source
           map :source_hyperlinked, to: :source_hyperlinked
           map :full_source, to: :full_source
@@ -111,6 +113,20 @@ module Expressir
           Expressir::Express::SchemaSourceFormatter.format(self)
         end
 
+        # FULL schema text with cross-references rendered as hyperlinks
+        # — what a schema document page renders (#255): every line of
+        # the schema, live links included.
+        def formatted_hyperlinked
+          @formatted_hyperlinked ||= Expressir::Express::SourceFormatter.format(self)
+        end
+
+        # FULL schema text with cross-references as AsciiDoc xref macros
+        # (+<<schema.item,item>>+) — drop-in for a schema document page
+        # rendered through a +subs="+macros"+ source block.
+        def formatted_hyperlinked_adoc
+          @formatted_hyperlinked_adoc ||= Expressir::Express::AdocSourceFormatter.format(self)
+        end
+
         private
 
         # @param [String] id

data/lib/expressir/version.rb

@@ -3,6 +3,6 @@ module Expressir
   # autoload it (Ruby autoload only works for module/class constants, not
   # for string constants like `Expressir::VERSION`).
   module Version
-    VERSION = "2.4.4".freeze
+    VERSION = "2.4.6".freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: expressir
 version: !ruby/object:Gem::Version
-  version: 2.4.4
+  version: 2.4.6
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-22 00:00:00.000000000 Z
+date: 2026-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.8.50
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.8.50
 - !ruby/object:Gem::Dependency
   name: moxml
   requirement: !ruby/object:Gem::Requirement
@@ -312,6 +312,12 @@ files:
 - TODO.parity-ee/09-smrl-index-and-listing.md
 - TODO.parity-ee/10-interface-dot-graph.md
 - TODO.parity-ee/11-import-eeng-tests.md
+- TODO.parity-ee/12-full-check-catalog.md
+- TODO.parity-ee/13-population-p21.md
+- TODO.parity-ee/14-shtolo-completion.md
+- TODO.parity-ee/15-part28-xml.md
+- TODO.parity-ee/16-compare-patch.md
+- TODO.parity-ee/17-official-tests.md
 - TODO.parity-ee/parity-matrix.md
 - benchmark/srl_benchmark.rb
 - benchmark/srl_native_benchmark.rb
@@ -436,6 +442,8 @@ files:
 - lib/expressir/eengine/modified_object.rb
 - lib/expressir/errors.rb
 - lib/expressir/express.rb
+- lib/expressir/express/adoc_hyperlink_formatter.rb
+- lib/expressir/express/adoc_source_formatter.rb
 - lib/expressir/express/ast_key_converter.rb
 - lib/expressir/express/builder.rb
 - lib/expressir/express/builder_context.rb