semantifold 0.1.1 → 0.2.0

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

@@ -1 +1 @@
-{"version":3,"file":"scalars.d.ts","sourceRoot":"","sources":["../../../src/frontends/scalars.js"],"names":[],"mappings":"AA6CA;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAL9B,OAAO,sBAAsB,EAAE,gBAKD,EAAE,UAAU,EAJ1C,MAI0C,EAAE,QAAQ,AAH5D,CACA,EADQ,OAAO,sBAAsB,EAAE,cAGqB,GAFlD,OAAO,sBAAsB,EAAE,aAAa,GAAG,SAAS,CASpE;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAPrC,OAAO,sBAAsB,EAAE,gBAOM,EAAE,UAAU,EANjD,MAAM,GAAG,SAMwC,EAAE,OAAO,EAL1D,MAK0D,EAAE,QAAQ,EAJpE,OAAO,sBAAsB,EAAE,cAIqC,EAAE,YAAY,AAH1F,CACA,EADQ,OAAO,sBAAsB,EAAE,cAG8D,GAF3F,OAAO,sBAAsB,EAAE,aAAa,CAQxD"}
+{"version":3,"file":"scalars.d.ts","sourceRoot":"","sources":["../../../src/frontends/scalars.js"],"names":[],"mappings":"AAkDA;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAL9B,OAAO,sBAAsB,EAAE,gBAKD,EAAE,UAAU,EAJ1C,MAI0C,EAAE,QAAQ,AAH5D,CACA,EADQ,OAAO,sBAAsB,EAAE,cAGqB,GAFlD,OAAO,sBAAsB,EAAE,aAAa,GAAG,SAAS,CASpE;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAPrC,OAAO,sBAAsB,EAAE,gBAOM,EAAE,UAAU,EANjD,MAAM,GAAG,SAMwC,EAAE,OAAO,EAL1D,MAK0D,EAAE,QAAQ,EAJpE,OAAO,sBAAsB,EAAE,cAIqC,EAAE,YAAY,AAH1F,CACA,EADQ,OAAO,sBAAsB,EAAE,cAG8D,GAF3F,OAAO,sBAAsB,EAAE,aAAa,CAQxD"}

package/build/src/frontends/scalars.js

@@ -28,6 +28,11 @@ const sourceScalarTypes = Object.freeze({
         ["bool", "boolean"],
         ["string", "string"]
     ]),
+    python: sourceTypeMap([
+        ["int", "integer"],
+        ["bool", "boolean"],
+        ["str", "string"]
+    ]),
     ruby: sourceTypeMap([
         ["[Integer]", "integer"],
         ["[bool]", "boolean"],
@@ -68,4 +73,4 @@ export function requireSourceScalarType(language, sourceType, subject, location,
         return missingType(language, subject, location);
     return type;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NhbGFycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9mcm9udGVuZHMvc2NhbGFycy5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZO0FBRVosT0FBTyxFQUFDLFdBQVcsRUFBQyxNQUFNLGtCQUFrQixDQUFBO0FBQzVDLE9BQU8sRUFBQyxlQUFlLEVBQUMsTUFBTSwyQkFBMkIsQ0FBQTtBQUN6RCxPQUFPLEVBQUMsVUFBVSxFQUFDLE1BQU0sd0JBQXdCLENBQUE7QUFFakQ7Ozs7R0FJRztBQUNILFNBQVMsYUFBYSxDQUFDLE9BQU87SUFDNUIsT0FBTyxJQUFJLEdBQUcsQ0FBQyxPQUFPLENBQUMsQ0FBQTtBQUN6QixDQUFDO0FBRUQsOElBQThJO0FBQzlJLE1BQU0saUJBQWlCLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQztJQUN0QyxJQUFJLEVBQUUsYUFBYSxDQUFDO1FBQ2xCLENBQUMsS0FBSyxFQUFFLFNBQVMsQ0FBQztRQUNsQixDQUFDLFNBQVMsRUFBRSxTQUFTLENBQUM7UUFDdEIsQ0FBQyxRQUFRLEVBQUUsUUFBUSxDQUFDO1FBQ3BCLENBQUMsa0JBQWtCLEVBQUUsUUFBUSxDQUFDO0tBQy9CLENBQUM7SUFDRixVQUFVLEVBQUUsYUFBYSxDQUFDO1FBQ3hCLENBQUMsUUFBUSxFQUFFLFNBQVMsQ0FBQztRQUNyQixDQUFDLFNBQVMsRUFBRSxTQUFTLENBQUM7UUFDdEIsQ0FBQyxRQUFRLEVBQUUsUUFBUSxDQUFDO0tBQ3JCLENBQUM7SUFDRixHQUFHLEVBQUUsYUFBYSxDQUFDO1FBQ2pCLENBQUMsS0FBSyxFQUFFLFNBQVMsQ0FBQztRQUNsQixDQUFDLE1BQU0sRUFBRSxTQUFTLENBQUM7UUFDbkIsQ0FBQyxRQUFRLEVBQUUsUUFBUSxDQUFDO0tBQ3JCLENBQUM7SUFDRixJQUFJLEVBQUUsYUFBYSxDQUFDO1FBQ2xCLENBQUMsV0FBVyxFQUFFLFNBQVMsQ0FBQztRQUN4QixDQUFDLFFBQVEsRUFBRSxTQUFTLENBQUM7UUFDckIsQ0FBQyxVQUFVLEVBQUUsUUFBUSxDQUFDO0tBQ3ZCLENBQUM7SUFDRixVQUFVLEVBQUUsYUFBYSxDQUFDO1FBQ3hCLENBQUMsUUFBUSxFQUFFLFNBQVMsQ0FBQztRQUNyQixDQUFDLFNBQVMsRUFBRSxTQUFTLENBQUM7UUFDdEIsQ0FBQyxRQUFRLEVBQUUsUUFBUSxDQUFDO0tBQ3JCLENBQUM7Q0FDSCxDQUFDLENBQUE7QUFFRjs7Ozs7O0dBTUc7QUFDSCxNQUFNLFVBQVUsZ0JBQWdCLENBQUMsUUFBUSxFQUFFLFVBQVUsRUFBRSxRQUFRO0lBQzdELE1BQU0sSUFBSSxHQUFHLGlCQUFpQixDQUFDLFFBQVEsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsQ0FBQTtJQUN4RCxNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsQ0FBQyxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFBO0lBRWhELElBQUksSUFBSSxJQUFJLFFBQVE7UUFBRSxlQUFlLENBQUMsSUFBSSxFQUFFLEVBQUMsSUFBSSxFQUFFLFFBQVEsRUFBQyxDQUFDLENBQUE7SUFFN0QsT0FBTyxJQUFJLENBQUE7QUFDYixDQUFDO0FBRUQ7Ozs7Ozs7O0dBUUc7QUFDSCxNQUFNLFVBQVUsdUJBQXVCLENBQUMsUUFBUSxFQUFFLFVBQVUsRUFBRSxPQUFPLEVBQUUsUUFBUSxFQUFFLFlBQVksR0FBRyxRQUFRO0lBQ3RHLE1BQU0sSUFBSSxHQUFHLFVBQVUsQ0FBQyxDQUFDLENBQUMsZ0JBQWdCLENBQUMsUUFBUSxFQUFFLFVBQVUsRUFBRSxZQUFZLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFBO0lBRTFGLElBQUksQ0FBQyxJQUFJO1FBQUUsT0FBTyxXQUFXLENBQUMsUUFBUSxFQUFFLE9BQU8sRUFBRSxRQUFRLENBQUMsQ0FBQTtJQUUxRCxPQUFPLElBQUksQ0FBQTtBQUNiLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBAdHMtY2hlY2tcblxuaW1wb3J0IHttaXNzaW5nVHlwZX0gZnJvbSBcIi4uL2RpYWdub3N0aWMuanNcIlxuaW1wb3J0IHtzZXRQYXJzZXJSYW5nZXN9IGZyb20gXCIuLi9zZW1hbnRpYy9wcm92ZW5hbmNlLmpzXCJcbmltcG9ydCB7c2NhbGFyVHlwZX0gZnJvbSBcIi4uL3NlbWFudGljL3NjYWxhcnMuanNcIlxuXG4vKipcbiAqIEJ1aWxkcyBhIHNvdXJjZS1zcGVsbGluZyBtYXAgd2l0aCBleGFjdCBzZW1hbnRpYyBzY2FsYXIgdmFsdWVzLlxuICogQHBhcmFtIHtyZWFkb25seSAocmVhZG9ubHkgW3N0cmluZywgaW1wb3J0KFwiLi4vc2VtYW50aWMvdHlwZXMuanNcIikuU2VtYW50aWNUeXBlTmFtZV0pW119IGVudHJpZXMgLSBTb3VyY2UgbWFwcGluZ3MuXG4gKiBAcmV0dXJucyB7TWFwPHN0cmluZywgaW1wb3J0KFwiLi4vc2VtYW50aWMvdHlwZXMuanNcIikuU2VtYW50aWNUeXBlTmFtZT59IFNvdXJjZSB0eXBlIG1hcC5cbiAqL1xuZnVuY3Rpb24gc291cmNlVHlwZU1hcChlbnRyaWVzKSB7XG4gIHJldHVybiBuZXcgTWFwKGVudHJpZXMpXG59XG5cbi8qKiBAdHlwZSB7UmVhZG9ubHk8UmVjb3JkPGltcG9ydChcIi4uL3NlbWFudGljL3R5cGVzLmpzXCIpLlNlbWFudGljTGFuZ3VhZ2UsIE1hcDxzdHJpbmcsIGltcG9ydChcIi4uL3NlbWFudGljL3R5cGVzLmpzXCIpLlNlbWFudGljVHlwZU5hbWU+Pj59ICovXG5jb25zdCBzb3VyY2VTY2FsYXJUeXBlcyA9IE9iamVjdC5mcmVlemUoe1xuICBqYXZhOiBzb3VyY2VUeXBlTWFwKFtcbiAgICBbXCJpbnRcIiwgXCJpbnRlZ2VyXCJdLFxuICAgIFtcImJvb2xlYW5cIiwgXCJib29sZWFuXCJdLFxuICAgIFtcIlN0cmluZ1wiLCBcInN0cmluZ1wiXSxcbiAgICBbXCJqYXZhLmxhbmcuU3RyaW5nXCIsIFwic3RyaW5nXCJdXG4gIF0pLFxuICBqYXZhc2NyaXB0OiBzb3VyY2VUeXBlTWFwKFtcbiAgICBbXCJudW1iZXJcIiwgXCJpbnRlZ2VyXCJdLFxuICAgIFtcImJvb2xlYW5cIiwgXCJib29sZWFuXCJdLFxuICAgIFtcInN0cmluZ1wiLCBcInN0cmluZ1wiXVxuICBdKSxcbiAgcGhwOiBzb3VyY2VUeXBlTWFwKFtcbiAgICBbXCJpbnRcIiwgXCJpbnRlZ2VyXCJdLFxuICAgIFtcImJvb2xcIiwgXCJib29sZWFuXCJdLFxuICAgIFtcInN0cmluZ1wiLCBcInN0cmluZ1wiXVxuICBdKSxcbiAgcnVieTogc291cmNlVHlwZU1hcChbXG4gICAgW1wiW0ludGVnZXJdXCIsIFwiaW50ZWdlclwiXSxcbiAgICBbXCJbYm9vbF1cIiwgXCJib29sZWFuXCJdLFxuICAgIFtcIltTdHJpbmddXCIsIFwic3RyaW5nXCJdXG4gIF0pLFxuICB0eXBlc2NyaXB0OiBzb3VyY2VUeXBlTWFwKFtcbiAgICBbXCJudW1iZXJcIiwgXCJpbnRlZ2VyXCJdLFxuICAgIFtcImJvb2xlYW5cIiwgXCJib29sZWFuXCJdLFxuICAgIFtcInN0cmluZ1wiLCBcInN0cmluZ1wiXVxuICBdKVxufSlcblxuLyoqXG4gKiBMb29rcyB1cCBhbiBleGFjdCBzb3VyY2Ugc2NhbGFyIHNwZWxsaW5nIHdpdGhvdXQgaW5zcGVjdGluZyBwYXJzZXIgbm9kZXMuXG4gKiBAcGFyYW0ge2ltcG9ydChcIi4uL3NlbWFudGljL3R5cGVzLmpzXCIpLlNlbWFudGljTGFuZ3VhZ2V9IGxhbmd1YWdlIC0gU291cmNlIGxhbmd1YWdlLlxuICogQHBhcmFtIHtzdHJpbmd9IHNvdXJjZVR5cGUgLSBFeGFjdCBzb3VyY2UgdHlwZSBzcGVsbGluZy5cbiAqIEBwYXJhbSB7aW1wb3J0KFwiLi4vc2VtYW50aWMvdHlwZXMuanNcIikuU291cmNlTG9jYXRpb259IFtsb2NhdGlvbl0gLSBFeGFjdCBwYXJzZXItb3duZWQgdHlwZSBzcGVsbGluZy5cbiAqIEByZXR1cm5zIHtpbXBvcnQoXCIuLi9zZW1hbnRpYy90eXBlcy5qc1wiKS5UeXBlUmVmZXJlbmNlIHwgdW5kZWZpbmVkfSBTZW1hbnRpYyB0eXBlIHdoZW4gc3VwcG9ydGVkLlxuICovXG5leHBvcnQgZnVuY3Rpb24gc291cmNlU2NhbGFyVHlwZShsYW5ndWFnZSwgc291cmNlVHlwZSwgbG9jYXRpb24pIHtcbiAgY29uc3QgbmFtZSA9IHNvdXJjZVNjYWxhclR5cGVzW2xhbmd1YWdlXS5nZXQoc291cmNlVHlwZSlcbiAgY29uc3QgdHlwZSA9IG5hbWUgPyBzY2FsYXJUeXBlKG5hbWUpIDogdW5kZWZpbmVkXG5cbiAgaWYgKHR5cGUgJiYgbG9jYXRpb24pIHNldFBhcnNlclJhbmdlcyh0eXBlLCB7dHlwZTogbG9jYXRpb259KVxuXG4gIHJldHVybiB0eXBlXG59XG5cbi8qKlxuICogUmVxdWlyZXMgYW4gZXhhY3Qgc3VwcG9ydGVkIHNvdXJjZSBzY2FsYXIgc3BlbGxpbmcuXG4gKiBAcGFyYW0ge2ltcG9ydChcIi4uL3NlbWFudGljL3R5cGVzLmpzXCIpLlNlbWFudGljTGFuZ3VhZ2V9IGxhbmd1YWdlIC0gU291cmNlIGxhbmd1YWdlLlxuICogQHBhcmFtIHtzdHJpbmcgfCB1bmRlZmluZWR9IHNvdXJjZVR5cGUgLSBFeGFjdCBzb3VyY2UgdHlwZSBzcGVsbGluZy5cbiAqIEBwYXJhbSB7c3RyaW5nfSBzdWJqZWN0IC0gVHlwZWQgc291cmNlIHN1YmplY3QuXG4gKiBAcGFyYW0ge2ltcG9ydChcIi4uL3NlbWFudGljL3R5cGVzLmpzXCIpLlNvdXJjZUxvY2F0aW9ufSBsb2NhdGlvbiAtIE93bmluZyBzb3VyY2UgbG9jYXRpb24uXG4gKiBAcGFyYW0ge2ltcG9ydChcIi4uL3NlbWFudGljL3R5cGVzLmpzXCIpLlNvdXJjZUxvY2F0aW9ufSBbdHlwZUxvY2F0aW9uXSAtIEV4YWN0IHBhcnNlci1vd25lZCB0eXBlIHNwZWxsaW5nLlxuICogQHJldHVybnMge2ltcG9ydChcIi4uL3NlbWFudGljL3R5cGVzLmpzXCIpLlR5cGVSZWZlcmVuY2V9IFNlbWFudGljIHNjYWxhciB0eXBlLlxuICovXG5leHBvcnQgZnVuY3Rpb24gcmVxdWlyZVNvdXJjZVNjYWxhclR5cGUobGFuZ3VhZ2UsIHNvdXJjZVR5cGUsIHN1YmplY3QsIGxvY2F0aW9uLCB0eXBlTG9jYXRpb24gPSBsb2NhdGlvbikge1xuICBjb25zdCB0eXBlID0gc291cmNlVHlwZSA/IHNvdXJjZVNjYWxhclR5cGUobGFuZ3VhZ2UsIHNvdXJjZVR5cGUsIHR5cGVMb2NhdGlvbikgOiB1bmRlZmluZWRcblxuICBpZiAoIXR5cGUpIHJldHVybiBtaXNzaW5nVHlwZShsYW5ndWFnZSwgc3ViamVjdCwgbG9jYXRpb24pXG5cbiAgcmV0dXJuIHR5cGVcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/language-registry.d.ts

@@ -0,0 +1,113 @@
+export type RegistryRole = "frontend" | "textBackend" | "binaryBackend" | "applicationBackend" | "interoperability";
+export type Frontend = (input: {
+    filename: string;
+    source: string;
+}) => import("./semantic/types.js").SemanticModule;
+export type RegistryImplementation = (...values: unknown[]) => unknown;
+export type LanguageRegistryRecord = {
+    /**
+     * - Stable identity.
+     */
+    id: string;
+    /**
+     * - Acceptance declaration.
+     */
+    acceptance: {
+        stages: import("./semantic/types.js").AcceptanceStage[];
+        toolchains: string[];
+    };
+    /**
+     * - Artifact multiplicity.
+     */
+    artifactMultiplicity: "single" | "multiple";
+    /**
+     * - Mapping capabilities.
+     */
+    mapping: import("./semantic/types.js").LanguageMappingCapabilities;
+    /**
+     * - Round-trip declaration.
+     */
+    roundTrip: boolean;
+    /**
+     * - Default backend filename.
+     */
+    defaultFilename?: string;
+    /**
+     * - Default backend media type.
+     */
+    mediaType?: string;
+    /**
+     * - Frontend adapter.
+     */
+    frontend?: RegistryImplementation;
+    /**
+     * - Text backend.
+     */
+    textBackend?: RegistryImplementation;
+    /**
+     * - Binary backend.
+     */
+    binaryBackend?: RegistryImplementation;
+    /**
+     * - Application-artifact backend.
+     */
+    applicationBackend?: RegistryImplementation;
+    /**
+     * - Interoperability bridge.
+     */
+    interoperability?: RegistryImplementation;
+};
+export type LanguageRegistry = {
+    /**
+     * - Public descriptors.
+     */
+    descriptors: readonly import("./semantic/types.js").LanguageCapabilities[];
+    /**
+     * - Registered IDs in stable order.
+     */
+    ids: readonly string[];
+    /**
+     * - Exact record lookup.
+     */
+    record: (id: string) => Readonly<LanguageRegistryRecord>;
+    /**
+     * - Role lookup.
+     */
+    resolve: (id: string, role: RegistryRole, location?: import("./semantic/types.js").SourceLocation) => RegistryImplementation;
+};
+/** @typedef {"frontend" | "textBackend" | "binaryBackend" | "applicationBackend" | "interoperability"} RegistryRole */
+/** @typedef {(input: {filename: string, source: string}) => import("./semantic/types.js").SemanticModule} Frontend */
+/** @typedef {(...values: unknown[]) => unknown} RegistryImplementation */
+/**
+ * @typedef LanguageRegistryRecord
+ * @property {string} id - Stable identity.
+ * @property {{stages: import("./semantic/types.js").AcceptanceStage[], toolchains: string[]}} acceptance - Acceptance declaration.
+ * @property {"single" | "multiple"} artifactMultiplicity - Artifact multiplicity.
+ * @property {import("./semantic/types.js").LanguageMappingCapabilities} mapping - Mapping capabilities.
+ * @property {boolean} roundTrip - Round-trip declaration.
+ * @property {string} [defaultFilename] - Default backend filename.
+ * @property {string} [mediaType] - Default backend media type.
+ * @property {RegistryImplementation} [frontend] - Frontend adapter.
+ * @property {RegistryImplementation} [textBackend] - Text backend.
+ * @property {RegistryImplementation} [binaryBackend] - Binary backend.
+ * @property {RegistryImplementation} [applicationBackend] - Application-artifact backend.
+ * @property {RegistryImplementation} [interoperability] - Interoperability bridge.
+ */
+/**
+ * @typedef LanguageRegistry
+ * @property {readonly import("./semantic/types.js").LanguageCapabilities[]} descriptors - Public descriptors.
+ * @property {readonly string[]} ids - Registered IDs in stable order.
+ * @property {(id: string) => Readonly<LanguageRegistryRecord>} record - Exact record lookup.
+ * @property {(id: string, role: RegistryRole, location?: import("./semantic/types.js").SourceLocation) => RegistryImplementation} resolve - Role lookup.
+ */
+/**
+ * Constructs an immutable role registry from ordered records.
+ * @param {unknown} candidateRecords - Ordered language records.
+ * @returns {Readonly<LanguageRegistry>} Registry.
+ */
+export declare function createLanguageRegistry(candidateRecords: unknown): Readonly<LanguageRegistry>;
+export declare const languageRegistry: Readonly<LanguageRegistry>;
+export declare const languageCapabilities: readonly import("./semantic/types.js").LanguageCapabilities[];
+/** @type {readonly import("./semantic/types.js").SemanticLanguage[]} */
+export declare const supportedLanguages: readonly import("./semantic/types.js").SemanticLanguage[];
+//# sourceMappingURL=language-registry.d.ts.map

package/build/src/language-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-registry.d.ts","sourceRoot":"","sources":["../../src/language-registry.js"],"names":[],"mappings":"AAwBI,YAAoG,YAAY,GAAtG,UAAU,GAAG,aAAa,GAAG,eAAe,GAAG,oBAAoB,GAAG,kBAAkB,CAAc;AAChH,YAAuG,QAAQ,GAArG,CAAC,KAAK,EAAE;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,KAAK,OAAO,qBAAqB,EAAE,cAAc,CAAU;AAC/G,YAA6C,sBAAsB,GAAzD,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,KAAK,OAAO,CAAwB;AAGpE,YAAS,sBAAsB,GAC/B;;;;IAAmB,EAAE,EAAV,MAAM,CACjB;;;;IAA4F,UAAU,EAA3F;QAAC,MAAM,EAAE,OAAO,qBAAqB,EAAE,eAAe,EAAE,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAA;KAAC,CAC1F;;;;IAAkC,oBAAoB,EAA3C,QAAQ,GAAG,UAAU,CAChC;;;;IAAsE,OAAO,EAAlE,OAAO,qBAAqB,EAAE,2BAA2B,CACpE;;;;IAAoB,SAAS,EAAlB,OAAO,CAClB;;;;IAAoB,eAAe,AAAnC,CACA,EADW,MAAM,CACjB;;;;IAAoB,SAAS,AAA7B,CACA,EADW,MAAM,CACjB;;;;IAAoC,QAAQ,AAA5C,CACA,EADW,sBAAsB,CACjC;;;;IAAoC,WAAW,AAA/C,CACA,EADW,sBAAsB,CACjC;;;;IAAoC,aAAa,AAAjD,CACA,EADW,sBAAsB,CACjC;;;;IAAoC,kBAAkB,AAAtD,CACA,EADW,sBAAsB,CACjC;;;;IAAoC,gBAAgB,AAApD,CACF,EADa,sBAAsB,CACnC;CAAA,CAAA;AAGE,YAAS,gBAAgB,GACzB;;;;IAA0E,WAAW,EAA1E,SAAS,OAAO,qBAAqB,EAAE,oBAAoB,EAAE,CACxE;;;;IAA8B,GAAG,EAAtB,SAAS,MAAM,EAAE,CAC5B;;;;IAA6D,MAAM,EAAxD,CAAC,EAAE,EAAE,MAAM,KAAK,QAAQ,CAAC,sBAAsB,CAAC,CAC3D;;;;IAAgI,OAAO,EAA5H,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,OAAO,qBAAqB,EAAE,cAAc,KAAK,sBAAsB,CAChI;CAAA,CAAA;AA1BD,uHAAuH;AACvH,sHAAsH;AACtH,0EAA0E;AAE1E;;;;;;;;;;;;;;GAcG;AAEH;;;;;;GAMG;AAEH;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,gBAAgB,EAH5C,OAG4C,GAF1C,QAAQ,CAAC,gBAAgB,CAAC,CA6KtC;AAyFD,eAAO,MAAM,gBAAgB,4BAAkC,CAAA;AAC/D,eAAO,MAAM,oBAAoB,+DAA+B,CAAA;AAChE,wEAAwE;AACxE,eAAO,MAAM,kBAAkB,EADpB,SAAS,OAAO,qBAAqB,EAAE,gBAAgB,EAGmB,CAAA"}

package/build/src/language-registry.js

@@ -0,0 +1,372 @@
+// @ts-check
+import { isDenseArray } from "./array.js";
+import { SemantifoldDiagnostic, unsupportedRole } from "./diagnostic.js";
+import { generateJava } from "./backends/java.js";
+import { generateJavaScript } from "./backends/javascript.js";
+import { generatePhp } from "./backends/php.js";
+import { generatePython } from "./backends/python.js";
+import { generateRuby } from "./backends/ruby.js";
+import { generateTypeScript } from "./backends/typescript.js";
+import { parseJava } from "./frontends/java.js";
+import { parseJavaScriptTypeScript } from "./frontends/javascript-typescript.js";
+import { parsePhp } from "./frontends/php.js";
+import { parsePython } from "./frontends/python.js";
+import { parseRuby } from "./frontends/ruby.js";
+const registryRoles = Object.freeze(["frontend", "textBackend", "binaryBackend", "applicationBackend", "interoperability"]);
+const acceptanceStageOrder = ["parse", "generate", "compile", "link", "validate", "instantiate", "execute"];
+const acceptanceStages = new Map(acceptanceStageOrder.map((stage, index) => [stage, index]));
+const registryKeys = new Set([
+    "acceptance", "applicationBackend", "artifactMultiplicity", "binaryBackend", "defaultFilename", "frontend", "id",
+    "interoperability", "mapping", "mediaType", "roundTrip", "textBackend"
+]);
+/** @typedef {"frontend" | "textBackend" | "binaryBackend" | "applicationBackend" | "interoperability"} RegistryRole */
+/** @typedef {(input: {filename: string, source: string}) => import("./semantic/types.js").SemanticModule} Frontend */
+/** @typedef {(...values: unknown[]) => unknown} RegistryImplementation */
+/**
+ * @typedef LanguageRegistryRecord
+ * @property {string} id - Stable identity.
+ * @property {{stages: import("./semantic/types.js").AcceptanceStage[], toolchains: string[]}} acceptance - Acceptance declaration.
+ * @property {"single" | "multiple"} artifactMultiplicity - Artifact multiplicity.
+ * @property {import("./semantic/types.js").LanguageMappingCapabilities} mapping - Mapping capabilities.
+ * @property {boolean} roundTrip - Round-trip declaration.
+ * @property {string} [defaultFilename] - Default backend filename.
+ * @property {string} [mediaType] - Default backend media type.
+ * @property {RegistryImplementation} [frontend] - Frontend adapter.
+ * @property {RegistryImplementation} [textBackend] - Text backend.
+ * @property {RegistryImplementation} [binaryBackend] - Binary backend.
+ * @property {RegistryImplementation} [applicationBackend] - Application-artifact backend.
+ * @property {RegistryImplementation} [interoperability] - Interoperability bridge.
+ */
+/**
+ * @typedef LanguageRegistry
+ * @property {readonly import("./semantic/types.js").LanguageCapabilities[]} descriptors - Public descriptors.
+ * @property {readonly string[]} ids - Registered IDs in stable order.
+ * @property {(id: string) => Readonly<LanguageRegistryRecord>} record - Exact record lookup.
+ * @property {(id: string, role: RegistryRole, location?: import("./semantic/types.js").SourceLocation) => RegistryImplementation} resolve - Role lookup.
+ */
+/**
+ * Constructs an immutable role registry from ordered records.
+ * @param {unknown} candidateRecords - Ordered language records.
+ * @returns {Readonly<LanguageRegistry>} Registry.
+ */
+export function createLanguageRegistry(candidateRecords) {
+    if (!isDenseArray(candidateRecords))
+        invalidRegistry("Registry records must be an ordered dense array.");
+    /** @type {Map<string, Readonly<LanguageRegistryRecord>>} */
+    const recordsById = new Map();
+    /** @type {import("./semantic/types.js").LanguageCapabilities[]} */
+    const descriptors = [];
+    for (let recordIndex = 0; recordIndex < candidateRecords.length; recordIndex += 1) {
+        const candidate = candidateRecords[recordIndex];
+        if (!isPlainObject(candidate))
+            invalidRegistry("Every registry record must be a plain object.");
+        const id = candidate.id;
+        if (typeof id != "string" || id.length == 0 || !/^[a-z][a-z0-9-]*$/u.test(id)) {
+            invalidRegistry("Every registry record requires a stable lowercase ID.", typeof id == "string" ? id : undefined);
+        }
+        if (recordsById.has(id))
+            invalidRegistry(`Duplicate registry ID '${id}'.`, id);
+        if (Object.keys(candidate).some((key) => !registryKeys.has(key)))
+            invalidRegistry(`Registry record '${id}' has unknown fields.`, id);
+        for (const role of registryRoles) {
+            if (candidate[role] !== undefined && typeof candidate[role] != "function") {
+                invalidRegistry(`Registry role '${role}' for '${id}' must be a function when present.`, id);
+            }
+        }
+        const artifactMultiplicity = candidate.artifactMultiplicity;
+        if (artifactMultiplicity != "single" && artifactMultiplicity != "multiple") {
+            invalidRegistry(`Registry record '${id}' has an invalid artifact multiplicity.`, id);
+        }
+        if (typeof candidate.roundTrip != "boolean")
+            invalidRegistry(`Registry record '${id}' requires a Boolean round-trip declaration.`, id);
+        const mappingCandidate = candidate.mapping;
+        if (!isPlainObject(mappingCandidate))
+            invalidRegistry(`Registry record '${id}' has an invalid mapping declaration.`, id);
+        const mappingSnapshot = {
+            binaryRanges: mappingCandidate.binaryRanges,
+            richText: mappingCandidate.richText,
+            sourceMapV3: mappingCandidate.sourceMapV3
+        };
+        if (typeof mappingSnapshot.richText != "boolean" || typeof mappingSnapshot.sourceMapV3 != "boolean" ||
+            typeof mappingSnapshot.binaryRanges != "boolean") {
+            invalidRegistry(`Registry record '${id}' has an invalid mapping declaration.`, id);
+        }
+        const mapping = deepFreeze(/** @type {import("./semantic/types.js").LanguageMappingCapabilities} */ (mappingSnapshot));
+        const acceptanceCandidate = candidate.acceptance;
+        if (!isPlainObject(acceptanceCandidate) || !isDenseArray(acceptanceCandidate.stages) ||
+            !isDenseArray(acceptanceCandidate.toolchains)) {
+            invalidRegistry(`Registry record '${id}' has an invalid acceptance declaration.`, id);
+        }
+        /** @type {unknown[]} */
+        const stageSnapshot = [];
+        /** @type {unknown[]} */
+        const toolchainSnapshot = [];
+        for (let index = 0; index < acceptanceCandidate.stages.length; index += 1) {
+            stageSnapshot.push(acceptanceCandidate.stages[index]);
+        }
+        for (let index = 0; index < acceptanceCandidate.toolchains.length; index += 1) {
+            toolchainSnapshot.push(acceptanceCandidate.toolchains[index]);
+        }
+        if (!stageSnapshot.every((stage) => typeof stage == "string" && acceptanceStages.has(stage)) ||
+            !toolchainSnapshot.every((toolchain) => typeof toolchain == "string" && toolchain.length > 0)) {
+            invalidRegistry(`Registry record '${id}' has an invalid acceptance declaration.`, id);
+        }
+        const stages = /** @type {import("./semantic/types.js").AcceptanceStage[]} */ (stageSnapshot);
+        const toolchains = /** @type {string[]} */ (toolchainSnapshot);
+        let previousStage = -1;
+        const declaredStages = new Set();
+        for (const stage of stages) {
+            const stageIndex = /** @type {number} */ (acceptanceStages.get(/** @type {string} */ (stage)));
+            if (declaredStages.has(stage) || stageIndex < previousStage)
+                invalidRegistry(`Registry record '${id}' has unordered or duplicate acceptance stages.`, id);
+            declaredStages.add(stage);
+            previousStage = stageIndex;
+        }
+        if (new Set(toolchains).size != toolchains.length) {
+            invalidRegistry(`Registry record '${id}' has duplicate acceptance toolchains.`, id);
+        }
+        const hasFrontend = typeof candidate.frontend == "function";
+        const hasTextBackend = typeof candidate.textBackend == "function";
+        const hasBinaryBackend = typeof candidate.binaryBackend == "function";
+        const hasApplicationBackend = typeof candidate.applicationBackend == "function";
+        const hasBackend = hasTextBackend || hasBinaryBackend || hasApplicationBackend;
+        if ((mapping.richText || mapping.sourceMapV3) && !hasTextBackend ||
+            mapping.sourceMapV3 && !mapping.richText ||
+            mapping.binaryRanges && !hasBinaryBackend && !hasApplicationBackend) {
+            invalidRegistry(`Registry record '${id}' declares mapping support without its required backend role.`, id);
+        }
+        if (candidate.roundTrip && (!hasFrontend || !hasBackend)) {
+            invalidRegistry(`Registry record '${id}' declares round-trip support without frontend and backend roles.`, id);
+        }
+        if (stages.includes("parse") && !hasFrontend || stages.includes("generate") && !hasBackend) {
+            invalidRegistry(`Registry record '${id}' declares an acceptance stage without its required role.`, id);
+        }
+        if ((hasBackend || candidate.defaultFilename !== undefined) &&
+            (typeof candidate.defaultFilename != "string" || candidate.defaultFilename.length == 0)) {
+            invalidRegistry(`Registry backend '${id}' requires a default filename.`, id);
+        }
+        if ((hasBackend || candidate.mediaType !== undefined) &&
+            (typeof candidate.mediaType != "string" || candidate.mediaType.length == 0)) {
+            invalidRegistry(`Registry backend '${id}' requires a media type.`, id);
+        }
+        const acceptance = deepFreeze(/** @type {import("./semantic/types.js").LanguageAcceptanceCapabilities} */ ({
+            stages,
+            toolchains
+        }));
+        const record = deepFreeze(/** @type {LanguageRegistryRecord} */ ({
+            acceptance,
+            artifactMultiplicity,
+            id,
+            mapping,
+            roundTrip: candidate.roundTrip,
+            ...(typeof candidate.defaultFilename == "string" ? { defaultFilename: candidate.defaultFilename } : {}),
+            ...(typeof candidate.mediaType == "string" ? { mediaType: candidate.mediaType } : {}),
+            ...(typeof candidate.frontend == "function" ? { frontend: candidate.frontend } : {}),
+            ...(typeof candidate.textBackend == "function" ? { textBackend: candidate.textBackend } : {}),
+            ...(typeof candidate.binaryBackend == "function" ? { binaryBackend: candidate.binaryBackend } : {}),
+            ...(typeof candidate.applicationBackend == "function" ? { applicationBackend: candidate.applicationBackend } : {}),
+            ...(typeof candidate.interoperability == "function" ? { interoperability: candidate.interoperability } : {})
+        }));
+        const descriptor = deepFreeze(/** @type {import("./semantic/types.js").LanguageCapabilities} */ ({
+            acceptance,
+            artifactMultiplicity,
+            id,
+            mapping,
+            roles: {
+                applicationBackend: typeof candidate.applicationBackend == "function",
+                binaryBackend: typeof candidate.binaryBackend == "function",
+                frontend: typeof candidate.frontend == "function",
+                interoperability: typeof candidate.interoperability == "function",
+                textBackend: typeof candidate.textBackend == "function"
+            },
+            roundTrip: candidate.roundTrip
+        }));
+        recordsById.set(id, record);
+        descriptors.push(descriptor);
+    }
+    const frozenDescriptors = deepFreeze(descriptors);
+    const ids = Object.freeze(frozenDescriptors.map(({ id }) => id));
+    return Object.freeze({
+        descriptors: frozenDescriptors,
+        ids,
+        record(id) {
+            const record = recordsById.get(id);
+            if (!record)
+                unsupportedLanguage(id);
+            return record;
+        },
+        resolve(id, role, location) {
+            if (!registryRoles.includes(role))
+                invalidRegistry(`Unknown registry role '${role}'.`, id);
+            const record = recordsById.get(id);
+            if (!record)
+                unsupportedLanguage(id, location, role);
+            const implementation = record[role];
+            if (typeof implementation != "function")
+                unsupportedRole(id, publicRoleName(role), location);
+            return implementation;
+        }
+    });
+}
+/**
+ * PHP registry frontend wrapper.
+ * @type {Frontend}
+ */
+const phpFrontend = ({ filename, source }) => parsePhp({ filename, source });
+/**
+ * Ruby registry frontend wrapper.
+ * @type {Frontend}
+ */
+const rubyFrontend = ({ filename, source }) => parseRuby({ filename, source });
+/**
+ * JavaScript registry frontend wrapper.
+ * @type {Frontend}
+ */
+const javaScriptFrontend = ({ filename, source }) => parseJavaScriptTypeScript({ filename, language: "javascript", source });
+/**
+ * TypeScript registry frontend wrapper.
+ * @type {Frontend}
+ */
+const typeScriptFrontend = ({ filename, source }) => parseJavaScriptTypeScript({ filename, language: "typescript", source });
+/**
+ * Java registry frontend wrapper.
+ * @type {Frontend}
+ */
+const javaFrontend = ({ filename, source }) => parseJava({ filename, source });
+/**
+ * Python registry frontend wrapper.
+ * @type {Frontend}
+ */
+const pythonFrontend = ({ filename, source }) => parsePython({ filename, source });
+const records = [
+    language({
+        acceptance: { stages: ["parse", "generate", "execute"], toolchains: ["php"] },
+        defaultFilename: "program.php",
+        frontend: phpFrontend,
+        id: "php",
+        mediaType: "application/x-httpd-php",
+        textBackend: generatePhp
+    }),
+    language({
+        acceptance: { stages: ["parse", "generate", "execute"], toolchains: ["ruby"] },
+        defaultFilename: "program.rb",
+        frontend: rubyFrontend,
+        id: "ruby",
+        mediaType: "text/x-ruby",
+        textBackend: generateRuby
+    }),
+    language({
+        acceptance: { stages: ["parse", "generate", "execute"], toolchains: ["node"] },
+        defaultFilename: "program.js",
+        frontend: javaScriptFrontend,
+        id: "javascript",
+        mediaType: "text/javascript",
+        textBackend: generateJavaScript
+    }),
+    language({
+        acceptance: { stages: ["parse", "generate", "compile", "execute"], toolchains: ["tsc", "node"] },
+        defaultFilename: "program.ts",
+        frontend: typeScriptFrontend,
+        id: "typescript",
+        mediaType: "text/typescript",
+        textBackend: generateTypeScript
+    }),
+    language({
+        acceptance: { stages: ["parse", "generate", "compile", "execute"], toolchains: ["javac", "java"] },
+        defaultFilename: "Main.java",
+        frontend: javaFrontend,
+        id: "java",
+        mediaType: "text/x-java-source",
+        textBackend: generateJava
+    }),
+    language({
+        acceptance: { stages: ["parse", "generate", "compile", "execute"], toolchains: ["python"] },
+        defaultFilename: "program.py",
+        frontend: pythonFrontend,
+        id: "python",
+        mediaType: "text/x-python",
+        textBackend: generatePython
+    })
+];
+export const languageRegistry = createLanguageRegistry(records);
+export const languageCapabilities = languageRegistry.descriptors;
+/** @type {readonly import("./semantic/types.js").SemanticLanguage[]} */
+export const supportedLanguages = Object.freeze(languageCapabilities
+    .filter(({ roles }) => roles.frontend && roles.textBackend)
+    .map(({ id }) => /** @type {import("./semantic/types.js").SemanticLanguage} */ (id)));
+/**
+ * Supplies common original-five capability declarations.
+ * @param {Record<string, unknown>} values - Language-specific record fields.
+ * @returns {Record<string, unknown>} Complete record.
+ */
+function language(values) {
+    return {
+        artifactMultiplicity: "single",
+        mapping: { binaryRanges: false, richText: true, sourceMapV3: true },
+        roundTrip: true,
+        ...values
+    };
+}
+/**
+ * Formats an internal registry key for a public role diagnostic.
+ * @param {string} role - Internal role key.
+ * @returns {string} Public role name.
+ */
+function publicRoleName(role) {
+    if (role == "textBackend")
+        return "text backend";
+    if (role == "binaryBackend")
+        return "binary backend";
+    if (role == "applicationBackend")
+        return "application-artifact backend";
+    return role;
+}
+/**
+ * Throws an unknown-language diagnostic.
+ * @param {string} id - Unknown identity.
+ * @param {import("./semantic/types.js").SourceLocation | undefined} [location] - Related location.
+ * @param {RegistryRole | undefined} [role] - Requested role.
+ * @returns {never} Always throws.
+ */
+function unsupportedLanguage(id, location, role) {
+    const message = role == "frontend" ? "No frontend adapter is registered for this language." :
+        role == "textBackend" ? "No source backend is registered for this language." :
+            "No language or target is registered for this ID.";
+    throw new SemantifoldDiagnostic({
+        code: "UNSUPPORTED_LANGUAGE",
+        language: id,
+        location,
+        message
+    });
+}
+/**
+ * Throws a normalized registry-shape diagnostic.
+ * @param {string} message - Failure detail.
+ * @param {string | undefined} [id] - Candidate registry ID.
+ * @returns {never} Always throws.
+ */
+function invalidRegistry(message, id = "registry") {
+    throw new SemantifoldDiagnostic({ code: "INVALID_REGISTRY", language: id, 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 registry records and public descriptors.
+ * @template T
+ * @param {T} value - Registry-owned 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":"language-registry.js","sourceRoot":"","sources":["../../src/language-registry.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {isDenseArray} from \"./array.js\"\nimport {SemantifoldDiagnostic, unsupportedRole} from \"./diagnostic.js\"\nimport {generateJava} from \"./backends/java.js\"\nimport {generateJavaScript} from \"./backends/javascript.js\"\nimport {generatePhp} from \"./backends/php.js\"\nimport {generatePython} from \"./backends/python.js\"\nimport {generateRuby} from \"./backends/ruby.js\"\nimport {generateTypeScript} from \"./backends/typescript.js\"\nimport {parseJava} from \"./frontends/java.js\"\nimport {parseJavaScriptTypeScript} from \"./frontends/javascript-typescript.js\"\nimport {parsePhp} from \"./frontends/php.js\"\nimport {parsePython} from \"./frontends/python.js\"\nimport {parseRuby} from \"./frontends/ruby.js\"\n\nconst registryRoles = Object.freeze([\"frontend\", \"textBackend\", \"binaryBackend\", \"applicationBackend\", \"interoperability\"])\nconst acceptanceStageOrder = [\"parse\", \"generate\", \"compile\", \"link\", \"validate\", \"instantiate\", \"execute\"]\nconst acceptanceStages = new Map(acceptanceStageOrder.map((stage, index) => [stage, index]))\nconst registryKeys = new Set([\n  \"acceptance\", \"applicationBackend\", \"artifactMultiplicity\", \"binaryBackend\", \"defaultFilename\", \"frontend\", \"id\",\n  \"interoperability\", \"mapping\", \"mediaType\", \"roundTrip\", \"textBackend\"\n])\n\n/** @typedef {\"frontend\" | \"textBackend\" | \"binaryBackend\" | \"applicationBackend\" | \"interoperability\"} RegistryRole */\n/** @typedef {(input: {filename: string, source: string}) => import(\"./semantic/types.js\").SemanticModule} Frontend */\n/** @typedef {(...values: unknown[]) => unknown} RegistryImplementation */\n\n/**\n * @typedef LanguageRegistryRecord\n * @property {string} id - Stable identity.\n * @property {{stages: import(\"./semantic/types.js\").AcceptanceStage[], toolchains: string[]}} acceptance - Acceptance declaration.\n * @property {\"single\" | \"multiple\"} artifactMultiplicity - Artifact multiplicity.\n * @property {import(\"./semantic/types.js\").LanguageMappingCapabilities} mapping - Mapping capabilities.\n * @property {boolean} roundTrip - Round-trip declaration.\n * @property {string} [defaultFilename] - Default backend filename.\n * @property {string} [mediaType] - Default backend media type.\n * @property {RegistryImplementation} [frontend] - Frontend adapter.\n * @property {RegistryImplementation} [textBackend] - Text backend.\n * @property {RegistryImplementation} [binaryBackend] - Binary backend.\n * @property {RegistryImplementation} [applicationBackend] - Application-artifact backend.\n * @property {RegistryImplementation} [interoperability] - Interoperability bridge.\n */\n\n/**\n * @typedef LanguageRegistry\n * @property {readonly import(\"./semantic/types.js\").LanguageCapabilities[]} descriptors - Public descriptors.\n * @property {readonly string[]} ids - Registered IDs in stable order.\n * @property {(id: string) => Readonly<LanguageRegistryRecord>} record - Exact record lookup.\n * @property {(id: string, role: RegistryRole, location?: import(\"./semantic/types.js\").SourceLocation) => RegistryImplementation} resolve - Role lookup.\n */\n\n/**\n * Constructs an immutable role registry from ordered records.\n * @param {unknown} candidateRecords - Ordered language records.\n * @returns {Readonly<LanguageRegistry>} Registry.\n */\nexport function createLanguageRegistry(candidateRecords) {\n  if (!isDenseArray(candidateRecords)) invalidRegistry(\"Registry records must be an ordered dense array.\")\n\n  /** @type {Map<string, Readonly<LanguageRegistryRecord>>} */\n  const recordsById = new Map()\n  /** @type {import(\"./semantic/types.js\").LanguageCapabilities[]} */\n  const descriptors = []\n\n  for (let recordIndex = 0; recordIndex < candidateRecords.length; recordIndex += 1) {\n    const candidate = candidateRecords[recordIndex]\n\n    if (!isPlainObject(candidate)) invalidRegistry(\"Every registry record must be a plain object.\")\n    const id = candidate.id\n\n    if (typeof id != \"string\" || id.length == 0 || !/^[a-z][a-z0-9-]*$/u.test(id)) {\n      invalidRegistry(\"Every registry record requires a stable lowercase ID.\", typeof id == \"string\" ? id : undefined)\n    }\n    if (recordsById.has(id)) invalidRegistry(`Duplicate registry ID '${id}'.`, id)\n    if (Object.keys(candidate).some((key) => !registryKeys.has(key))) invalidRegistry(`Registry record '${id}' has unknown fields.`, id)\n\n    for (const role of registryRoles) {\n      if (candidate[role] !== undefined && typeof candidate[role] != \"function\") {\n        invalidRegistry(`Registry role '${role}' for '${id}' must be a function when present.`, id)\n      }\n    }\n    const artifactMultiplicity = candidate.artifactMultiplicity\n\n    if (artifactMultiplicity != \"single\" && artifactMultiplicity != \"multiple\") {\n      invalidRegistry(`Registry record '${id}' has an invalid artifact multiplicity.`, id)\n    }\n    if (typeof candidate.roundTrip != \"boolean\") invalidRegistry(`Registry record '${id}' requires a Boolean round-trip declaration.`, id)\n    const mappingCandidate = candidate.mapping\n\n    if (!isPlainObject(mappingCandidate)) invalidRegistry(`Registry record '${id}' has an invalid mapping declaration.`, id)\n    const mappingSnapshot = {\n      binaryRanges: mappingCandidate.binaryRanges,\n      richText: mappingCandidate.richText,\n      sourceMapV3: mappingCandidate.sourceMapV3\n    }\n\n    if (typeof mappingSnapshot.richText != \"boolean\" || typeof mappingSnapshot.sourceMapV3 != \"boolean\" ||\n      typeof mappingSnapshot.binaryRanges != \"boolean\") {\n      invalidRegistry(`Registry record '${id}' has an invalid mapping declaration.`, id)\n    }\n    const mapping = deepFreeze(/** @type {import(\"./semantic/types.js\").LanguageMappingCapabilities} */ (mappingSnapshot))\n    const acceptanceCandidate = candidate.acceptance\n\n    if (!isPlainObject(acceptanceCandidate) || !isDenseArray(acceptanceCandidate.stages) ||\n      !isDenseArray(acceptanceCandidate.toolchains)) {\n      invalidRegistry(`Registry record '${id}' has an invalid acceptance declaration.`, id)\n    }\n    /** @type {unknown[]} */\n    const stageSnapshot = []\n    /** @type {unknown[]} */\n    const toolchainSnapshot = []\n\n    for (let index = 0; index < acceptanceCandidate.stages.length; index += 1) {\n      stageSnapshot.push(acceptanceCandidate.stages[index])\n    }\n    for (let index = 0; index < acceptanceCandidate.toolchains.length; index += 1) {\n      toolchainSnapshot.push(acceptanceCandidate.toolchains[index])\n    }\n    if (!stageSnapshot.every((stage) => typeof stage == \"string\" && acceptanceStages.has(stage)) ||\n      !toolchainSnapshot.every((toolchain) => typeof toolchain == \"string\" && toolchain.length > 0)) {\n      invalidRegistry(`Registry record '${id}' has an invalid acceptance declaration.`, id)\n    }\n    const stages = /** @type {import(\"./semantic/types.js\").AcceptanceStage[]} */ (stageSnapshot)\n    const toolchains = /** @type {string[]} */ (toolchainSnapshot)\n    let previousStage = -1\n    const declaredStages = new Set()\n\n    for (const stage of stages) {\n      const stageIndex = /** @type {number} */ (acceptanceStages.get(/** @type {string} */ (stage)))\n\n      if (declaredStages.has(stage) || stageIndex < previousStage) invalidRegistry(`Registry record '${id}' has unordered or duplicate acceptance stages.`, id)\n      declaredStages.add(stage)\n      previousStage = stageIndex\n    }\n    if (new Set(toolchains).size != toolchains.length) {\n      invalidRegistry(`Registry record '${id}' has duplicate acceptance toolchains.`, id)\n    }\n\n    const hasFrontend = typeof candidate.frontend == \"function\"\n    const hasTextBackend = typeof candidate.textBackend == \"function\"\n    const hasBinaryBackend = typeof candidate.binaryBackend == \"function\"\n    const hasApplicationBackend = typeof candidate.applicationBackend == \"function\"\n    const hasBackend = hasTextBackend || hasBinaryBackend || hasApplicationBackend\n\n    if ((mapping.richText || mapping.sourceMapV3) && !hasTextBackend ||\n      mapping.sourceMapV3 && !mapping.richText ||\n      mapping.binaryRanges && !hasBinaryBackend && !hasApplicationBackend) {\n      invalidRegistry(`Registry record '${id}' declares mapping support without its required backend role.`, id)\n    }\n    if (candidate.roundTrip && (!hasFrontend || !hasBackend)) {\n      invalidRegistry(`Registry record '${id}' declares round-trip support without frontend and backend roles.`, id)\n    }\n    if (stages.includes(\"parse\") && !hasFrontend || stages.includes(\"generate\") && !hasBackend) {\n      invalidRegistry(`Registry record '${id}' declares an acceptance stage without its required role.`, id)\n    }\n\n    if ((hasBackend || candidate.defaultFilename !== undefined) &&\n      (typeof candidate.defaultFilename != \"string\" || candidate.defaultFilename.length == 0)) {\n      invalidRegistry(`Registry backend '${id}' requires a default filename.`, id)\n    }\n    if ((hasBackend || candidate.mediaType !== undefined) &&\n      (typeof candidate.mediaType != \"string\" || candidate.mediaType.length == 0)) {\n      invalidRegistry(`Registry backend '${id}' requires a media type.`, id)\n    }\n\n    const acceptance = deepFreeze(/** @type {import(\"./semantic/types.js\").LanguageAcceptanceCapabilities} */ ({\n      stages,\n      toolchains\n    }))\n    const record = deepFreeze(/** @type {LanguageRegistryRecord} */ ({\n      acceptance,\n      artifactMultiplicity,\n      id,\n      mapping,\n      roundTrip: candidate.roundTrip,\n      ...(typeof candidate.defaultFilename == \"string\" ? {defaultFilename: candidate.defaultFilename} : {}),\n      ...(typeof candidate.mediaType == \"string\" ? {mediaType: candidate.mediaType} : {}),\n      ...(typeof candidate.frontend == \"function\" ? {frontend: candidate.frontend} : {}),\n      ...(typeof candidate.textBackend == \"function\" ? {textBackend: candidate.textBackend} : {}),\n      ...(typeof candidate.binaryBackend == \"function\" ? {binaryBackend: candidate.binaryBackend} : {}),\n      ...(typeof candidate.applicationBackend == \"function\" ? {applicationBackend: candidate.applicationBackend} : {}),\n      ...(typeof candidate.interoperability == \"function\" ? {interoperability: candidate.interoperability} : {})\n    }))\n    const descriptor = deepFreeze(/** @type {import(\"./semantic/types.js\").LanguageCapabilities} */ ({\n      acceptance,\n      artifactMultiplicity,\n      id,\n      mapping,\n      roles: {\n        applicationBackend: typeof candidate.applicationBackend == \"function\",\n        binaryBackend: typeof candidate.binaryBackend == \"function\",\n        frontend: typeof candidate.frontend == \"function\",\n        interoperability: typeof candidate.interoperability == \"function\",\n        textBackend: typeof candidate.textBackend == \"function\"\n      },\n      roundTrip: candidate.roundTrip\n    }))\n\n    recordsById.set(id, record)\n    descriptors.push(descriptor)\n  }\n\n  const frozenDescriptors = deepFreeze(descriptors)\n  const ids = Object.freeze(frozenDescriptors.map(({id}) => id))\n\n  return Object.freeze({\n    descriptors: frozenDescriptors,\n    ids,\n    record(id) {\n      const record = recordsById.get(id)\n\n      if (!record) unsupportedLanguage(id)\n\n      return record\n    },\n    resolve(id, role, location) {\n      if (!registryRoles.includes(role)) invalidRegistry(`Unknown registry role '${role}'.`, id)\n      const record = recordsById.get(id)\n\n      if (!record) unsupportedLanguage(id, location, role)\n      const implementation = record[role]\n\n      if (typeof implementation != \"function\") unsupportedRole(id, publicRoleName(role), location)\n\n      return implementation\n    }\n  })\n}\n\n/**\n * PHP registry frontend wrapper.\n * @type {Frontend}\n */\nconst phpFrontend = ({filename, source}) => parsePhp({filename, source})\n\n/**\n * Ruby registry frontend wrapper.\n * @type {Frontend}\n */\nconst rubyFrontend = ({filename, source}) => parseRuby({filename, source})\n\n/**\n * JavaScript registry frontend wrapper.\n * @type {Frontend}\n */\nconst javaScriptFrontend = ({filename, source}) => parseJavaScriptTypeScript({filename, language: \"javascript\", source})\n\n/**\n * TypeScript registry frontend wrapper.\n * @type {Frontend}\n */\nconst typeScriptFrontend = ({filename, source}) => parseJavaScriptTypeScript({filename, language: \"typescript\", source})\n\n/**\n * Java registry frontend wrapper.\n * @type {Frontend}\n */\nconst javaFrontend = ({filename, source}) => parseJava({filename, source})\n\n/**\n * Python registry frontend wrapper.\n * @type {Frontend}\n */\nconst pythonFrontend = ({filename, source}) => parsePython({filename, source})\n\nconst records = [\n  language({\n    acceptance: {stages: [\"parse\", \"generate\", \"execute\"], toolchains: [\"php\"]},\n    defaultFilename: \"program.php\",\n    frontend: phpFrontend,\n    id: \"php\",\n    mediaType: \"application/x-httpd-php\",\n    textBackend: generatePhp\n  }),\n  language({\n    acceptance: {stages: [\"parse\", \"generate\", \"execute\"], toolchains: [\"ruby\"]},\n    defaultFilename: \"program.rb\",\n    frontend: rubyFrontend,\n    id: \"ruby\",\n    mediaType: \"text/x-ruby\",\n    textBackend: generateRuby\n  }),\n  language({\n    acceptance: {stages: [\"parse\", \"generate\", \"execute\"], toolchains: [\"node\"]},\n    defaultFilename: \"program.js\",\n    frontend: javaScriptFrontend,\n    id: \"javascript\",\n    mediaType: \"text/javascript\",\n    textBackend: generateJavaScript\n  }),\n  language({\n    acceptance: {stages: [\"parse\", \"generate\", \"compile\", \"execute\"], toolchains: [\"tsc\", \"node\"]},\n    defaultFilename: \"program.ts\",\n    frontend: typeScriptFrontend,\n    id: \"typescript\",\n    mediaType: \"text/typescript\",\n    textBackend: generateTypeScript\n  }),\n  language({\n    acceptance: {stages: [\"parse\", \"generate\", \"compile\", \"execute\"], toolchains: [\"javac\", \"java\"]},\n    defaultFilename: \"Main.java\",\n    frontend: javaFrontend,\n    id: \"java\",\n    mediaType: \"text/x-java-source\",\n    textBackend: generateJava\n  }),\n  language({\n    acceptance: {stages: [\"parse\", \"generate\", \"compile\", \"execute\"], toolchains: [\"python\"]},\n    defaultFilename: \"program.py\",\n    frontend: pythonFrontend,\n    id: \"python\",\n    mediaType: \"text/x-python\",\n    textBackend: generatePython\n  })\n]\n\nexport const languageRegistry = createLanguageRegistry(records)\nexport const languageCapabilities = languageRegistry.descriptors\n/** @type {readonly import(\"./semantic/types.js\").SemanticLanguage[]} */\nexport const supportedLanguages = Object.freeze(languageCapabilities\n  .filter(({roles}) => roles.frontend && roles.textBackend)\n  .map(({id}) => /** @type {import(\"./semantic/types.js\").SemanticLanguage} */ (id)))\n\n/**\n * Supplies common original-five capability declarations.\n * @param {Record<string, unknown>} values - Language-specific record fields.\n * @returns {Record<string, unknown>} Complete record.\n */\nfunction language(values) {\n  return {\n    artifactMultiplicity: \"single\",\n    mapping: {binaryRanges: false, richText: true, sourceMapV3: true},\n    roundTrip: true,\n    ...values\n  }\n}\n\n/**\n * Formats an internal registry key for a public role diagnostic.\n * @param {string} role - Internal role key.\n * @returns {string} Public role name.\n */\nfunction publicRoleName(role) {\n  if (role == \"textBackend\") return \"text backend\"\n  if (role == \"binaryBackend\") return \"binary backend\"\n  if (role == \"applicationBackend\") return \"application-artifact backend\"\n\n  return role\n}\n\n/**\n * Throws an unknown-language diagnostic.\n * @param {string} id - Unknown identity.\n * @param {import(\"./semantic/types.js\").SourceLocation | undefined} [location] - Related location.\n * @param {RegistryRole | undefined} [role] - Requested role.\n * @returns {never} Always throws.\n */\nfunction unsupportedLanguage(id, location, role) {\n  const message = role == \"frontend\" ? \"No frontend adapter is registered for this language.\" :\n    role == \"textBackend\" ? \"No source backend is registered for this language.\" :\n      \"No language or target is registered for this ID.\"\n\n  throw new SemantifoldDiagnostic({\n    code: \"UNSUPPORTED_LANGUAGE\",\n    language: id,\n    location,\n    message\n  })\n}\n\n/**\n * Throws a normalized registry-shape diagnostic.\n * @param {string} message - Failure detail.\n * @param {string | undefined} [id] - Candidate registry ID.\n * @returns {never} Always throws.\n */\nfunction invalidRegistry(message, id = \"registry\") {\n  throw new SemantifoldDiagnostic({code: \"INVALID_REGISTRY\", language: id, message})\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 registry records and public descriptors.\n * @template T\n * @param {T} value - Registry-owned 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"]}