semantifold 0.1.1 → 0.2.0

package/build/src/binary-mapping.js

@@ -0,0 +1,285 @@
+// @ts-check
+import { isDenseArray } from "./array.js";
+import { isSafeArtifactPath } from "./artifact-path.js";
+import { SemantifoldDiagnostic } from "./diagnostic.js";
+import { isSourceRangeOrdered } from "./semantic/location.js";
+/**
+ * Creates and validates an immutable byte-coordinate provenance map.
+ * @param {object} input - Mapping fields.
+ * @param {number} input.byteLength - Generated artifact byte length.
+ * @param {string} input.path - Generated artifact path.
+ * @param {import("./semantic/types.js").GeneratedByteRange[]} input.ranges - Ordered byte ranges.
+ * @returns {import("./semantic/types.js").SemantifoldByteMapping} Validated mapping.
+ */
+export function createByteMapping(input) {
+    if (!isPlainObject(input))
+        invalidByteMapping("Byte mapping construction requires an object.");
+    const { byteLength, path, ranges } = input;
+    return finalizeByteMapping({
+        coordinateSystem: "bytes",
+        generated: { byteLength, path },
+        ranges,
+        schema: "SemantifoldByteMapping",
+        version: 1
+    });
+}
+/**
+ * Parses serialized byte-coordinate provenance.
+ * @param {string} serialized - JSON mapping.
+ * @returns {import("./semantic/types.js").SemantifoldByteMapping} Validated mapping.
+ */
+export function parseByteMapping(serialized) {
+    try {
+        return finalizeByteMapping(JSON.parse(serialized));
+    }
+    catch (error) {
+        if (error instanceof SemantifoldDiagnostic && error.code == "INVALID_BYTE_MAPPING")
+            throw error;
+        return invalidByteMapping("Byte mapping must be valid JSON.", error);
+    }
+}
+/**
+ * Serializes a validated mapping with stable object-key ordering.
+ * @param {import("./semantic/types.js").SemantifoldByteMapping} mapping - Byte mapping.
+ * @returns {string} Canonical JSON with trailing LF.
+ */
+export function stringifyByteMapping(mapping) {
+    const validated = finalizeByteMapping(mapping);
+    return `${JSON.stringify(sortJson(validated), null, 2)}\n`;
+}
+/**
+ * Validates an existing mapping and returns a detached immutable value.
+ * @param {unknown} candidate - Mapping candidate.
+ * @returns {import("./semantic/types.js").SemantifoldByteMapping} Validated mapping.
+ */
+export function finalizeByteMapping(candidate) {
+    try {
+        if (!isPlainObject(candidate))
+            invalidByteMapping("Byte mapping must be a plain object.");
+        if (candidate.schema != "SemantifoldByteMapping" || candidate.version !== 1 || candidate.coordinateSystem != "bytes") {
+            invalidByteMapping("Byte mapping requires SemantifoldByteMapping version 1 with byte coordinates.");
+        }
+        if (!isPlainObject(candidate.generated)) {
+            invalidByteMapping("Byte mapping requires a safe generated artifact path.");
+        }
+        const generatedPath = candidate.generated.path;
+        if (!isSafeArtifactPath(generatedPath)) {
+            invalidByteMapping("Byte mapping requires a safe generated artifact path.");
+        }
+        const byteLength = candidate.generated.byteLength;
+        if (typeof byteLength != "number" || !Number.isSafeInteger(byteLength) || byteLength < 0) {
+            invalidByteMapping("Byte mapping requires a non-negative safe byte length.");
+        }
+        if (!isDenseArray(candidate.ranges))
+            invalidByteMapping("Byte mapping ranges must be an ordered dense array.");
+        let previousEnd = 0;
+        /** @type {import("./semantic/types.js").GeneratedByteRange[]} */
+        const ranges = [];
+        for (let index = 0; index < candidate.ranges.length; index += 1) {
+            const range = candidate.ranges[index];
+            if (!isPlainObject(range) || !isPlainObject(range.generated))
+                invalidByteMapping(`Byte range ${index} is malformed.`);
+            const end = range.generated.end;
+            const start = range.generated.start;
+            if (typeof start != "number" || typeof end != "number" || !Number.isSafeInteger(start) || !Number.isSafeInteger(end) ||
+                start < 0 || end <= start || end > byteLength) {
+                invalidByteMapping(`Byte range ${index} must be a non-empty in-bounds half-open integer range.`);
+            }
+            if (start < previousEnd)
+                invalidByteMapping(`Byte range ${index} is out of order or overlaps its predecessor.`);
+            previousEnd = end;
+            const origin = validateOrigin(range.origin, `Byte range ${index}`);
+            const result = {
+                generated: { end, start },
+                origin,
+                ...(optionalIdentity(range.nodeId, "nodeId", index)),
+                ...(optionalIdentity(range.symbolId, "symbolId", index)),
+                ...(optionalIdentity(range.role, "role", index))
+            };
+            ranges.push(result);
+        }
+        const mapping = {
+            coordinateSystem: /** @type {const} */ ("bytes"),
+            generated: { byteLength, path: generatedPath },
+            ranges,
+            schema: /** @type {const} */ ("SemantifoldByteMapping"),
+            version: /** @type {const} */ (1)
+        };
+        return deepFreeze(mapping);
+    }
+    catch (error) {
+        if (error instanceof SemantifoldDiagnostic && error.code == "INVALID_BYTE_MAPPING")
+            throw error;
+        return invalidByteMapping("Byte mapping validation failed.", error);
+    }
+}
+/**
+ * Validates one closed provenance origin.
+ * @param {unknown} value - Origin candidate.
+ * @param {string} label - Diagnostic range label.
+ * @returns {import("./semantic/types.js").SemanticOrigin} Detached origin.
+ */
+function validateOrigin(value, label) {
+    if (!isPlainObject(value))
+        invalidByteMapping(`${label} requires provenance.`);
+    if (value.kind == "synthetic") {
+        if (typeof value.reason != "string" || value.reason.length == 0 || !isDenseArray(value.relatedOrigins)) {
+            invalidByteMapping(`${label} synthetic provenance requires an explicit reason and related-origin array.`);
+        }
+        /** @type {import("./semantic/types.js").RelatedOrigin[]} */
+        const relatedOrigins = [];
+        for (let index = 0; index < value.relatedOrigins.length; index += 1) {
+            relatedOrigins.push(validateRelatedOrigin(value.relatedOrigins[index], `${label} related origin ${index}`));
+        }
+        return { kind: "synthetic", reason: value.reason, relatedOrigins };
+    }
+    if (value.kind == "source") {
+        if (typeof value.sourceId != "string" || value.sourceId.length == 0)
+            invalidByteMapping(`${label} source provenance requires a source ID.`);
+        return { kind: "source", location: validateLocation(value.location, label), sourceId: value.sourceId };
+    }
+    if (value.kind == "derived") {
+        if (!isDenseArray(value.origins) || value.origins.length == 0)
+            invalidByteMapping(`${label} derived provenance requires origins.`);
+        /** @type {import("./semantic/types.js").RelatedOrigin[]} */
+        const origins = [];
+        for (let index = 0; index < value.origins.length; index += 1) {
+            origins.push(validateRelatedOrigin(value.origins[index], `${label} origin ${index}`));
+        }
+        return { kind: "derived", origins };
+    }
+    return invalidByteMapping(`${label} has an unknown provenance kind.`);
+}
+/**
+ * Validates one related source origin.
+ * @param {unknown} value - Related-origin candidate.
+ * @param {string} label - Diagnostic range label.
+ * @returns {import("./semantic/types.js").RelatedOrigin} Detached related origin.
+ */
+function validateRelatedOrigin(value, label) {
+    if (!isPlainObject(value) || typeof value.sourceId != "string" || value.sourceId.length == 0) {
+        invalidByteMapping(`${label} requires a source ID and location.`);
+    }
+    const result = {
+        location: validateLocation(value.location, label),
+        sourceId: value.sourceId,
+        ...optionalRelated(value.nodeId, "nodeId", label),
+        ...optionalRelated(value.symbolId, "symbolId", label),
+        ...optionalRelated(value.role, "role", label)
+    };
+    return result;
+}
+/**
+ * Validates a UTF-16 original source location carried by byte provenance.
+ * @param {unknown} value - Location candidate.
+ * @param {string} label - Diagnostic range label.
+ * @returns {import("./semantic/types.js").SourceLocation} Detached source location.
+ */
+function validateLocation(value, label) {
+    if (!isPlainObject(value) || typeof value.filename != "string" || value.filename.length == 0) {
+        invalidByteMapping(`${label} contains an invalid source location.`);
+    }
+    const start = snapshotPoint(value.start);
+    const end = snapshotPoint(value.end);
+    if (start == undefined || end == undefined || end.offset < start.offset || !isSourceRangeOrdered(start, end)) {
+        invalidByteMapping(`${label} contains an invalid source location.`);
+    }
+    return {
+        end,
+        filename: value.filename,
+        start
+    };
+}
+/**
+ * Snapshots one valid UTF-16 source point without retaining undeclared fields.
+ * @param {unknown} value - Candidate point.
+ * @returns {import("./semantic/types.js").SourcePoint | undefined} Canonical point when valid.
+ */
+function snapshotPoint(value) {
+    if (!isPlainObject(value))
+        return undefined;
+    const line = value.line;
+    const column = value.column;
+    const offset = value.offset;
+    if (typeof line != "number" || !Number.isSafeInteger(line) || line <= 0 ||
+        typeof column != "number" || !Number.isSafeInteger(column) || column <= 0 ||
+        typeof offset != "number" || !Number.isSafeInteger(offset) || offset < 0)
+        return undefined;
+    return { column, line, offset };
+}
+/**
+ * Validates an optional byte-range identity.
+ * @param {unknown} value - Candidate identity.
+ * @param {string} property - Property name.
+ * @param {number} index - Byte-range index.
+ * @returns {Record<string, string>} Present identity or an empty record.
+ */
+function optionalIdentity(value, property, index) {
+    if (value === undefined)
+        return {};
+    if (typeof value != "string" || value.length == 0)
+        invalidByteMapping(`Byte range ${index} has an invalid ${property}.`);
+    return { [property]: value };
+}
+/**
+ * Validates an optional related-origin identity.
+ * @param {unknown} value - Candidate identity.
+ * @param {string} property - Property name.
+ * @param {string} label - Diagnostic range label.
+ * @returns {Record<string, string>} Present identity or an empty record.
+ */
+function optionalRelated(value, property, label) {
+    if (value === undefined)
+        return {};
+    if (typeof value != "string" || value.length == 0)
+        invalidByteMapping(`${label} has an invalid ${property}.`);
+    return { [property]: value };
+}
+/**
+ * Throws a normalized byte-mapping diagnostic.
+ * @param {string} message - Failure detail.
+ * @param {unknown} [error] - Preserved validation cause.
+ * @returns {never} Always throws.
+ */
+function invalidByteMapping(message, error) {
+    throw new SemantifoldDiagnostic({
+        cause: error instanceof Error ? error : undefined,
+        code: "INVALID_BYTE_MAPPING",
+        language: "binary",
+        message
+    });
+}
+/**
+ * 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;
+}
+/**
+ * Deeply freezes detached JSON mapping values.
+ * @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);
+}
+/**
+ * Recursively sorts JSON object keys without reordering arrays.
+ * @param {unknown} value - JSON value.
+ * @returns {unknown} Key-sorted JSON value.
+ */
+function sortJson(value) {
+    if (Array.isArray(value))
+        return value.map(sortJson);
+    if (!isPlainObject(value))
+        return value;
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, sortJson(value[key])]));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"binary-mapping.js","sourceRoot":"","sources":["../../src/binary-mapping.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {isDenseArray} from \"./array.js\"\nimport {isSafeArtifactPath} from \"./artifact-path.js\"\nimport {SemantifoldDiagnostic} from \"./diagnostic.js\"\nimport {isSourceRangeOrdered} from \"./semantic/location.js\"\n\n/**\n * Creates and validates an immutable byte-coordinate provenance map.\n * @param {object} input - Mapping fields.\n * @param {number} input.byteLength - Generated artifact byte length.\n * @param {string} input.path - Generated artifact path.\n * @param {import(\"./semantic/types.js\").GeneratedByteRange[]} input.ranges - Ordered byte ranges.\n * @returns {import(\"./semantic/types.js\").SemantifoldByteMapping} Validated mapping.\n */\nexport function createByteMapping(input) {\n  if (!isPlainObject(input)) invalidByteMapping(\"Byte mapping construction requires an object.\")\n  const {byteLength, path, ranges} = input\n\n  return finalizeByteMapping({\n    coordinateSystem: \"bytes\",\n    generated: {byteLength, path},\n    ranges,\n    schema: \"SemantifoldByteMapping\",\n    version: 1\n  })\n}\n\n/**\n * Parses serialized byte-coordinate provenance.\n * @param {string} serialized - JSON mapping.\n * @returns {import(\"./semantic/types.js\").SemantifoldByteMapping} Validated mapping.\n */\nexport function parseByteMapping(serialized) {\n  try {\n    return finalizeByteMapping(JSON.parse(serialized))\n  } catch (error) {\n    if (error instanceof SemantifoldDiagnostic && error.code == \"INVALID_BYTE_MAPPING\") throw error\n\n    return invalidByteMapping(\"Byte mapping must be valid JSON.\", error)\n  }\n}\n\n/**\n * Serializes a validated mapping with stable object-key ordering.\n * @param {import(\"./semantic/types.js\").SemantifoldByteMapping} mapping - Byte mapping.\n * @returns {string} Canonical JSON with trailing LF.\n */\nexport function stringifyByteMapping(mapping) {\n  const validated = finalizeByteMapping(mapping)\n\n  return `${JSON.stringify(sortJson(validated), null, 2)}\\n`\n}\n\n/**\n * Validates an existing mapping and returns a detached immutable value.\n * @param {unknown} candidate - Mapping candidate.\n * @returns {import(\"./semantic/types.js\").SemantifoldByteMapping} Validated mapping.\n */\nexport function finalizeByteMapping(candidate) {\n  try {\n    if (!isPlainObject(candidate)) invalidByteMapping(\"Byte mapping must be a plain object.\")\n    if (candidate.schema != \"SemantifoldByteMapping\" || candidate.version !== 1 || candidate.coordinateSystem != \"bytes\") {\n      invalidByteMapping(\"Byte mapping requires SemantifoldByteMapping version 1 with byte coordinates.\")\n    }\n    if (!isPlainObject(candidate.generated)) {\n      invalidByteMapping(\"Byte mapping requires a safe generated artifact path.\")\n    }\n    const generatedPath = candidate.generated.path\n\n    if (!isSafeArtifactPath(generatedPath)) {\n      invalidByteMapping(\"Byte mapping requires a safe generated artifact path.\")\n    }\n    const byteLength = candidate.generated.byteLength\n\n    if (typeof byteLength != \"number\" || !Number.isSafeInteger(byteLength) || byteLength < 0) {\n      invalidByteMapping(\"Byte mapping requires a non-negative safe byte length.\")\n    }\n    if (!isDenseArray(candidate.ranges)) invalidByteMapping(\"Byte mapping ranges must be an ordered dense array.\")\n    let previousEnd = 0\n    /** @type {import(\"./semantic/types.js\").GeneratedByteRange[]} */\n    const ranges = []\n\n    for (let index = 0; index < candidate.ranges.length; index += 1) {\n      const range = candidate.ranges[index]\n\n      if (!isPlainObject(range) || !isPlainObject(range.generated)) invalidByteMapping(`Byte range ${index} is malformed.`)\n      const end = range.generated.end\n      const start = range.generated.start\n\n      if (typeof start != \"number\" || typeof end != \"number\" || !Number.isSafeInteger(start) || !Number.isSafeInteger(end) ||\n        start < 0 || end <= start || end > byteLength) {\n        invalidByteMapping(`Byte range ${index} must be a non-empty in-bounds half-open integer range.`)\n      }\n      if (start < previousEnd) invalidByteMapping(`Byte range ${index} is out of order or overlaps its predecessor.`)\n      previousEnd = end\n      const origin = validateOrigin(range.origin, `Byte range ${index}`)\n      const result = {\n        generated: {end, start},\n        origin,\n        ...(optionalIdentity(range.nodeId, \"nodeId\", index)),\n        ...(optionalIdentity(range.symbolId, \"symbolId\", index)),\n        ...(optionalIdentity(range.role, \"role\", index))\n      }\n\n      ranges.push(result)\n    }\n    const mapping = {\n      coordinateSystem: /** @type {const} */ (\"bytes\"),\n      generated: {byteLength, path: generatedPath},\n      ranges,\n      schema: /** @type {const} */ (\"SemantifoldByteMapping\"),\n      version: /** @type {const} */ (1)\n    }\n\n    return deepFreeze(mapping)\n  } catch (error) {\n    if (error instanceof SemantifoldDiagnostic && error.code == \"INVALID_BYTE_MAPPING\") throw error\n\n    return invalidByteMapping(\"Byte mapping validation failed.\", error)\n  }\n}\n\n/**\n * Validates one closed provenance origin.\n * @param {unknown} value - Origin candidate.\n * @param {string} label - Diagnostic range label.\n * @returns {import(\"./semantic/types.js\").SemanticOrigin} Detached origin.\n */\nfunction validateOrigin(value, label) {\n  if (!isPlainObject(value)) invalidByteMapping(`${label} requires provenance.`)\n\n  if (value.kind == \"synthetic\") {\n    if (typeof value.reason != \"string\" || value.reason.length == 0 || !isDenseArray(value.relatedOrigins)) {\n      invalidByteMapping(`${label} synthetic provenance requires an explicit reason and related-origin array.`)\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], `${label} related origin ${index}`))\n    }\n\n    return {kind: \"synthetic\", reason: value.reason, relatedOrigins}\n  }\n  if (value.kind == \"source\") {\n    if (typeof value.sourceId != \"string\" || value.sourceId.length == 0) invalidByteMapping(`${label} source provenance requires a source ID.`)\n\n    return {kind: \"source\", location: validateLocation(value.location, label), sourceId: value.sourceId}\n  }\n  if (value.kind == \"derived\") {\n    if (!isDenseArray(value.origins) || value.origins.length == 0) invalidByteMapping(`${label} derived provenance requires origins.`)\n    /** @type {import(\"./semantic/types.js\").RelatedOrigin[]} */\n    const origins = []\n\n    for (let index = 0; index < value.origins.length; index += 1) {\n      origins.push(validateRelatedOrigin(value.origins[index], `${label} origin ${index}`))\n    }\n\n    return {kind: \"derived\", origins}\n  }\n\n  return invalidByteMapping(`${label} has an unknown provenance kind.`)\n}\n\n/**\n * Validates one related source origin.\n * @param {unknown} value - Related-origin candidate.\n * @param {string} label - Diagnostic range label.\n * @returns {import(\"./semantic/types.js\").RelatedOrigin} Detached related origin.\n */\nfunction validateRelatedOrigin(value, label) {\n  if (!isPlainObject(value) || typeof value.sourceId != \"string\" || value.sourceId.length == 0) {\n    invalidByteMapping(`${label} requires a source ID and location.`)\n  }\n  const result = {\n    location: validateLocation(value.location, label),\n    sourceId: value.sourceId,\n    ...optionalRelated(value.nodeId, \"nodeId\", label),\n    ...optionalRelated(value.symbolId, \"symbolId\", label),\n    ...optionalRelated(value.role, \"role\", label)\n  }\n\n  return result\n}\n\n/**\n * Validates a UTF-16 original source location carried by byte provenance.\n * @param {unknown} value - Location candidate.\n * @param {string} label - Diagnostic range label.\n * @returns {import(\"./semantic/types.js\").SourceLocation} Detached source location.\n */\nfunction validateLocation(value, label) {\n  if (!isPlainObject(value) || typeof value.filename != \"string\" || value.filename.length == 0) {\n    invalidByteMapping(`${label} contains an invalid source location.`)\n  }\n  const start = snapshotPoint(value.start)\n  const end = snapshotPoint(value.end)\n\n  if (start == undefined || end == undefined || end.offset < start.offset || !isSourceRangeOrdered(start, end)) {\n    invalidByteMapping(`${label} contains an invalid source location.`)\n  }\n\n  return {\n    end,\n    filename: value.filename,\n    start\n  }\n}\n\n/**\n * Snapshots one valid UTF-16 source point without retaining undeclared fields.\n * @param {unknown} value - Candidate point.\n * @returns {import(\"./semantic/types.js\").SourcePoint | undefined} Canonical point when valid.\n */\nfunction snapshotPoint(value) {\n  if (!isPlainObject(value)) return undefined\n  const line = value.line\n  const column = value.column\n  const offset = value.offset\n\n  if (typeof line != \"number\" || !Number.isSafeInteger(line) || line <= 0 ||\n    typeof column != \"number\" || !Number.isSafeInteger(column) || column <= 0 ||\n    typeof offset != \"number\" || !Number.isSafeInteger(offset) || offset < 0) return undefined\n\n  return {column, line, offset}\n}\n\n/**\n * Validates an optional byte-range identity.\n * @param {unknown} value - Candidate identity.\n * @param {string} property - Property name.\n * @param {number} index - Byte-range index.\n * @returns {Record<string, string>} Present identity or an empty record.\n */\nfunction optionalIdentity(value, property, index) {\n  if (value === undefined) return {}\n  if (typeof value != \"string\" || value.length == 0) invalidByteMapping(`Byte range ${index} has an invalid ${property}.`)\n\n  return {[property]: value}\n}\n\n/**\n * Validates an optional related-origin identity.\n * @param {unknown} value - Candidate identity.\n * @param {string} property - Property name.\n * @param {string} label - Diagnostic range label.\n * @returns {Record<string, string>} Present identity or an empty record.\n */\nfunction optionalRelated(value, property, label) {\n  if (value === undefined) return {}\n  if (typeof value != \"string\" || value.length == 0) invalidByteMapping(`${label} has an invalid ${property}.`)\n\n  return {[property]: value}\n}\n\n/**\n * Throws a normalized byte-mapping diagnostic.\n * @param {string} message - Failure detail.\n * @param {unknown} [error] - Preserved validation cause.\n * @returns {never} Always throws.\n */\nfunction invalidByteMapping(message, error) {\n  throw new SemantifoldDiagnostic({\n    cause: error instanceof Error ? error : undefined,\n    code: \"INVALID_BYTE_MAPPING\",\n    language: \"binary\",\n    message\n  })\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 * Deeply freezes detached JSON mapping values.\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\n/**\n * Recursively sorts JSON object keys without reordering arrays.\n * @param {unknown} value - JSON value.\n * @returns {unknown} Key-sorted JSON value.\n */\nfunction sortJson(value) {\n  if (Array.isArray(value)) return value.map(sortJson)\n  if (!isPlainObject(value)) return value\n\n  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, sortJson(value[key])]))\n}\n"]}

package/build/src/diagnostic.d.ts

@@ -3,25 +3,49 @@ export declare class SemantifoldDiagnostic extends Error {
     code: string;
     detail: string;
     generatedLocation: import("./semantic/types.js").SourceLocation | undefined;
-    language: import("./semantic/types.js").SemanticLanguage;
+    language: string;
     location: import("./semantic/types.js").SourceLocation | undefined;
+    command: string | undefined;
+    executable: string | undefined;
+    exitCode: number | undefined;
+    signal: string | undefined;
+    stage: string | undefined;
+    stderr: string | undefined;
+    stdout: string | undefined;
+    version: string | undefined;
     /**
      * Creates a diagnostic.
      * @param {object} options - Diagnostic fields.
      * @param {string} options.code - Stable diagnostic code.
      * @param {string} options.message - Human-readable message.
-     * @param {import("./semantic/types.js").SemanticLanguage} options.language - Related language.
+     * @param {string} options.language - Related language, target, tool, or registry identity.
      * @param {import("./semantic/types.js").SourceLocation | undefined} [options.location] - Related location.
      * @param {import("./semantic/types.js").SourceLocation | undefined} [options.generatedLocation] - Pre-remapping generated location.
      * @param {Error | undefined} [options.cause] - Preserved parser error.
+     * @param {string | undefined} [options.command] - Canonical command when tool discovery is involved.
+     * @param {string | undefined} [options.executable] - Exact resolved executable when known.
+     * @param {number | undefined} [options.exitCode] - Process exit code when available.
+     * @param {string | undefined} [options.signal] - Process termination signal when available.
+     * @param {string | undefined} [options.stage] - Acceptance stage when execution is involved.
+     * @param {string | undefined} [options.stderr] - Captured standard error when available.
+     * @param {string | undefined} [options.stdout] - Captured standard output when available.
+     * @param {string | undefined} [options.version] - Captured executable version when known.
      */
-    constructor({ cause, code, generatedLocation, language, location, message }: {
+    constructor({ cause, code, command, executable, exitCode, generatedLocation, language, location, message, signal, stage, stderr, stdout, version }: {
         code: string;
         message: string;
-        language: import("./semantic/types.js").SemanticLanguage;
+        language: string;
         location?: import("./semantic/types.js").SourceLocation | undefined;
         generatedLocation?: import("./semantic/types.js").SourceLocation | undefined;
         cause?: Error | undefined;
+        command?: string | undefined;
+        executable?: string | undefined;
+        exitCode?: number | undefined;
+        signal?: string | undefined;
+        stage?: string | undefined;
+        stderr?: string | undefined;
+        stdout?: string | undefined;
+        version?: string | undefined;
     });
 }
 /**
@@ -64,4 +88,12 @@ export declare function semanticFailure(language: import("./semantic/types.js").
  * @returns {never} Always throws.
  */
 export declare function unsupportedCapability(language: import("./semantic/types.js").SemanticLanguage, capability: string, location: import("./semantic/types.js").SourceLocation | undefined): never;
+/**
+ * Throws when a registered identity lacks one requested role.
+ * @param {string} language - Registered language or target identity.
+ * @param {string} role - Requested registry role.
+ * @param {import("./semantic/types.js").SourceLocation | undefined} [location] - Related semantic location.
+ * @returns {never} Always throws.
+ */
+export declare function unsupportedRole(language: string, role: string, location?: import("./semantic/types.js").SourceLocation | undefined): never;
 //# sourceMappingURL=diagnostic.d.ts.map

package/build/src/diagnostic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diagnostic.d.ts","sourceRoot":"","sources":["../../src/diagnostic.js"],"names":[],"mappings":"AAEA,kEAAkE;AAClE,qBAAa,qBAAsB,SAAQ,KAAK;IAgBvC,IAAI;IACJ,MAAM;IACN,iBAAiB;IACjB,QAAQ;IACR,QAAQ;IAnBf;;;;;;;;;OASG;IACH,YAAY,EAAC,KAAK,EAAE,IAAI,EAAE,iBAAiB,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAC,EAPtE;QAAwB,IAAI,EAApB,MAAM,CACd;QAAwB,OAAO,EAAvB,MAAM,CACd;QAAgE,QAAQ,EAAhE,OAAO,qBAAqB,EAAE,gBAAgB,CACtD;QAA2E,QAAQ,AAAnF,CACA,EADQ,OAAO,qBAAqB,EAAE,cAAc,GAAG,SAAS,CAChE;QAA2E,iBAAiB,AAA5F,CACA,EADQ,OAAO,qBAAqB,EAAE,cAAc,GAAG,SAAS,CAChE;QAAoC,KAAK,AAAzC,CACF,EADU,KAAK,GAAG,SAAS,CAC3B;KACwE,EAUxE;CACF;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAJ1B,OAAO,qBAAqB,EAAE,gBAIJ,EAAE,KAAK,EAHjC,OAGiC,GAF/B,KAAK,CAWjB;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAL/B,OAAO,qBAAqB,EAAE,gBAKC,EAAE,MAAM,EAJvC,MAIuC,EAAE,QAAQ,EAHjD,OAAO,qBAAqB,EAAE,cAAc,GAAG,SAGE,GAF/C,KAAK,CASjB;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EALzB,OAAO,qBAAqB,EAAE,gBAKL,EAAE,OAAO,EAJlC,MAIkC,EAAE,QAAQ,EAH5C,OAAO,qBAAqB,EAAE,cAAc,GAAG,SAGH,GAF1C,KAAK,CASjB;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAN7B,OAAO,qBAAqB,EAAE,gBAMD,EAAE,IAAI,EALnC,MAKmC,EAAE,MAAM,EAJ3C,MAI2C,EAAE,QAAQ,EAHrD,OAAO,qBAAqB,EAAE,cAAc,GAAG,SAGM,GAFnD,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EALnC,OAAO,qBAAqB,EAAE,gBAKK,EAAE,UAAU,EAJ/C,MAI+C,EAAE,QAAQ,EAHzD,OAAO,qBAAqB,EAAE,cAAc,GAAG,SAGU,GAFvD,KAAK,CASjB"}
+{"version":3,"file":"diagnostic.d.ts","sourceRoot":"","sources":["../../src/diagnostic.js"],"names":[],"mappings":"AAEA,kEAAkE;AAClE,qBAAa,qBAAsB,SAAQ,KAAK;IAwBvC,IAAI;IACJ,MAAM;IACN,iBAAiB;IACjB,QAAQ;IACR,QAAQ;IACkB,OAAO;IACJ,UAAU;IACZ,QAAQ;IACV,MAAM;IACP,KAAK;IACJ,MAAM;IACN,MAAM;IACL,OAAO;IAnCxC;;;;;;;;;;;;;;;;;OAiBG;IACH,YAAY,EAAC,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,iBAAiB,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAC,EAf7I;QAAwB,IAAI,EAApB,MAAM,CACd;QAAwB,OAAO,EAAvB,MAAM,CACd;QAAwB,QAAQ,EAAxB,MAAM,CACd;QAA2E,QAAQ,AAAnF,CACA,EADQ,OAAO,qBAAqB,EAAE,cAAc,GAAG,SAAS,CAChE;QAA2E,iBAAiB,AAA5F,CACA,EADQ,OAAO,qBAAqB,EAAE,cAAc,GAAG,SAAS,CAChE;QAAoC,KAAK,AAAzC,CACA,EADQ,KAAK,GAAG,SAAS,CACzB;QAAqC,OAAO,AAA5C,CACA,EADQ,MAAM,GAAG,SAAS,CAC1B;QAAqC,UAAU,AAA/C,CACA,EADQ,MAAM,GAAG,SAAS,CAC1B;QAAqC,QAAQ,AAA7C,CACA,EADQ,MAAM,GAAG,SAAS,CAC1B;QAAqC,MAAM,AAA3C,CACA,EADQ,MAAM,GAAG,SAAS,CAC1B;QAAqC,KAAK,AAA1C,CACA,EADQ,MAAM,GAAG,SAAS,CAC1B;QAAqC,MAAM,AAA3C,CACA,EADQ,MAAM,GAAG,SAAS,CAC1B;QAAqC,MAAM,AAA3C,CACA,EADQ,MAAM,GAAG,SAAS,CAC1B;QAAqC,OAAO,AAA5C,CACF,EADU,MAAM,GAAG,SAAS,CAC5B;KAC+I,EAkB/I;CACF;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAJ1B,OAAO,qBAAqB,EAAE,gBAIJ,EAAE,KAAK,EAHjC,OAGiC,GAF/B,KAAK,CAWjB;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAL/B,OAAO,qBAAqB,EAAE,gBAKC,EAAE,MAAM,EAJvC,MAIuC,EAAE,QAAQ,EAHjD,OAAO,qBAAqB,EAAE,cAAc,GAAG,SAGE,GAF/C,KAAK,CASjB;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EALzB,OAAO,qBAAqB,EAAE,gBAKL,EAAE,OAAO,EAJlC,MAIkC,EAAE,QAAQ,EAH5C,OAAO,qBAAqB,EAAE,cAAc,GAAG,SAGH,GAF1C,KAAK,CASjB;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAN7B,OAAO,qBAAqB,EAAE,gBAMD,EAAE,IAAI,EALnC,MAKmC,EAAE,MAAM,EAJ3C,MAI2C,EAAE,QAAQ,EAHrD,OAAO,qBAAqB,EAAE,cAAc,GAAG,SAGM,GAFnD,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EALnC,OAAO,qBAAqB,EAAE,gBAKK,EAAE,UAAU,EAJ/C,MAI+C,EAAE,QAAQ,EAHzD,OAAO,qBAAqB,EAAE,cAAc,GAAG,SAGU,GAFvD,KAAK,CASjB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAL7B,MAK6B,EAAE,IAAI,EAJnC,MAImC,EAAE,QAAQ,AAHrD,CACA,EADQ,OAAO,qBAAqB,EAAE,cAAc,GAAG,SAGF,GAF3C,KAAK,CASjB"}

package/build/src/diagnostic.js

@@ -6,12 +6,20 @@ export class SemantifoldDiagnostic extends Error {
      * @param {object} options - Diagnostic fields.
      * @param {string} options.code - Stable diagnostic code.
      * @param {string} options.message - Human-readable message.
-     * @param {import("./semantic/types.js").SemanticLanguage} options.language - Related language.
+     * @param {string} options.language - Related language, target, tool, or registry identity.
      * @param {import("./semantic/types.js").SourceLocation | undefined} [options.location] - Related location.
      * @param {import("./semantic/types.js").SourceLocation | undefined} [options.generatedLocation] - Pre-remapping generated location.
      * @param {Error | undefined} [options.cause] - Preserved parser error.
+     * @param {string | undefined} [options.command] - Canonical command when tool discovery is involved.
+     * @param {string | undefined} [options.executable] - Exact resolved executable when known.
+     * @param {number | undefined} [options.exitCode] - Process exit code when available.
+     * @param {string | undefined} [options.signal] - Process termination signal when available.
+     * @param {string | undefined} [options.stage] - Acceptance stage when execution is involved.
+     * @param {string | undefined} [options.stderr] - Captured standard error when available.
+     * @param {string | undefined} [options.stdout] - Captured standard output when available.
+     * @param {string | undefined} [options.version] - Captured executable version when known.
      */
-    constructor({ cause, code, generatedLocation, language, location, message }) {
+    constructor({ cause, code, command, executable, exitCode, generatedLocation, language, location, message, signal, stage, stderr, stdout, version }) {
         const locationText = location ? ` at ${location.filename}:${location.start.line}:${location.start.column}` : "";
         super(`[${code}] ${language}${locationText}: ${message}`, cause ? { cause } : undefined);
         this.name = "SemantifoldDiagnostic";
@@ -20,6 +28,22 @@ export class SemantifoldDiagnostic extends Error {
         this.generatedLocation = generatedLocation;
         this.language = language;
         this.location = location;
+        if (command != undefined)
+            this.command = command;
+        if (executable != undefined)
+            this.executable = executable;
+        if (exitCode != undefined)
+            this.exitCode = exitCode;
+        if (signal != undefined)
+            this.signal = signal;
+        if (stage != undefined)
+            this.stage = stage;
+        if (stderr != undefined)
+            this.stderr = stderr;
+        if (stdout != undefined)
+            this.stdout = stdout;
+        if (version != undefined)
+            this.version = version;
     }
 }
 /**
@@ -93,4 +117,19 @@ export function unsupportedCapability(language, capability, location) {
         message: `Backend cannot emit semantic capability '${capability}'.`
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"diagnostic.js","sourceRoot":"","sources":["../../src/diagnostic.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,kEAAkE;AAClE,MAAM,OAAO,qBAAsB,SAAQ,KAAK;IAC9C;;;;;;;;;OASG;IACH,YAAY,EAAC,KAAK,EAAE,IAAI,EAAE,iBAAiB,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAC;QACvE,MAAM,YAAY,GAAG,QAAQ,CAAC,CAAC,CAAC,OAAO,QAAQ,CAAC,QAAQ,IAAI,QAAQ,CAAC,KAAK,CAAC,IAAI,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;QAE/G,KAAK,CAAC,IAAI,IAAI,KAAK,QAAQ,GAAG,YAAY,KAAK,OAAO,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC,EAAC,KAAK,EAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAA;QACtF,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAA;QACnC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,CAAC,MAAM,GAAG,OAAO,CAAA;QACrB,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAA;QAC1C,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;QACxB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;IAC1B,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,QAAQ,EAAE,KAAK;IAC1C,MAAM,KAAK,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;IAEvE,MAAM,IAAI,qBAAqB,CAAC;QAC9B,KAAK;QACL,IAAI,EAAE,aAAa;QACnB,QAAQ;QACR,OAAO,EAAE,KAAK,CAAC,OAAO;KACvB,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ;IAC1D,MAAM,IAAI,qBAAqB,CAAC;QAC9B,IAAI,EAAE,oBAAoB;QAC1B,QAAQ;QACR,QAAQ;QACR,OAAO,EAAE,WAAW,MAAM,+CAA+C;KAC1E,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ;IACrD,MAAM,IAAI,qBAAqB,CAAC;QAC9B,IAAI,EAAE,cAAc;QACpB,QAAQ;QACR,QAAQ;QACR,OAAO,EAAE,GAAG,OAAO,2EAA2E;KAC/F,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAAC,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ;IAC9D,MAAM,IAAI,qBAAqB,CAAC,EAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAC,CAAC,CAAA;AAC9E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CAAC,QAAQ,EAAE,UAAU,EAAE,QAAQ;IAClE,MAAM,IAAI,qBAAqB,CAAC;QAC9B,IAAI,EAAE,wBAAwB;QAC9B,QAAQ;QACR,QAAQ;QACR,OAAO,EAAE,4CAA4C,UAAU,IAAI;KACpE,CAAC,CAAA;AACJ,CAAC","sourcesContent":["// @ts-check\n\n/** A clear parser, semantic, or backend capability diagnostic. */\nexport class SemantifoldDiagnostic extends Error {\n  /**\n   * Creates a diagnostic.\n   * @param {object} options - Diagnostic fields.\n   * @param {string} options.code - Stable diagnostic code.\n   * @param {string} options.message - Human-readable message.\n   * @param {import(\"./semantic/types.js\").SemanticLanguage} options.language - Related language.\n   * @param {import(\"./semantic/types.js\").SourceLocation | undefined} [options.location] - Related location.\n   * @param {import(\"./semantic/types.js\").SourceLocation | undefined} [options.generatedLocation] - Pre-remapping generated location.\n   * @param {Error | undefined} [options.cause] - Preserved parser error.\n   */\n  constructor({cause, code, generatedLocation, language, location, message}) {\n    const locationText = location ? ` at ${location.filename}:${location.start.line}:${location.start.column}` : \"\"\n\n    super(`[${code}] ${language}${locationText}: ${message}`, cause ? {cause} : undefined)\n    this.name = \"SemantifoldDiagnostic\"\n    this.code = code\n    this.detail = message\n    this.generatedLocation = generatedLocation\n    this.language = language\n    this.location = location\n  }\n}\n\n/**\n * Throws a normalized parser diagnostic while preserving the parser error.\n * @param {import(\"./semantic/types.js\").SemanticLanguage} language - Frontend language.\n * @param {unknown} error - Opaque parser error, narrowed immediately.\n * @returns {never} Always throws.\n */\nexport function parseFailure(language, error) {\n  const cause = error instanceof Error ? error : new Error(String(error))\n\n  throw new SemantifoldDiagnostic({\n    cause,\n    code: \"PARSE_ERROR\",\n    language,\n    message: cause.message\n  })\n}\n\n/**\n * Throws an unsupported-syntax diagnostic.\n * @param {import(\"./semantic/types.js\").SemanticLanguage} language - Frontend language.\n * @param {string} syntax - Parser syntax kind.\n * @param {import(\"./semantic/types.js\").SourceLocation | undefined} location - Source location.\n * @returns {never} Always throws.\n */\nexport function unsupportedSyntax(language, syntax, location) {\n  throw new SemantifoldDiagnostic({\n    code: \"UNSUPPORTED_SYNTAX\",\n    language,\n    location,\n    message: `Syntax '${syntax}' is outside the implemented semantic subset.`\n  })\n}\n\n/**\n * Throws a missing-type diagnostic.\n * @param {import(\"./semantic/types.js\").SemanticLanguage} language - Frontend language.\n * @param {string} subject - Untyped subject.\n * @param {import(\"./semantic/types.js\").SourceLocation | undefined} location - Source location.\n * @returns {never} Always throws.\n */\nexport function missingType(language, subject, location) {\n  throw new SemantifoldDiagnostic({\n    code: \"MISSING_TYPE\",\n    language,\n    location,\n    message: `${subject} requires an explicit supported scalar type: integer, boolean, or string.`\n  })\n}\n\n/**\n * Throws a language-neutral semantic diagnostic discovered after adaptation.\n * @param {import(\"./semantic/types.js\").SemanticLanguage} language - Source language.\n * @param {string} code - Stable semantic diagnostic code.\n * @param {string} detail - Human-readable semantic failure.\n * @param {import(\"./semantic/types.js\").SourceLocation | undefined} location - Source location.\n * @returns {never} Always throws.\n */\nexport function semanticFailure(language, code, detail, location) {\n  throw new SemantifoldDiagnostic({code, language, location, message: detail})\n}\n\n/**\n * Throws an unsupported backend-capability diagnostic.\n * @param {import(\"./semantic/types.js\").SemanticLanguage} language - Backend language.\n * @param {string} capability - Unsupported semantic capability.\n * @param {import(\"./semantic/types.js\").SourceLocation | undefined} location - Semantic source location.\n * @returns {never} Always throws.\n */\nexport function unsupportedCapability(language, capability, location) {\n  throw new SemantifoldDiagnostic({\n    code: \"UNSUPPORTED_CAPABILITY\",\n    language,\n    location,\n    message: `Backend cannot emit semantic capability '${capability}'.`\n  })\n}\n"]}
+/**
+ * Throws when a registered identity lacks one requested role.
+ * @param {string} language - Registered language or target identity.
+ * @param {string} role - Requested registry role.
+ * @param {import("./semantic/types.js").SourceLocation | undefined} [location] - Related semantic location.
+ * @returns {never} Always throws.
+ */
+export function unsupportedRole(language, role, location) {
+    throw new SemantifoldDiagnostic({
+        code: "UNSUPPORTED_ROLE",
+        language,
+        location,
+        message: `Registered language or target does not provide role '${role}'.`
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"diagnostic.js","sourceRoot":"","sources":["../../src/diagnostic.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/** A clear parser, semantic, or backend capability diagnostic. */\nexport class SemantifoldDiagnostic extends Error {\n  /**\n   * Creates a diagnostic.\n   * @param {object} options - Diagnostic fields.\n   * @param {string} options.code - Stable diagnostic code.\n   * @param {string} options.message - Human-readable message.\n   * @param {string} options.language - Related language, target, tool, or registry identity.\n   * @param {import(\"./semantic/types.js\").SourceLocation | undefined} [options.location] - Related location.\n   * @param {import(\"./semantic/types.js\").SourceLocation | undefined} [options.generatedLocation] - Pre-remapping generated location.\n   * @param {Error | undefined} [options.cause] - Preserved parser error.\n   * @param {string | undefined} [options.command] - Canonical command when tool discovery is involved.\n   * @param {string | undefined} [options.executable] - Exact resolved executable when known.\n   * @param {number | undefined} [options.exitCode] - Process exit code when available.\n   * @param {string | undefined} [options.signal] - Process termination signal when available.\n   * @param {string | undefined} [options.stage] - Acceptance stage when execution is involved.\n   * @param {string | undefined} [options.stderr] - Captured standard error when available.\n   * @param {string | undefined} [options.stdout] - Captured standard output when available.\n   * @param {string | undefined} [options.version] - Captured executable version when known.\n   */\n  constructor({cause, code, command, executable, exitCode, generatedLocation, language, location, message, signal, stage, stderr, stdout, version}) {\n    const locationText = location ? ` at ${location.filename}:${location.start.line}:${location.start.column}` : \"\"\n\n    super(`[${code}] ${language}${locationText}: ${message}`, cause ? {cause} : undefined)\n    this.name = \"SemantifoldDiagnostic\"\n    this.code = code\n    this.detail = message\n    this.generatedLocation = generatedLocation\n    this.language = language\n    this.location = location\n    if (command != undefined) this.command = command\n    if (executable != undefined) this.executable = executable\n    if (exitCode != undefined) this.exitCode = exitCode\n    if (signal != undefined) this.signal = signal\n    if (stage != undefined) this.stage = stage\n    if (stderr != undefined) this.stderr = stderr\n    if (stdout != undefined) this.stdout = stdout\n    if (version != undefined) this.version = version\n  }\n}\n\n/**\n * Throws a normalized parser diagnostic while preserving the parser error.\n * @param {import(\"./semantic/types.js\").SemanticLanguage} language - Frontend language.\n * @param {unknown} error - Opaque parser error, narrowed immediately.\n * @returns {never} Always throws.\n */\nexport function parseFailure(language, error) {\n  const cause = error instanceof Error ? error : new Error(String(error))\n\n  throw new SemantifoldDiagnostic({\n    cause,\n    code: \"PARSE_ERROR\",\n    language,\n    message: cause.message\n  })\n}\n\n/**\n * Throws an unsupported-syntax diagnostic.\n * @param {import(\"./semantic/types.js\").SemanticLanguage} language - Frontend language.\n * @param {string} syntax - Parser syntax kind.\n * @param {import(\"./semantic/types.js\").SourceLocation | undefined} location - Source location.\n * @returns {never} Always throws.\n */\nexport function unsupportedSyntax(language, syntax, location) {\n  throw new SemantifoldDiagnostic({\n    code: \"UNSUPPORTED_SYNTAX\",\n    language,\n    location,\n    message: `Syntax '${syntax}' is outside the implemented semantic subset.`\n  })\n}\n\n/**\n * Throws a missing-type diagnostic.\n * @param {import(\"./semantic/types.js\").SemanticLanguage} language - Frontend language.\n * @param {string} subject - Untyped subject.\n * @param {import(\"./semantic/types.js\").SourceLocation | undefined} location - Source location.\n * @returns {never} Always throws.\n */\nexport function missingType(language, subject, location) {\n  throw new SemantifoldDiagnostic({\n    code: \"MISSING_TYPE\",\n    language,\n    location,\n    message: `${subject} requires an explicit supported scalar type: integer, boolean, or string.`\n  })\n}\n\n/**\n * Throws a language-neutral semantic diagnostic discovered after adaptation.\n * @param {import(\"./semantic/types.js\").SemanticLanguage} language - Source language.\n * @param {string} code - Stable semantic diagnostic code.\n * @param {string} detail - Human-readable semantic failure.\n * @param {import(\"./semantic/types.js\").SourceLocation | undefined} location - Source location.\n * @returns {never} Always throws.\n */\nexport function semanticFailure(language, code, detail, location) {\n  throw new SemantifoldDiagnostic({code, language, location, message: detail})\n}\n\n/**\n * Throws an unsupported backend-capability diagnostic.\n * @param {import(\"./semantic/types.js\").SemanticLanguage} language - Backend language.\n * @param {string} capability - Unsupported semantic capability.\n * @param {import(\"./semantic/types.js\").SourceLocation | undefined} location - Semantic source location.\n * @returns {never} Always throws.\n */\nexport function unsupportedCapability(language, capability, location) {\n  throw new SemantifoldDiagnostic({\n    code: \"UNSUPPORTED_CAPABILITY\",\n    language,\n    location,\n    message: `Backend cannot emit semantic capability '${capability}'.`\n  })\n}\n\n/**\n * Throws when a registered identity lacks one requested role.\n * @param {string} language - Registered language or target identity.\n * @param {string} role - Requested registry role.\n * @param {import(\"./semantic/types.js\").SourceLocation | undefined} [location] - Related semantic location.\n * @returns {never} Always throws.\n */\nexport function unsupportedRole(language, role, location) {\n  throw new SemantifoldDiagnostic({\n    code: \"UNSUPPORTED_ROLE\",\n    language,\n    location,\n    message: `Registered language or target does not provide role '${role}'.`\n  })\n}\n"]}

package/build/src/frontends/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/frontends/index.js"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,EAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAC,EALrD;IAAsB,QAAQ,EAAtB,MAAM,CACd;IAA+D,QAAQ,EAA/D,OAAO,sBAAsB,EAAE,gBAAgB,CACvD;IAAsB,MAAM,EAApB,MAAM,CACd;CAEqD,GAF3C,OAAO,sBAAsB,EAAE,cAAc,CAmBzD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/frontends/index.js"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,EAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAC,EALrD;IAAsB,QAAQ,EAAtB,MAAM,CACd;IAA+D,QAAQ,EAA/D,OAAO,sBAAsB,EAAE,gBAAgB,CACvD;IAAsB,MAAM,EAApB,MAAM,CACd;CAEqD,GAF3C,OAAO,sBAAsB,EAAE,cAAc,CAQzD"}

package/build/src/frontends/index.js

@@ -1,11 +1,7 @@
 // @ts-check
-import { SemantifoldDiagnostic } from "../diagnostic.js";
+import { languageRegistry } from "../language-registry.js";
 import { annotateParsedModule } from "../semantic/provenance.js";
 import { validateParsedModule } from "../semantic/validate.js";
-import { parseJava } from "./java.js";
-import { parseJavaScriptTypeScript } from "./javascript-typescript.js";
-import { parsePhp } from "./php.js";
-import { parseRuby } from "./ruby.js";
 /**
  * Parses supported source into a shared semantic module.
  * @param {object} input - Parse request.
@@ -15,22 +11,8 @@ import { parseRuby } from "./ruby.js";
  * @returns {import("../semantic/types.js").SemanticModule} Semantic module.
  */
 export function parseSource({ filename, language, source }) {
-    let module;
-    if (language == "php")
-        module = validateParsedModule(parsePhp({ filename, source }), language);
-    else if (language == "ruby")
-        module = validateParsedModule(parseRuby({ filename, source }), language);
-    if (language == "javascript" || language == "typescript") {
-        module = validateParsedModule(parseJavaScriptTypeScript({ filename, language, source }), language);
-    }
-    else if (language == "java")
-        module = validateParsedModule(parseJava({ filename, source }), language);
-    if (module)
-        return annotateParsedModule(module, { filename, language, source });
-    throw new SemantifoldDiagnostic({
-        code: "UNSUPPORTED_LANGUAGE",
-        language,
-        message: "No frontend adapter is registered for this language."
-    });
+    const frontend = /** @type {(input: {filename: string, source: string}) => import("../semantic/types.js").SemanticModule} */ (languageRegistry.resolve(language, "frontend"));
+    const module = validateParsedModule(frontend({ filename, source }), language);
+    return annotateParsedModule(module, { filename, language, source });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/frontends/python.d.ts

@@ -0,0 +1,14 @@
+export type PythonContext = {
+    comments: import("tree-sitter").SyntaxNode[];
+    usedImmutableMarkers: Set<import("tree-sitter").SyntaxNode>;
+};
+/**
+ * Parses the strict Task 016 Python profile.
+ * @param {{filename: string, source: string}} input - Parser input.
+ * @returns {import("../semantic/types.js").SemanticModule} Semantic module.
+ */
+export declare function parsePython({ filename, source }: {
+    filename: string;
+    source: string;
+}): import("../semantic/types.js").SemanticModule;
+//# sourceMappingURL=python.d.ts.map

package/build/src/frontends/python.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"python.d.ts","sourceRoot":"","sources":["../../../src/frontends/python.js"],"names":[],"mappings":"AAoCI,YAAuH,aAAa,GAA1H;IAAC,QAAQ,EAAE,OAAO,aAAa,EAAE,UAAU,EAAE,CAAC;IAAC,oBAAoB,EAAE,GAAG,CAAC,OAAO,aAAa,EAAE,UAAU,CAAC,CAAA;CAAC,CAAe;AAqkBxI;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,EAAC,QAAQ,EAAE,MAAM,EAAC,EAHnC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAGE,GAFjC,OAAO,sBAAsB,EAAE,cAAc,CAoEzD"}