@emeryld/rrroutes-export 1.0.3 → 1.0.5

package/README.md

@@ -2,9 +2,138 @@
 
 Export helpers and CLI for RRRoutes finalized leaves.
 
-- Runtime API: `exportFinalizedLeaves`, `writeFinalizedLeavesExport`
-- CLI: `rrroutes-export-finalized-leaves`
-- Schema utilities: `serializeLeafContract`, `flattenLeafSchemas`, `introspectSchema`
+## What this package provides
+
+- Runtime API:
+  - `exportFinalizedLeaves`
+  - `writeFinalizedLeavesExport`
+  - `exportFinalizedLeavesChangelog`
+  - `writeFinalizedLeavesChangelogExport`
+- CLI:
+  - `rrroutes-export-finalized-leaves`
+  - `rrroutes-export-changelog`
+- Schema utilities:
+  - `serializeLeafContract`
+  - `flattenLeafSchemas`
+  - `introspectSchema`
 
 Depends on `@emeryld/rrroutes-contract` for contract types and schema parsing.
 This package is configured to install `@emeryld/rrroutes-contract` from npm (not from the local workspace) to ensure release-version parity.
+
+## Finalized leaves export CLI
+
+Command:
+
+```bash
+rrroutes-export-finalized-leaves \
+  --module ./path/to/leaves-module.cjs \
+  --export leaves \
+  --out ./finalized-leaves.export.json \
+  --with-source \
+  --tsconfig ./tsconfig.json
+```
+
+Settings:
+
+- `--module <path>`: required. Path to the module that exports your leaves/registry.
+- `--export <name>`: optional. Export name to load from the module. Default: `leaves`.
+- `--out <path>`: optional. JSON output file path. Default: `finalized-leaves.export.json`.
+- `--with-source`: optional flag. Enables AST source extraction (`sourceByLeaf`).
+- `--tsconfig <path>`: optional. TS config used by source extraction.
+
+## Changelog export CLI
+
+Command:
+
+```bash
+rrroutes-export-changelog \
+  --module ./path/to/leaves-module.cjs \
+  --export leaves \
+  --from v1.4.0 \
+  --to HEAD \
+  --out ./finalized-leaves.changelog.json \
+  --html ./finalized-leaves.changelog.viewer.html \
+  --tsconfig ./tsconfig.json
+```
+
+Settings:
+
+- `--module <path>`: required. Module path used for per-commit snapshots.
+- `--export <name>`: optional. Export name in the module. Default: `leaves`.
+- `--from <rev>`: optional. Baseline revision/tag. Default: last reachable semver tag.
+- `--to <rev>`: optional. End revision/tag. Default: `HEAD`.
+- `--out <path>`: optional. Changelog JSON output. Default: `finalized-leaves.changelog.json`.
+- `--html <path>`: optional. Baked HTML viewer for changelog payload.
+- `--tsconfig <path>`: optional. TS config used for source extraction in snapshots.
+- `--with-source`: accepted for parity; changelog mode always enables source extraction.
+
+Behavior summary:
+
+- Resolves commit path from `from..to` (chronological).
+- Filters commits to those touching module tree/relevant config files.
+- Ensures tip commit is always included.
+- Creates a temp git worktree per selected commit.
+- Exports snapshots, then computes adjacent diffs:
+  - route events (`route_added`, `route_removed`, `schema_changed`, `cfg_changed`)
+  - source-object events (`source_object_added`, `source_object_removed`, `source_schema_changed`)
+
+## Recommended end-to-end script
+
+Use this when you want one command to produce everything (snapshot + changelog + HTML + summary + timestamped storage).
+
+Script command:
+
+```bash
+pnpm --filter @emeryld/rrroutes-export run export:bundle -- \
+  --module ./src/contract/leaves.cjs \
+  --export leaves \
+  --tsconfig ./tsconfig.json \
+  --from v1.4.0 \
+  --to HEAD \
+  --dir ./.rrroutes-exports
+```
+
+Bundle script settings (`scripts/export-release-bundle.ts`):
+
+- `--module <path>`: required.
+- `--export <name>`: optional. Default: `leaves`.
+- `--tsconfig <path>`: optional.
+- `--from <rev>`: optional.
+- `--to <rev>`: optional.
+- `--dir <path>`: optional base directory for stored bundles. Default: `.rrroutes-exports`.
+
+Per run, it writes a timestamped directory:
+
+- `finalized-leaves.export.json`
+- `finalized-leaves.viewer.html`
+- `finalized-leaves.changelog.json`
+- `finalized-leaves.changelog.viewer.html`
+- `summary.json`
+
+This is the recommended CI/release flow because outputs are immutable per run and easy to archive.
+
+## Runtime API (quick example)
+
+```ts
+import {
+  exportFinalizedLeaves,
+  exportFinalizedLeavesChangelog,
+} from '@emeryld/rrroutes-export'
+
+const snapshot = await exportFinalizedLeaves(leaves, {
+  outFile: './finalized-leaves.export.json',
+  htmlFile: './finalized-leaves.viewer.html',
+  includeSource: true,
+  sourceModulePath: './src/contract/leaves.cjs',
+  sourceExportName: 'leaves',
+})
+
+const changelog = await exportFinalizedLeavesChangelog({
+  modulePath: './src/contract/leaves.cjs',
+  exportName: 'leaves',
+  from: 'v1.4.0',
+  to: 'HEAD',
+  outFile: './finalized-leaves.changelog.json',
+  htmlFile: './finalized-leaves.changelog.viewer.html',
+})
+```

package/bin/rrroutes-export-changelog.mjs

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+import { runExportFinalizedLeavesChangelogCli } from '../dist/index.mjs'
+
+runExportFinalizedLeavesChangelogCli(process.argv.slice(2))
+  .then(({ payload, outFile }) => {
+    process.stdout.write(
+      `Exported changelog for ${payload.commits.length} commits to ${outFile}\n`,
+    )
+  })
+  .catch((error) => {
+    process.stderr.write(
+      `${error instanceof Error ? error.message : String(error)}\n`,
+    )
+    process.exitCode = 1
+  })

package/dist/defaultViewerTemplate.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_VIEWER_TEMPLATE = "<!doctype html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"UTF-8\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\" />\n    <title>Finalized Leaves Viewer</title>\n    <style>\n      :root {\n        --bg: #212121;\n        --surface: #2a2a2a;\n        --border: #4a4a4a;\n        --text: #fffafa;\n        --muted: #c8c2c2;\n        --accent: #a764d3;\n        --schema-accent: #fbbd23;\n      }\n      body {\n        margin: 0;\n        font-family: 'Iosevka Web', 'SFMono-Regular', Menlo, Consolas, monospace;\n        color: var(--text);\n        background: var(--bg);\n      }\n      a { color: var(--schema-accent); }\n      .wrap { max-width: 1100px; margin: 0 auto; padding: 20px; }\n      .card { background: var(--surface); border: 1px solid var(--border); border-radius: 12px; padding: 14px; }\n      .meta { color: var(--muted); font-size: 12px; }\n      #results { margin-top: 12px; display: grid; gap: 8px; }\n      details { background: var(--surface); border: 1px solid var(--border); border-radius: 10px; padding: 8px 10px; }\n      summary { cursor: pointer; font-weight: 700; color: var(--accent); }\n      pre { margin: 10px 0 0; overflow: auto; border: 1px solid var(--border); border-radius: 8px; padding: 10px; background: #303030; color: var(--text); }\n    </style>\n  </head>\n  <body>\n    <div class=\"wrap\">\n      <h1>Finalized Leaves Viewer (Baked)</h1>\n      <div class=\"card\">\n        <div id=\"status\" class=\"meta\">Waiting for baked payload...</div>\n      </div>\n      <div id=\"results\"></div>\n    </div>\n\n    <!--__FINALIZED_LEAVES_BAKED_PAYLOAD__-->\n\n    <script>\n      const statusEl = document.getElementById('status')\n      const resultsEl = document.getElementById('results')\n      const payload = window.__FINALIZED_LEAVES_PAYLOAD\n\n      if (payload && payload.kind === 'finalized-leaves-changelog') {\n        statusEl.textContent =\n          'Loaded changelog payload with ' + (payload.commits?.length || 0) + ' commits.'\n\n        const wrapSection = (title, value) => {\n          const card = document.createElement('details')\n          const summary = document.createElement('summary')\n          summary.textContent = title\n          const pre = document.createElement('pre')\n          pre.textContent = JSON.stringify(value, null, 2)\n          card.appendChild(summary)\n          card.appendChild(pre)\n          return card\n        }\n\n        resultsEl.appendChild(wrapSection('Commits', payload.commits || []))\n        resultsEl.appendChild(wrapSection('By Route', payload.byRoute || {}))\n        resultsEl.appendChild(\n          wrapSection('By Source Object', payload.bySourceObject || {}),\n        )\n      } else if (!payload || !Array.isArray(payload.leaves)) {\n        statusEl.textContent = 'No baked payload found in this HTML file.'\n      } else {\n        statusEl.textContent =           'Loaded baked payload with ' + payload.leaves.length + ' routes.'\n\n        const toHref = (source) => {\n          if (!source || !source.file) return null\n          const normalizedPath = String(source.file).replace(/\\\\/g, '/')\n          const platform =\n            (navigator.userAgentData && navigator.userAgentData.platform) ||\n            navigator.platform ||\n            ''\n          const isWindows = /win/i.test(platform)\n          const vscodePath = isWindows\n            ? normalizedPath.replace(/^\\/+/, '')\n            : normalizedPath.startsWith('/')\n              ? normalizedPath\n              : '/' + normalizedPath\n          const line = Number.isFinite(source.line) ? source.line : 1\n          const column = Number.isFinite(source.column) ? source.column : 1\n          return 'vscode://file/' + encodeURI(vscodePath) + ':' + line + ':' + column\n        }\n\n        const sourceDisplay = (source) => {\n          return ''\n        }\n\n        payload.leaves.forEach((leaf) => {\n          const details = document.createElement('details')\n          const summary = document.createElement('summary')\n          summary.textContent = String(leaf.method || '').toUpperCase() + ' ' + (leaf.path || '')\n\n          const pre = document.createElement('pre')\n          pre.textContent = JSON.stringify(leaf, null, 2)\n\n          const source = payload.sourceByLeaf && payload.sourceByLeaf[leaf.key]\n          let sourceWrap = null\n          if (source) {\n            sourceWrap = document.createElement('div')\n            sourceWrap.className = 'meta'\n\n            const definitionHref = toHref(source.definition)\n            if (definitionHref) {\n              const label = document.createElement('div')\n              const link = document.createElement('a')\n              link.href = definitionHref\n              link.target = '_blank'\n              link.rel = 'noopener noreferrer'\n              link.textContent = 'definition'\n              label.appendChild(link)\n              sourceWrap.appendChild(label)\n            }\n\n            if (source.schemas && typeof source.schemas === 'object') {\n              Object.entries(source.schemas).forEach(([name, schema]) => {\n                if (!schema) return\n                const href = toHref(schema)\n                const row = document.createElement('div')\n                if (href) {\n                  const link = document.createElement('a')\n                  link.href = href\n                  link.target = '_blank'\n                  link.rel = 'noopener noreferrer'\n                  link.textContent =\n                    name + ': ' + (schema.sourceName || schema.tag || '<anonymous>')\n                  row.appendChild(link)\n                } else {\n                  row.textContent = name + ': ' + (schema.sourceName || schema.tag || '<anonymous>')\n                }\n                sourceWrap.appendChild(row)\n              })\n            }\n\n          }\n\n          details.appendChild(summary)\n          if (sourceWrap) details.appendChild(sourceWrap)\n          details.appendChild(pre)\n          resultsEl.appendChild(details)\n        })\n      }\n    </script>\n  </body>\n</html>\n";

package/dist/exportFinalizedLeaves.changelog.cli.d.ts

@@ -0,0 +1,15 @@
+export type FinalizedLeavesChangelogCliArgs = {
+    modulePath: string;
+    exportName: string;
+    outFile: string;
+    htmlFile?: string;
+    tsconfigPath?: string;
+    from?: string;
+    to?: string;
+};
+export declare function parseFinalizedLeavesChangelogCliArgs(argv: string[]): FinalizedLeavesChangelogCliArgs;
+export declare function runExportFinalizedLeavesChangelogCli(argv: string[]): Promise<{
+    payload: import("./exportFinalizedLeaves.changelog").FinalizedLeavesChangelogExport;
+    outFile: string;
+    htmlFile: string | undefined;
+}>;

package/dist/exportFinalizedLeaves.changelog.d.ts

@@ -0,0 +1,145 @@
+import { type ExportFinalizedLeavesOptions, type FinalizedLeavesExport, type WriteFinalizedLeavesExportOptions } from './exportFinalizedLeaves';
+import type { FlatSchemaEntry, FlatSchemaMap } from './flattenSchema';
+declare const CHANGESET_CFG_FIELDS: readonly ["summary", "description", "tags", "deprecated", "stability", "docsGroup", "docsHidden", "feed"];
+declare const SCHEMA_SECTIONS: readonly ["params", "query", "body", "output"];
+type ChangelogSchemaSection = (typeof SCHEMA_SECTIONS)[number];
+type RouteCfgSubset = Partial<Record<(typeof CHANGESET_CFG_FIELDS)[number], unknown>>;
+type SourceIdentity = {
+    id: string;
+    displayName: string;
+    file?: string;
+    line?: number;
+    column?: number;
+    tag?: string;
+    sourceName?: string;
+};
+type RouteSnapshot = {
+    key: string;
+    method: string;
+    path: string;
+    cfg: RouteCfgSubset;
+    flatSchema: FlatSchemaMap;
+    sourceBySection: Partial<Record<ChangelogSchemaSection, SourceIdentity>>;
+};
+type SourceObjectSectionSnapshot = Record<string, string[]>;
+type SourceObjectSnapshot = {
+    id: string;
+    displayName: string;
+    routeKeys: string[];
+    sections: Record<ChangelogSchemaSection, SourceObjectSectionSnapshot>;
+};
+type CommitSnapshot = {
+    commit: ChangelogCommit;
+    routesByKey: Record<string, RouteSnapshot>;
+    sourceObjectsById: Record<string, SourceObjectSnapshot>;
+};
+type DiffOp = 'added' | 'removed' | 'changed';
+export type SchemaPathDelta = {
+    path: string;
+    op: DiffOp;
+    before?: FlatSchemaEntry;
+    after?: FlatSchemaEntry;
+};
+export type RouteCfgFieldDelta = {
+    field: (typeof CHANGESET_CFG_FIELDS)[number];
+    before?: unknown;
+    after?: unknown;
+};
+export type SourceSchemaPathDelta = {
+    section: ChangelogSchemaSection;
+    path: string;
+    op: DiffOp;
+    before?: string[];
+    after?: string[];
+};
+export type ChangelogCommit = {
+    sha: string;
+    authorDate: string;
+    subject: string;
+};
+export type RouteChangeType = 'route_added' | 'route_removed' | 'schema_changed' | 'cfg_changed';
+export type SourceObjectChangeType = 'source_object_added' | 'source_object_removed' | 'source_schema_changed';
+export type RouteChangeEvent = {
+    type: RouteChangeType;
+    commitSha: string;
+    routeKey: string;
+    method?: string;
+    path?: string;
+    schemaDiff?: SchemaPathDelta[];
+    cfgDiff?: RouteCfgFieldDelta[];
+};
+export type SourceObjectChangeEvent = {
+    type: SourceObjectChangeType;
+    commitSha: string;
+    sourceObjectId: string;
+    displayName: string;
+    impactedRoutes: string[];
+    schemaDiff?: SourceSchemaPathDelta[];
+    routeAdded?: string[];
+    routeRemoved?: string[];
+};
+export type ChangelogRollups = {
+    route: Record<RouteChangeType, number>;
+    sourceObject: Record<SourceObjectChangeType, number>;
+    byCommit: Record<string, {
+        routeEvents: number;
+        sourceEvents: number;
+    }>;
+};
+export type FinalizedLeavesChangelogExport = {
+    kind: 'finalized-leaves-changelog';
+    _meta: {
+        generatedAt: string;
+        description: string;
+        modulePath: string;
+        exportName: string;
+        from: string;
+        to: string;
+        selectedCommitCount: number;
+    };
+    commits: ChangelogCommit[];
+    byRoute: Record<string, RouteChangeEvent[]>;
+    bySourceObject: Record<string, SourceObjectChangeEvent[]>;
+    rollups: ChangelogRollups;
+};
+export type ExportFinalizedLeavesChangelogOptions = {
+    modulePath: string;
+    exportName?: string;
+    tsconfigPath?: string;
+    from?: string;
+    to?: string;
+    outFile?: string;
+    htmlFile?: string;
+    viewerTemplateFile?: string;
+    openOnFinish?: boolean;
+    includeSource?: boolean;
+    handlers?: ExportFinalizedLeavesOptions['handlers'];
+};
+declare function resolveCommitWindow(cwd: string, from?: string, to?: string): Promise<{
+    from: string;
+    to: string;
+}>;
+declare function resolveCommitPath(cwd: string, fromCommit: string, toCommit: string): Promise<string[]>;
+declare function filterCommits(cwd: string, commits: string[], moduleRel: string, tsconfigRel?: string): Promise<string[]>;
+declare function buildSourceIdentity(section: ChangelogSchemaSection, value: Record<string, unknown>): SourceIdentity;
+declare function toRouteSnapshots(payload: FinalizedLeavesExport): Record<string, RouteSnapshot>;
+declare function toSourceObjectSnapshots(routesByKey: Record<string, RouteSnapshot>): Record<string, SourceObjectSnapshot>;
+declare function diffSnapshots(previous: CommitSnapshot, current: CommitSnapshot): {
+    routeEvents: RouteChangeEvent[];
+    sourceEvents: SourceObjectChangeEvent[];
+};
+export declare function writeFinalizedLeavesChangelogExport(payload: FinalizedLeavesChangelogExport, outFileOrOptions: string | WriteFinalizedLeavesExportOptions): Promise<{
+    outFile?: string;
+    htmlFile?: string;
+}>;
+export declare function exportFinalizedLeavesChangelog(options: ExportFinalizedLeavesChangelogOptions): Promise<FinalizedLeavesChangelogExport>;
+export declare const __private: {
+    resolveCommitWindow: typeof resolveCommitWindow;
+    resolveCommitPath: typeof resolveCommitPath;
+    filterCommits: typeof filterCommits;
+    toRouteSnapshots: typeof toRouteSnapshots;
+    toSourceObjectSnapshots: typeof toSourceObjectSnapshots;
+    diffSnapshots: typeof diffSnapshots;
+    buildSourceIdentity: typeof buildSourceIdentity;
+};
+export {};

package/dist/exportFinalizedLeaves.cli.d.ts

@@ -0,0 +1,14 @@
+import { type ExportFinalizedLeavesInput } from './exportFinalizedLeaves';
+export type FinalizedLeavesCliArgs = {
+    modulePath: string;
+    exportName: string;
+    outFile: string;
+    withSource: boolean;
+    tsconfigPath?: string;
+};
+export declare function parseFinalizedLeavesCliArgs(argv: string[]): FinalizedLeavesCliArgs;
+export declare function loadFinalizedLeavesInput({ modulePath, exportName, }: FinalizedLeavesCliArgs): Promise<ExportFinalizedLeavesInput>;
+export declare function runExportFinalizedLeavesCli(argv: string[]): Promise<{
+    payload: import("./exportFinalizedLeaves").FinalizedLeavesExport;
+    outFile: string;
+}>;

package/dist/exportFinalizedLeaves.d.ts

@@ -0,0 +1,61 @@
+import type { AnyLeafLowProfile, FinalizedRegistry } from '@emeryld/rrroutes-contract';
+import { type FlatSchemaMap } from './flattenSchema';
+import { type SerializeLeafContractOptions, type SerializedLeafContract } from './serializeLeafContract';
+import { type LeafSourceByKey, type SourceExtractionReason } from './extractLeafSourceByAst';
+export type ExportFinalizedLeavesInput = readonly AnyLeafLowProfile[] | FinalizedRegistry<readonly AnyLeafLowProfile[]>;
+export type ExportFinalizedLeavesMeta = {
+    generatedAt: string;
+    description: string;
+    sourceExtraction?: {
+        mode: 'ast';
+        enabled: boolean;
+        modulePath?: string;
+        exportName?: string;
+        tsconfigPath?: string;
+        resolvedLeafCount: number;
+        reason?: SourceExtractionReason;
+        stats?: {
+            visitedSymbols: number;
+            visitedFiles: number;
+            unresolvedReferences: number;
+        };
+    };
+    fieldCatalog: {
+        leaf: string[];
+        cfg: string[];
+        schemaNode: string[];
+        flatSchemaEntry: string[];
+    };
+    flattening: {
+        notation: 'dot+[]';
+        unionBranchSuffix: '-N';
+        sections: readonly ['params', 'query', 'body', 'output'];
+    };
+};
+export type FinalizedLeavesExport = {
+    _meta: ExportFinalizedLeavesMeta;
+    leaves: SerializedLeafContract[];
+    schemaFlatByLeaf: Record<string, FlatSchemaMap>;
+    sourceByLeaf?: LeafSourceByKey;
+};
+export type ExportFinalizedLeavesOptions = SerializeLeafContractOptions & {
+    outFile?: string;
+    htmlFile?: string;
+    viewerTemplateFile?: string;
+    openOnFinish?: boolean;
+    includeSource?: boolean;
+    tsconfigPath?: string;
+    sourceModulePath?: string;
+    sourceExportName?: string;
+};
+export type WriteFinalizedLeavesExportOptions = {
+    outFile?: string;
+    htmlFile?: string;
+    viewerTemplateFile?: string;
+    openOnFinish?: boolean;
+};
+export declare function writeFinalizedLeavesExport(payload: FinalizedLeavesExport, outFileOrOptions: string | WriteFinalizedLeavesExportOptions): Promise<{
+    outFile?: string;
+    htmlFile?: string;
+}>;
+export declare function exportFinalizedLeaves(input: ExportFinalizedLeavesInput, options?: ExportFinalizedLeavesOptions): Promise<FinalizedLeavesExport>;

package/dist/extractLeafSourceByAst.d.ts

@@ -0,0 +1,38 @@
+declare const SCHEMA_KEYS: readonly ["bodySchema", "querySchema", "paramsSchema", "outputSchema", "outputMetaSchema", "queryExtensionSchema"];
+export type SourceExtractionReason = 'module_not_in_program' | 'export_not_found' | 'unsupported_expression_shape' | 'resolved_zero_leaves';
+type SchemaKey = (typeof SCHEMA_KEYS)[number];
+export type LeafSourceLocation = {
+    file: string;
+    line: number;
+    column: number;
+};
+export type SchemaSourceMetadata = LeafSourceLocation & {
+    sourceName?: string;
+    tag?: '<inline>' | '<anonymous>' | '<expression>';
+};
+export type LeafSourceMetadata = {
+    definition: LeafSourceLocation & {
+        symbolName?: string;
+    };
+    schemas: Partial<Record<SchemaKey, SchemaSourceMetadata>>;
+};
+export type LeafSourceByKey = Record<string, LeafSourceMetadata>;
+export type ExtractLeafSourceByAstOptions = {
+    modulePath: string;
+    exportName: string;
+    tsconfigPath?: string;
+    cwd?: string;
+};
+export type ExtractLeafSourceByAstStats = {
+    visitedSymbols: number;
+    visitedFiles: number;
+    unresolvedReferences: number;
+};
+export type ExtractLeafSourceByAstResult = {
+    sourceByLeaf: LeafSourceByKey;
+    tsconfigPath?: string;
+    reason?: SourceExtractionReason;
+    stats: ExtractLeafSourceByAstStats;
+};
+export declare function extractLeafSourceByAst({ modulePath, exportName, tsconfigPath, cwd, }: ExtractLeafSourceByAstOptions): ExtractLeafSourceByAstResult;
+export {};

package/dist/flattenSchema.d.ts

@@ -0,0 +1,12 @@
+import type { AnyLeafLowProfile } from '@emeryld/rrroutes-contract';
+import { type SerializedLeafContract } from './serializeLeafContract';
+import type { SerializableSchema } from './schemaIntrospection';
+export type FlatSchemaEntry = {
+    type: string;
+    nullable: boolean;
+    optional: boolean;
+    literal?: unknown;
+};
+export type FlatSchemaMap = Record<string, FlatSchemaEntry>;
+export declare function flattenSerializableSchema(schema: SerializableSchema | undefined, path: string): FlatSchemaMap;
+export declare function flattenLeafSchemas(leaf: AnyLeafLowProfile | SerializedLeafContract): FlatSchemaMap;