semantifold 0.1.1 → 0.3.0

package/build/src/artifacts.js

@@ -0,0 +1,389 @@
+// @ts-check
+import { decodedMappings, encodedMappings, presortedDecodedMap, TraceMap } from "@jridgewell/trace-mapping";
+import { isDenseArray } from "./array.js";
+import { isSafeArtifactPath, isValidFilenameMetadata } from "./artifact-path.js";
+import { finalizeByteMapping } from "./binary-mapping.js";
+import { SemantifoldDiagnostic } from "./diagnostic.js";
+import { finalizeMapping, toSourceMapV3 } from "./mapping.js";
+import { isSourceRangeOrdered } from "./semantic/location.js";
+import { hasOnlyUnicodeScalars } from "./semantic/scalars.js";
+const artifactRoles = new Set(["entry", "source", "manifest", "support", "mapping", "resource", "loader"]);
+const mediaTypePattern = /^[A-Za-z0-9!#$&^_.+-]+\/[A-Za-z0-9!#$&^_.+-]+(?:;[\u0020-\u007e]+)?$/u;
+/**
+ * Transactionally validates and constructs one deterministic generated artifact set.
+ * @param {unknown} candidate - Artifact-set fields.
+ * @returns {import("./semantic/types.js").GeneratedArtifactSet} Detached immutable set.
+ */
+export function createGeneratedArtifactSet(candidate) {
+    try {
+        if (!isPlainObject(candidate) || typeof candidate.target != "string" || candidate.target.length == 0 ||
+            !/^[a-z][a-z0-9-]*$/u.test(candidate.target)) {
+            invalidArtifactSet("Artifact set requires a stable lowercase target ID.", targetOf(candidate));
+        }
+        if (!isDenseArray(candidate.artifacts) || candidate.artifacts.length == 0) {
+            invalidArtifactSet("Artifact set requires a non-empty ordered artifact array.", candidate.target);
+        }
+        const target = candidate.target;
+        const paths = new Set();
+        const directoryPaths = new Set();
+        /** @type {string[]} */
+        const entryPaths = [];
+        /** @type {import("./semantic/types.js").GeneratedSetArtifact[]} */
+        const artifacts = [];
+        for (let index = 0; index < candidate.artifacts.length; index += 1) {
+            const artifact = candidate.artifacts[index];
+            if (!isPlainObject(artifact))
+                invalidArtifactSet(`Artifact ${index} must be a plain object.`, target);
+            const artifactPath = artifact.path;
+            const mediaType = artifact.mediaType;
+            const role = artifact.role;
+            const contentKind = artifact.contentKind;
+            if (!isSafeArtifactPath(artifactPath))
+                invalidArtifactSet(`Artifact ${index} has an unsafe path.`, target);
+            if (paths.has(artifactPath))
+                invalidArtifactSet(`Duplicate artifact path '${artifactPath}'.`, target);
+            if (directoryPaths.has(artifactPath)) {
+                invalidArtifactSet(`Artifact path '${artifactPath}' collides with a required directory.`, target);
+            }
+            const parentPaths = artifactDirectoryPaths(artifactPath);
+            for (const parentPath of parentPaths) {
+                if (paths.has(parentPath)) {
+                    invalidArtifactSet(`Artifact path '${artifactPath}' descends from artifact file '${parentPath}'.`, target);
+                }
+            }
+            paths.add(artifactPath);
+            for (const parentPath of parentPaths)
+                directoryPaths.add(parentPath);
+            if (typeof mediaType != "string" || !mediaTypePattern.test(mediaType) || /[\r\n]/u.test(mediaType)) {
+                invalidArtifactSet(`Artifact '${artifactPath}' has an invalid media type.`, target);
+            }
+            if (typeof role != "string" || !artifactRoles.has(role))
+                invalidArtifactSet(`Artifact '${artifactPath}' has an invalid role.`, target);
+            if (artifact.ownership != "generated")
+                invalidArtifactSet(`Artifact '${artifactPath}' must have generated ownership.`, target);
+            if (role == "entry") {
+                if (entryPaths.length > 0)
+                    invalidArtifactSet("Artifact set must declare exactly one entry artifact.", target);
+                entryPaths.push(artifactPath);
+            }
+            const contentValue = artifact.content;
+            /** @type {string | Uint8Array} */
+            let content;
+            if (contentKind == "text") {
+                if (typeof contentValue != "string" || contentValue.length == 0 || !hasOnlyUnicodeScalars(contentValue)) {
+                    invalidArtifactSet(`Text artifact '${artifactPath}' requires non-empty string content.`, target);
+                }
+                content = contentValue;
+            }
+            else if (contentKind == "binary") {
+                if (!(contentValue instanceof Uint8Array) || contentValue.byteLength == 0) {
+                    invalidArtifactSet(`Binary artifact '${artifactPath}' requires non-empty bytes.`, target);
+                }
+                content = new Uint8Array(contentValue);
+            }
+            else
+                invalidArtifactSet(`Artifact '${artifactPath}' has an invalid content kind.`, target);
+            const provenance = validateArtifactProvenance(artifact.provenance, contentKind, artifactPath, content, target);
+            artifacts.push(/** @type {import("./semantic/types.js").GeneratedSetArtifact} */ (freezeArtifact({
+                content,
+                contentKind,
+                mediaType,
+                ownership: /** @type {const} */ ("generated"),
+                path: artifactPath,
+                provenance,
+                role
+            })));
+        }
+        if (entryPaths.length != 1)
+            invalidArtifactSet("Artifact set must declare exactly one entry artifact.", candidate.target);
+        return Object.freeze({
+            artifacts: Object.freeze(artifacts),
+            entry: entryPaths[0],
+            schema: /** @type {const} */ ("GeneratedArtifactSet"),
+            target,
+            version: /** @type {const} */ (1)
+        });
+    }
+    catch (error) {
+        if (error instanceof SemantifoldDiagnostic && error.code == "INVALID_ARTIFACT_SET")
+            throw error;
+        return invalidArtifactSet("Artifact-set validation failed.", targetOf(candidate), error);
+    }
+}
+/**
+ * Validates artifact-level text, byte, or synthetic provenance.
+ * @param {unknown} value - Provenance candidate.
+ * @param {unknown} contentKind - Validated artifact content kind.
+ * @param {string} artifactPath - Validated artifact path.
+ * @param {string | Uint8Array} content - Detached artifact content.
+ * @param {string} target - Artifact target.
+ * @returns {import("./semantic/types.js").ArtifactProvenance} Validated provenance.
+ */
+function validateArtifactProvenance(value, contentKind, artifactPath, content, target) {
+    if (!isPlainObject(value))
+        invalidArtifactSet(`Artifact '${artifactPath}' requires provenance.`, target);
+    if (value.kind == "synthetic") {
+        if (typeof value.reason != "string" || value.reason.length == 0 || !isDenseArray(value.relatedOrigins)) {
+            invalidArtifactSet(`Synthetic artifact '${artifactPath}' requires an explicit reason and related origins.`, target);
+        }
+        if (contentKind == "binary") {
+            invalidArtifactSet(`Binary artifact '${artifactPath}' requires byte-range provenance.`, target);
+        }
+        /** @type {import("./semantic/types.js").RelatedOrigin[]} */
+        const relatedOrigins = [];
+        for (let index = 0; index < value.relatedOrigins.length; index += 1) {
+            relatedOrigins.push(validateRelatedOrigin(value.relatedOrigins[index], artifactPath, index, target));
+        }
+        return Object.freeze({ kind: /** @type {const} */ ("synthetic"), reason: value.reason, relatedOrigins: Object.freeze(relatedOrigins) });
+    }
+    if (value.kind == "text") {
+        const mappingCandidate = value.mapping;
+        if (contentKind != "text" || !isPlainObject(mappingCandidate) || mappingCandidate.schema != "SemantifoldMapping" ||
+            !isPlainObject(mappingCandidate.generated) || mappingCandidate.generated.filename != artifactPath ||
+            mappingCandidate.generated.content != content || !isPlainObject(value.sourceMap)) {
+            invalidArtifactSet(`Text artifact '${artifactPath}' has mismatched rich or Source Map provenance.`, target);
+        }
+        if (value.sourceMapFilename !== undefined && !isValidFilenameMetadata(value.sourceMapFilename)) {
+            invalidArtifactSet(`Text artifact '${artifactPath}' has invalid Source Map filename metadata.`, target);
+        }
+        const mapping = finalizeMapping(mappingCandidate);
+        const sourceMap = validateSourceMap(value.sourceMap, artifactPath, target);
+        const projectedSourceMap = toSourceMapV3(mapping);
+        if (!sameJsonValue(sourceMap, projectedSourceMap)) {
+            invalidArtifactSet(`Text artifact '${artifactPath}' has Source Map provenance that contradicts its rich mapping.`, target);
+        }
+        return Object.freeze({
+            kind: /** @type {const} */ ("text"),
+            mapping,
+            sourceMap,
+            sourceMapFilename: value.sourceMapFilename
+        });
+    }
+    if (value.kind == "bytes") {
+        if (contentKind != "binary")
+            invalidArtifactSet(`Byte provenance requires binary content for '${artifactPath}'.`, target);
+        const mapping = finalizeByteMapping(value.mapping);
+        if (mapping.generated.path != artifactPath || mapping.generated.byteLength != /** @type {Uint8Array} */ (content).byteLength) {
+            invalidArtifactSet(`Byte provenance does not match artifact '${artifactPath}'.`, target);
+        }
+        return Object.freeze({ kind: /** @type {const} */ ("bytes"), mapping });
+    }
+    return invalidArtifactSet(`Artifact '${artifactPath}' has an unknown provenance kind.`, target);
+}
+/**
+ * Freezes one validated artifact record.
+ * @param {Record<string, unknown>} artifact - Validated fields.
+ * @returns {Readonly<Record<string, unknown>>} Frozen record.
+ */
+function freezeArtifact(artifact) {
+    if (artifact.contentKind == "binary" && artifact.content instanceof Uint8Array) {
+        const content = artifact.content;
+        Object.defineProperty(artifact, "content", {
+            configurable: false,
+            enumerable: true,
+            get() {
+                return new Uint8Array(content);
+            }
+        });
+    }
+    return Object.freeze(artifact);
+}
+/**
+ * Lists every directory a safe relative POSIX artifact path requires.
+ * @param {string} artifactPath - Validated artifact path.
+ * @returns {string[]} Ordered parent directory paths.
+ */
+function artifactDirectoryPaths(artifactPath) {
+    const parts = artifactPath.split("/");
+    /** @type {string[]} */
+    const directories = [];
+    for (let index = 1; index < parts.length; index += 1)
+        directories.push(parts.slice(0, index).join("/"));
+    return directories;
+}
+/**
+ * Throws a normalized artifact-set diagnostic.
+ * @param {string} message - Failure detail.
+ * @param {string} target - Artifact target.
+ * @param {unknown} [error] - Preserved validation cause.
+ * @returns {never} Always throws.
+ */
+function invalidArtifactSet(message, target, error) {
+    throw new SemantifoldDiagnostic({
+        cause: error instanceof Error ? error : undefined,
+        code: "INVALID_ARTIFACT_SET",
+        language: target,
+        message
+    });
+}
+/**
+ * Derives a safe diagnostic identity from an unknown request.
+ * @param {unknown} value - Candidate set.
+ * @returns {string} Diagnostic identity.
+ */
+function targetOf(value) {
+    return isPlainObject(value) && typeof value.target == "string" && value.target.length > 0 ? value.target : "artifact";
+}
+/**
+ * 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;
+}
+/**
+ * Validates an artifact-level related origin without interpreting source offsets as generated bytes.
+ * @param {unknown} value - Related-origin candidate.
+ * @param {string} artifactPath - Owning artifact path.
+ * @param {number} index - Origin index.
+ * @param {string} target - Artifact target.
+ * @returns {import("./semantic/types.js").RelatedOrigin} Detached related origin.
+ */
+function validateRelatedOrigin(value, artifactPath, index, target) {
+    if (!isPlainObject(value) || typeof value.sourceId != "string" || value.sourceId.length == 0 ||
+        !isPlainObject(value.location) || typeof value.location.filename != "string" || value.location.filename.length == 0 ||
+        !validSourcePoint(value.location.start) || !validSourcePoint(value.location.end) ||
+        value.location.end.offset < value.location.start.offset || !isSourceRangeOrdered(value.location.start, value.location.end)) {
+        invalidArtifactSet(`Artifact '${artifactPath}' has malformed related origin ${index}.`, target);
+    }
+    return deepFreeze({
+        location: {
+            end: { ...value.location.end },
+            filename: value.location.filename,
+            start: { ...value.location.start }
+        },
+        sourceId: value.sourceId,
+        ...(optionalString(value.nodeId, "nodeId", artifactPath, index, target)),
+        ...(optionalString(value.symbolId, "symbolId", artifactPath, index, target)),
+        ...(optionalString(value.role, "role", artifactPath, index, target))
+    });
+}
+/**
+ * Validates one optional related-origin string field.
+ * @param {unknown} value - Candidate value.
+ * @param {string} property - Property name.
+ * @param {string} artifactPath - Owning artifact path.
+ * @param {number} index - Origin index.
+ * @param {string} target - Artifact target.
+ * @returns {Record<string, string>} Present validated property or an empty record.
+ */
+function optionalString(value, property, artifactPath, index, target) {
+    if (value === undefined)
+        return {};
+    if (typeof value != "string" || value.length == 0) {
+        invalidArtifactSet(`Artifact '${artifactPath}' has invalid ${property} in related origin ${index}.`, target);
+    }
+    return { [property]: value };
+}
+/**
+ * Checks one UTF-16 source point.
+ * @param {unknown} value - Candidate point.
+ * @returns {value is import("./semantic/types.js").SourcePoint} Whether the point is structurally valid.
+ */
+function validSourcePoint(value) {
+    return isPlainObject(value) && typeof value.line == "number" && Number.isSafeInteger(value.line) && value.line > 0 &&
+        typeof value.column == "number" && Number.isSafeInteger(value.column) && value.column > 0 &&
+        typeof value.offset == "number" && Number.isSafeInteger(value.offset) && value.offset >= 0;
+}
+/**
+ * Validates and detaches the Source Map v3 projection carried by a text artifact.
+ * @param {unknown} value - Source Map candidate.
+ * @param {string} artifactPath - Owning artifact path.
+ * @param {string} target - Artifact target.
+ * @returns {import("@jridgewell/gen-mapping").EncodedSourceMap} Detached Source Map.
+ */
+function validateSourceMap(value, artifactPath, target) {
+    if (!isPlainObject(value) || value.version != 3 || value.file != artifactPath || typeof value.mappings != "string" ||
+        !isDenseArray(value.names) || !value.names.every((name) => typeof name == "string") ||
+        !isDenseArray(value.sources) || !value.sources.every((source) => typeof source == "string") ||
+        (value.sourcesContent !== undefined && (!isDenseArray(value.sourcesContent) ||
+            !value.sourcesContent.every((source) => source == null || typeof source == "string")))) {
+        invalidArtifactSet(`Text artifact '${artifactPath}' has malformed Source Map v3 provenance.`, target);
+    }
+    validateEncodedSourceMapMappings(
+    /** @type {import("@jridgewell/trace-mapping").EncodedSourceMap} */ ( /** @type {unknown} */(value)), artifactPath, target);
+    const detached = /** @type {unknown} */ (structuredClone(value));
+    return deepFreeze(/** @type {import("@jridgewell/gen-mapping").EncodedSourceMap} */ (detached));
+}
+/**
+ * Decodes and validates the Source Map payload with the installed mapping implementation.
+ * @param {import("@jridgewell/trace-mapping").EncodedSourceMap} sourceMap - Structurally validated map.
+ * @param {string} artifactPath - Owning artifact path.
+ * @param {string} target - Artifact target.
+ * @returns {void}
+ */
+function validateEncodedSourceMapMappings(sourceMap, artifactPath, target) {
+    /** @type {Readonly<import("@jridgewell/trace-mapping").SourceMapSegment[][]>} */
+    let decoded;
+    let canonicalMappings;
+    try {
+        decoded = decodedMappings(new TraceMap(sourceMap));
+        const decodedMap = /** @type {import("@jridgewell/trace-mapping").DecodedSourceMap} */ ({
+            ...sourceMap,
+            mappings: structuredClone(decoded)
+        });
+        canonicalMappings = encodedMappings(presortedDecodedMap(decodedMap));
+    }
+    catch (error) {
+        invalidArtifactSet(`Text artifact '${artifactPath}' has invalid encoded Source Map mappings.`, target, error);
+    }
+    if (canonicalMappings != sourceMap.mappings ||
+        !validDecodedSourceMapMappings(decoded, sourceMap.sources.length, sourceMap.names.length)) {
+        invalidArtifactSet(`Text artifact '${artifactPath}' has invalid encoded Source Map mappings.`, target);
+    }
+}
+/**
+ * Validates decoded Source Map segment shape and referenced indices.
+ * @param {Readonly<import("@jridgewell/trace-mapping").SourceMapSegment[][]>} lines - Decoded mapping lines.
+ * @param {number} sourceCount - Declared source count.
+ * @param {number} nameCount - Declared name count.
+ * @returns {boolean} Whether every segment is semantically valid.
+ */
+function validDecodedSourceMapMappings(lines, sourceCount, nameCount) {
+    return lines.every((line) => line.every((segment) => {
+        if (segment.length != 1 && segment.length != 4 && segment.length != 5)
+            return false;
+        if (!segment.every((field) => Number.isSafeInteger(field) && field >= 0))
+            return false;
+        if (segment.length == 1)
+            return true;
+        if (segment[1] >= sourceCount)
+            return false;
+        return segment.length == 4 || segment[4] < nameCount;
+    }));
+}
+/**
+ * Compares detached JSON values without depending on caller object-key order.
+ * @param {unknown} left - First JSON value.
+ * @param {unknown} right - Second JSON value.
+ * @returns {boolean} Whether both values are structurally identical.
+ */
+function sameJsonValue(left, right) {
+    if (left === right)
+        return true;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        return Array.isArray(left) && Array.isArray(right) && left.length == right.length &&
+            left.every((entry, index) => sameJsonValue(entry, right[index]));
+    }
+    if (!isPlainObject(left) || !isPlainObject(right))
+        return false;
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    return leftKeys.length == rightKeys.length &&
+        leftKeys.every((key) => Object.hasOwn(right, key) && sameJsonValue(left[key], right[key]));
+}
+/**
+ * Deeply freezes a detached JSON value.
+ * @template T
+ * @param {T} value - Detached value.
+ * @returns {T} Frozen value.
+ */
+function deepFreeze(value) {
+    if (!value || typeof value != "object" || Object.isFrozen(value))
+        return value;
+    for (const nested of Object.values(value))
+        deepFreeze(nested);
+    return Object.freeze(value);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"artifacts.js","sourceRoot":"","sources":["../../src/artifacts.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {decodedMappings, encodedMappings, presortedDecodedMap, TraceMap} from \"@jridgewell/trace-mapping\"\nimport {isDenseArray} from \"./array.js\"\nimport {isSafeArtifactPath, isValidFilenameMetadata} from \"./artifact-path.js\"\nimport {finalizeByteMapping} from \"./binary-mapping.js\"\nimport {SemantifoldDiagnostic} from \"./diagnostic.js\"\nimport {finalizeMapping, toSourceMapV3} from \"./mapping.js\"\nimport {isSourceRangeOrdered} from \"./semantic/location.js\"\nimport {hasOnlyUnicodeScalars} from \"./semantic/scalars.js\"\n\nconst artifactRoles = new Set([\"entry\", \"source\", \"manifest\", \"support\", \"mapping\", \"resource\", \"loader\"])\nconst mediaTypePattern = /^[A-Za-z0-9!#$&^_.+-]+\\/[A-Za-z0-9!#$&^_.+-]+(?:;[\\u0020-\\u007e]+)?$/u\n\n/**\n * Transactionally validates and constructs one deterministic generated artifact set.\n * @param {unknown} candidate - Artifact-set fields.\n * @returns {import(\"./semantic/types.js\").GeneratedArtifactSet} Detached immutable set.\n */\nexport function createGeneratedArtifactSet(candidate) {\n  try {\n    if (!isPlainObject(candidate) || typeof candidate.target != \"string\" || candidate.target.length == 0 ||\n      !/^[a-z][a-z0-9-]*$/u.test(candidate.target)) {\n      invalidArtifactSet(\"Artifact set requires a stable lowercase target ID.\", targetOf(candidate))\n    }\n    if (!isDenseArray(candidate.artifacts) || candidate.artifacts.length == 0) {\n      invalidArtifactSet(\"Artifact set requires a non-empty ordered artifact array.\", candidate.target)\n    }\n    const target = candidate.target\n\n    const paths = new Set()\n    const directoryPaths = new Set()\n    /** @type {string[]} */\n    const entryPaths = []\n    /** @type {import(\"./semantic/types.js\").GeneratedSetArtifact[]} */\n    const artifacts = []\n\n    for (let index = 0; index < candidate.artifacts.length; index += 1) {\n      const artifact = candidate.artifacts[index]\n\n      if (!isPlainObject(artifact)) invalidArtifactSet(`Artifact ${index} must be a plain object.`, target)\n      const artifactPath = artifact.path\n      const mediaType = artifact.mediaType\n      const role = artifact.role\n      const contentKind = artifact.contentKind\n\n      if (!isSafeArtifactPath(artifactPath)) invalidArtifactSet(`Artifact ${index} has an unsafe path.`, target)\n      if (paths.has(artifactPath)) invalidArtifactSet(`Duplicate artifact path '${artifactPath}'.`, target)\n      if (directoryPaths.has(artifactPath)) {\n        invalidArtifactSet(`Artifact path '${artifactPath}' collides with a required directory.`, target)\n      }\n      const parentPaths = artifactDirectoryPaths(artifactPath)\n\n      for (const parentPath of parentPaths) {\n        if (paths.has(parentPath)) {\n          invalidArtifactSet(`Artifact path '${artifactPath}' descends from artifact file '${parentPath}'.`, target)\n        }\n      }\n      paths.add(artifactPath)\n      for (const parentPath of parentPaths) directoryPaths.add(parentPath)\n      if (typeof mediaType != \"string\" || !mediaTypePattern.test(mediaType) || /[\\r\\n]/u.test(mediaType)) {\n        invalidArtifactSet(`Artifact '${artifactPath}' has an invalid media type.`, target)\n      }\n      if (typeof role != \"string\" || !artifactRoles.has(role)) invalidArtifactSet(`Artifact '${artifactPath}' has an invalid role.`, target)\n      if (artifact.ownership != \"generated\") invalidArtifactSet(`Artifact '${artifactPath}' must have generated ownership.`, target)\n      if (role == \"entry\") {\n        if (entryPaths.length > 0) invalidArtifactSet(\"Artifact set must declare exactly one entry artifact.\", target)\n        entryPaths.push(artifactPath)\n      }\n\n      const contentValue = artifact.content\n      /** @type {string | Uint8Array} */\n      let content\n\n      if (contentKind == \"text\") {\n        if (typeof contentValue != \"string\" || contentValue.length == 0 || !hasOnlyUnicodeScalars(contentValue)) {\n          invalidArtifactSet(`Text artifact '${artifactPath}' requires non-empty string content.`, target)\n        }\n        content = contentValue\n      } else if (contentKind == \"binary\") {\n        if (!(contentValue instanceof Uint8Array) || contentValue.byteLength == 0) {\n          invalidArtifactSet(`Binary artifact '${artifactPath}' requires non-empty bytes.`, target)\n        }\n        content = new Uint8Array(contentValue)\n      } else invalidArtifactSet(`Artifact '${artifactPath}' has an invalid content kind.`, target)\n\n      const provenance = validateArtifactProvenance(artifact.provenance, contentKind, artifactPath, content, target)\n\n      artifacts.push(/** @type {import(\"./semantic/types.js\").GeneratedSetArtifact} */ (freezeArtifact({\n        content,\n        contentKind,\n        mediaType,\n        ownership: /** @type {const} */ (\"generated\"),\n        path: artifactPath,\n        provenance,\n        role\n      })))\n    }\n\n    if (entryPaths.length != 1) invalidArtifactSet(\"Artifact set must declare exactly one entry artifact.\", candidate.target)\n\n    return Object.freeze({\n      artifacts: Object.freeze(artifacts),\n      entry: entryPaths[0],\n      schema: /** @type {const} */ (\"GeneratedArtifactSet\"),\n      target,\n      version: /** @type {const} */ (1)\n    })\n  } catch (error) {\n    if (error instanceof SemantifoldDiagnostic && error.code == \"INVALID_ARTIFACT_SET\") throw error\n\n    return invalidArtifactSet(\"Artifact-set validation failed.\", targetOf(candidate), error)\n  }\n}\n\n/**\n * Validates artifact-level text, byte, or synthetic provenance.\n * @param {unknown} value - Provenance candidate.\n * @param {unknown} contentKind - Validated artifact content kind.\n * @param {string} artifactPath - Validated artifact path.\n * @param {string | Uint8Array} content - Detached artifact content.\n * @param {string} target - Artifact target.\n * @returns {import(\"./semantic/types.js\").ArtifactProvenance} Validated provenance.\n */\nfunction validateArtifactProvenance(value, contentKind, artifactPath, content, target) {\n  if (!isPlainObject(value)) invalidArtifactSet(`Artifact '${artifactPath}' requires provenance.`, target)\n\n  if (value.kind == \"synthetic\") {\n    if (typeof value.reason != \"string\" || value.reason.length == 0 || !isDenseArray(value.relatedOrigins)) {\n      invalidArtifactSet(`Synthetic artifact '${artifactPath}' requires an explicit reason and related origins.`, target)\n    }\n    if (contentKind == \"binary\") {\n      invalidArtifactSet(`Binary artifact '${artifactPath}' requires byte-range provenance.`, target)\n    }\n    /** @type {import(\"./semantic/types.js\").RelatedOrigin[]} */\n    const relatedOrigins = []\n\n    for (let index = 0; index < value.relatedOrigins.length; index += 1) {\n      relatedOrigins.push(validateRelatedOrigin(value.relatedOrigins[index], artifactPath, index, target))\n    }\n\n    return Object.freeze({kind: /** @type {const} */ (\"synthetic\"), reason: value.reason, relatedOrigins: Object.freeze(relatedOrigins)})\n  }\n\n  if (value.kind == \"text\") {\n    const mappingCandidate = value.mapping\n\n    if (contentKind != \"text\" || !isPlainObject(mappingCandidate) || mappingCandidate.schema != \"SemantifoldMapping\" ||\n      !isPlainObject(mappingCandidate.generated) || mappingCandidate.generated.filename != artifactPath ||\n      mappingCandidate.generated.content != content || !isPlainObject(value.sourceMap)) {\n      invalidArtifactSet(`Text artifact '${artifactPath}' has mismatched rich or Source Map provenance.`, target)\n    }\n    if (value.sourceMapFilename !== undefined && !isValidFilenameMetadata(value.sourceMapFilename)) {\n      invalidArtifactSet(`Text artifact '${artifactPath}' has invalid Source Map filename metadata.`, target)\n    }\n    const mapping = finalizeMapping(mappingCandidate)\n    const sourceMap = validateSourceMap(value.sourceMap, artifactPath, target)\n    const projectedSourceMap = toSourceMapV3(mapping)\n\n    if (!sameJsonValue(sourceMap, projectedSourceMap)) {\n      invalidArtifactSet(`Text artifact '${artifactPath}' has Source Map provenance that contradicts its rich mapping.`, target)\n    }\n\n    return Object.freeze({\n      kind: /** @type {const} */ (\"text\"),\n      mapping,\n      sourceMap,\n      sourceMapFilename: value.sourceMapFilename\n    })\n  }\n\n  if (value.kind == \"bytes\") {\n    if (contentKind != \"binary\") invalidArtifactSet(`Byte provenance requires binary content for '${artifactPath}'.`, target)\n    const mapping = finalizeByteMapping(value.mapping)\n\n    if (mapping.generated.path != artifactPath || mapping.generated.byteLength != /** @type {Uint8Array} */ (content).byteLength) {\n      invalidArtifactSet(`Byte provenance does not match artifact '${artifactPath}'.`, target)\n    }\n\n    return Object.freeze({kind: /** @type {const} */ (\"bytes\"), mapping})\n  }\n\n  return invalidArtifactSet(`Artifact '${artifactPath}' has an unknown provenance kind.`, target)\n}\n\n/**\n * Freezes one validated artifact record.\n * @param {Record<string, unknown>} artifact - Validated fields.\n * @returns {Readonly<Record<string, unknown>>} Frozen record.\n */\nfunction freezeArtifact(artifact) {\n  if (artifact.contentKind == \"binary\" && artifact.content instanceof Uint8Array) {\n    const content = artifact.content\n\n    Object.defineProperty(artifact, \"content\", {\n      configurable: false,\n      enumerable: true,\n      get() {\n        return new Uint8Array(content)\n      }\n    })\n  }\n\n  return Object.freeze(artifact)\n}\n\n/**\n * Lists every directory a safe relative POSIX artifact path requires.\n * @param {string} artifactPath - Validated artifact path.\n * @returns {string[]} Ordered parent directory paths.\n */\nfunction artifactDirectoryPaths(artifactPath) {\n  const parts = artifactPath.split(\"/\")\n  /** @type {string[]} */\n  const directories = []\n\n  for (let index = 1; index < parts.length; index += 1) directories.push(parts.slice(0, index).join(\"/\"))\n\n  return directories\n}\n\n/**\n * Throws a normalized artifact-set diagnostic.\n * @param {string} message - Failure detail.\n * @param {string} target - Artifact target.\n * @param {unknown} [error] - Preserved validation cause.\n * @returns {never} Always throws.\n */\nfunction invalidArtifactSet(message, target, error) {\n  throw new SemantifoldDiagnostic({\n    cause: error instanceof Error ? error : undefined,\n    code: \"INVALID_ARTIFACT_SET\",\n    language: target,\n    message\n  })\n}\n\n/**\n * Derives a safe diagnostic identity from an unknown request.\n * @param {unknown} value - Candidate set.\n * @returns {string} Diagnostic identity.\n */\nfunction targetOf(value) {\n  return isPlainObject(value) && typeof value.target == \"string\" && value.target.length > 0 ? value.target : \"artifact\"\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 * Validates an artifact-level related origin without interpreting source offsets as generated bytes.\n * @param {unknown} value - Related-origin candidate.\n * @param {string} artifactPath - Owning artifact path.\n * @param {number} index - Origin index.\n * @param {string} target - Artifact target.\n * @returns {import(\"./semantic/types.js\").RelatedOrigin} Detached related origin.\n */\nfunction validateRelatedOrigin(value, artifactPath, index, target) {\n  if (!isPlainObject(value) || typeof value.sourceId != \"string\" || value.sourceId.length == 0 ||\n    !isPlainObject(value.location) || typeof value.location.filename != \"string\" || value.location.filename.length == 0 ||\n    !validSourcePoint(value.location.start) || !validSourcePoint(value.location.end) ||\n    value.location.end.offset < value.location.start.offset || !isSourceRangeOrdered(value.location.start, value.location.end)) {\n    invalidArtifactSet(`Artifact '${artifactPath}' has malformed related origin ${index}.`, target)\n  }\n\n  return deepFreeze({\n    location: {\n      end: {...value.location.end},\n      filename: value.location.filename,\n      start: {...value.location.start}\n    },\n    sourceId: value.sourceId,\n    ...(optionalString(value.nodeId, \"nodeId\", artifactPath, index, target)),\n    ...(optionalString(value.symbolId, \"symbolId\", artifactPath, index, target)),\n    ...(optionalString(value.role, \"role\", artifactPath, index, target))\n  })\n}\n\n/**\n * Validates one optional related-origin string field.\n * @param {unknown} value - Candidate value.\n * @param {string} property - Property name.\n * @param {string} artifactPath - Owning artifact path.\n * @param {number} index - Origin index.\n * @param {string} target - Artifact target.\n * @returns {Record<string, string>} Present validated property or an empty record.\n */\nfunction optionalString(value, property, artifactPath, index, target) {\n  if (value === undefined) return {}\n  if (typeof value != \"string\" || value.length == 0) {\n    invalidArtifactSet(`Artifact '${artifactPath}' has invalid ${property} in related origin ${index}.`, target)\n  }\n\n  return {[property]: value}\n}\n\n/**\n * Checks one UTF-16 source point.\n * @param {unknown} value - Candidate point.\n * @returns {value is import(\"./semantic/types.js\").SourcePoint} Whether the point is structurally valid.\n */\nfunction validSourcePoint(value) {\n  return isPlainObject(value) && typeof value.line == \"number\" && Number.isSafeInteger(value.line) && value.line > 0 &&\n    typeof value.column == \"number\" && Number.isSafeInteger(value.column) && value.column > 0 &&\n    typeof value.offset == \"number\" && Number.isSafeInteger(value.offset) && value.offset >= 0\n}\n\n/**\n * Validates and detaches the Source Map v3 projection carried by a text artifact.\n * @param {unknown} value - Source Map candidate.\n * @param {string} artifactPath - Owning artifact path.\n * @param {string} target - Artifact target.\n * @returns {import(\"@jridgewell/gen-mapping\").EncodedSourceMap} Detached Source Map.\n */\nfunction validateSourceMap(value, artifactPath, target) {\n  if (!isPlainObject(value) || value.version != 3 || value.file != artifactPath || typeof value.mappings != \"string\" ||\n    !isDenseArray(value.names) || !value.names.every((name) => typeof name == \"string\") ||\n    !isDenseArray(value.sources) || !value.sources.every((source) => typeof source == \"string\") ||\n    (value.sourcesContent !== undefined && (!isDenseArray(value.sourcesContent) ||\n      !value.sourcesContent.every((source) => source == null || typeof source == \"string\")))) {\n    invalidArtifactSet(`Text artifact '${artifactPath}' has malformed Source Map v3 provenance.`, target)\n  }\n  validateEncodedSourceMapMappings(\n    /** @type {import(\"@jridgewell/trace-mapping\").EncodedSourceMap} */ (/** @type {unknown} */ (value)),\n    artifactPath,\n    target\n  )\n\n  const detached = /** @type {unknown} */ (structuredClone(value))\n\n  return deepFreeze(/** @type {import(\"@jridgewell/gen-mapping\").EncodedSourceMap} */ (detached))\n}\n\n/**\n * Decodes and validates the Source Map payload with the installed mapping implementation.\n * @param {import(\"@jridgewell/trace-mapping\").EncodedSourceMap} sourceMap - Structurally validated map.\n * @param {string} artifactPath - Owning artifact path.\n * @param {string} target - Artifact target.\n * @returns {void}\n */\nfunction validateEncodedSourceMapMappings(sourceMap, artifactPath, target) {\n  /** @type {Readonly<import(\"@jridgewell/trace-mapping\").SourceMapSegment[][]>} */\n  let decoded\n  let canonicalMappings\n\n  try {\n    decoded = decodedMappings(new TraceMap(sourceMap))\n    const decodedMap = /** @type {import(\"@jridgewell/trace-mapping\").DecodedSourceMap} */ ({\n      ...sourceMap,\n      mappings: structuredClone(decoded)\n    })\n\n    canonicalMappings = encodedMappings(presortedDecodedMap(decodedMap))\n  } catch (error) {\n    invalidArtifactSet(`Text artifact '${artifactPath}' has invalid encoded Source Map mappings.`, target, error)\n  }\n\n  if (canonicalMappings != sourceMap.mappings ||\n    !validDecodedSourceMapMappings(decoded, sourceMap.sources.length, sourceMap.names.length)) {\n    invalidArtifactSet(`Text artifact '${artifactPath}' has invalid encoded Source Map mappings.`, target)\n  }\n}\n\n/**\n * Validates decoded Source Map segment shape and referenced indices.\n * @param {Readonly<import(\"@jridgewell/trace-mapping\").SourceMapSegment[][]>} lines - Decoded mapping lines.\n * @param {number} sourceCount - Declared source count.\n * @param {number} nameCount - Declared name count.\n * @returns {boolean} Whether every segment is semantically valid.\n */\nfunction validDecodedSourceMapMappings(lines, sourceCount, nameCount) {\n  return lines.every((line) => line.every((segment) => {\n    if (segment.length != 1 && segment.length != 4 && segment.length != 5) return false\n    if (!segment.every((field) => Number.isSafeInteger(field) && field >= 0)) return false\n    if (segment.length == 1) return true\n    if (segment[1] >= sourceCount) return false\n\n    return segment.length == 4 || segment[4] < nameCount\n  }))\n}\n\n/**\n * Compares detached JSON values without depending on caller object-key order.\n * @param {unknown} left - First JSON value.\n * @param {unknown} right - Second JSON value.\n * @returns {boolean} Whether both values are structurally identical.\n */\nfunction sameJsonValue(left, right) {\n  if (left === right) return true\n  if (Array.isArray(left) || Array.isArray(right)) {\n    return Array.isArray(left) && Array.isArray(right) && left.length == right.length &&\n      left.every((entry, index) => sameJsonValue(entry, right[index]))\n  }\n  if (!isPlainObject(left) || !isPlainObject(right)) return false\n  const leftKeys = Object.keys(left)\n  const rightKeys = Object.keys(right)\n\n  return leftKeys.length == rightKeys.length &&\n    leftKeys.every((key) => Object.hasOwn(right, key) && sameJsonValue(left[key], right[key]))\n}\n\n/**\n * Deeply freezes a detached JSON value.\n * @template T\n * @param {T} value - Detached value.\n * @returns {T} Frozen value.\n */\nfunction deepFreeze(value) {\n  if (!value || typeof value != \"object\" || Object.isFrozen(value)) return value\n\n  for (const nested of Object.values(value)) deepFreeze(nested)\n\n  return Object.freeze(value)\n}\n"]}

package/build/src/backends/c-runtime.d.ts

@@ -0,0 +1,3 @@
+/** Canonical C17 support header; native ownership never enters semantic IR. */
+export declare const cRuntimeHeader = "#ifndef SEMANTIFOLD_RUNTIME_H\n#define SEMANTIFOLD_RUNTIME_H\n\n#include <stdbool.h>\n#include <stddef.h>\n#include <stdint.h>\n#include <limits.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\n_Static_assert(CHAR_BIT == 8, \"Semantifold requires eight-bit bytes\");\n_Static_assert(sizeof(int64_t) == 8, \"Semantifold requires exact int64_t\");\n_Static_assert(sizeof(size_t) == 8 && PTRDIFF_MAX == INT64_MAX, \"Semantifold requires the qualified 64-bit ABI\");\n\ntypedef struct {\n    const unsigned char *data;\n    size_t length;\n} SemantifoldString;\n\n#define SEMANTIFOLD_STRING(literal) ((SemantifoldString){(const unsigned char *)(literal), sizeof(literal) - 1})\n\ntypedef struct SemantifoldAllocation {\n    struct SemantifoldAllocation *next;\n    unsigned char data[];\n} SemantifoldAllocation;\n\n_Static_assert(sizeof(SemantifoldAllocation) == 8, \"Semantifold requires the qualified arena metadata size\");\n\nstatic SemantifoldAllocation *semantifold_arena = NULL;\nstatic size_t semantifold_arena_bytes = 0;\n\nstatic inline void semantifold_cleanup(void) {\n    while (semantifold_arena != NULL) {\n        SemantifoldAllocation *allocation = semantifold_arena;\n        semantifold_arena = allocation->next;\n        free(allocation);\n    }\n    semantifold_arena_bytes = 0;\n}\n\n_Noreturn static inline void semantifold_fatal(const char *message, size_t length) {\n    semantifold_cleanup();\n    (void)fwrite(message, 1, length, stderr);\n    exit(70);\n}\n\nstatic inline int64_t semantifold_integer_add(int64_t left, int64_t right) {\n    int64_t result;\n    if (__builtin_add_overflow(left, right, &result)) {\n        semantifold_fatal(\"semantifold: integer overflow\\n\", sizeof(\"semantifold: integer overflow\\n\") - 1);\n    }\n    return result;\n}\n\nstatic inline int64_t semantifold_integer_subtract(int64_t left, int64_t right) {\n    int64_t result;\n    if (__builtin_sub_overflow(left, right, &result)) {\n        semantifold_fatal(\"semantifold: integer overflow\\n\", sizeof(\"semantifold: integer overflow\\n\") - 1);\n    }\n    return result;\n}\n\nstatic inline int64_t semantifold_integer_multiply(int64_t left, int64_t right) {\n    int64_t result;\n    if (__builtin_mul_overflow(left, right, &result)) {\n        semantifold_fatal(\"semantifold: integer overflow\\n\", sizeof(\"semantifold: integer overflow\\n\") - 1);\n    }\n    return result;\n}\n\nstatic inline int64_t semantifold_integer_negate(int64_t value) {\n    return semantifold_integer_subtract(INT64_C(0), value);\n}\n\nstatic inline size_t semantifold_allocation_size(size_t left, size_t right) {\n    const size_t maximum = (size_t)PTRDIFF_MAX;\n    if (left > maximum || right > maximum - left ||\n        left + right > maximum - sizeof(SemantifoldAllocation)) {\n        semantifold_fatal(\"semantifold: allocation size\\n\", sizeof(\"semantifold: allocation size\\n\") - 1);\n    }\n    const size_t size = sizeof(SemantifoldAllocation) + left + right;\n    if (semantifold_arena_bytes > maximum - size) {\n        semantifold_fatal(\"semantifold: allocation size\\n\", sizeof(\"semantifold: allocation size\\n\") - 1);\n    }\n    return size;\n}\n\nstatic inline SemantifoldString semantifold_string_concat(SemantifoldString left, SemantifoldString right) {\n    const size_t size = semantifold_allocation_size(left.length, right.length);\n    SemantifoldAllocation *allocation = malloc(size);\n    if (allocation == NULL) {\n        semantifold_fatal(\"semantifold: allocation failure\\n\", sizeof(\"semantifold: allocation failure\\n\") - 1);\n    }\n    allocation->next = semantifold_arena;\n    semantifold_arena = allocation;\n    semantifold_arena_bytes += size;\n    if (left.length != 0) (void)memcpy(allocation->data, left.data, left.length);\n    if (right.length != 0) (void)memcpy(allocation->data + left.length, right.data, right.length);\n    return (SemantifoldString){allocation->data, left.length + right.length};\n}\n\nstatic inline bool semantifold_string_equal(SemantifoldString left, SemantifoldString right) {\n    return left.length == right.length && (left.length == 0 || memcmp(left.data, right.data, left.length) == 0);\n}\n\nstatic inline bool semantifold_string_not_equal(SemantifoldString left, SemantifoldString right) {\n    return !semantifold_string_equal(left, right);\n}\n\nstatic inline void semantifold_write(const unsigned char *data, size_t length) {\n    if (length != 0 && fwrite(data, 1, length, stdout) != length) {\n        semantifold_fatal(\"semantifold: output failure\\n\", sizeof(\"semantifold: output failure\\n\") - 1);\n    }\n}\n\nstatic inline void semantifold_newline(void) {\n    semantifold_write((const unsigned char *)\"\\n\", 1);\n    if (fflush(stdout) != 0) semantifold_fatal(\"semantifold: output failure\\n\", sizeof(\"semantifold: output failure\\n\") - 1);\n}\n\nstatic inline void semantifold_print_string(SemantifoldString value) {\n    semantifold_write(value.data, value.length);\n    semantifold_newline();\n}\n\nstatic inline void semantifold_print_boolean(bool value) {\n    if (value) semantifold_write((const unsigned char *)\"true\", 4);\n    else semantifold_write((const unsigned char *)\"false\", 5);\n    semantifold_newline();\n}\n\nstatic inline void semantifold_print_integer(int64_t value) {\n    unsigned char digits[20];\n    size_t position = sizeof(digits);\n    uint64_t magnitude = (uint64_t)value;\n    if (value < 0) magnitude = UINT64_C(0) - magnitude;\n    do {\n        digits[--position] = (unsigned char)(UINT64_C(48) + magnitude % UINT64_C(10));\n        magnitude /= UINT64_C(10);\n    } while (magnitude != 0);\n    if (value < 0) digits[--position] = (unsigned char)45;\n    semantifold_write(digits + position, sizeof(digits) - position);\n    semantifold_newline();\n}\n\n#endif\n";
+//# sourceMappingURL=c-runtime.d.ts.map

package/build/src/backends/c-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"c-runtime.d.ts","sourceRoot":"","sources":["../../../src/backends/c-runtime.js"],"names":[],"mappings":"AAEA,+EAA+E;AAC/E,eAAO,MAAM,cAAc,2sLAmJ1B,CAAA"}