mosaic-headless 1.2.0

package/tools/copy_styles.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+"""Copy one node's style object onto other nodes, by attrID.
+
+    python copy_styles.py --config sweep.json --from mk-svc-0 --to mk-svc-1,mk-svc-2
+    python copy_styles.py --config sweep.json --from mk-svc-0 --to-prefix mk-svc-
+    python copy_styles.py --config sweep.json --from mk-svc-0 --to-prefix mk-svc- --dry-run
+    python copy_styles.py --config sweep.json --from a --to b --only "&._m"
+
+Why this exists
+---------------
+There is no "paste style" in the data model. A node's appearance lives in
+`data.style`, and the only way to give twenty rows the same treatment is to write the
+same object twenty times - which is exactly how a page drifts, because the twenty-
+first gets edited and the rest do not.
+
+This reads the source node's `style` straight out of its document and writes it to
+each target, so what lands is what the source has, not what a spec file thinks the
+source has.
+
+  --only takes `state.breakpoint` selectors and copies just those slices, so you can
+  push a corrected `_m` across a row of siblings without touching their desktop
+  styles. `&._m` is the base state's mobile breakpoint; `&.*` is every breakpoint of
+  the base state; `hover.*` is the whole hover state.
+
+Always shows the diff and asks, unless --yes. A style copy is not reversible from
+this tool - the previous value is gone once the commit lands - so it prints the
+before and after of every target first.
+"""
+import argparse
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from sweep_node_types import Client, envelopes, exceptions_of, unwrap  # noqa: E402
+
+
+def documents(client, cfg):
+    """Every document on the theme that can hold nodes, newest master first."""
+    tei = unwrap(client.get("adminTemplateEditorInstance"), "adminTemplateEditorInstance")
+    seen, out = set(), []
+    for tpl in reversed(tei.get("template", [])):
+        master = tpl["masterID"]
+        if master not in seen:
+            seen.add(master)
+            out.append(("masterDocumentInstance/%s" % master,
+                        "node/master/%s" % master))
+        out.append(("templateDocumentInstance/%s/%s" % (master, tpl["ID"]),
+                    "node/template/%s" % tpl["ID"]))
+    return out
+
+
+def find(client, cfg, attrs):
+    """attrID -> (instance, key, node, whole document). One pass over the theme."""
+    found = {}
+    for instance, key in documents(client, cfg):
+        doc = client.get(instance)
+        if "_httperror" in doc:
+            continue
+        doc = unwrap(doc, instance.split("/")[0])
+        for node in doc.get(key, []):
+            a = (node.get("data") or {}).get("attrID")
+            if a in attrs and a not in found:
+                found[a] = (instance, key, node, doc)
+        if len(found) == len(attrs):
+            break
+    return found
+
+
+def slice_style(style, only):
+    """Keep just the state.breakpoint slices named by --only."""
+    if not only:
+        return style
+    out = {}
+    for sel in only.split(","):
+        sel = sel.strip()
+        state, _, bp = sel.partition(".")
+        if state not in (style or {}):
+            continue
+        if bp in ("", "*"):
+            out[state] = style[state]
+        elif bp in style[state]:
+            out.setdefault(state, {})[bp] = style[state][bp]
+    return out
+
+
+def merge(dst, src):
+    """State-and-breakpoint-wise merge, so a partial copy leaves the rest alone."""
+    out = json.loads(json.dumps(dst or {}))
+    for state, bps in (src or {}).items():
+        out.setdefault(state, {})
+        for bp, props in bps.items():
+            out[state][bp] = props
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--config", required=True)
+    ap.add_argument("--from", dest="src", required=True, help="source attrID")
+    ap.add_argument("--to", help="comma-separated target attrIDs")
+    ap.add_argument("--to-prefix", help="every attrID starting with this, except the source")
+    ap.add_argument("--only", help="state.breakpoint slices, e.g. '&._m' or 'hover.*'")
+    ap.add_argument("--replace", action="store_true",
+                    help="overwrite the target style instead of merging into it")
+    ap.add_argument("--dry-run", action="store_true")
+    ap.add_argument("--yes", action="store_true")
+    a = ap.parse_args()
+
+    cfg = json.load(open(a.config, encoding="utf-8"))
+    client = Client(cfg)
+
+    if a.to_prefix:
+        wanted = None       # resolved after scanning, since we need every attrID
+    elif a.to:
+        wanted = {x.strip() for x in a.to.split(",") if x.strip()}
+    else:
+        sys.exit("give --to or --to-prefix")
+
+    # one pass collecting everything, so a prefix match does not need a second scan
+    catalogue = {}
+    for instance, key in documents(client, cfg):
+        doc = client.get(instance)
+        if "_httperror" in doc:
+            continue
+        doc = unwrap(doc, instance.split("/")[0])
+        for node in doc.get(key, []):
+            attr = (node.get("data") or {}).get("attrID")
+            if attr and attr not in catalogue:
+                catalogue[attr] = (instance, key, node, doc)
+
+    if a.src not in catalogue:
+        sys.exit("source attrID not found on this theme: %s" % a.src)
+    if wanted is None:
+        wanted = {k for k in catalogue if k.startswith(a.to_prefix) and k != a.src}
+        if not wanted:
+            sys.exit("no attrID starts with %r" % a.to_prefix)
+
+    missing = wanted - set(catalogue)
+    if missing:
+        print("not found, skipping: %s" % ", ".join(sorted(missing)))
+    targets = sorted(wanted & set(catalogue))
+    if not targets:
+        sys.exit("nothing to write")
+
+    src_style = ((catalogue[a.src][2].get("data") or {}).get("style") or {})
+    src_states = src_style.get("states", src_style)
+    payload = slice_style(src_states, a.only)
+    if not payload:
+        sys.exit("the source has nothing matching --only %r" % a.only)
+
+    print("copying from %s:" % a.src)
+    print("  " + json.dumps(payload, ensure_ascii=False)[:400])
+    print()
+
+    # group the writes by document, because each one commits separately
+    by_doc = {}
+    for attr in targets:
+        instance, key, node, doc = catalogue[attr]
+        dst_style = ((node.get("data") or {}).get("style") or {})
+        dst_states = dst_style.get("states", dst_style)
+        new_states = payload if a.replace else merge(dst_states, payload)
+        before = json.dumps(dst_states, ensure_ascii=False)
+        after = json.dumps(new_states, ensure_ascii=False)
+        print("  %-22s %s" % (attr, "unchanged" if before == after else "CHANGES"))
+        if before != after:
+            print("      before %s" % (before[:150] or "{}"))
+            print("      after  %s" % after[:150])
+        if before != after:
+            by_doc.setdefault((instance, key), []).append((node, doc, new_states))
+
+    if a.dry_run:
+        print("\ndry run, nothing written")
+        return
+    if not by_doc:
+        print("\nnothing to change")
+        return
+    if not a.yes:
+        try:
+            if input("\nwrite these? [y/N] ").strip().lower() not in ("y", "yes"):
+                print("aborted")
+                return
+        except EOFError:
+            sys.exit("no tty; pass --yes to write without confirming")
+
+    written = 0
+    for (instance, key), items in by_doc.items():
+        doc = items[0][1]
+        records = []
+        for node, _doc, new_states in items:
+            updated = json.loads(json.dumps(node))
+            updated.setdefault("data", {})["style"] = {"states": new_states}
+            records.append({"newRevisionRecord": updated, "originalRevisionRecord": node})
+        resp = client.commit(instance, envelopes(doc), {key: records})
+        err = exceptions_of(resp)
+        if err:
+            print("  %s: REJECTED %s" % (key, err[:200]))
+            continue
+        written += len(records)
+    print("\nwrote %d node(s)" % written)
+
+
+if __name__ == "__main__":
+    main()

package/tools/extract_default_children.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""Extract the required internal structure of Mosaic's composite node types.
+
+    python extract_default_children.py <path-to-mosaic-plugin-root> <out-data-dir>
+
+Writes default-children.csv.
+
+## Why this is a separate table from placement-rules.csv
+
+`canBeParentFor()` answers "will the editor let me drop this in here". It does NOT
+describe what a composite type needs inside it to work. `accordion-item` is the proof:
+
+    canBeParentFor  -> accordion-item | accordion-loop-items      (nothing useful)
+    default children -> accordion-title, accordion-content        (what it actually needs)
+
+Build an accordion-item without a title and the page still renders - but Mosaic's own
+Accordion.js throws `Cannot read properties of null (reading 'addEventListener')` in the
+browser, because the title is the element it binds the click handler to. Nothing on the
+server side complains. This table is where that requirement is written down.
+
+The source of truth is the `get<Something>DefaultData()` static on each type factory,
+which is what the editor calls when you insert one of these from the UI.
+"""
+import csv
+import os
+import re
+import sys
+
+RE_DEFAULT = re.compile(
+    r"function\s+get\w*DefaultData\s*\([^)]*\)\s*:\s*object\s*\{(.*?)\n    \}", re.S
+)
+RE_TYPE = re.compile(r'"type"\s*=>\s*"([^"]+)"')
+RE_CHILD_CALL = re.compile(r"(\w+)ElementTypeFactory::get(\w+)DefaultData|(\w+)NodeTypeFactory::get(\w+)DefaultData")
+
+
+def read(path):
+    with open(path, encoding="utf-8", errors="replace") as fh:
+        return fh.read()
+
+
+def extract(plugin_root, out_dir):
+    node_root = os.path.join(plugin_root, "Mosaic", "NodeTypes")
+    if not os.path.isdir(node_root):
+        sys.exit("no Mosaic/NodeTypes under %s" % plugin_root)
+
+    # factory class stem -> slug, so a child call can be reported as a node type
+    stem_to_slug = {}
+    files = []
+    for dirpath, _dirs, names in os.walk(node_root):
+        for fn in sorted(names):
+            if fn.endswith("TypeFactory.php"):
+                path = os.path.join(dirpath, fn)
+                src = read(path)
+                files.append((path, src))
+                ctor = re.search(r"parent::__construct\s*\(\s*\$\w+\s*,\s*'([^']+)'", src)
+                stem = fn.replace("ElementTypeFactory.php", "").replace("NodeTypeFactory.php", "")
+                if ctor:
+                    stem_to_slug[stem] = ctor.group(1)
+
+    rows = []
+    for path, src in files:
+        for body in RE_DEFAULT.findall(src):
+            owner = RE_TYPE.search(body)
+            if not owner:
+                continue
+            children = []
+            for m in RE_CHILD_CALL.finditer(body):
+                stem = m.group(1) or m.group(3)
+                children.append(stem_to_slug.get(stem, stem.lower()))
+            if not children:
+                continue
+            rows.append({
+                "type": owner.group(1),
+                "default_children": "|".join(children),
+                "child_count": len(children),
+                "declared_in": os.path.relpath(path, plugin_root).replace(os.sep, "/"),
+            })
+
+    rows.sort(key=lambda r: r["type"])
+    os.makedirs(out_dir, exist_ok=True)
+    out = os.path.join(out_dir, "default-children.csv")
+    with open(out, "w", newline="", encoding="utf-8") as fh:
+        w = csv.DictWriter(fh, fieldnames=["type", "default_children", "child_count", "declared_in"])
+        w.writeheader()
+        w.writerows(rows)
+    print("composite types with a declared default structure: %d" % len(rows))
+    for r in rows:
+        print("  %-26s -> %s" % (r["type"], r["default_children"]))
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        sys.exit(__doc__)
+    extract(sys.argv[1], sys.argv[2])

package/tools/extract_dynamic_variables.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Extract the dynamic-variable namespace: every `@VAR('namespace/name')` Mosaic resolves.
+
+    python extract_dynamic_variables.py <path-to-mosaic-plugin-root> <out-data-dir>
+
+Writes dynamic-variables.csv.
+
+This is Mosaic's answer to Elementor's dynamic tags, and the syntax is not guessable:
+a bare identifier does nothing (`Evaluator` literally returns the string
+"Identifiers are not used currently" for one), and the resolvable name is a
+`namespace/name` pair passed as a STRING argument to the `VAR` function:
+
+    @VAR('post/title')                                 -> the post's title
+    @concat('[', @VAR('post/title'), '] #', @VAR('post/id'))
+    @fallback(@VAR('post/nope'), 'DEFAULTED')
+
+`@VAR_RAW(...)` is the same lookup without HTML-escaping - the evaluator escapes
+untrusted (request-derived) values at the interpolation point, and VAR_RAW opts out.
+
+Namespaces come from `setNamespace(...)` on the variable providers; the names under
+each come from `setName(...)` in the schema each provider defines. A provider is only
+registered when its context exists, so `post/*` resolves on a post/page template and
+not on, say, a bare archive - an unresolvable name yields an empty string rather than
+an error, which is why `@fallback()` exists.
+"""
+import csv
+import os
+import re
+import sys
+
+RE_NAMESPACE = re.compile(r"setNamespace\('([^']+)'\)")
+RE_NAME = re.compile(r"setName\('([^']+)'\)")
+RE_SHORT_LABEL = re.compile(r"setShortLabelCallback\(fn\(\)\s*:\s*string\s*=>\s*__\('([^']*)'")
+RE_LABEL = re.compile(r"setLabelCallback\(fn\(\)\s*:\s*string\s*=>\s*__\('([^']*)'")
+
+
+def read(path):
+    with open(path, encoding="utf-8", errors="replace") as fh:
+        return fh.read()
+
+
+def extract(plugin_root, out_dir):
+    root = os.path.join(plugin_root, "Mosaic")
+    files = []
+    for dirpath, _dirs, names in os.walk(root):
+        for fn in sorted(names):
+            if fn.endswith(".php"):
+                files.append(os.path.join(dirpath, fn))
+
+    # namespace -> the files that declare it, so names can be attributed
+    namespaces = {}
+    for path in files:
+        src = read(path)
+        for ns in RE_NAMESPACE.findall(src):
+            namespaces.setdefault(ns, []).append(path)
+
+    rows, seen = [], set()
+    for path in files:
+        src = read(path)
+        declared = RE_NAMESPACE.findall(src)
+        if not declared:
+            continue
+        # a file usually declares one namespace and the names beside it; when it
+        # declares several, the attribution is ambiguous and is recorded as such
+        ns = declared[0] if len(declared) == 1 else "|".join(sorted(set(declared)))
+        rel = os.path.relpath(path, plugin_root).replace(os.sep, "/")
+        for m in RE_NAME.finditer(src):
+            name = m.group(1)
+            key = (ns, name)
+            if key in seen:
+                continue
+            seen.add(key)
+            tail = src[m.end(): m.end() + 400]
+            label = RE_SHORT_LABEL.search(tail) or RE_LABEL.search(tail)
+            rows.append({
+                "expression": "@VAR('%s/%s')" % (ns, name) if "|" not in ns else "",
+                "namespace": ns, "name": name,
+                "label": label.group(1) if label else "",
+                "declared_in": rel,
+            })
+
+    # schema helpers declare names without their own setNamespace; attribute those to
+    # the namespace whose provider includes them, by directory proximity
+    rows.sort(key=lambda r: (r["namespace"], r["name"]))
+    os.makedirs(out_dir, exist_ok=True)
+    with open(os.path.join(out_dir, "dynamic-variables.csv"), "w", newline="", encoding="utf-8") as fh:
+        w = csv.DictWriter(fh, fieldnames=["expression", "namespace", "name", "label", "declared_in"])
+        w.writeheader()
+        w.writerows(rows)
+
+    by_ns = {}
+    for r in rows:
+        by_ns.setdefault(r["namespace"], []).append(r["name"])
+    print("dynamic variables: %d across %d namespaces" % (len(rows), len(by_ns)))
+    for ns in sorted(by_ns):
+        print("  %-22s %2d  %s" % (ns, len(by_ns[ns]), ", ".join(by_ns[ns][:8])))
+    print("\nnamespaces with no names found in the same file (schema declared elsewhere):")
+    print("  " + ", ".join(sorted(set(namespaces) - set(by_ns))) or "  none")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        sys.exit(__doc__)
+    extract(sys.argv[1], sys.argv[2])

package/tools/extract_interactions.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""Extract Mosaic's interaction surface: trigger types, action types, animatable properties.
+
+    python extract_interactions.py <path-to-mosaic-plugin-root> <out-data-dir>
+
+Writes interaction-types.csv and animatable-properties.csv.
+
+Interactions are Mosaic's JavaScript animation system, separate from the CSS
+transition/hover path. A node carries `data.interactions`, an array of trigger
+definitions, each holding action slots, each holding actions, each holding a timeline
+of keyframes. See references/interactions.md for how far that is verified.
+
+The animatable-property list matters on its own: it is NOT the same set as the 98
+style properties. Only these 22 can be driven by an interaction keyframe, and several
+of them animate through a CSS custom property (`--mosaic-translate-y` and friends)
+rather than the CSS property itself.
+"""
+import csv
+import os
+import re
+import sys
+
+RE_PREDEFINED = re.compile(
+    r"_addPropertyMetaOption\(\s*new\s+(\w+)KeyframePropertyMetaOption\("
+    r"[^)]*?(?:,\s*'([^']+)'\s*(?:,\s*'([^']+)')?)?\s*\)", re.S
+)
+RE_SETID = re.compile(r"->setID\('([^']+)'\)")
+RE_LABEL = re.compile(r"setLabelCallback\(fn\(\)\s*:\s*string\s*=>\s*__\('([^']*)'")
+RE_DESC = re.compile(r"setDescriptionCallback\(fn\(\)\s*:\s*string\s*=>\s*__\('([^']*)'")
+
+
+def read(path):
+    with open(path, encoding="utf-8", errors="replace") as fh:
+        return fh.read()
+
+
+def extract(plugin_root, out_dir):
+    root = os.path.join(plugin_root, "Mosaic")
+    os.makedirs(out_dir, exist_ok=True)
+
+    # ---- trigger types, grouped by the family that registers them -------------
+    rows = []
+    ix_root = os.path.join(root, "Plugins", "InteractionTypes")
+    for dirpath, _dirs, files in os.walk(ix_root):
+        for fn in sorted(files):
+            if not fn.endswith(".php"):
+                continue
+            path = os.path.join(dirpath, fn)
+            src = read(path)
+            m = RE_SETID.search(src)
+            if not m:
+                continue
+            rel = os.path.relpath(path, plugin_root).replace(os.sep, "/")
+            # the directory under InteractionTypes is the family: timed or progress.
+            # A timed interaction runs on its own clock; a progress one is driven by a
+            # scalar (scroll position, pointer position) and reports timelineKeys.
+            family = rel.split("InteractionTypes/")[1].split("/")[0] if "InteractionTypes/" in rel else ""
+            label = RE_LABEL.search(src)
+            desc = RE_DESC.search(src)
+            rows.append({
+                "id": m.group(1), "family": family,
+                "label": label.group(1) if label else "",
+                "description": desc.group(1) if desc else "",
+                "declared_in": rel,
+            })
+    rows.sort(key=lambda r: (r["family"], r["id"]))
+    with open(os.path.join(out_dir, "interaction-types.csv"), "w", newline="", encoding="utf-8") as fh:
+        w = csv.DictWriter(fh, fieldnames=["id", "family", "label", "description", "declared_in"])
+        w.writeheader()
+        w.writerows(rows)
+    print("interaction trigger types: %d (%s)" % (
+        len(rows), ", ".join(sorted({r["family"] for r in rows if r["family"]}))))
+
+    # ---- animatable properties ------------------------------------------------
+    factory = os.path.join(root, "Builder", "Interactions", "Data", "Keyframe", "PropertyMetas",
+                           "Meta", "Predefined", "PredefinedKeyframePropertyMetaTypeFactory.php")
+    props = []
+    if os.path.exists(factory):
+        for kind, name, custom_prop in RE_PREDEFINED.findall(read(factory)):
+            props.append({
+                "property": name or kind[0].lower() + kind[1:],
+                "kind": kind,
+                # several properties animate a CSS custom property rather than the
+                # CSS property itself, which is why they compose instead of clobbering
+                "animates_via": custom_prop or "(the CSS property)",
+            })
+    with open(os.path.join(out_dir, "animatable-properties.csv"), "w", newline="", encoding="utf-8") as fh:
+        w = csv.DictWriter(fh, fieldnames=["property", "kind", "animates_via"])
+        w.writeheader()
+        w.writerows(props)
+    print("animatable keyframe properties: %d (%d via a custom property)"
+          % (len(props), sum(1 for p in props if p["animates_via"].startswith("--"))))
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        sys.exit(__doc__)
+    extract(sys.argv[1], sys.argv[2])

package/tools/extract_node_types.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""Extract Mosaic's node-type (element) registry and property surface from plugin source.
+
+Usage:
+    python extract_node_types.py <path-to-mosaic-plugin-root> <out-data-dir>
+
+Writes:
+    node-types.csv       one row per registered node type
+    node-properties.csv  one row per (node type, data property)
+
+Mosaic has no runtime endpoint that dumps the element registry, so the registry is
+recovered from the PHP source: every `*TypeFactory.php` under Mosaic/NodeTypes
+registers exactly one type slug via its parent::__construct() call, and the paired
+`*MResourceData*.php` declares that type's own data properties via createData*().
+Inherited properties come from the abstract chain and are emitted under the
+abstract class name so callers can resolve them once instead of per type.
+"""
+import csv
+import os
+import re
+import sys
+
+# parent::__construct($nodeFactoryManager, 'slug', <label expr>)  -- may span lines
+RE_CTOR = re.compile(
+    r"parent::__construct\s*\(\s*\$\w+\s*,\s*'([^']+)'\s*,\s*(.*?)\)\s*;",
+    re.S,
+)
+RE_CLASS = re.compile(r"^\s*(?:final\s+)?(abstract\s+)?class\s+(\w+)\s+extends\s+(\w+)", re.M)
+RE_METHOD_BOOL = re.compile(r"function\s+(\w+)\s*\([^)]*\)\s*:\s*bool\s*\{\s*return\s+(true|false)\s*;", re.S)
+RE_ALIAS = re.compile(r"function\s+getAliasTypes\s*\([^)]*\)\s*:\s*array\s*\{\s*return\s*\[(.*?)\]", re.S)
+RE_DEFAULT_CLASS = re.compile(
+    r"function\s+getDefaultElementClassID\s*\([^)]*\)\s*:\s*string\s*\{\s*return\s+([^;]+);", re.S
+)
+# createDataSimple('name', ... ) / createDataSub / createDataArray / createDataResponsive ...
+RE_CREATE_DATA = re.compile(r"\$this->(createData\w*)\s*\(\s*'([^']+)'", re.S)
+RE_VALIDATOR = re.compile(r"(Validator\w+|ValidateAllowUndefined)")
+RE_OPTS = re.compile(r"'(supportsInherit|isResponsive|supportsState|allowDuplicates)'\s*=>\s*(true|false)")
+# createValidatorAcceptedValues([...]) is Mosaic's enum; the list is the only place
+# the legal values for a property are written down
+RE_ACCEPTED = re.compile(r"createValidatorAcceptedValues\s*\(\s*\[(.*?)\]", re.S)
+RE_LABEL_TEXT = re.compile(r"__\(\s*'([^']*)'")
+RE_RESERVED = re.compile(r"setReservedAttributes\s*\(\s*\[(.*?)\]", re.S)
+
+
+def php_label(expr):
+    m = RE_LABEL_TEXT.search(expr or "")
+    return m.group(1) if m else ""
+
+
+def rel(path, root):
+    return os.path.relpath(path, root).replace(os.sep, "/")
+
+
+def walk(root, suffixes):
+    for dirpath, _dirs, files in os.walk(root):
+        for fn in files:
+            if any(fn.endswith(s) for s in suffixes):
+                yield os.path.join(dirpath, fn)
+
+
+def read(path):
+    with open(path, encoding="utf-8", errors="replace") as fh:
+        return fh.read()
+
+
+def extract(plugin_root, out_dir):
+    node_root = os.path.join(plugin_root, "Mosaic", "NodeTypes")
+    if not os.path.isdir(node_root):
+        sys.exit("no Mosaic/NodeTypes under %s" % plugin_root)
+
+    types = []
+    for path in sorted(walk(node_root, ("TypeFactory.php",))):
+        src = read(path)
+        cls = RE_CLASS.search(src)
+        ctor = RE_CTOR.search(src)
+        if not ctor:
+            continue  # abstract factory with no own slug
+        relpath = rel(path, plugin_root)
+        # the data class declaring this type's own properties sits beside the factory;
+        # node-properties.csv is keyed by that class name, so record it to make the join
+        data_class = ""
+        for sibling in sorted(os.listdir(os.path.dirname(path))):
+            if sibling.endswith("MResourceData.php"):
+                data_class = sibling[:-4]
+                break
+        bools = dict(RE_METHOD_BOOL.findall(src))
+        alias = RE_ALIAS.search(src)
+        aliases = re.findall(r"'([^']+)'", alias.group(1)) if alias else []
+        dflt = RE_DEFAULT_CLASS.search(src)
+        types.append(
+            {
+                "type": ctor.group(1),
+                "label": php_label(ctor.group(2)),
+                "class": cls.group(2) if cls else "",
+                "extends": cls.group(3) if cls else "",
+                "abstract": "yes" if (cls and cls.group(1)) else "no",
+                "edition": "pro" if "/Pro/" in relpath else "free",
+                "alias_types": "|".join(aliases),
+                "is_link": bools.get("isLink", ""),
+                "can_be_parent": bools.get("canBeParentFor", ""),
+                "default_element_class": (dflt.group(1).strip() if dflt else ""),
+                "data_class": data_class,
+                "file": relpath,
+            }
+        )
+
+    props = []
+    for path in sorted(walk(node_root, ("MResourceData.php", "MResourceDataAbstract.php"))):
+        src = read(path)
+        cls = RE_CLASS.search(src)
+        owner = cls.group(2) if cls else os.path.basename(path)[:-4]
+        relpath = rel(path, plugin_root)
+        reserved = RE_RESERVED.search(src)
+        reserved_attrs = re.findall(r"'([^']+)'", reserved.group(1)) if reserved else []
+        for m in RE_CREATE_DATA.finditer(src):
+            tail = src[m.end() : m.end() + 1400]
+            # cut at the next createData call so validators do not bleed across properties
+            nxt = RE_CREATE_DATA.search(tail)
+            if nxt:
+                tail = tail[: nxt.start()]
+            validators = sorted(set(RE_VALIDATOR.findall(tail)))
+            opts = {k: v for k, v in RE_OPTS.findall(tail)}
+            acc = RE_ACCEPTED.search(tail)
+            # constants (MResourceStatus::PUBLISH) sit alongside plain strings; keep
+            # the literal strings and record the constants by their short name
+            accepted = []
+            if acc:
+                accepted = re.findall(r"'([^']+)'", acc.group(1))
+                accepted += [c for c in re.findall(r"\w+::(\w+)", acc.group(1))]
+            props.append(
+                {
+                    "owner_class": owner,
+                    "extends": cls.group(3) if cls else "",
+                    "edition": "pro" if "/Pro/" in relpath else "free",
+                    "creator": m.group(1),
+                    "property": m.group(2),
+                    "validators": "|".join(validators),
+                    "accepted_values": "|".join(accepted),
+                    "supports_inherit": opts.get("supportsInherit", ""),
+                    "is_responsive": opts.get("isResponsive", ""),
+                    "reserved_attributes": "|".join(reserved_attrs),
+                    "file": relpath,
+                }
+            )
+
+    os.makedirs(out_dir, exist_ok=True)
+    write_csv(os.path.join(out_dir, "node-types.csv"), types)
+    write_csv(os.path.join(out_dir, "node-properties.csv"), props)
+    print("node types:      %d (%d pro)" % (len(types), sum(t["edition"] == "pro" for t in types)))
+    print("node properties: %d across %d classes" % (len(props), len({p["owner_class"] for p in props})))
+
+
+def write_csv(path, rows):
+    if not rows:
+        return
+    with open(path, "w", newline="", encoding="utf-8") as fh:
+        w = csv.DictWriter(fh, fieldnames=list(rows[0].keys()))
+        w.writeheader()
+        w.writerows(rows)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        sys.exit(__doc__)
+    extract(sys.argv[1], sys.argv[2])