semantifold 0.9.0 → 0.10.0

package/build/src/project-manifest.js

@@ -0,0 +1,432 @@
+// @ts-check
+import { lstat, readFile, realpath } from "node:fs/promises";
+import path from "node:path";
+import { findPortableArtifactPathConflict, findPortableSourcePathConflict, isSafeArtifactPath, isSafeSourcePath } from "./artifact-path.js";
+import { supportsProgramArtifactRole } from "./backends/program.js";
+import { SemantifoldDiagnostic } from "./diagnostic.js";
+import { supportsProgramSourceLanguage } from "./frontends/program.js";
+import { languageRegistry } from "./language-registry.js";
+const projectIdentityPattern = /^[a-z][a-z0-9-]*$/u;
+const moduleIdentityPattern = /^[a-z][a-z0-9_]*(?:[.-][a-z][a-z0-9_]*)*$/u;
+const sourceRoles = new Map([
+    ["text", "textBackend"],
+    ["binary", "binaryBackend"],
+    ["application", "applicationBackend"]
+]);
+const manifestDefaultApplicationTargets = new Set(["android", "flutter"]);
+const projectFields = ["id", "publicationRoot", "schema", "sources", "targets", "version"];
+const sourceFields = ["entry", "id", "language", "path"];
+const targetRequiredFields = ["id", "language", "role", "sourceProjection"];
+const targetOptionalFields = ["buildProjection"];
+/**
+ * One validated immutable Semantifold project request.
+ */
+export class SemantifoldProject {
+    /**
+     * Constructs a trusted normalized project value for the manifest loader.
+     * @param {NormalizedProject} value - Validated normalized fields.
+     */
+    constructor(value) {
+        this.entryModule = value.entryModule;
+        this.id = value.id;
+        this.manifestPath = value.manifestPath;
+        this.manifestText = value.manifestText;
+        this.projectRoot = value.projectRoot;
+        this.publicationRoot = value.publicationRoot;
+        this.sources = Object.freeze(value.sources.map(source => Object.freeze({ ...source })));
+        this.targets = Object.freeze(value.targets.map(target => Object.freeze({ ...target })));
+        this.version = /** @type {const} */ (1);
+        Object.freeze(this);
+    }
+}
+/**
+ * Loads and validates the strict versioned project-manifest boundary.
+ */
+export class ProjectManifestLoader {
+    /**
+     * Loads one project manifest without reading source content.
+     * @param {string} [projectPath] - Manifest path, relative to the process working directory or absolute.
+     * @returns {Promise<SemantifoldProject>} Immutable normalized project.
+     */
+    async load(projectPath = "./semantifold.json") {
+        if (typeof projectPath != "string" || projectPath.length == 0 || projectPath.includes("\0")) {
+            projectFailure("INVALID_PROJECT_MANIFEST", "project", "Project manifest path must be a non-empty path string.");
+        }
+        const manifestPath = path.resolve(projectPath);
+        const projectRoot = path.dirname(manifestPath);
+        await requireCanonicalProjectRoot(projectRoot);
+        await requireRegularFile(manifestPath, "semantifold.json", "PROJECT_MANIFEST_READ_FAILED");
+        let bytes;
+        try {
+            bytes = await readFile(manifestPath);
+        }
+        catch (error) {
+            projectFailure("PROJECT_MANIFEST_READ_FAILED", "project", "Project manifest could not be read.", manifestLocation(), error);
+        }
+        let manifestText;
+        try {
+            manifestText = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+        }
+        catch (error) {
+            projectFailure("INVALID_PROJECT_MANIFEST", "project", "Project manifest must be valid UTF-8.", manifestLocation(), error);
+        }
+        let candidate;
+        try {
+            candidate = JSON.parse(manifestText);
+        }
+        catch (error) {
+            projectFailure("INVALID_PROJECT_MANIFEST", "project", "Project manifest must contain valid JSON.", manifestLocation(), error);
+        }
+        return normalizeProject(candidate, { manifestPath, manifestText, projectRoot });
+    }
+}
+/**
+ * Validates and normalizes one parsed manifest.
+ * @param {unknown} candidate - Parsed JSON value.
+ * @param {{manifestPath: string, manifestText: string, projectRoot: string}} context - Canonical manifest context.
+ * @returns {Promise<SemantifoldProject>} Immutable project value.
+ */
+async function normalizeProject(candidate, context) {
+    if (!isPlainObject(candidate) || !hasExactKeys(candidate, projectFields)) {
+        projectFailure("INVALID_PROJECT_MANIFEST", "project", "Project manifest requires exactly the version-1 root fields.", manifestLocation());
+    }
+    const { id, publicationRoot, schema, sources, targets, version } = candidate;
+    if (schema != "SemantifoldProject" || version != 1) {
+        projectFailure("INVALID_PROJECT_MANIFEST", typeof id == "string" ? id : "project", "Project manifest requires schema 'SemantifoldProject' version 1.", manifestLocation());
+    }
+    if (typeof id != "string" || !projectIdentityPattern.test(id)) {
+        projectFailure("INVALID_PROJECT_MANIFEST", "project", "Project identity must be a stable lowercase ID.", manifestLocation());
+    }
+    if (!isSafeArtifactPath(publicationRoot)) {
+        projectFailure("INVALID_PROJECT_PATH", id, "Publication root must be one canonical project-relative path.", manifestLocation());
+    }
+    if (!isDenseArray(sources) || sources.length == 0) {
+        projectFailure("INVALID_PROJECT_MANIFEST", id, "Project sources must be a non-empty ordered array.", manifestLocation());
+    }
+    if (!isDenseArray(targets) || targets.length == 0) {
+        projectFailure("INVALID_PROJECT_MANIFEST", id, "Project targets must be a non-empty ordered array.", manifestLocation());
+    }
+    const normalizedPublicationRoot = path.join(context.projectRoot, publicationRoot);
+    const sourceIds = new Set();
+    const sourcePaths = [];
+    /** @type {NormalizedProjectSource[]} */
+    const normalizedSources = [];
+    let entryModule;
+    for (let index = 0; index < sources.length; index += 1) {
+        const source = sources[index];
+        if (!isPlainObject(source) || !hasExactKeys(source, sourceFields)) {
+            projectFailure("INVALID_PROJECT_MANIFEST", id, `Source ${index} requires exactly path, language, ID, and entry fields.`, manifestLocation());
+        }
+        if (typeof source.id != "string" || !moduleIdentityPattern.test(source.id) || sourceIds.has(source.id)) {
+            projectFailure("INVALID_PROJECT_MANIFEST", id, `Source ${index} has an invalid or duplicate module identity.`, manifestLocation());
+        }
+        if (!isSafeSourcePath(source.path)) {
+            projectFailure("INVALID_PROJECT_PATH", id, `Source '${source.id}' path must be canonical and project-relative.`, manifestLocation());
+        }
+        if (typeof source.language != "string") {
+            projectFailure("INVALID_PROJECT_MANIFEST", id, `Source '${source.id}' requires a registered source language.`, manifestLocation());
+        }
+        languageRegistry.resolve(source.language, "frontend", manifestLocation());
+        if (!supportsProgramSourceLanguage(source.language)) {
+            projectFailure("UNSUPPORTED_PROJECT_SOURCE", source.language, "Registered frontend does not participate in the explicit multi-file project profile.", manifestLocation());
+        }
+        if (typeof source.entry != "boolean") {
+            projectFailure("INVALID_PROJECT_MANIFEST", id, `Source '${source.id}' entry must be Boolean.`, manifestLocation());
+        }
+        if (source.entry) {
+            if (entryModule !== undefined) {
+                projectFailure("INVALID_PROJECT_MANIFEST", id, "Project sources must declare exactly one entry module.", manifestLocation());
+            }
+            entryModule = source.id;
+        }
+        const absolutePath = path.join(context.projectRoot, source.path);
+        if (portablePathsOverlap(source.path, publicationRoot)) {
+            projectFailure("PROJECT_SOURCE_PUBLICATION_OVERLAP", id, `Source '${source.id}' overlaps the publisher-owned publication root.`, manifestLocation());
+        }
+        sourceIds.add(source.id);
+        sourcePaths.push(source.path);
+        normalizedSources.push({
+            absolutePath,
+            entry: source.entry,
+            id: source.id,
+            language: /** @type {import("./semantic/types.js").SemanticLanguage} */ (source.language),
+            path: source.path
+        });
+    }
+    if (entryModule === undefined) {
+        projectFailure("INVALID_PROJECT_MANIFEST", id, "Project sources must declare exactly one entry module.", manifestLocation());
+    }
+    const sourceConflict = findPortableSourcePathConflict(sourcePaths);
+    if (sourceConflict) {
+        projectFailure("PROJECT_SOURCE_ALIAS", id, "Project source paths must be unique under portable comparison.", manifestLocation());
+    }
+    const sourceLanguages = new Set(normalizedSources.map(({ language }) => language));
+    if (sourceLanguages.size != 1) {
+        projectFailure("INVALID_PROJECT_MANIFEST", id, "A project must use one source-language compatibility profile.", manifestLocation());
+    }
+    await requireExistingProjectPaths(context.projectRoot, normalizedPublicationRoot, normalizedSources, id);
+    const targetIds = new Set();
+    /** @type {NormalizedProjectTarget[]} */
+    const normalizedTargets = [];
+    /** @type {string[]} */
+    const projections = [];
+    for (let index = 0; index < targets.length; index += 1) {
+        const target = targets[index];
+        if (!isPlainObject(target) || !hasRequiredAndOptionalKeys(target, targetRequiredFields, targetOptionalFields)) {
+            projectFailure("INVALID_PROJECT_MANIFEST", id, `Target ${index} contains missing or unknown fields.`, manifestLocation());
+        }
+        if (typeof target.id != "string" || !projectIdentityPattern.test(target.id) || targetIds.has(target.id)) {
+            projectFailure("INVALID_PROJECT_MANIFEST", id, `Target ${index} has an invalid or duplicate identity.`, manifestLocation());
+        }
+        if (typeof target.language != "string" || typeof target.role != "string" || !sourceRoles.has(target.role)) {
+            projectFailure("INVALID_PROJECT_MANIFEST", id, `Target '${target.id}' requires a registered target and explicit role.`, manifestLocation());
+        }
+        languageRegistry.resolve(target.language, /** @type {"textBackend" | "binaryBackend" | "applicationBackend"} */ (sourceRoles.get(target.role)), manifestLocation());
+        if (!supportsProgramArtifactRole(target.language, target.role)) {
+            projectFailure("UNSUPPORTED_PROJECT_TARGET", target.language, `Registered target does not support '${target.role}' generation for complete semantic programs.`, manifestLocation());
+        }
+        if (target.role == "application" && !manifestDefaultApplicationTargets.has(target.language)) {
+            projectFailure("UNSUPPORTED_PROJECT_TARGET", target.language, "Project manifest version 1 cannot express the target's required application configuration.", manifestLocation());
+        }
+        const buildProjection = target.buildProjection === undefined ? `targets/${target.id}/build` : target.buildProjection;
+        if (!isSafeArtifactPath(target.sourceProjection) || !isSafeArtifactPath(buildProjection)) {
+            projectFailure("INVALID_PROJECT_PATH", id, `Target '${target.id}' projections must be canonical generation-relative paths.`, manifestLocation());
+        }
+        targetIds.add(target.id);
+        projections.push(target.sourceProjection, buildProjection);
+        normalizedTargets.push({
+            buildProjection,
+            id: target.id,
+            language: /** @type {import("./semantic/types.js").BackendLanguage} */ (target.language),
+            role: /** @type {import("./semantic/types.js").PublicationTargetRole} */ (target.role),
+            sourceProjection: target.sourceProjection
+        });
+    }
+    if (findPortableArtifactPathConflict(projections)) {
+        projectFailure("PROJECT_PROJECTION_COLLISION", id, "Target source/build projections must be distinct and non-nested under portable comparison.", manifestLocation());
+    }
+    if (findPortableArtifactPathConflict([...projections, "manifest.json"])) {
+        projectFailure("INVALID_PROJECT_PATH", id, "Target source/build projections must not overlap the reserved generation manifest path.", manifestLocation());
+    }
+    return new SemantifoldProject({
+        entryModule,
+        id,
+        manifestPath: context.manifestPath,
+        manifestText: context.manifestText,
+        projectRoot: context.projectRoot,
+        publicationRoot: normalizedPublicationRoot,
+        sources: normalizedSources,
+        targets: normalizedTargets
+    });
+}
+/**
+ * Requires a canonical real project root.
+ * @param {string} projectRoot - Absolute manifest directory.
+ * @returns {Promise<void>} Completion.
+ */
+async function requireCanonicalProjectRoot(projectRoot) {
+    try {
+        const exact = await realpath(projectRoot);
+        if (exact != projectRoot) {
+            projectFailure("PROJECT_SYMLINK_TRAVERSAL", "project", "Project root must not be reached through a symbolic link.", manifestLocation());
+        }
+    }
+    catch (error) {
+        if (error instanceof SemantifoldDiagnostic)
+            throw error;
+        projectFailure("PROJECT_MANIFEST_READ_FAILED", "project", "Project root could not be resolved.", manifestLocation(), error);
+    }
+}
+/**
+ * Validates every source path and every existing publication-root component.
+ * @param {string} projectRoot - Canonical project root.
+ * @param {string} publicationRoot - Normalized publication root.
+ * @param {readonly NormalizedProjectSource[]} sources - Normalized sources.
+ * @param {string} projectId - Project identity.
+ * @returns {Promise<void>} Completion.
+ */
+async function requireExistingProjectPaths(projectRoot, publicationRoot, sources, projectId) {
+    await requireNoSymlinkComponents(projectRoot, publicationRoot, projectId, true);
+    const fileIdentities = new Set();
+    for (const source of sources) {
+        await requireNoSymlinkComponents(projectRoot, source.absolutePath, projectId, false);
+        const status = await requireRegularFile(source.absolutePath, source.path, "PROJECT_SOURCE_READ_FAILED", projectId);
+        const identity = `${String(status.dev)}:${String(status.ino)}`;
+        if (fileIdentities.has(identity)) {
+            projectFailure("PROJECT_SOURCE_ALIAS", projectId, "Project source paths must not alias the same file.", sourceLocation(source.path));
+        }
+        fileIdentities.add(identity);
+    }
+}
+/**
+ * Rejects symlinks beneath a canonical project root.
+ * @param {string} projectRoot - Canonical project root.
+ * @param {string} target - Absolute target.
+ * @param {string} projectId - Project identity.
+ * @param {boolean} allowMissing - Whether a missing suffix is permitted.
+ * @returns {Promise<void>} Completion.
+ */
+async function requireNoSymlinkComponents(projectRoot, target, projectId, allowMissing) {
+    const relative = path.relative(projectRoot, target);
+    let current = projectRoot;
+    for (const part of relative.split(path.sep).filter(Boolean)) {
+        current = path.join(current, part);
+        try {
+            const status = await lstat(current);
+            if (status.isSymbolicLink()) {
+                projectFailure("PROJECT_SYMLINK_TRAVERSAL", projectId, "Project path traversal encountered a symbolic link.", manifestLocation());
+            }
+        }
+        catch (error) {
+            if (allowMissing && isErrorCode(error, "ENOENT"))
+                return;
+            if (error instanceof SemantifoldDiagnostic)
+                throw error;
+            projectFailure("PROJECT_SOURCE_READ_FAILED", projectId, "Declared project path could not be inspected.", manifestLocation(), error);
+        }
+    }
+}
+/**
+ * Requires one real regular file.
+ * @param {string} filename - Absolute file path.
+ * @param {string} displayPath - Stable diagnostic filename.
+ * @param {string} code - Diagnostic code.
+ * @param {string} [projectId] - Project identity.
+ * @returns {Promise<import("node:fs").Stats>} File status.
+ */
+async function requireRegularFile(filename, displayPath, code, projectId = "project") {
+    try {
+        const status = await lstat(filename);
+        if (status.isSymbolicLink()) {
+            projectFailure("PROJECT_SYMLINK_TRAVERSAL", projectId, "Declared project file must not be a symbolic link.", sourceLocation(displayPath));
+        }
+        if (!status.isFile())
+            projectFailure(code, projectId, "Declared project file must be a regular file.", sourceLocation(displayPath));
+        return status;
+    }
+    catch (error) {
+        if (error instanceof SemantifoldDiagnostic)
+            throw error;
+        projectFailure(code, projectId, "Declared project file could not be inspected.", sourceLocation(displayPath), error);
+    }
+}
+/**
+ * Checks whether two validated POSIX-relative paths overlap portably.
+ * @param {string} left - First path.
+ * @param {string} right - Second path.
+ * @returns {boolean} Whether either path contains the other.
+ */
+function portablePathsOverlap(left, right) {
+    const leftKey = left.toLowerCase();
+    const rightKey = right.toLowerCase();
+    return leftKey == rightKey || leftKey.startsWith(`${rightKey}/`) || rightKey.startsWith(`${leftKey}/`);
+}
+/**
+ * Checks for an ordinary string-keyed object.
+ * @param {unknown} value - Candidate value.
+ * @returns {value is Record<string, unknown>} Whether the value is a plain object.
+ */
+function isPlainObject(value) {
+    return typeof value == "object" && value != null && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype;
+}
+/**
+ * Checks for a dense array without extra enumerable keys.
+ * @param {unknown} value - Candidate value.
+ * @returns {value is unknown[]} Whether the value is a dense array.
+ */
+function isDenseArray(value) {
+    return Array.isArray(value) && Object.keys(value).every((key, index) => key == String(index));
+}
+/**
+ * Checks an object's exact closed key set.
+ * @param {Record<string, unknown>} value - Candidate object.
+ * @param {readonly string[]} keys - Required exact keys.
+ * @returns {boolean} Whether the key set is exact.
+ */
+function hasExactKeys(value, keys) {
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    return actual.length == expected.length && actual.every((key, index) => key == expected[index]);
+}
+/**
+ * Checks exact required fields plus an optional closed field set.
+ * @param {Record<string, unknown>} value - Candidate record.
+ * @param {readonly string[]} required - Required fields.
+ * @param {readonly string[]} optional - Optional fields.
+ * @returns {boolean} Whether the shape is exact.
+ */
+function hasRequiredAndOptionalKeys(value, required, optional) {
+    const actual = Object.keys(value);
+    return required.every(key => actual.includes(key)) && actual.every(key => required.includes(key) || optional.includes(key));
+}
+/**
+ * Creates the stable manifest boundary location.
+ * @returns {import("./semantic/types.js").SourceLocation} Manifest location.
+ */
+function manifestLocation() {
+    return sourceLocation("semantifold.json");
+}
+/**
+ * Creates a stable project-relative file location.
+ * @param {string} filename - Project-relative filename.
+ * @returns {import("./semantic/types.js").SourceLocation} Start-of-file location.
+ */
+function sourceLocation(filename) {
+    const point = { column: 1, line: 1, offset: 0 };
+    return { end: point, filename, start: point };
+}
+/**
+ * Checks one narrowed filesystem error code.
+ * @param {unknown} error - Opaque failure.
+ * @param {string} code - Expected code.
+ * @returns {boolean} Whether the code matches.
+ */
+function isErrorCode(error, code) {
+    return error instanceof Error && "code" in error && error.code == code;
+}
+/**
+ * Throws one stable located project diagnostic.
+ * @param {string} code - Stable diagnostic code.
+ * @param {string} language - Project or registration identity.
+ * @param {string} message - Stable detail.
+ * @param {import("./semantic/types.js").SourceLocation} [location] - Project-relative location.
+ * @param {unknown} [error] - Preserved cause.
+ * @returns {never} Always throws.
+ */
+function projectFailure(code, language, message, location, error) {
+    throw new SemantifoldDiagnostic({
+        cause: error instanceof Error ? error : undefined,
+        code,
+        language,
+        location,
+        message
+    });
+}
+/**
+ * @typedef NormalizedProjectSource
+ * @property {string} absolutePath - Canonical project-absolute file path.
+ * @property {boolean} entry - Whether this is the sole entry module.
+ * @property {string} id - Stable semantic module identity.
+ * @property {import("./semantic/types.js").SemanticLanguage} language - Registered source language.
+ * @property {string} path - Canonical project-relative file path.
+ */
+/**
+ * @typedef NormalizedProjectTarget
+ * @property {string} buildProjection - Generation-relative reserved build projection.
+ * @property {string} id - Stable project target identity.
+ * @property {import("./semantic/types.js").BackendLanguage} language - Registered target identity.
+ * @property {import("./semantic/types.js").PublicationTargetRole} role - Explicit target role.
+ * @property {string} sourceProjection - Generation-relative generated-source projection.
+ */
+/**
+ * @typedef NormalizedProject
+ * @property {string} entryModule - Sole entry module identity.
+ * @property {string} id - Stable project identity.
+ * @property {string} manifestPath - Canonical absolute manifest path.
+ * @property {string} manifestText - Exact validated manifest text.
+ * @property {string} projectRoot - Canonical absolute project root.
+ * @property {string} publicationRoot - Canonical absolute publication root.
+ * @property {NormalizedProjectSource[]} sources - Ordered normalized sources.
+ * @property {NormalizedProjectTarget[]} targets - Ordered normalized targets.
+ */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project-manifest.js","sourceRoot":"","sources":["../../src/project-manifest.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {lstat, readFile, realpath} from \"node:fs/promises\"\nimport path from \"node:path\"\nimport {\n  findPortableArtifactPathConflict,\n  findPortableSourcePathConflict,\n  isSafeArtifactPath,\n  isSafeSourcePath\n} from \"./artifact-path.js\"\nimport {supportsProgramArtifactRole} from \"./backends/program.js\"\nimport {SemantifoldDiagnostic} from \"./diagnostic.js\"\nimport {supportsProgramSourceLanguage} from \"./frontends/program.js\"\nimport {languageRegistry} from \"./language-registry.js\"\n\nconst projectIdentityPattern = /^[a-z][a-z0-9-]*$/u\nconst moduleIdentityPattern = /^[a-z][a-z0-9_]*(?:[.-][a-z][a-z0-9_]*)*$/u\nconst sourceRoles = new Map([\n  [\"text\", \"textBackend\"],\n  [\"binary\", \"binaryBackend\"],\n  [\"application\", \"applicationBackend\"]\n])\nconst manifestDefaultApplicationTargets = new Set([\"android\", \"flutter\"])\nconst projectFields = [\"id\", \"publicationRoot\", \"schema\", \"sources\", \"targets\", \"version\"]\nconst sourceFields = [\"entry\", \"id\", \"language\", \"path\"]\nconst targetRequiredFields = [\"id\", \"language\", \"role\", \"sourceProjection\"]\nconst targetOptionalFields = [\"buildProjection\"]\n\n/**\n * One validated immutable Semantifold project request.\n */\nexport class SemantifoldProject {\n  /**\n   * Constructs a trusted normalized project value for the manifest loader.\n   * @param {NormalizedProject} value - Validated normalized fields.\n   */\n  constructor(value) {\n    this.entryModule = value.entryModule\n    this.id = value.id\n    this.manifestPath = value.manifestPath\n    this.manifestText = value.manifestText\n    this.projectRoot = value.projectRoot\n    this.publicationRoot = value.publicationRoot\n    this.sources = Object.freeze(value.sources.map(source => Object.freeze({...source})))\n    this.targets = Object.freeze(value.targets.map(target => Object.freeze({...target})))\n    this.version = /** @type {const} */ (1)\n    Object.freeze(this)\n  }\n}\n\n/**\n * Loads and validates the strict versioned project-manifest boundary.\n */\nexport class ProjectManifestLoader {\n  /**\n   * Loads one project manifest without reading source content.\n   * @param {string} [projectPath] - Manifest path, relative to the process working directory or absolute.\n   * @returns {Promise<SemantifoldProject>} Immutable normalized project.\n   */\n  async load(projectPath = \"./semantifold.json\") {\n    if (typeof projectPath != \"string\" || projectPath.length == 0 || projectPath.includes(\"\\0\")) {\n      projectFailure(\"INVALID_PROJECT_MANIFEST\", \"project\", \"Project manifest path must be a non-empty path string.\")\n    }\n    const manifestPath = path.resolve(projectPath)\n    const projectRoot = path.dirname(manifestPath)\n\n    await requireCanonicalProjectRoot(projectRoot)\n    await requireRegularFile(manifestPath, \"semantifold.json\", \"PROJECT_MANIFEST_READ_FAILED\")\n    let bytes\n\n    try {\n      bytes = await readFile(manifestPath)\n    } catch (error) {\n      projectFailure(\"PROJECT_MANIFEST_READ_FAILED\", \"project\", \"Project manifest could not be read.\", manifestLocation(), error)\n    }\n    let manifestText\n\n    try {\n      manifestText = new TextDecoder(\"utf-8\", {fatal: true}).decode(bytes)\n    } catch (error) {\n      projectFailure(\"INVALID_PROJECT_MANIFEST\", \"project\", \"Project manifest must be valid UTF-8.\", manifestLocation(), error)\n    }\n    let candidate\n\n    try {\n      candidate = JSON.parse(manifestText)\n    } catch (error) {\n      projectFailure(\"INVALID_PROJECT_MANIFEST\", \"project\", \"Project manifest must contain valid JSON.\", manifestLocation(), error)\n    }\n\n    return normalizeProject(candidate, {manifestPath, manifestText, projectRoot})\n  }\n}\n\n/**\n * Validates and normalizes one parsed manifest.\n * @param {unknown} candidate - Parsed JSON value.\n * @param {{manifestPath: string, manifestText: string, projectRoot: string}} context - Canonical manifest context.\n * @returns {Promise<SemantifoldProject>} Immutable project value.\n */\nasync function normalizeProject(candidate, context) {\n  if (!isPlainObject(candidate) || !hasExactKeys(candidate, projectFields)) {\n    projectFailure(\"INVALID_PROJECT_MANIFEST\", \"project\", \"Project manifest requires exactly the version-1 root fields.\", manifestLocation())\n  }\n  const {id, publicationRoot, schema, sources, targets, version} = candidate\n\n  if (schema != \"SemantifoldProject\" || version != 1) {\n    projectFailure(\"INVALID_PROJECT_MANIFEST\", typeof id == \"string\" ? id : \"project\",\n      \"Project manifest requires schema 'SemantifoldProject' version 1.\", manifestLocation())\n  }\n  if (typeof id != \"string\" || !projectIdentityPattern.test(id)) {\n    projectFailure(\"INVALID_PROJECT_MANIFEST\", \"project\", \"Project identity must be a stable lowercase ID.\", manifestLocation())\n  }\n  if (!isSafeArtifactPath(publicationRoot)) {\n    projectFailure(\"INVALID_PROJECT_PATH\", id, \"Publication root must be one canonical project-relative path.\", manifestLocation())\n  }\n  if (!isDenseArray(sources) || sources.length == 0) {\n    projectFailure(\"INVALID_PROJECT_MANIFEST\", id, \"Project sources must be a non-empty ordered array.\", manifestLocation())\n  }\n  if (!isDenseArray(targets) || targets.length == 0) {\n    projectFailure(\"INVALID_PROJECT_MANIFEST\", id, \"Project targets must be a non-empty ordered array.\", manifestLocation())\n  }\n  const normalizedPublicationRoot = path.join(context.projectRoot, publicationRoot)\n  const sourceIds = new Set()\n  const sourcePaths = []\n  /** @type {NormalizedProjectSource[]} */\n  const normalizedSources = []\n  let entryModule\n\n  for (let index = 0; index < sources.length; index += 1) {\n    const source = sources[index]\n\n    if (!isPlainObject(source) || !hasExactKeys(source, sourceFields)) {\n      projectFailure(\"INVALID_PROJECT_MANIFEST\", id, `Source ${index} requires exactly path, language, ID, and entry fields.`, manifestLocation())\n    }\n    if (typeof source.id != \"string\" || !moduleIdentityPattern.test(source.id) || sourceIds.has(source.id)) {\n      projectFailure(\"INVALID_PROJECT_MANIFEST\", id, `Source ${index} has an invalid or duplicate module identity.`, manifestLocation())\n    }\n    if (!isSafeSourcePath(source.path)) {\n      projectFailure(\"INVALID_PROJECT_PATH\", id, `Source '${source.id}' path must be canonical and project-relative.`, manifestLocation())\n    }\n    if (typeof source.language != \"string\") {\n      projectFailure(\"INVALID_PROJECT_MANIFEST\", id, `Source '${source.id}' requires a registered source language.`, manifestLocation())\n    }\n    languageRegistry.resolve(source.language, \"frontend\", manifestLocation())\n    if (!supportsProgramSourceLanguage(source.language)) {\n      projectFailure(\"UNSUPPORTED_PROJECT_SOURCE\", source.language,\n        \"Registered frontend does not participate in the explicit multi-file project profile.\", manifestLocation())\n    }\n    if (typeof source.entry != \"boolean\") {\n      projectFailure(\"INVALID_PROJECT_MANIFEST\", id, `Source '${source.id}' entry must be Boolean.`, manifestLocation())\n    }\n    if (source.entry) {\n      if (entryModule !== undefined) {\n        projectFailure(\"INVALID_PROJECT_MANIFEST\", id, \"Project sources must declare exactly one entry module.\", manifestLocation())\n      }\n      entryModule = source.id\n    }\n    const absolutePath = path.join(context.projectRoot, source.path)\n\n    if (portablePathsOverlap(source.path, publicationRoot)) {\n      projectFailure(\"PROJECT_SOURCE_PUBLICATION_OVERLAP\", id,\n        `Source '${source.id}' overlaps the publisher-owned publication root.`, manifestLocation())\n    }\n    sourceIds.add(source.id)\n    sourcePaths.push(source.path)\n    normalizedSources.push({\n      absolutePath,\n      entry: source.entry,\n      id: source.id,\n      language: /** @type {import(\"./semantic/types.js\").SemanticLanguage} */ (source.language),\n      path: source.path\n    })\n  }\n  if (entryModule === undefined) {\n    projectFailure(\"INVALID_PROJECT_MANIFEST\", id, \"Project sources must declare exactly one entry module.\", manifestLocation())\n  }\n  const sourceConflict = findPortableSourcePathConflict(sourcePaths)\n\n  if (sourceConflict) {\n    projectFailure(\"PROJECT_SOURCE_ALIAS\", id, \"Project source paths must be unique under portable comparison.\", manifestLocation())\n  }\n  const sourceLanguages = new Set(normalizedSources.map(({language}) => language))\n\n  if (sourceLanguages.size != 1) {\n    projectFailure(\"INVALID_PROJECT_MANIFEST\", id, \"A project must use one source-language compatibility profile.\", manifestLocation())\n  }\n  await requireExistingProjectPaths(context.projectRoot, normalizedPublicationRoot, normalizedSources, id)\n  const targetIds = new Set()\n  /** @type {NormalizedProjectTarget[]} */\n  const normalizedTargets = []\n  /** @type {string[]} */\n  const projections = []\n\n  for (let index = 0; index < targets.length; index += 1) {\n    const target = targets[index]\n\n    if (!isPlainObject(target) || !hasRequiredAndOptionalKeys(target, targetRequiredFields, targetOptionalFields)) {\n      projectFailure(\"INVALID_PROJECT_MANIFEST\", id, `Target ${index} contains missing or unknown fields.`, manifestLocation())\n    }\n    if (typeof target.id != \"string\" || !projectIdentityPattern.test(target.id) || targetIds.has(target.id)) {\n      projectFailure(\"INVALID_PROJECT_MANIFEST\", id, `Target ${index} has an invalid or duplicate identity.`, manifestLocation())\n    }\n    if (typeof target.language != \"string\" || typeof target.role != \"string\" || !sourceRoles.has(target.role)) {\n      projectFailure(\"INVALID_PROJECT_MANIFEST\", id, `Target '${target.id}' requires a registered target and explicit role.`, manifestLocation())\n    }\n    languageRegistry.resolve(target.language, /** @type {\"textBackend\" | \"binaryBackend\" | \"applicationBackend\"} */ (sourceRoles.get(target.role)), manifestLocation())\n    if (!supportsProgramArtifactRole(target.language, target.role)) {\n      projectFailure(\"UNSUPPORTED_PROJECT_TARGET\", target.language,\n        `Registered target does not support '${target.role}' generation for complete semantic programs.`, manifestLocation())\n    }\n    if (target.role == \"application\" && !manifestDefaultApplicationTargets.has(target.language)) {\n      projectFailure(\"UNSUPPORTED_PROJECT_TARGET\", target.language,\n        \"Project manifest version 1 cannot express the target's required application configuration.\", manifestLocation())\n    }\n    const buildProjection = target.buildProjection === undefined ? `targets/${target.id}/build` : target.buildProjection\n\n    if (!isSafeArtifactPath(target.sourceProjection) || !isSafeArtifactPath(buildProjection)) {\n      projectFailure(\"INVALID_PROJECT_PATH\", id, `Target '${target.id}' projections must be canonical generation-relative paths.`, manifestLocation())\n    }\n    targetIds.add(target.id)\n    projections.push(target.sourceProjection, buildProjection)\n    normalizedTargets.push({\n      buildProjection,\n      id: target.id,\n      language: /** @type {import(\"./semantic/types.js\").BackendLanguage} */ (target.language),\n      role: /** @type {import(\"./semantic/types.js\").PublicationTargetRole} */ (target.role),\n      sourceProjection: target.sourceProjection\n    })\n  }\n  if (findPortableArtifactPathConflict(projections)) {\n    projectFailure(\"PROJECT_PROJECTION_COLLISION\", id,\n      \"Target source/build projections must be distinct and non-nested under portable comparison.\", manifestLocation())\n  }\n  if (findPortableArtifactPathConflict([...projections, \"manifest.json\"])) {\n    projectFailure(\"INVALID_PROJECT_PATH\", id,\n      \"Target source/build projections must not overlap the reserved generation manifest path.\", manifestLocation())\n  }\n\n  return new SemantifoldProject({\n    entryModule,\n    id,\n    manifestPath: context.manifestPath,\n    manifestText: context.manifestText,\n    projectRoot: context.projectRoot,\n    publicationRoot: normalizedPublicationRoot,\n    sources: normalizedSources,\n    targets: normalizedTargets\n  })\n}\n\n/**\n * Requires a canonical real project root.\n * @param {string} projectRoot - Absolute manifest directory.\n * @returns {Promise<void>} Completion.\n */\nasync function requireCanonicalProjectRoot(projectRoot) {\n  try {\n    const exact = await realpath(projectRoot)\n\n    if (exact != projectRoot) {\n      projectFailure(\"PROJECT_SYMLINK_TRAVERSAL\", \"project\", \"Project root must not be reached through a symbolic link.\", manifestLocation())\n    }\n  } catch (error) {\n    if (error instanceof SemantifoldDiagnostic) throw error\n    projectFailure(\"PROJECT_MANIFEST_READ_FAILED\", \"project\", \"Project root could not be resolved.\", manifestLocation(), error)\n  }\n}\n\n/**\n * Validates every source path and every existing publication-root component.\n * @param {string} projectRoot - Canonical project root.\n * @param {string} publicationRoot - Normalized publication root.\n * @param {readonly NormalizedProjectSource[]} sources - Normalized sources.\n * @param {string} projectId - Project identity.\n * @returns {Promise<void>} Completion.\n */\nasync function requireExistingProjectPaths(projectRoot, publicationRoot, sources, projectId) {\n  await requireNoSymlinkComponents(projectRoot, publicationRoot, projectId, true)\n  const fileIdentities = new Set()\n\n  for (const source of sources) {\n    await requireNoSymlinkComponents(projectRoot, source.absolutePath, projectId, false)\n    const status = await requireRegularFile(source.absolutePath, source.path, \"PROJECT_SOURCE_READ_FAILED\", projectId)\n    const identity = `${String(status.dev)}:${String(status.ino)}`\n\n    if (fileIdentities.has(identity)) {\n      projectFailure(\"PROJECT_SOURCE_ALIAS\", projectId, \"Project source paths must not alias the same file.\", sourceLocation(source.path))\n    }\n    fileIdentities.add(identity)\n  }\n}\n\n/**\n * Rejects symlinks beneath a canonical project root.\n * @param {string} projectRoot - Canonical project root.\n * @param {string} target - Absolute target.\n * @param {string} projectId - Project identity.\n * @param {boolean} allowMissing - Whether a missing suffix is permitted.\n * @returns {Promise<void>} Completion.\n */\nasync function requireNoSymlinkComponents(projectRoot, target, projectId, allowMissing) {\n  const relative = path.relative(projectRoot, target)\n  let current = projectRoot\n\n  for (const part of relative.split(path.sep).filter(Boolean)) {\n    current = path.join(current, part)\n    try {\n      const status = await lstat(current)\n\n      if (status.isSymbolicLink()) {\n        projectFailure(\"PROJECT_SYMLINK_TRAVERSAL\", projectId, \"Project path traversal encountered a symbolic link.\", manifestLocation())\n      }\n    } catch (error) {\n      if (allowMissing && isErrorCode(error, \"ENOENT\")) return\n      if (error instanceof SemantifoldDiagnostic) throw error\n      projectFailure(\"PROJECT_SOURCE_READ_FAILED\", projectId, \"Declared project path could not be inspected.\", manifestLocation(), error)\n    }\n  }\n}\n\n/**\n * Requires one real regular file.\n * @param {string} filename - Absolute file path.\n * @param {string} displayPath - Stable diagnostic filename.\n * @param {string} code - Diagnostic code.\n * @param {string} [projectId] - Project identity.\n * @returns {Promise<import(\"node:fs\").Stats>} File status.\n */\nasync function requireRegularFile(filename, displayPath, code, projectId = \"project\") {\n  try {\n    const status = await lstat(filename)\n\n    if (status.isSymbolicLink()) {\n      projectFailure(\"PROJECT_SYMLINK_TRAVERSAL\", projectId, \"Declared project file must not be a symbolic link.\", sourceLocation(displayPath))\n    }\n    if (!status.isFile()) projectFailure(code, projectId, \"Declared project file must be a regular file.\", sourceLocation(displayPath))\n\n    return status\n  } catch (error) {\n    if (error instanceof SemantifoldDiagnostic) throw error\n    projectFailure(code, projectId, \"Declared project file could not be inspected.\", sourceLocation(displayPath), error)\n  }\n}\n\n/**\n * Checks whether two validated POSIX-relative paths overlap portably.\n * @param {string} left - First path.\n * @param {string} right - Second path.\n * @returns {boolean} Whether either path contains the other.\n */\nfunction portablePathsOverlap(left, right) {\n  const leftKey = left.toLowerCase()\n  const rightKey = right.toLowerCase()\n\n  return leftKey == rightKey || leftKey.startsWith(`${rightKey}/`) || rightKey.startsWith(`${leftKey}/`)\n}\n\n/**\n * Checks for an ordinary string-keyed object.\n * @param {unknown} value - Candidate value.\n * @returns {value is Record<string, unknown>} Whether the value is a plain object.\n */\nfunction isPlainObject(value) {\n  return typeof value == \"object\" && value != null && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype\n}\n\n/**\n * Checks for a dense array without extra enumerable keys.\n * @param {unknown} value - Candidate value.\n * @returns {value is unknown[]} Whether the value is a dense array.\n */\nfunction isDenseArray(value) {\n  return Array.isArray(value) && Object.keys(value).every((key, index) => key == String(index))\n}\n\n/**\n * Checks an object's exact closed key set.\n * @param {Record<string, unknown>} value - Candidate object.\n * @param {readonly string[]} keys - Required exact keys.\n * @returns {boolean} Whether the key set is exact.\n */\nfunction hasExactKeys(value, keys) {\n  const actual = Object.keys(value).sort()\n  const expected = [...keys].sort()\n\n  return actual.length == expected.length && actual.every((key, index) => key == expected[index])\n}\n\n/**\n * Checks exact required fields plus an optional closed field set.\n * @param {Record<string, unknown>} value - Candidate record.\n * @param {readonly string[]} required - Required fields.\n * @param {readonly string[]} optional - Optional fields.\n * @returns {boolean} Whether the shape is exact.\n */\nfunction hasRequiredAndOptionalKeys(value, required, optional) {\n  const actual = Object.keys(value)\n\n  return required.every(key => actual.includes(key)) && actual.every(key => required.includes(key) || optional.includes(key))\n}\n\n/**\n * Creates the stable manifest boundary location.\n * @returns {import(\"./semantic/types.js\").SourceLocation} Manifest location.\n */\nfunction manifestLocation() {\n  return sourceLocation(\"semantifold.json\")\n}\n\n/**\n * Creates a stable project-relative file location.\n * @param {string} filename - Project-relative filename.\n * @returns {import(\"./semantic/types.js\").SourceLocation} Start-of-file location.\n */\nfunction sourceLocation(filename) {\n  const point = {column: 1, line: 1, offset: 0}\n\n  return {end: point, filename, start: point}\n}\n\n/**\n * Checks one narrowed filesystem error code.\n * @param {unknown} error - Opaque failure.\n * @param {string} code - Expected code.\n * @returns {boolean} Whether the code matches.\n */\nfunction isErrorCode(error, code) {\n  return error instanceof Error && \"code\" in error && error.code == code\n}\n\n/**\n * Throws one stable located project diagnostic.\n * @param {string} code - Stable diagnostic code.\n * @param {string} language - Project or registration identity.\n * @param {string} message - Stable detail.\n * @param {import(\"./semantic/types.js\").SourceLocation} [location] - Project-relative location.\n * @param {unknown} [error] - Preserved cause.\n * @returns {never} Always throws.\n */\nfunction projectFailure(code, language, message, location, error) {\n  throw new SemantifoldDiagnostic({\n    cause: error instanceof Error ? error : undefined,\n    code,\n    language,\n    location,\n    message\n  })\n}\n\n/**\n * @typedef NormalizedProjectSource\n * @property {string} absolutePath - Canonical project-absolute file path.\n * @property {boolean} entry - Whether this is the sole entry module.\n * @property {string} id - Stable semantic module identity.\n * @property {import(\"./semantic/types.js\").SemanticLanguage} language - Registered source language.\n * @property {string} path - Canonical project-relative file path.\n */\n\n/**\n * @typedef NormalizedProjectTarget\n * @property {string} buildProjection - Generation-relative reserved build projection.\n * @property {string} id - Stable project target identity.\n * @property {import(\"./semantic/types.js\").BackendLanguage} language - Registered target identity.\n * @property {import(\"./semantic/types.js\").PublicationTargetRole} role - Explicit target role.\n * @property {string} sourceProjection - Generation-relative generated-source projection.\n */\n\n/**\n * @typedef NormalizedProject\n * @property {string} entryModule - Sole entry module identity.\n * @property {string} id - Stable project identity.\n * @property {string} manifestPath - Canonical absolute manifest path.\n * @property {string} manifestText - Exact validated manifest text.\n * @property {string} projectRoot - Canonical absolute project root.\n * @property {string} publicationRoot - Canonical absolute publication root.\n * @property {NormalizedProjectSource[]} sources - Ordered normalized sources.\n * @property {NormalizedProjectTarget[]} targets - Ordered normalized targets.\n */\n"]}

package/build/src/project-reporter.d.ts

@@ -0,0 +1,81 @@
+import { SemantifoldDiagnostic } from "./diagnostic.js";
+/**
+ * Emits concise human output or the deterministic Task-039 NDJSON state protocol.
+ */
+export declare class ProjectBuildReporter {
+    #private;
+    /**
+     * Creates a one-cycle reporter.
+     * @param {{format?: "human" | "ndjson", stderr?: WritableOutput, stdout?: WritableOutput}} [options] - Output mode and sinks.
+     */
+    constructor(options?: {
+        format?: "human" | "ndjson";
+        stderr?: WritableOutput;
+        stdout?: WritableOutput;
+    });
+    /**
+     * Reports validated project configuration.
+     * @param {string} projectId - Stable project identity.
+     * @returns {void}
+     */
+    projectLoaded(projectId: string): void;
+    /**
+     * Reports one stable complete source snapshot.
+     * @param {string} snapshotHash - Complete ordered snapshot hash.
+     * @returns {void}
+     */
+    snapshotLoaded(snapshotHash: string): void;
+    /**
+     * Reports one ordered generated target.
+     * @param {import("./project-build.js").ProjectBuildTargetResult} target - Completed target result.
+     * @returns {void}
+     */
+    targetGenerated(target: import("./project-build.js").ProjectBuildTargetResult): void;
+    /**
+     * Reports one successful target-check stage with exact process evidence.
+     * @param {{id: string, language: string, stage: import("./semantic/types.js").TargetCheckStageResult}} checked - Target and stage result.
+     * @returns {void}
+     */
+    targetChecked(checked: {
+        id: string;
+        language: string;
+        stage: import("./semantic/types.js").TargetCheckStageResult;
+    }): void;
+    /**
+     * Emits the sole successful terminal record.
+     * @param {import("./project-build.js").ProjectBuildSuccess} result - Committed build result.
+     * @returns {void}
+     */
+    succeeded(result: import("./project-build.js").ProjectBuildSuccess): void;
+    /**
+     * Emits the sole failed terminal record while preserving the first diagnostic.
+     * @param {unknown} failure - Build or CLI failure.
+     * @returns {void}
+     */
+    failed(failure: unknown): void;
+}
+/**
+ * Normalizes an unexpected failure without replacing a Semantifold diagnostic.
+ * @param {unknown} failure - Opaque failure.
+ * @returns {SemantifoldDiagnostic} Stable diagnostic.
+ */
+export declare function normalizeDiagnostic(failure: unknown): SemantifoldDiagnostic;
+/**
+ * Serializes stable public diagnostic fields without causes or host paths.
+ * @param {SemantifoldDiagnostic} diagnostic - Normalized diagnostic.
+ * @returns {Record<string, unknown>} Protocol diagnostic.
+ */
+export declare function diagnosticRecord(diagnostic: SemantifoldDiagnostic): Record<string, unknown>;
+/**
+ * Formats one normalized failure with preserved nested process evidence.
+ * This helper is shared by the one-shot and watch reporters but is not a package-root API.
+ * @param {unknown} failure - Opaque or normalized failure.
+ * @param {string} heading - Human output heading without punctuation.
+ * @returns {string} Complete newline-terminated failure text.
+ */
+export declare function formatHumanProjectFailure(failure: unknown, heading: string): string;
+export type WritableOutput = {
+    write: (chunk: string) => unknown;
+};
+/** @typedef {{write: (chunk: string) => unknown}} WritableOutput */
+//# sourceMappingURL=project-reporter.d.ts.map

package/build/src/project-reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-reporter.d.ts","sourceRoot":"","sources":["../../src/project-reporter.js"],"names":[],"mappings":"AAEA,OAAO,EAAC,qBAAqB,EAAC,MAAM,iBAAiB,CAAA;AAErD;;GAEG;AACH,qBAAa,oBAAoB;;IAa/B;;;OAGG;IACH,YAAY,OAAO,AAFhB,CACF,EADU;QAAC,MAAM,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;QAAC,MAAM,CAAC,EAAE,cAAc,CAAC;QAAC,MAAM,CAAC,EAAE,cAAc,CAAA;KAEjE,EAUvB;IAED;;;;OAIG;IACH,aAAa,CAAC,SAAS,EAHZ,MAGY,GAFV,IAAI,CAKhB;IAED;;;;OAIG;IACH,cAAc,CAAC,YAAY,EAHhB,MAGgB,GAFd,IAAI,CAKhB;IAED;;;;OAIG;IACH,eAAe,CAAC,MAAM,EAHX,OAAO,oBAAoB,EAAE,wBAGlB,GAFT,IAAI,CAUhB;IAED;;;;OAIG;IACH,aAAa,CAAC,OAAO,EAHV;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,qBAAqB,EAAE,sBAAsB,CAAA;KAGhF,GAFR,IAAI,CAgBhB;IAED;;;;OAIG;IACH,SAAS,CAAC,MAAM,EAHL,OAAO,oBAAoB,EAAE,mBAGxB,GAFH,IAAI,CA6BhB;IAED;;;;OAIG;IACH,MAAM,CAAC,OAAO,EAHH,OAGG,GAFD,IAAI,CAkBhB;CAiCF;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAHhC,OAGgC,GAF9B,qBAAqB,CAYjC;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAHhC,qBAGgC,GAF9B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAWnC;AA8ED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAJtC,OAIsC,EAAE,OAAO,EAH/C,MAG+C,GAF7C,MAAM,CASlB;AAcG,YAA+C,cAAc,GAAnD;IAAC,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAA;CAAC,CAAgB;AAAjE,oEAAoE"}