@dialecte/create 0.0.1

package/README.md

@@ -0,0 +1,88 @@
+# @dialecte/create
+
+Scaffold and generate [Dialecte](https://github.com/dialecte) SDKs from an XSD schema.
+
+The XSD-to-TypeScript generator is written in Python but runs inside Node via
+[Pyodide](https://pyodide.org/) (WebAssembly), so **end users do not need Python
+installed**. Pure-Python dependencies are vendored as wheels and installed
+offline at runtime.
+
+## Quick start
+
+Scaffold a brand-new dialecte package from a schema:
+
+```sh
+npm create @dialecte -- ./my-schema.xsd --name @acme/widget
+```
+
+> `npm create @dialecte` resolves to the `@dialecte/create` package. The `--`
+> separator is required so npm forwards the schema path and flags to the CLI
+> instead of consuming them itself.
+
+Or just regenerate definition files into an existing package:
+
+```sh
+npx @dialecte/create generate --entry ./my-schema.xsd --out-dir ./src/v1/definition
+```
+
+## Commands
+
+### `create <schema.xsd>`
+
+Scaffolds a new dialecte package (built on `@dialecte/core`) and generates its
+element definitions from the schema in one step.
+
+| Option                 | Default                       | Description                    |
+| ---------------------- | ----------------------------- | ------------------------------ |
+| `--name <pkg>`         | `@dialecte/<schema basename>` | npm package name               |
+| `--out <dir>`          | `./<dialecte id>`             | target directory               |
+| `--version <vN>`       | `v1`                          | version folder name            |
+| `--namespace <uri>`    | `urn:dialecte:<id>`           | default XML namespace URI      |
+| `--core-version <ver>` | `^0.2.19`                     | `@dialecte/core` version range |
+
+The generated package includes:
+
+- Hydrated type aliases bound to your config (`Dialecte.Project`, `Dialecte.Query`, ...)
+- A project factory (`create<Name>Project`)
+- Test hydration utilities wired to `@dialecte/core/test`
+- VitePress documentation scaffolding
+
+### `generate`
+
+Generates only the three definition files
+(`definition.generated.ts`, `constants.generated.ts`, `types.generated.ts`).
+
+| Option                 | Description                 |
+| ---------------------- | --------------------------- |
+| `--entry <schema.xsd>` | entry XSD file (required)   |
+| `--out-dir <dir>`      | output directory (required) |
+
+## Bring your own XSD
+
+This package does **not** bundle IEC or other proprietary schemas. Point it at
+your own `.xsd` file. Optional sidecar files next to the entry XSD are honored:
+
+- `parent-mapping.json` - declares parents for orphan (wildcard) elements
+- `attribute-mapping.json` - injects extension-namespace attributes
+
+## Development
+
+The generator engine is a Python package under `python/`. Develop and test it
+with native Python (fast loop), then ship it to users via WebAssembly.
+
+```sh
+# Engine (Python) tests
+cd python && python -m pytest
+
+# Vendor the runtime wheels (network required; run once / on dep bump)
+npm run vendor
+
+# Build the Node CLI
+npm run build
+
+# Try it
+node dist/cli/index.js generate --entry ./xsd/SCL/IEC61850-6-100.xsd --out-dir .tmp/out
+```
+
+`xsd/` and `local/` are git-ignored: they hold local-only schemas and the
+maintainer's batch generation script.

package/dist/cli/index.js

@@ -0,0 +1,281 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { existsSync as existsSync2 } from "fs";
+import { basename as basename2, resolve as resolve4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/cli/pyodide-runner.ts
+import { readdir, mkdir } from "fs/promises";
+import { dirname as dirname2, basename, resolve as resolve2 } from "path";
+
+// src/cli/paths.ts
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+var here = dirname(fileURLToPath(import.meta.url));
+var PACKAGE_ROOT = resolve(here, "..", "..");
+var PYTHON_ENGINE_DIR = resolve(PACKAGE_ROOT, "python");
+var VENDOR_DIR = resolve(PACKAGE_ROOT, "vendor");
+var TEMPLATES_DIR = resolve(PACKAGE_ROOT, "templates");
+
+// src/cli/pyodide-runner.ts
+import { loadPyodide } from "pyodide";
+var pyodidePromise;
+function fs(py) {
+  return py.FS;
+}
+async function getPyodide(quiet) {
+  if (!pyodidePromise) {
+    pyodidePromise = loadPyodide({
+      stdout: quiet ? () => {
+      } : (msg) => console.log(msg),
+      stderr: (msg) => console.error(msg)
+    });
+  }
+  return pyodidePromise;
+}
+async function mountReadOnly(py, mountPoint, hostRoot) {
+  const f = fs(py);
+  try {
+    f.mkdir(mountPoint);
+  } catch {
+  }
+  f.mount(f.filesystems.NODEFS, { root: hostRoot }, mountPoint);
+}
+async function listWheels() {
+  const entries = await readdir(VENDOR_DIR);
+  return entries.filter((f) => f.endsWith(".whl"));
+}
+async function runGenerator(options) {
+  const { entry, outDir, quiet = false } = options;
+  const entryAbs = resolve2(entry);
+  const outAbs = resolve2(outDir);
+  const entryDir = dirname2(entryAbs);
+  const entryName = basename(entryAbs);
+  await mkdir(outAbs, { recursive: true });
+  const py = await getPyodide(quiet);
+  await mountReadOnly(py, "/engine", PYTHON_ENGINE_DIR);
+  await mountReadOnly(py, "/vendor", VENDOR_DIR);
+  const wheels = await listWheels();
+  if (wheels.length === 0) {
+    throw new Error(
+      `No vendored wheels found in ${VENDOR_DIR}. Run "npm run vendor" to download them.`
+    );
+  }
+  const wheelPaths = JSON.stringify(wheels.map((w) => `/vendor/${w}`));
+  await mountReadOnly(py, "/in", entryDir);
+  await mountReadOnly(py, "/out", outAbs);
+  const argv = JSON.stringify(["--entry", `/in/${entryName}`, "--out-dir", "/out"]);
+  await py.runPythonAsync(`
+import sys, os, zipfile
+
+site_dir = '/site-packages'
+if not os.path.isdir(site_dir):
+    os.makedirs(site_dir, exist_ok=True)
+    for wheel in ${wheelPaths}:
+        with zipfile.ZipFile(wheel) as zf:
+            zf.extractall(site_dir)
+
+if site_dir not in sys.path:
+    sys.path.insert(0, site_dir)
+if '/engine' not in sys.path:
+    sys.path.insert(0, '/engine')
+
+from generate.__main__ import main
+main(${argv})
+`);
+  const f = fs(py);
+  f.unmount("/in");
+  f.unmount("/out");
+  f.rmdir("/in");
+  f.rmdir("/out");
+}
+
+// src/cli/scaffold.ts
+import { existsSync } from "fs";
+import { readdir as readdir2, mkdir as mkdir2, readFile, writeFile, rm } from "fs/promises";
+import { join, resolve as resolve3 } from "path";
+function dialecteIdFromPackageName(packageName) {
+  const last = packageName.split("/").pop() ?? packageName;
+  return last.replace(/[^a-zA-Z0-9]+/g, "").toLowerCase();
+}
+function buildReplacements(options) {
+  const dialecteId = dialecteIdFromPackageName(options.packageName);
+  const DialecteName = dialecteId.charAt(0).toUpperCase() + dialecteId.slice(1);
+  const DIALECTE_NAME = dialecteId.toUpperCase();
+  return {
+    packageName: options.packageName,
+    dialecteId,
+    DialecteName,
+    DIALECTE_NAME,
+    version: options.version,
+    namespaceUri: options.namespaceUri,
+    coreVersion: options.coreVersion
+  };
+}
+function applyReplacements(text, r) {
+  return text.replaceAll("__packageName__", r.packageName).replaceAll("__DIALECTE_NAME__", r.DIALECTE_NAME).replaceAll("__DialecteName__", r.DialecteName).replaceAll("__dialecteId__", r.dialecteId).replaceAll("__version__", r.version).replaceAll("__namespaceUri__", r.namespaceUri).replaceAll("__coreVersion__", r.coreVersion);
+}
+function applyPathReplacements(path, r) {
+  const replaced = path.replaceAll("__version__", r.version);
+  return replaced.replace(/(^|\/)_gitignore$/, "$1.gitignore");
+}
+async function copyTemplateTree(srcDir, destDir, r) {
+  const entries = await readdir2(srcDir, { withFileTypes: true });
+  await mkdir2(destDir, { recursive: true });
+  for (const entry of entries) {
+    const srcPath = join(srcDir, entry.name);
+    const destName = applyPathReplacements(entry.name, r);
+    const destPath = join(destDir, destName);
+    if (entry.isDirectory()) {
+      await copyTemplateTree(srcPath, destPath, r);
+      continue;
+    }
+    if (entry.name === ".gitkeep") continue;
+    const raw = await readFile(srcPath, "utf8");
+    await writeFile(destPath, applyReplacements(raw, r), "utf8");
+  }
+}
+async function scaffoldDialecte(options) {
+  const targetDir = resolve3(options.targetDir);
+  const templateRoot = join(TEMPLATES_DIR, "dialecte");
+  if (existsSync(targetDir)) {
+    const remaining = await readdir2(targetDir);
+    if (remaining.length > 0) {
+      throw new Error(`Target directory is not empty: ${targetDir}`);
+    }
+  }
+  const replacements = buildReplacements(options);
+  console.log(`Scaffolding ${options.packageName} -> ${targetDir}`);
+  await copyTemplateTree(templateRoot, targetDir, replacements);
+  const definitionDir = join(targetDir, "src", options.version, "definition");
+  console.log(`Generating definitions from ${options.entry}`);
+  await runGenerator({ entry: options.entry, outDir: definitionDir });
+  await rm(join(definitionDir, ".gitkeep"), { force: true });
+  console.log("");
+  console.log("Done. Next steps:");
+  console.log(`  cd ${options.targetDir}`);
+  console.log("  npm install");
+  console.log("  npm run build");
+}
+
+// src/cli/index.ts
+var DEFAULT_CORE_VERSION = "^0.2.19";
+var DEFAULT_VERSION = "v1";
+function parseArgs(argv) {
+  const _ = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = argv[i + 1];
+      if (next === void 0 || next.startsWith("--")) {
+        flags[key] = true;
+      } else {
+        flags[key] = next;
+        i++;
+      }
+    } else {
+      _.push(arg);
+    }
+  }
+  return { _, flags };
+}
+function printHelp() {
+  console.log(`@dialecte/create - scaffold and generate Dialecte SDKs from XSD
+
+Usage:
+  create-dialecte create <schema.xsd> [options]   Scaffold a new dialecte package
+  create-dialecte generate [options]              Generate definition files only
+  create-dialecte <schema.xsd>                    Shorthand for "create"
+
+create options:
+  --name <pkg>           npm package name (default: @dialecte/<schema basename>)
+  --out <dir>            target directory (default: ./<dialecte id>)
+  --version <vN>         version folder name (default: ${DEFAULT_VERSION})
+  --namespace <uri>      default XML namespace URI (default: derived placeholder)
+  --core-version <ver>   @dialecte/core version range (default: ${DEFAULT_CORE_VERSION})
+
+generate options:
+  --entry <schema.xsd>   entry XSD file (required)
+  --out-dir <dir>        output directory for generated .ts files (required)
+
+  -h, --help             show this help
+`);
+}
+async function runGenerateCommand(flags) {
+  const entry = typeof flags.entry === "string" ? flags.entry : void 0;
+  const outDir = typeof flags["out-dir"] === "string" ? flags["out-dir"] : void 0;
+  if (!entry || !outDir) {
+    throw new Error("generate requires --entry <schema.xsd> and --out-dir <dir>");
+  }
+  if (!existsSync2(resolve4(entry))) {
+    throw new Error(`XSD file not found: ${entry}`);
+  }
+  await runGenerator({ entry, outDir });
+}
+async function runCreateCommand(positionals, flags) {
+  const entry = positionals[0];
+  if (!entry) {
+    throw new Error("create requires a path to an XSD schema: create-dialecte create <schema.xsd>");
+  }
+  if (!existsSync2(resolve4(entry))) {
+    throw new Error(`XSD file not found: ${entry}`);
+  }
+  const schemaBase = basename2(entry).replace(/\.xsd$/i, "");
+  const packageName = typeof flags.name === "string" ? flags.name : `@dialecte/${schemaBase.toLowerCase()}`;
+  const dialecteId = dialecteIdFromPackageName(packageName);
+  const version = typeof flags.version === "string" ? flags.version : DEFAULT_VERSION;
+  const namespaceUri = typeof flags.namespace === "string" ? flags.namespace : `urn:dialecte:${dialecteId}`;
+  const coreVersion = typeof flags["core-version"] === "string" ? flags["core-version"] : DEFAULT_CORE_VERSION;
+  const targetDir = typeof flags.out === "string" ? flags.out : positionals[1] ?? `./${dialecteId}`;
+  await scaffoldDialecte({
+    entry,
+    targetDir,
+    packageName,
+    version,
+    namespaceUri,
+    coreVersion
+  });
+  if (typeof flags.namespace !== "string") {
+    console.log("");
+    console.log(
+      `Note: default namespace set to "${namespaceUri}". Update src/${version}/config/namespaces.ts if needed.`
+    );
+  }
+}
+async function main(argv = process.argv.slice(2)) {
+  const { _, flags } = parseArgs(argv);
+  if (flags.help || flags.h || _.length === 0 && Object.keys(flags).length === 0) {
+    printHelp();
+    return;
+  }
+  const command = _[0];
+  if (command === "generate") {
+    await runGenerateCommand(flags);
+    return;
+  }
+  if (command === "create") {
+    await runCreateCommand(_.slice(1), flags);
+    return;
+  }
+  if (command && command.toLowerCase().endsWith(".xsd")) {
+    await runCreateCommand(_, flags);
+    return;
+  }
+  printHelp();
+  throw new Error(`Unknown command: ${command ?? "(none)"}`);
+}
+var invokedDirectly = process.argv[1] !== void 0 && resolve4(process.argv[1]) === fileURLToPath2(import.meta.url);
+if (invokedDirectly) {
+  main().catch((err) => {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  });
+}
+export {
+  main,
+  runGenerator,
+  scaffoldDialecte
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+	"name": "@dialecte/create",
+	"version": "0.0.1",
+	"description": "Scaffold and generate Dialecte SDKs from an XSD schema. Runs the Python generator in WebAssembly - no Python required.",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/dialecte/create.git"
+	},
+	"type": "module",
+	"bin": {
+		"create-dialecte": "./dist/cli/index.js"
+	},
+	"files": [
+		"dist",
+		"templates",
+		"vendor",
+		"python/generate",
+		"python/pyproject.toml",
+		"README.md"
+	],
+	"engines": {
+		"node": ">=20"
+	},
+	"scripts": {
+		"build": "tsup",
+		"dev": "tsup --watch",
+		"start": "node dist/cli/index.js",
+		"vendor": "node scripts/vendor-wheels.mjs",
+		"test:py": "cd python && python -m pytest",
+		"test:cli": "node scripts/smoke.mjs",
+		"prepack": "find python -name __pycache__ -type d -prune -exec rm -rf {} + 2>/dev/null || true",
+		"prepublishOnly": "npm run vendor && npm run build"
+	},
+	"dependencies": {
+		"pyodide": "^0.27.2"
+	},
+	"devDependencies": {
+		"@types/node": "^22.0.0",
+		"tsup": "^8.5.1",
+		"typescript": "^5.6.0"
+	}
+}

package/python/generate/__init__.py

@@ -0,0 +1 @@
+# XSD to TypeScript generation package

package/python/generate/__main__.py

@@ -0,0 +1,103 @@
+"""CLI entry point: python -m generate --entry <xsd> --out-dir <dir>"""
+import argparse
+import sys
+from pathlib import Path
+
+import xmlschema
+
+from generate.collector import collect
+from generate.deriver import derive_graph, derive_identity_fields, derive_root_element, derive_singleton_elements
+from generate.emitters.constants import emit_constants
+from generate.emitters.definition import emit_definition
+from generate.emitters.types import emit_types
+from generate.globals import inject_mapped_attributes, load_attr_mapping
+from generate.orphans import detect_orphans, inject_orphan_parents, load_parent_mapping
+from generate.xsi_type import XsiTypeExpander
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        description='Generate TypeScript definition files from XSD schemas.',
+    )
+    parser.add_argument(
+        '--entry',
+        type=Path,
+        required=True,
+        help='Path to the entry XSD file (e.g. IEC61850-6-100.xsd)',
+    )
+    parser.add_argument(
+        '--out-dir',
+        type=Path,
+        required=True,
+        help='Output directory for generated .ts files',
+    )
+    args = parser.parse_args(argv)
+
+    entry: Path = args.entry
+    out_dir: Path = args.out_dir
+
+    if not entry.exists():
+        print(f'Error: XSD file not found: {entry}', file=sys.stderr)
+        sys.exit(1)
+
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    # Phase 1: Parse
+    print(f'Loading schema: {entry}')
+    schema = xmlschema.XMLSchema(str(entry))
+
+    # Phase 2: Collect
+    print('Collecting elements...')
+    expander = XsiTypeExpander(schema)
+    elements = collect(schema, expander=expander)
+    print(f'  Found {len(elements)} elements')
+
+    # Phase 2b: Orphan injection
+    mapping = load_parent_mapping(entry)
+    # Determine root before injection so orphans don't compete
+    roots = sorted(n for n, e in elements.items() if not e.parents)
+    root_candidate = max(roots, key=lambda n: len(elements[n].children)) if roots else None
+
+    orphans_injected = 0
+    unmapped_count = 0
+    if mapping:
+        orphans = detect_orphans(elements, root_candidate or '')
+        if orphans:
+            unmapped = inject_orphan_parents(elements, mapping, root_name=root_candidate or '')
+            orphans_injected = len(orphans) - len(unmapped)
+            unmapped_count = len(unmapped)
+            for name in unmapped:
+                print(f'  WARNING: unmapped orphan element: {name}', file=sys.stderr)
+
+    # Phase 2c: Mapped attribute injection (attribute-mapping.json sidecar)
+    attr_mapping = load_attr_mapping(entry)
+    mapped_attrs_injected = inject_mapped_attributes(schema, elements, attr_mapping)
+    if mapped_attrs_injected:
+        print(f'  Mapped attributes injected: {mapped_attrs_injected}')
+
+    # Phase 3: Derive
+    print('Deriving graphs...')
+    descendants, ancestors = derive_graph(elements)
+    root_element = derive_root_element(elements, override=root_candidate)
+    singleton_elements = derive_singleton_elements(elements, root_element)
+    identity_fields = derive_identity_fields(elements)
+    for name, fields in identity_fields.items():
+        elements[name].identity_fields = fields
+    print(f'  Root: {root_element}')
+    print(f'  Singletons: {len(singleton_elements)}')
+
+    # Phase 4: Emit
+    def_path = out_dir / 'definition.generated.ts'
+    const_path = out_dir / 'constants.generated.ts'
+    types_path = out_dir / 'types.generated.ts'
+
+    print('Emitting files...')
+    emit_definition(elements, def_path)
+    emit_constants(elements, descendants, ancestors, root_element, singleton_elements, const_path)
+    emit_types(elements, types_path)
+
+    print(f'  {def_path}')
+    print(f'  {const_path}')
+    print(f'  {types_path}')
+    warnings = f', {unmapped_count} unmapped warnings' if unmapped_count else ', 0 unmapped warnings'
+    print(f'Done. {len(elements)} elements, {orphans_injected} orphans injected{warnings}, ROOT={root_element}')
+if __name__ == '__main__':
+    main()

package/python/generate/collector.py

@@ -0,0 +1,128 @@
+"""Collector — recursive walk of XSD schema into ElementDef IR.
+
+Phase 2 of the pipeline: Parse → **Collect** → Derive → Emit.
+"""
+from typing import Any
+
+from generate.extractors.attributes import extract_attributes
+from generate.extractors.children import extract_children, extract_choices, extract_text_content, iter_child_elements
+from generate.extractors.constraints import extract_constraints
+from generate.extractors.docs import extract_docs
+from generate.extractors.namespace import extract_namespace
+from generate.ir import ElementDef
+from generate.xsi_type import XsiTypeExpander
+def collect(schema: Any, expander: XsiTypeExpander | None = None) -> dict[str, ElementDef]:
+    """Walk all elements across all schemas (root + imported/included) into a flat IR dict.
+
+    When *expander* is provided, abstract-typed element slots are additionally enriched
+    with their ``xsi:type`` substitution variants (children/attributes unioned in, and
+    variant-only children walked for recursion). When omitted, behaviour is unchanged.
+
+    xmlschema API:
+      XMLSchemaBase.elements: NamespaceView — global elements of this schema
+      XMLSchemaBase.includes: dict[str, XMLSchemaBase] — included schemas
+      XMLSchemaBase.imports: dict[str, XMLSchemaBase | None] — imported schemas
+    """
+    elements: dict[str, ElementDef] = {}
+
+    def walk(xsd_elem: Any, parent_name: str | None = None, visited: set[int] | None = None) -> None:
+        if visited is None:
+            visited = set()
+
+        name = getattr(xsd_elem, 'local_name', None)
+        if not name:
+            return
+
+        # Already seen this element by tag name — always add parent link first,
+        # then id-guard the recursion to prevent infinite loops.
+        if name in elements:
+            existing = elements[name]
+            if parent_name and parent_name not in existing.parents:
+                existing.parents.append(parent_name)
+            if expander is not None:
+                expander.expand(
+                    xsd_elem,
+                    existing.attr_sequence,
+                    existing.attributes,
+                    existing.child_sequence,
+                    existing.children,
+                )
+            elem_id = id(xsd_elem)
+            if elem_id in visited:
+                return
+            visited.add(elem_id)
+            # Still recurse into children to discover deeper elements
+            for child_xsd in iter_child_elements(xsd_elem):
+                walk(child_xsd, parent_name=name, visited=visited)
+            if expander is not None:
+                for child_xsd in expander.iter_variant_child_elements(xsd_elem):
+                    walk(child_xsd, parent_name=name, visited=visited)
+            return
+
+        elem_id = id(xsd_elem)
+        if elem_id in visited:
+            return
+        visited.add(elem_id)
+
+        attr_seq, attr_any, attrs = extract_attributes(xsd_elem)
+        child_seq, child_any, children = extract_children(xsd_elem)
+
+        if expander is not None:
+            expander.expand(xsd_elem, attr_seq, attrs, child_seq, children)
+
+        elements[name] = ElementDef(
+            tag=name,
+            namespace=extract_namespace(xsd_elem),
+            documentation=extract_docs(xsd_elem),
+            parents=[parent_name] if parent_name else [],
+            attr_sequence=attr_seq,
+            attr_any=attr_any,
+            attributes=attrs,
+            child_sequence=child_seq,
+            child_any=child_any,
+            children=children,
+            choices=extract_choices(xsd_elem),
+            constraints=extract_constraints(xsd_elem),
+            text_content=extract_text_content(xsd_elem),
+        )
+
+        for child_xsd in iter_child_elements(xsd_elem):
+            walk(child_xsd, parent_name=name, visited=visited)
+        if expander is not None:
+            for child_xsd in expander.iter_variant_child_elements(xsd_elem):
+                walk(child_xsd, parent_name=name, visited=visited)
+
+    # Walk imported/included schemas FIRST so standard elements (e.g. scl:LNode)
+    # are registered with their canonical namespace before the root extension
+    # schema re-declares them as local elements (e.g. eIEC61850-6-100:LNode).
+    for sub_schema in _iter_sub_schemas(schema):
+        for root_elem in sub_schema.elements.values():
+            walk(root_elem)
+
+    # Walk root schema's global elements (adds extension elements + parent links)
+    for root_elem in schema.elements.values():
+        walk(root_elem)
+
+    return elements
+def _iter_sub_schemas(schema: Any):
+    """Yield all imported and included schemas.
+
+    xmlschema API:
+      XMLSchemaBase.includes: dict[str, XMLSchemaBase]
+      XMLSchemaBase.imports: dict[str, XMLSchemaBase | None]
+    """
+    seen: set[int] = set()
+
+    includes = getattr(schema, 'includes', None) or {}
+    if hasattr(includes, 'values'):
+        for included in includes.values():
+            if included is not None and id(included) not in seen:
+                seen.add(id(included))
+                yield included
+
+    imports = getattr(schema, 'imports', None) or {}
+    if hasattr(imports, 'values'):
+        for imported in imports.values():
+            if imported is not None and id(imported) not in seen:
+                seen.add(id(imported))
+                yield imported