@oa-sdk/spec-bundler 0.1.0

package/dist/schema.js

@@ -0,0 +1,670 @@
+export const BUNDLE_MANIFEST_SCHEMA = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://spec-platform.org/schemas/bundle-manifest.v1.json",
+    title: "BundleManifest",
+    description: "Declarative configuration schema for @spec-platform/meta-bundler",
+    type: "object",
+    required: ["name", "version", "output", "targets"],
+    properties: {
+        $schema: { type: "string" },
+        name: { type: "string", description: "Identifier name for the bundle" },
+        version: { type: "string", description: "Semantic version of the bundle" },
+        description: { type: "string", description: "Human-readable description" },
+        output: {
+            type: "string",
+            description: "Output zip archive or directory path relative to manifest",
+        },
+        format: {
+            type: "string",
+            enum: ["zip", "directory"],
+            default: "zip",
+            description: "Output bundle format",
+        },
+        targets: {
+            type: "array",
+            description: "List of target file mappings",
+            items: {
+                type: "object",
+                required: ["source", "dest"],
+                properties: {
+                    source: {
+                        type: "string",
+                        description: "Source file path or glob pattern relative to manifest directory",
+                    },
+                    dest: {
+                        type: "string",
+                        description: "Destination directory or file path inside bundle",
+                    },
+                    exclude: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Target-specific exclusion glob patterns",
+                    },
+                },
+                additionalProperties: false,
+            },
+        },
+        exclude: {
+            type: "array",
+            items: { type: "string" },
+            description: "Global exclusion glob patterns",
+        },
+        deduplicate: {
+            type: "object",
+            description: "Deduplication and collision resolution rules",
+            properties: {
+                byPath: {
+                    type: "string",
+                    enum: ["warn-overwrite", "overwrite", "error"],
+                    default: "warn-overwrite",
+                    description: "Collision handling strategy when two sources map to same destination",
+                },
+                byContentHash: {
+                    type: "boolean",
+                    default: true,
+                    description: "Whether to report content hash duplicates",
+                },
+            },
+            additionalProperties: false,
+        },
+        linkResolution: {
+            type: "object",
+            description: "Markdown link rewriting and resolution configuration",
+            properties: {
+                enabled: {
+                    type: "boolean",
+                    default: true,
+                    description: "Whether automatic link resolution is enabled",
+                },
+                rewriteRelativeLinks: {
+                    type: "boolean",
+                    default: true,
+                    description: "Whether to rewrite relative links to bundle coordinates",
+                },
+                normalizeFileSchemes: {
+                    type: "boolean",
+                    default: true,
+                    description: "Whether to normalize file:/// URIs",
+                },
+                unbundledPolicy: {
+                    type: "string",
+                    enum: ["warn", "error", "preserve", "github-fallback"],
+                    default: "warn",
+                    description: "Handling strategy for links pointing to unbundled files",
+                },
+                gitRepositoryUrl: {
+                    type: "string",
+                    description: "Base remote GitHub repository URL for github-fallback policy",
+                },
+            },
+            additionalProperties: false,
+        },
+        treeShake: {
+            type: "object",
+            description: "Declarative tree-shaking reachability configuration",
+            required: ["entrypoints"],
+            properties: {
+                enabled: {
+                    type: "boolean",
+                    default: false,
+                    description: "Whether tree-shaking reachability pruning is enabled",
+                },
+                entrypoints: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Entrypoint files from which reachability traversal begins",
+                },
+                scope: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Boundary scope patterns allowed to be pulled into the bundle",
+                },
+                stopAt: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Terminal boundary patterns where traversal immediately halts",
+                },
+                maxDepth: {
+                    type: "integer",
+                    minimum: 1,
+                    description: "Maximum traversal hop depth from entrypoints",
+                },
+                preserve: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Unconditionally preserved file patterns exempt from tree-shaking pruning",
+                },
+                reportEliminated: {
+                    type: "boolean",
+                    default: true,
+                    description: "Whether to list eliminated files in output report",
+                },
+                traversalMode: {
+                    type: "string",
+                    enum: ["hybrid", "reachability", "explicit"],
+                    default: "hybrid",
+                    description: "Reachability traversal mode: hybrid (preserve targets), reachability, or explicit",
+                },
+                preserveTargets: {
+                    type: "boolean",
+                    default: true,
+                    description: "Whether to unconditionally preserve all declared targets",
+                },
+            },
+            additionalProperties: false,
+        },
+        topics: {
+            type: "object",
+            description: "Declarative named topic profiles for repeatable modular documentation bundling",
+            additionalProperties: {
+                type: "object",
+                required: ["targets"],
+                properties: {
+                    phase: {
+                        type: "string",
+                        enum: ["develop", "fix", "test", "review"],
+                        description: "Work activity lifecycle phase designated for this topic",
+                    },
+                    author: {
+                        type: "string",
+                        description: "Initial worker or author who established this topic definition",
+                    },
+                    description: { type: "string", description: "Human-readable description of the topic" },
+                    output: {
+                        type: "string",
+                        description: "Output zip archive or directory path relative to manifest",
+                    },
+                    format: {
+                        type: "string",
+                        enum: ["zip", "directory"],
+                        description: "Output bundle format",
+                    },
+                    targets: {
+                        type: "array",
+                        description: "List of target file mappings designated for this topic",
+                        items: {
+                            type: "object",
+                            required: ["source", "dest"],
+                            properties: {
+                                source: {
+                                    type: "string",
+                                    description: "Source file path or glob pattern relative to manifest directory",
+                                },
+                                dest: {
+                                    type: "string",
+                                    description: "Destination directory or file path inside bundle",
+                                },
+                                exclude: {
+                                    type: "array",
+                                    items: { type: "string" },
+                                    description: "Target-specific exclusion glob patterns",
+                                },
+                            },
+                            additionalProperties: false,
+                        },
+                    },
+                    exclude: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Topic-specific exclusion glob patterns",
+                    },
+                    deduplicate: {
+                        type: "object",
+                        description: "Deduplication and collision resolution rules",
+                        properties: {
+                            byPath: {
+                                type: "string",
+                                enum: ["warn-overwrite", "overwrite", "error"],
+                                default: "warn-overwrite",
+                            },
+                            byContentHash: {
+                                type: "boolean",
+                                default: true,
+                            },
+                        },
+                        additionalProperties: false,
+                    },
+                    linkResolution: {
+                        type: "object",
+                        description: "Markdown link rewriting and resolution configuration",
+                        properties: {
+                            enabled: { type: "boolean", default: true },
+                            rewriteRelativeLinks: { type: "boolean", default: true },
+                            normalizeFileSchemes: { type: "boolean", default: true },
+                            unbundledPolicy: {
+                                type: "string",
+                                enum: ["warn", "error", "preserve", "github-fallback"],
+                                default: "warn",
+                            },
+                            gitRepositoryUrl: { type: "string" },
+                        },
+                        additionalProperties: false,
+                    },
+                    treeShake: {
+                        type: "object",
+                        description: "Topic-specific tree-shaking and boundary-scoped reachability configuration",
+                        required: ["entrypoints"],
+                        properties: {
+                            enabled: { type: "boolean", default: true },
+                            entrypoints: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Entrypoint files from which reachability traversal begins",
+                            },
+                            scope: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Boundary scope patterns allowed to be pulled into this topic",
+                            },
+                            stopAt: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Terminal boundary patterns where traversal immediately halts",
+                            },
+                            maxDepth: {
+                                type: "integer",
+                                minimum: 1,
+                                description: "Maximum traversal hop depth from entrypoints",
+                            },
+                            preserve: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Unconditionally preserved file patterns exempt from tree-shaking pruning",
+                            },
+                            reportEliminated: {
+                                type: "boolean",
+                                default: true,
+                                description: "Whether to list eliminated files in output report",
+                            },
+                            traversalMode: {
+                                type: "string",
+                                enum: ["hybrid", "reachability", "explicit"],
+                                default: "hybrid",
+                            },
+                            preserveTargets: {
+                                type: "boolean",
+                                default: true,
+                            },
+                        },
+                        additionalProperties: false,
+                    },
+                    scope: {
+                        type: "object",
+                        description: "Declarative extraction scope and domain boundary configuration",
+                        properties: {
+                            entrypoints: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Entrypoint files from which extraction traversal begins",
+                            },
+                            include: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Allowed boundary patterns for documents pulled into this topic",
+                            },
+                            exclude: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Patterns strictly excluded from this topic",
+                            },
+                            stopAt: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Terminal boundary patterns where traversal immediately halts",
+                            },
+                            maxDepth: {
+                                type: "integer",
+                                minimum: 1,
+                                description: "Maximum traversal hop depth from entrypoints",
+                            },
+                            sections: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Section/heading patterns to slice from multi-topic documents",
+                            },
+                            direction: {
+                                type: "string",
+                                enum: ["downstream", "upstream", "bidirectional"],
+                                default: "downstream",
+                                description: "Graph reachability traversal direction",
+                            },
+                            upstreamDepth: {
+                                type: "integer",
+                                minimum: 1,
+                                default: 1,
+                                description: "Maximum traversal depth when traversing upstream",
+                            },
+                            includeCategories: {
+                                type: "array",
+                                items: {
+                                    type: "string",
+                                    enum: ["feature", "mechanism", "error", "issue", "convention"],
+                                },
+                                description: "Document categories permitted in topic bundle",
+                            },
+                            excludeCategories: {
+                                type: "array",
+                                items: {
+                                    type: "string",
+                                    enum: ["feature", "mechanism", "error", "issue", "convention"],
+                                },
+                                description: "Document categories strictly pruned from topic bundle",
+                            },
+                            categoryFidelity: {
+                                type: "object",
+                                description: "Level of detail/fidelity per category or upstream contracts",
+                                properties: {
+                                    feature: { type: "string", enum: ["full", "contract-only", "summary"] },
+                                    mechanism: { type: "string", enum: ["full", "contract-only", "summary"] },
+                                    error: { type: "string", enum: ["full", "contract-only", "summary"] },
+                                    issue: { type: "string", enum: ["full", "contract-only", "summary"] },
+                                    convention: { type: "string", enum: ["full", "contract-only", "summary"] },
+                                    upstream: { type: "string", enum: ["full", "contract-only", "summary"] },
+                                    default: { type: "string", enum: ["full", "contract-only", "summary"] },
+                                },
+                                additionalProperties: false,
+                            },
+                            traversalMode: {
+                                type: "string",
+                                enum: ["hybrid", "reachability", "explicit"],
+                                default: "hybrid",
+                            },
+                            preserveTargets: {
+                                type: "boolean",
+                                default: true,
+                            },
+                        },
+                        additionalProperties: false,
+                    },
+                    context: {
+                        type: "object",
+                        description: "Ambient background context, metadata, prompt, and documentation",
+                        properties: {
+                            description: { type: "string", description: "Context description" },
+                            template: {
+                                type: "string",
+                                description: "Custom CONTEXT.md template file path relative to manifest, or raw template string",
+                            },
+                            domain: { type: "string", description: "Target domain identifier" },
+                            issue: { type: "string", description: "Associated issue/ticket ID" },
+                            tags: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Category tags",
+                            },
+                            prompt: { type: "string", description: "Agent system prompt or developer instructions" },
+                            persona: { type: "string", description: "Target persona or role" },
+                            prerequisites: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Dependent topic names or prerequisites",
+                            },
+                            generateContextDoc: {
+                                type: "boolean",
+                                default: true,
+                                description: "Whether to synthesize CONTEXT.md at bundle root",
+                            },
+                            metadata: {
+                                type: "object",
+                                description: "Arbitrary structured metadata",
+                            },
+                            docs: {
+                                type: "array",
+                                description: "Ambient background context documents",
+                                items: {
+                                    type: "object",
+                                    required: ["source"],
+                                    properties: {
+                                        source: { type: "string", description: "Source path or glob pattern" },
+                                        dest: { type: "string", description: "Destination inside bundle (defaults to 'context/')" },
+                                        exclude: {
+                                            type: "array",
+                                            items: { type: "string" },
+                                            description: "Exclusion patterns",
+                                        },
+                                    },
+                                    additionalProperties: false,
+                                },
+                            },
+                        },
+                        additionalProperties: false,
+                    },
+                },
+                additionalProperties: false,
+            },
+        },
+        lockfileMode: {
+            type: "string",
+            enum: ["consolidated", "split"],
+            default: "consolidated",
+            description: "Lockfile storage mode (consolidated into bundle.manifest.lock.json or split per topic)",
+        },
+    },
+    additionalProperties: false,
+};
+/**
+ * Emits the JSON Schema 2020-12 as formatted JSON string.
+ */
+export function emitJsonSchema() {
+    return JSON.stringify(BUNDLE_MANIFEST_SCHEMA, null, 2);
+}
+/**
+ * Validates a manifest object against schema invariants and returns a list of human-readable errors.
+ */
+export function validateManifestSchema(raw) {
+    const errors = [];
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        errors.push("Manifest root must be a JSON object.");
+        return errors;
+    }
+    const knownTopLevel = new Set([
+        "$schema",
+        "name",
+        "version",
+        "description",
+        "output",
+        "format",
+        "phase",
+        "author",
+        "targets",
+        "exclude",
+        "deduplicate",
+        "linkResolution",
+        "treeShake",
+        "scope",
+        "context",
+        "topics",
+        "lockfileMode",
+    ]);
+    if (raw.lockfileMode !== undefined &&
+        raw.lockfileMode !== "consolidated" &&
+        raw.lockfileMode !== "split") {
+        errors.push(`Invalid 'lockfileMode' '${raw.lockfileMode}'. Expected 'consolidated' or 'split'.`);
+    }
+    // Check unknown properties and typos
+    for (const key of Object.keys(raw)) {
+        if (!knownTopLevel.has(key)) {
+            if (key === "target") {
+                errors.push("Unknown property 'target'. Did you mean 'targets'?");
+            }
+            else if (key === "topic") {
+                errors.push("Unknown property 'topic'. Did you mean 'topics'?");
+            }
+            else if (key === "treesake" || key === "treeshake") {
+                errors.push(`Unknown property '${key}'. Did you mean 'treeShake'?`);
+            }
+            else {
+                errors.push(`Unknown top-level property '${key}'.`);
+            }
+        }
+    }
+    // Required fields
+    if (!raw.name || typeof raw.name !== "string") {
+        errors.push("Missing or invalid required field 'name' (must be a non-empty string).");
+    }
+    if (!raw.version || typeof raw.version !== "string") {
+        errors.push("Missing or invalid required field 'version' (must be a non-empty string).");
+    }
+    if (!raw.output || typeof raw.output !== "string") {
+        errors.push("Missing or invalid required field 'output' (must be a non-empty string).");
+    }
+    if (!raw.targets || !Array.isArray(raw.targets)) {
+        errors.push("Missing or invalid required field 'targets' (must be an array of target mappings).");
+    }
+    else {
+        raw.targets.forEach((t, index) => {
+            if (!t || typeof t !== "object" || Array.isArray(t)) {
+                errors.push(`targets[${index}]: must be an object.`);
+                return;
+            }
+            if (!t.source || typeof t.source !== "string") {
+                errors.push(`targets[${index}]: missing required 'source' path or glob pattern.`);
+            }
+            if (!t.dest || typeof t.dest !== "string") {
+                errors.push(`targets[${index}]: missing required 'dest' path.`);
+            }
+        });
+    }
+    // Format validation
+    if (raw.format && raw.format !== "zip" && raw.format !== "directory") {
+        errors.push(`Invalid 'format' '${raw.format}'. Expected 'zip' or 'directory'.`);
+    }
+    // Work Phase and Author validation
+    if (raw.phase !== undefined && !["develop", "fix", "test", "review"].includes(raw.phase)) {
+        errors.push(`Invalid 'phase' '${raw.phase}'. Expected 'develop', 'fix', 'test', or 'review'.`);
+    }
+    if (raw.author !== undefined && typeof raw.author !== "string") {
+        errors.push("'author' must be a string.");
+    }
+    // Deduplicate validation
+    if (raw.deduplicate && typeof raw.deduplicate === "object") {
+        const validStrategies = ["warn-overwrite", "overwrite", "error"];
+        if (raw.deduplicate.byPath &&
+            !validStrategies.includes(raw.deduplicate.byPath)) {
+            errors.push(`Invalid deduplicate.byPath '${raw.deduplicate.byPath}'. Expected one of: ${validStrategies.join(", ")}`);
+        }
+    }
+    // LinkResolution validation
+    if (raw.linkResolution && typeof raw.linkResolution === "object") {
+        const validPolicies = ["warn", "error", "preserve", "github-fallback"];
+        if (raw.linkResolution.unbundledPolicy &&
+            !validPolicies.includes(raw.linkResolution.unbundledPolicy)) {
+            errors.push(`Invalid linkResolution.unbundledPolicy '${raw.linkResolution.unbundledPolicy}'. Expected one of: ${validPolicies.join(", ")}`);
+        }
+    }
+    // TreeShake validation
+    if (raw.treeShake && typeof raw.treeShake === "object") {
+        if (raw.treeShake.enabled !== false && !Array.isArray(raw.treeShake.entrypoints)) {
+            errors.push("treeShake.entrypoints must be an array of entrypoint file paths.");
+        }
+        if (raw.treeShake.maxDepth !== undefined &&
+            (typeof raw.treeShake.maxDepth !== "number" || raw.treeShake.maxDepth < 1 || !Number.isInteger(raw.treeShake.maxDepth))) {
+            errors.push("treeShake.maxDepth must be a positive integer.");
+        }
+    }
+    // Topics validation
+    if (raw.topics !== undefined) {
+        if (!raw.topics || typeof raw.topics !== "object" || Array.isArray(raw.topics)) {
+            errors.push("Property 'topics' must be an object dictionary of topic configurations.");
+        }
+        else {
+            for (const [topicName, topicConfig] of Object.entries(raw.topics)) {
+                if (!topicConfig || typeof topicConfig !== "object" || Array.isArray(topicConfig)) {
+                    errors.push(`topics['${topicName}']: must be an object.`);
+                    continue;
+                }
+                const topicAny = topicConfig;
+                if (!topicAny.targets || !Array.isArray(topicAny.targets)) {
+                    errors.push(`topics['${topicName}']: missing required field 'targets' (must be an array).`);
+                }
+                else {
+                    topicAny.targets.forEach((t, index) => {
+                        if (!t || typeof t !== "object" || Array.isArray(t)) {
+                            errors.push(`topics['${topicName}'].targets[${index}]: must be an object.`);
+                            return;
+                        }
+                        if (!t.source || typeof t.source !== "string") {
+                            errors.push(`topics['${topicName}'].targets[${index}]: missing required 'source'.`);
+                        }
+                        if (!t.dest || typeof t.dest !== "string") {
+                            errors.push(`topics['${topicName}'].targets[${index}]: missing required 'dest'.`);
+                        }
+                    });
+                }
+                if (topicAny.format && topicAny.format !== "zip" && topicAny.format !== "directory") {
+                    errors.push(`topics['${topicName}']: invalid 'format' '${topicAny.format}'. Expected 'zip' or 'directory'.`);
+                }
+                if (topicAny.phase !== undefined &&
+                    !["develop", "fix", "test", "review"].includes(topicAny.phase)) {
+                    errors.push(`topics['${topicName}']: invalid 'phase' '${topicAny.phase}'. Expected 'develop', 'fix', 'test', or 'review'.`);
+                }
+                if (topicAny.author !== undefined && typeof topicAny.author !== "string") {
+                    errors.push(`topics['${topicName}']: 'author' must be a string.`);
+                }
+                if (topicAny.treeShake && typeof topicAny.treeShake === "object") {
+                    if (topicAny.treeShake.enabled !== false && !Array.isArray(topicAny.treeShake.entrypoints)) {
+                        errors.push(`topics['${topicName}'].treeShake.entrypoints must be an array of entrypoint file paths.`);
+                    }
+                    if (topicAny.treeShake.maxDepth !== undefined &&
+                        (typeof topicAny.treeShake.maxDepth !== "number" || topicAny.treeShake.maxDepth < 1 || !Number.isInteger(topicAny.treeShake.maxDepth))) {
+                        errors.push(`topics['${topicName}'].treeShake.maxDepth must be a positive integer.`);
+                    }
+                }
+                if (topicAny.scope && typeof topicAny.scope === "object") {
+                    if (topicAny.scope.entrypoints && !Array.isArray(topicAny.scope.entrypoints)) {
+                        errors.push(`topics['${topicName}'].scope.entrypoints must be an array.`);
+                    }
+                    if (topicAny.scope.include && !Array.isArray(topicAny.scope.include)) {
+                        errors.push(`topics['${topicName}'].scope.include must be an array of glob strings.`);
+                    }
+                    if (topicAny.scope.exclude && !Array.isArray(topicAny.scope.exclude)) {
+                        errors.push(`topics['${topicName}'].scope.exclude must be an array of glob strings.`);
+                    }
+                    if (topicAny.scope.stopAt && !Array.isArray(topicAny.scope.stopAt)) {
+                        errors.push(`topics['${topicName}'].scope.stopAt must be an array of glob strings.`);
+                    }
+                    if (topicAny.scope.maxDepth !== undefined &&
+                        (typeof topicAny.scope.maxDepth !== "number" || topicAny.scope.maxDepth < 1 || !Number.isInteger(topicAny.scope.maxDepth))) {
+                        errors.push(`topics['${topicName}'].scope.maxDepth must be a positive integer.`);
+                    }
+                    if (topicAny.scope.sections && !Array.isArray(topicAny.scope.sections)) {
+                        errors.push(`topics['${topicName}'].scope.sections must be an array of section heading strings.`);
+                    }
+                    if (topicAny.scope.direction !== undefined &&
+                        !["downstream", "upstream", "bidirectional"].includes(topicAny.scope.direction)) {
+                        errors.push(`topics['${topicName}'].scope.direction must be 'downstream', 'upstream', or 'bidirectional'.`);
+                    }
+                    if (topicAny.scope.upstreamDepth !== undefined &&
+                        (typeof topicAny.scope.upstreamDepth !== "number" || topicAny.scope.upstreamDepth < 1 || !Number.isInteger(topicAny.scope.upstreamDepth))) {
+                        errors.push(`topics['${topicName}'].scope.upstreamDepth must be a positive integer.`);
+                    }
+                    if (topicAny.scope.includeCategories && !Array.isArray(topicAny.scope.includeCategories)) {
+                        errors.push(`topics['${topicName}'].scope.includeCategories must be an array of category names.`);
+                    }
+                    if (topicAny.scope.excludeCategories && !Array.isArray(topicAny.scope.excludeCategories)) {
+                        errors.push(`topics['${topicName}'].scope.excludeCategories must be an array of category names.`);
+                    }
+                }
+                if (topicAny.context && typeof topicAny.context === "object") {
+                    if (topicAny.context.tags && !Array.isArray(topicAny.context.tags)) {
+                        errors.push(`topics['${topicName}'].context.tags must be an array of strings.`);
+                    }
+                    if (topicAny.context.docs !== undefined) {
+                        if (!Array.isArray(topicAny.context.docs)) {
+                            errors.push(`topics['${topicName}'].context.docs must be an array of target mappings.`);
+                        }
+                        else {
+                            topicAny.context.docs.forEach((d, dIdx) => {
+                                if (!d || typeof d !== "object" || !d.source || typeof d.source !== "string") {
+                                    errors.push(`topics['${topicName}'].context.docs[${dIdx}] must have a valid 'source' path.`);
+                                }
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return errors;
+}
+//# sourceMappingURL=schema.js.map