motionspec 1.0.0

package/primitives/counterUp.json

@@ -0,0 +1,54 @@
+{
+  "name": "counterUp",
+  "version": "1.0.0",
+  "purpose": "Zahl zaehlt beim Einblenden in den Viewport von 0 bis zum Zielwert hoch.",
+  "output": "js",
+  "engine": "gsap.ScrollTrigger",
+  "paramSchema": {
+    "duration": {
+      "type": "number",
+      "default": 1.6,
+      "min": 0.2,
+      "max": 5
+    },
+    "ease": {
+      "type": "string",
+      "default": "power1.out",
+      "pattern": "^[A-Za-z0-9.()]{1,40}$"
+    },
+    "step": {
+      "type": "number",
+      "default": 1,
+      "min": 0.01,
+      "max": 1000
+    },
+    "locale": {
+      "type": "string",
+      "default": "de-DE",
+      "pattern": "^[A-Za-z]{2,3}(-[A-Za-z0-9]{2,8})*$"
+    }
+  },
+  "triggerDefaults": {
+    "start": "top 85%",
+    "once": true
+  },
+  "performance": {
+    "verified": true,
+    "lcpSafe": true,
+    "cost": 1,
+    "verifiedAt": "2026-06-12"
+  },
+  "a11y": {
+    "reducedMotionFallback": "instant-visible"
+  },
+  "template": "document.querySelectorAll({{target}}).forEach(function(el){ var end=parseFloat(el.getAttribute('data-count')||el.textContent); if(!isFinite(end)) end=0; var o={v:0}; gsap.to(o,{v:end,duration:{{params.duration}},ease:{{params.ease}},snap:{v:{{params.step}}},onUpdate:function(){el.textContent=o.v.toLocaleString({{params.locale}})},scrollTrigger:{trigger:el,start:{{trigger.start}},once:{{trigger.once}}}}); });",
+  "demo": {
+    "html": "<p class=\"counter d-counterUp\" data-count=\"12847\">12.847</p>\n<p class=\"counter d-counterUp\" data-count=\"99\">99</p>",
+    "params": {
+      "duration": 2,
+      "ease": "power2.out",
+      "step": 1,
+      "locale": "de-DE"
+    }
+  }
+}

package/primitives/cssTransition.json

@@ -0,0 +1,38 @@
+{
+  "name": "cssTransition",
+  "version": "1.1.0",
+  "purpose": "Einfache Hover-Mikrointeraktion ganz ohne JavaScript.",
+  "output": "css",
+  "engine": "native-css",
+  "paramSchema": {
+    "property": {
+      "type": "string",
+      "default": "transform"
+    },
+    "hoverValue": {
+      "type": "string",
+      "default": "translateY(-4px)"
+    },
+    "duration": {
+      "type": "number",
+      "default": 0.25,
+      "min": 0.05,
+      "max": 1
+    },
+    "easing": {
+      "type": "string",
+      "default": "ease-out"
+    }
+  },
+  "triggerDefaults": {},
+  "performance": {
+    "verified": true,
+    "lcpSafe": true,
+    "cost": 0,
+    "verifiedAt": "2026-06-12"
+  },
+  "a11y": {
+    "reducedMotionFallback": "none-needed"
+  },
+  "template": "{{css target}} { transition: {{css params.property}} {{css params.duration}}s {{css params.easing}}; }\n{{css target}}:hover { {{css params.property}}: {{css params.hoverValue}}; }"
+}

package/primitives/marquee.json

@@ -0,0 +1,44 @@
+{
+  "name": "marquee",
+  "version": "1.0.0",
+  "purpose": "Endlos laufendes horizontales Laufband — Inhalt als ZWEI identische Gruppen anlegen (nahtlose Schleife).",
+  "output": "css",
+  "engine": "native-css",
+  "paramSchema": {
+    "duration": {
+      "type": "number",
+      "default": 24,
+      "min": 4,
+      "max": 120
+    },
+    "gap": {
+      "type": "string",
+      "default": "3rem",
+      "pattern": "^[0-9]*\\.?[0-9]+(px|rem|em|vw|ch|%)$"
+    },
+    "direction": {
+      "type": "string",
+      "default": "normal",
+      "pattern": "^(normal|reverse)$"
+    }
+  },
+  "triggerDefaults": {},
+  "performance": {
+    "verified": true,
+    "lcpSafe": true,
+    "cost": 1,
+    "verifiedAt": "2026-06-12"
+  },
+  "a11y": {
+    "reducedMotionFallback": "static"
+  },
+  "template": "{{css target}} { display: flex; gap: {{css params.gap}}; overflow: hidden; }\n{{css target}} > * { flex-shrink: 0; animation: motion-marquee-{{css id}} {{css params.duration}}s linear infinite {{css params.direction}}; }\n@keyframes motion-marquee-{{css id}} { from { transform: translateX(0) } to { transform: translateX(-100%) } }",
+  "demo": {
+    "html": "<div class=\"marquee-track\"><div class=\"d-marquee\"><div><span style=\"padding:0 2rem\">ALPHA</span><span style=\"padding:0 2rem\">BETA</span><span style=\"padding:0 2rem\">GAMMA</span><span style=\"padding:0 2rem\">DELTA</span></div><div><span style=\"padding:0 2rem\">ALPHA</span><span style=\"padding:0 2rem\">BETA</span><span style=\"padding:0 2rem\">GAMMA</span><span style=\"padding:0 2rem\">DELTA</span></div></div></div>",
+    "params": {
+      "duration": 24,
+      "gap": "3rem",
+      "direction": "normal"
+    }
+  }
+}

package/primitives/parallaxLayer.json

@@ -0,0 +1,35 @@
+{
+  "name": "parallaxLayer",
+  "version": "1.1.0",
+  "purpose": "Tiefenversatz: Ebene bewegt sich beim Scrollen langsamer oder schneller als der Rest.",
+  "output": "js",
+  "engine": "gsap.ScrollTrigger",
+  "paramSchema": {
+    "yPercent": {
+      "type": "number",
+      "default": -20,
+      "min": -100,
+      "max": 100
+    },
+    "scrub": {
+      "type": "number",
+      "default": 1,
+      "min": 0,
+      "max": 4
+    }
+  },
+  "triggerDefaults": {
+    "start": "top bottom",
+    "end": "bottom top"
+  },
+  "performance": {
+    "verified": true,
+    "lcpSafe": true,
+    "cost": 2,
+    "verifiedAt": "2026-06-12"
+  },
+  "a11y": {
+    "reducedMotionFallback": "instant-visible"
+  },
+  "template": "gsap.to({{target}}, { yPercent: {{params.yPercent}}, ease: 'none', scrollTrigger: { trigger: {{target}}, start: {{trigger.start}}, end: {{trigger.end}}, scrub: {{params.scrub}} } });"
+}

package/primitives/pinnedSection.json

@@ -0,0 +1,30 @@
+{
+  "name": "pinnedSection",
+  "version": "1.1.0",
+  "purpose": "Sektion fixieren, waehrend der Inhalt hindurchscrollt.",
+  "output": "js",
+  "engine": "gsap.ScrollTrigger",
+  "paramSchema": {
+    "distance": {
+      "type": "string",
+      "default": "+=100%"
+    },
+    "pinSpacing": {
+      "type": "boolean",
+      "default": true
+    }
+  },
+  "triggerDefaults": {
+    "start": "top top"
+  },
+  "performance": {
+    "verified": true,
+    "lcpSafe": true,
+    "cost": 2,
+    "verifiedAt": "2026-06-12"
+  },
+  "a11y": {
+    "reducedMotionFallback": "instant-visible"
+  },
+  "template": "ScrollTrigger.create({ trigger: {{target}}, start: {{trigger.start}}, end: {{params.distance}}, pin: true, pinSpacing: {{params.pinSpacing}} });"
+}

package/primitives/scaleOnScroll.json

@@ -0,0 +1,55 @@
+{
+  "name": "scaleOnScroll",
+  "version": "1.0.0",
+  "purpose": "Element skaliert sich proportional zum Scroll-Fortschritt (GSAP ScrollTrigger scrub).",
+  "output": "js",
+  "engine": "gsap.ScrollTrigger",
+  "paramSchema": {
+    "fromScale": {
+      "type": "number",
+      "default": 0.8,
+      "min": 0.2,
+      "max": 1
+    },
+    "toScale": {
+      "type": "number",
+      "default": 1,
+      "min": 0.5,
+      "max": 2
+    },
+    "transformOrigin": {
+      "type": "string",
+      "default": "center center",
+      "pattern": "^[a-zA-Z0-9% ]{2,40}$"
+    },
+    "scrub": {
+      "type": "number",
+      "default": 1,
+      "min": 0,
+      "max": 4
+    }
+  },
+  "triggerDefaults": {
+    "start": "top bottom",
+    "end": "center center"
+  },
+  "performance": {
+    "verified": true,
+    "lcpSafe": true,
+    "cost": 2,
+    "verifiedAt": "2026-06-12"
+  },
+  "a11y": {
+    "reducedMotionFallback": "instant-visible"
+  },
+  "template": "gsap.fromTo({{target}}, { scale: {{params.fromScale}}, transformOrigin: {{params.transformOrigin}} }, { scale: {{params.toScale}}, transformOrigin: {{params.transformOrigin}}, ease: \"none\", scrollTrigger: { trigger: {{target}}, start: {{trigger.start}}, end: {{trigger.end}}, scrub: {{params.scrub}} } });",
+  "demo": {
+    "html": "<div class=\"d-scaleOnScroll\" style=\"width:200px;height:200px;background:#6366f1;border-radius:12px;margin:60vh auto;\">Scale me</div>",
+    "params": {
+      "fromScale": 0.6,
+      "toScale": 1,
+      "transformOrigin": "center center",
+      "scrub": 1.5
+    }
+  }
+}

package/primitives/scrollReveal.json

@@ -0,0 +1,43 @@
+{
+  "name": "scrollReveal",
+  "version": "1.1.0",
+  "purpose": "Element blendet beim Eintritt in den Viewport ein.",
+  "output": "js",
+  "engine": "gsap.ScrollTrigger",
+  "paramSchema": {
+    "from": {
+      "type": "transform",
+      "required": true
+    },
+    "duration": {
+      "type": "number",
+      "default": 0.8,
+      "min": 0.1,
+      "max": 3
+    },
+    "ease": {
+      "type": "string",
+      "default": "power3.out"
+    },
+    "stagger": {
+      "type": "number",
+      "default": 0,
+      "min": 0,
+      "max": 0.5
+    }
+  },
+  "triggerDefaults": {
+    "start": "top 80%",
+    "once": true
+  },
+  "performance": {
+    "verified": true,
+    "lcpSafe": true,
+    "cost": 1,
+    "verifiedAt": "2026-06-12"
+  },
+  "a11y": {
+    "reducedMotionFallback": "instant-visible"
+  },
+  "template": "gsap.from({{target}}, Object.assign({{params.from}}, { duration: {{params.duration}}, ease: {{params.ease}}, stagger: {{params.stagger}}, scrollTrigger: { trigger: {{target}}, start: {{trigger.start}}, once: {{trigger.once}} } }));"
+}

package/primitives/staggerReveal.json

@@ -0,0 +1,43 @@
+{
+  "name": "staggerReveal",
+  "version": "1.1.0",
+  "purpose": "Mehrere Kind-Elemente gestaffelt nacheinander einblenden.",
+  "output": "js",
+  "engine": "gsap.ScrollTrigger",
+  "paramSchema": {
+    "from": {
+      "type": "transform",
+      "required": true
+    },
+    "duration": {
+      "type": "number",
+      "default": 0.6,
+      "min": 0.1,
+      "max": 3
+    },
+    "ease": {
+      "type": "string",
+      "default": "power2.out"
+    },
+    "stagger": {
+      "type": "number",
+      "default": 0.12,
+      "min": 0.02,
+      "max": 0.6
+    }
+  },
+  "triggerDefaults": {
+    "start": "top 85%",
+    "once": true
+  },
+  "performance": {
+    "verified": true,
+    "lcpSafe": true,
+    "cost": 1,
+    "verifiedAt": "2026-06-12"
+  },
+  "a11y": {
+    "reducedMotionFallback": "instant-visible"
+  },
+  "template": "gsap.from({{target}}, Object.assign({{params.from}}, { duration: {{params.duration}}, ease: {{params.ease}}, stagger: {{params.stagger}}, scrollTrigger: { trigger: {{target}}, start: {{trigger.start}}, once: {{trigger.once}} } }));"
+}

package/schema/motionspec.schema.json

@@ -0,0 +1,56 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://motionspec.dev/schema/1.0/motionspec.schema.json",
+  "title": "MotionSpec",
+  "description": "Formale Zwischensprache fuer Web-Motion. FROZEN v1 (ADR-0001, 2026-06-15). Field shape is the published, stable contract. specVersion \"1.0\" is stable; \"0.1\" deprecated, accepted until v1.2. Static contract; the dynamic check (Primitive-Allow-List, per-primitive params, deprecation note) is the Trust-Boundary-Validator in compiler/validate.js. responsive is a known-but-deferred key (rejected at runtime until 0.2).",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["specVersion", "meta", "motions"],
+  "properties": {
+    "specVersion": { "type": "string", "enum": ["1.0", "0.1"] },
+    "catalogVersion": { "type": "string", "pattern": "^[0-9a-f]{16}$", "description": "Optional reproducibility pin (ADR-0001 D2): the 16-char catalog hash this spec was authored against. Rejected at runtime if it does not match the loaded catalog." },
+    "meta": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["target"],
+      "properties": {
+        "project": { "type": "string" },
+        "target": { "type": "string", "enum": ["vanilla-gsap"] },
+        "createdWith": { "type": "string" }
+      }
+    },
+    "globals": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "respectReducedMotion": { "type": "boolean" },
+        "defaultEase": { "type": "string" }
+      }
+    },
+    "motions": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["id", "primitive", "target"],
+        "properties": {
+          "id": { "type": "string", "minLength": 1 },
+          "primitive": { "type": "string", "description": "Muss ein Name aus dem Primitive-Katalog sein. Allow-List, zur Laufzeit geprueft." },
+          "target": { "type": "string", "minLength": 1 },
+          "params": { "type": "object" },
+          "trigger": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "start": { "type": "string" },
+              "end": { "type": "string" },
+              "once": { "type": "boolean" }
+            }
+          },
+          "responsive": { "type": "object" }
+        }
+      }
+    }
+  }
+}

package/src/compiler/catalog-semver.js

@@ -0,0 +1,133 @@
+"use strict";
+/*
+ * Catalog SemVer diff-gate — makes ADR-0001 D2 machine-checkable.
+ * ----------------------------------------------------------------------
+ * D2 says catalog changes follow SemVer:
+ *   patch = template/purpose fix (no contract change)
+ *   minor = new OPTIONAL param, or a new primitive
+ *   major = removed/renamed primitive, removed param, type change,
+ *           a param made required, or TIGHTENED bounds (min raised / max
+ *           lowered / pattern added or changed)
+ *
+ * The meta-schema only checks the version FORMAT. This module checks the
+ * version DIRECTION: given the released baseline (catalog.lock.json) and the
+ * current catalog, it classifies each primitive's change and asserts the
+ * version bump is at least the required class. A tightened bound shipped as a
+ * "patch" is a violation the test will catch.
+ *
+ * Baseline semantics: the lockfile is the LAST RELEASED state. You bump a
+ * primitive's version in its .json when you change it; the lock stays put
+ * until you deliberately relock at release time (`npm run catalog-lock`).
+ */
+
+function snapshotPrimitive(p) {
+  const params = {};
+  const ps = p.paramSchema || {};
+  Object.keys(ps).sort().forEach((k) => {
+    const d = ps[k] || {};
+    params[k] = {
+      type: d.type,
+      required: !!d.required,
+      min: typeof d.min === "number" ? d.min : null,
+      max: typeof d.max === "number" ? d.max : null,
+      pattern: typeof d.pattern === "string" ? d.pattern : null,
+    };
+  });
+  return { version: p.version, output: p.output, params };
+}
+
+function snapshotCatalog(catalog) {
+  const out = {};
+  Object.keys(catalog).sort().forEach((name) => { out[name] = snapshotPrimitive(catalog[name]); });
+  return out;
+}
+
+function parseSemver(v) {
+  const m = /^(\d+)\.(\d+)\.(\d+)$/.exec(String(v));
+  if (!m) return null;
+  return { major: +m[1], minor: +m[2], patch: +m[3] };
+}
+
+function cmpSemver(a, b) {
+  const x = parseSemver(a), y = parseSemver(b);
+  if (!x || !y) return null;
+  if (x.major !== y.major) return x.major - y.major;
+  if (x.minor !== y.minor) return x.minor - y.minor;
+  return x.patch - y.patch;
+}
+
+/* Classify the contract change of ONE primitive between baseline and current.
+ * Returns { class: "major"|"minor"|"patch"|"none", reasons: [] }. */
+function classifyChange(prev, curr) {
+  const reasons = [];
+  let cls = "none";
+  const bump = (level, why) => {
+    reasons.push(why);
+    const rank = { none: 0, patch: 1, minor: 2, major: 3 };
+    if (rank[level] > rank[cls]) cls = level;
+  };
+
+  if (prev.output !== curr.output) bump("major", "output changed " + prev.output + "->" + curr.output);
+
+  const prevKeys = Object.keys(prev.params);
+  const currKeys = Object.keys(curr.params);
+
+  prevKeys.forEach((k) => {
+    if (!(k in curr.params)) { bump("major", "param removed: " + k); return; }
+    const a = prev.params[k], b = curr.params[k];
+    if (a.type !== b.type) bump("major", "param type changed: " + k + " " + a.type + "->" + b.type);
+    if (!a.required && b.required) bump("major", "param made required: " + k);
+    if (a.min !== null && (b.min === null || b.min > a.min)) bump("major", "min raised: " + k + " " + a.min + "->" + b.min);
+    if (a.max !== null && (b.max === null || b.max < a.max)) bump("major", "max lowered: " + k + " " + a.max + "->" + b.max);
+    if (a.pattern === null && b.pattern !== null) bump("major", "pattern added: " + k);
+    else if (a.pattern !== null && b.pattern !== a.pattern) bump("major", "pattern changed: " + k);
+  });
+
+  currKeys.forEach((k) => {
+    if (!(k in prev.params)) {
+      if (curr.params[k].required) bump("major", "new REQUIRED param: " + k);
+      else bump("minor", "new optional param: " + k);
+    }
+  });
+
+  // Any non-structural diff (template/purpose) is detected by the caller via
+  // the catalogVersion hash; here, if nothing above fired, it's at most patch.
+  return { class: cls, reasons };
+}
+
+/* Diff baseline lock vs current catalog snapshot.
+ * Returns { violations: [{name, msg}], added: [], removed: [] }. */
+function diffCatalog(lock, current) {
+  const violations = [];
+  const added = [];
+  const removed = [];
+
+  Object.keys(lock).forEach((name) => {
+    if (!(name in current)) {
+      removed.push(name);
+      violations.push({ name, msg: 'primitive "' + name + '" REMOVED — breaking (major) catalog change. Acknowledge: update catalog.lock.json and note it as breaking.' });
+    }
+  });
+
+  Object.keys(current).forEach((name) => {
+    if (!(name in lock)) { added.push(name); return; } // new primitive = minor, allowed
+    const prev = lock[name], curr = current[name];
+    const { class: cls, reasons } = classifyChange(prev, curr);
+    const c = cmpSemver(curr.version, prev.version);
+
+    if (cls === "major" && !(parseSemver(curr.version).major > parseSemver(prev.version).major)) {
+      violations.push({ name, msg: '"' + name + '" needs a MAJOR bump (was ' + prev.version + ", now " + curr.version + "). Reason(s): " + reasons.join("; ") });
+    } else if (cls === "minor") {
+      const pv = parseSemver(prev.version), cv = parseSemver(curr.version);
+      const okMinor = cv.major > pv.major || (cv.major === pv.major && cv.minor > pv.minor);
+      if (!okMinor) violations.push({ name, msg: '"' + name + '" needs at least a MINOR bump (was ' + prev.version + ", now " + curr.version + "). Reason(s): " + reasons.join("; ") });
+    } else if (cls === "patch") {
+      if (c !== null && c <= 0) violations.push({ name, msg: '"' + name + '" changed but version not bumped (still ' + curr.version + ")." });
+    }
+    // class "none": no contract change; version may stay or move, no constraint.
+  });
+
+  return { violations, added, removed };
+}
+
+module.exports = { snapshotPrimitive, snapshotCatalog, classifyChange, diffCatalog, parseSemver, cmpSemver };

package/src/compiler/catalog.js

@@ -0,0 +1,94 @@
+"use strict";
+/*
+ * Primitive-Katalog — Laden + Meta-Schema + Versionierung
+ *
+ * Audit-Befund #8 (2026-06-12): Primitive-Dateien sind selbst eine
+ * Vertrauensgrenze. Jede Datei wird beim Laden gegen ein Meta-Schema
+ * geprueft (fail-closed): Groessen-Limits, Pflichtfelder, erlaubte
+ * paramSchema-Typen und ReDoS-Screening fuer pattern-Felder.
+ *
+ * catalogVersion = Hash ueber alle Primitiv-Definitionen -> Cache-Schluessel
+ * invalidiert automatisch bei jeder Katalog-Aenderung (auch Patches).
+ */
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+
+const MAX_FILE_BYTES = 64 * 1024;
+const MAX_TEMPLATE_CHARS = 4096;
+const MAX_PATTERN_CHARS = 100;
+const NAME_RE = /^[A-Za-z][A-Za-z0-9]{1,40}$/;
+const PARAM_TYPES = ["number", "string", "boolean", "transform"];
+const OUTPUTS = ["js", "css"];
+/* ReDoS-Heuristik: verschachtelte Quantifizierer wie (a+)+ oder (a*)* */
+const NESTED_QUANTIFIER_RE = /\([^)]*[+*][^)]*\)\s*[+*{]/;
+
+function screenPattern(pat, where, fail) {
+  if (typeof pat !== "string") fail(where + ": pattern muss ein String sein.");
+  if (pat.length > MAX_PATTERN_CHARS) fail(where + ": pattern zu lang (>" + MAX_PATTERN_CHARS + ").");
+  if (NESTED_QUANTIFIER_RE.test(pat)) fail(where + ": pattern enthaelt verschachtelte Quantifizierer (ReDoS-Risiko).");
+  try { new RegExp(pat); } catch (e) { fail(where + ": pattern ist kein gueltiger regulaerer Ausdruck (" + e.message + ")."); }
+}
+
+function checkPrimitive(p, file) {
+  const fail = (msg) => { throw new Error("Katalog abgelehnt (" + file + "): " + msg); };
+  if (typeof p !== "object" || p === null || Array.isArray(p)) fail("kein Objekt");
+  if (!NAME_RE.test(p.name || "")) fail("name fehlt oder verletzt " + NAME_RE);
+  if (typeof p.version !== "string" || !/^\d+\.\d+\.\d+$/.test(p.version)) fail("version fehlt oder ist kein SemVer.");
+  if (OUTPUTS.indexOf(p.output) === -1) fail('output muss "js" oder "css" sein.');
+  if (typeof p.template !== "string" || !p.template) fail("template fehlt.");
+  if (p.template.length > MAX_TEMPLATE_CHARS) fail("template zu lang (>" + MAX_TEMPLATE_CHARS + ").");
+  const ps = p.paramSchema || {};
+  if (typeof ps !== "object" || ps === null) fail("paramSchema muss ein Objekt sein.");
+  Object.keys(ps).forEach((k) => {
+    const def = ps[k];
+    if (typeof def !== "object" || def === null) fail('paramSchema.' + k + " muss ein Objekt sein.");
+    if (PARAM_TYPES.indexOf(def.type) === -1) fail('paramSchema.' + k + ".type unzulaessig (erlaubt: " + PARAM_TYPES.join(", ") + ").");
+    if (def.pattern !== undefined) screenPattern(def.pattern, "paramSchema." + k, fail);
+  });
+  return p;
+}
+
+/* Phase C / C3: reiner Katalog-Bau aus bereits geparsten Primitiv-Objekten
+ * (kein fs) — damit der Cloudflare Worker den gebundelten Katalog mit exakt
+ * derselben Validierung + demselben Pin erzeugt wie loadCatalog().  Reihenfolge
+ * egal: catalogVersion() sortiert nach Namen. */
+function buildCatalog(primitives) {
+  const cat = {};
+  primitives.forEach((p, i) => {
+    checkPrimitive(p, (p && p.name) ? p.name : ("#" + i));
+    if (cat[p.name]) throw new Error("Doppeltes Primitiv: " + p.name);
+    cat[p.name] = p;
+  });
+  return cat;
+}
+
+function loadCatalog(dir) {
+  const d = dir || path.join(__dirname, "..", "..", "primitives");
+  const cat = {};
+  fs.readdirSync(d)
+    .filter((f) => f.endsWith(".json"))
+    .sort()
+    .forEach((f) => {
+      const full = path.join(d, f);
+      const stat = fs.statSync(full);
+      if (stat.size > MAX_FILE_BYTES) throw new Error("Katalog abgelehnt (" + f + "): Datei zu gross (>" + MAX_FILE_BYTES + " Bytes).");
+      let p;
+      try { p = JSON.parse(fs.readFileSync(full, "utf8")); }
+      catch (e) { throw new Error("Katalog abgelehnt (" + f + "): kein gueltiges JSON (" + e.message + ").", { cause: e }); }
+      checkPrimitive(p, f);
+      if (cat[p.name]) throw new Error("Doppeltes Primitiv: " + p.name);
+      cat[p.name] = p;
+    });
+  return cat;
+}
+
+function catalogVersion(catalog) {
+  const stable = JSON.stringify(
+    Object.keys(catalog).sort().map((k) => catalog[k])
+  );
+  return crypto.createHash("sha256").update(stable).digest("hex").slice(0, 16);
+}
+
+module.exports = { loadCatalog, buildCatalog, catalogVersion, checkPrimitive };