semantifold 0.3.0 → 0.5.0

package/build/src/stdlib-facades.js

@@ -0,0 +1,1167 @@
+// @ts-check
+import { isDenseArray } from "./array.js";
+import { isSafeArtifactPath } from "./artifact-path.js";
+import { SemantifoldDiagnostic } from "./diagnostic.js";
+import { compareStdlibVersions, parseStdlibVersion, parseStdlibVersionRange, resolveStdlibModule, stdlibVersionSatisfies } from "./semantic/stdlib.js";
+const facadeIdentityPattern = /^[a-z][a-z0-9.-]*$/u;
+const moduleIdPattern = /^[a-z][a-z0-9_]*(?:[.-][a-z][a-z0-9_]*)*$/u;
+const declarationNamePattern = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+const supportedLanguages = new Set(["php", "ruby", "javascript", "typescript", "java"]);
+const canonicalTypes = new Set(["boolean", "integer", "string", "void"]);
+/**
+ * @typedef StdlibFacadeFunctionDeclaration
+ * @property {"function"} kind - Closed public declaration kind.
+ * @property {string} name - Exact source-visible symbol.
+ * @property {{name: string, type: string}[]} parameters - Ordered source signature.
+ * @property {string} returnType - Canonical result type.
+ * @property {string[]} effects - Closed public effects.
+ * @property {string[]} failures - Escaping canonical failure names.
+ * @property {("direct-call" | "unqualified-call" | "receiver-call")[]} forms - Accepted source call forms.
+ * @property {"not-applicable"} ownership - Initial scalar qualification ownership.
+ */
+/**
+ * @typedef StdlibFacadeClassDeclaration
+ * @property {"class"} kind - Closed public declaration kind.
+ * @property {string} name - Exact source-visible class symbol.
+ * @property {["constructor-call"]} forms - Accepted construction form.
+ * @property {"owned-reference"} ownership - Class instance ownership.
+ * @property {{effects: string[], failures: string[], ownership: "acquired", parameters: {name: string, type: string}[]}} constructor - Constructor contract.
+ * @property {{effects: string[], failures: string[], forms: ["receiver-call"], name: string, ownership: "borrowed" | "consumed", parameters: {name: string, type: string}[], returnType: string}[]} methods - Public instance methods.
+ */
+/** @typedef {StdlibFacadeFunctionDeclaration | StdlibFacadeClassDeclaration} StdlibFacadePublicDeclaration */
+/**
+ * @typedef StdlibFacadeRecord
+ * @property {{identity: string, range: string}[]} dependencies - Facade-module dependencies.
+ * @property {string} identity - Versioned facade identity.
+ * @property {import("./semantic/types.js").SemanticLanguage} language - Source language.
+ * @property {({identity: string, kind: "module", symbols: string[]} | {forms: ("unqualified-call" | "receiver-call")[], identity: string, kind: "builtin", symbols: string[]})[]} nativeModules - Exact source native identities.
+ * @property {StdlibFacadePublicDeclaration[]} publicDeclarations - Public source surface.
+ * @property {{module: string, operations: string[], range: string}[]} requirements - Canonical-only requirements.
+ * @property {string} runtimeProfile - Exact compatible source/runtime profile.
+ * @property {{content: string, filename: string, id: string}} source - Executable compiler-owned source module.
+ * @property {string} version - Exact facade version.
+ * @property {"internal" | "public"} visibility - Native-selectable visibility.
+ */
+/**
+ * @typedef FacadeSourceNames
+ * @property {string} extension - Source filename extension.
+ * @property {string} nativeModule - Public native stdlib module identity.
+ * @property {string} publicName - Public native symbol.
+ * @property {string} unusedName - Unused-elimination fixture symbol.
+ * @property {string} unusedNativeModule - Unused-elimination fixture module.
+ * @property {string} probeSource - Public executable facade source.
+ * @property {string} runnerSource - Internal canonical runner source.
+ * @property {string} unusedSource - Unused executable facade source.
+ */
+/**
+ * @typedef StdlibFacadeRegistry
+ * @property {readonly StdlibFacadeRecord[]} facades - Stable immutable facade records.
+ * @property {(language: string, nativeModule: string, symbol: string, range?: string) => StdlibFacadeRecord} resolveFacade - Exact native identity resolver.
+ * @property {(identity: string, language: string, range?: string) => StdlibFacadeRecord} resolveIdentity - Facade dependency resolver.
+ * @property {(language: string, nativeModule: string, range?: string) => StdlibFacadeRecord} resolveModule - Exact native module resolver.
+ */
+/**
+ * Creates a detached immutable source-language facade registry.
+ * @param {unknown} records - Optional facade definitions; built-in qualification definitions by default.
+ * @returns {Readonly<StdlibFacadeRegistry>} Validated facade registry.
+ */
+export function createStdlibFacadeRegistry(records = builtinFacadeRecords()) {
+    if (!isDenseArray(records))
+        invalidFacade("Facade records must be an ordered dense array.");
+    /** @type {StdlibFacadeRecord[]} */
+    const facades = [];
+    /** @type {Map<string, Map<string, StdlibFacadeRecord>>} */
+    const byIdentity = new Map();
+    /** @type {Map<string, StdlibFacadeRecord[]>} */
+    const byNativeModule = new Map();
+    const sourceIds = new Map();
+    const sourceFilenames = new Map();
+    for (let index = 0; index < records.length; index += 1) {
+        const record = validateFacadeRecord(records[index]);
+        const identityKey = `${record.language}\0${record.identity}`;
+        const versions = byIdentity.get(identityKey) ?? new Map();
+        if (versions.has(record.version))
+            invalidFacade(`Duplicate facade '${record.identity}' version '${record.version}' for '${record.language}'.`);
+        if (sourceIds.has(record.source.id) && sourceIds.get(record.source.id) != identityKey) {
+            invalidFacade(`Duplicate facade source module identity '${record.source.id}'.`);
+        }
+        if (sourceFilenames.has(record.source.filename) && sourceFilenames.get(record.source.filename) != identityKey) {
+            invalidFacade(`Duplicate facade source filename '${record.source.filename}'.`);
+        }
+        versions.set(record.version, record);
+        byIdentity.set(identityKey, versions);
+        sourceIds.set(record.source.id, identityKey);
+        sourceFilenames.set(record.source.filename, identityKey);
+        facades.push(record);
+        for (const nativeModule of record.nativeModules) {
+            const nativeKey = `${record.language}\0${nativeModule.identity}`;
+            const nativeRecords = byNativeModule.get(nativeKey) ?? [];
+            nativeRecords.push(record);
+            byNativeModule.set(nativeKey, nativeRecords);
+        }
+    }
+    for (const record of facades) {
+        for (const dependency of record.dependencies) {
+            resolveIdentityFromStore(byIdentity, dependency.identity, record.language, dependency.range, record.identity);
+        }
+    }
+    validateFacadeDependencyCycles(facades, byIdentity);
+    return Object.freeze(/** @type {StdlibFacadeRegistry} */ ({
+        facades: Object.freeze(facades),
+        resolveFacade(language, nativeModule, symbol, range) {
+            return resolveNativeFacadeFromStore(byNativeModule, language, nativeModule, symbol, range);
+        },
+        resolveIdentity(identity, language, range) {
+            return resolveIdentityFromStore(byIdentity, identity, language, range);
+        },
+        resolveModule(language, nativeModule, range) {
+            const records = byNativeModule.get(`${language}\0${nativeModule}`);
+            if (!records)
+                unprovedIdentity(language, nativeModule);
+            const identities = new Set(/** @type {StdlibFacadeRecord[]} */ (records).map(({ identity }) => identity));
+            if (identities.size != 1)
+                invalidFacade(`Native facade module '${nativeModule}' is ambiguous for '${language}'.`);
+            return selectFacadeVersion(new Map(/** @type {StdlibFacadeRecord[]} */ (records).map((record) => [record.version, record])), 
+            /** @type {StdlibFacadeRecord} */ (records[0]).identity, language, range);
+        }
+    }));
+}
+/**
+ * Rejects cycles after every versioned dependency has resolved successfully.
+ * @param {StdlibFacadeRecord[]} facades - Validated facade records.
+ * @param {Map<string, Map<string, StdlibFacadeRecord>>} store - Records by language and identity.
+ * @returns {void}
+ */
+function validateFacadeDependencyCycles(facades, store) {
+    const active = new Set();
+    const complete = new Set();
+    /**
+     * Visits one exact selected facade version.
+     * @param {StdlibFacadeRecord} record - Facade record.
+     * @returns {void}
+     */
+    function visit(record) {
+        const key = `${record.language}\0${record.identity}\0${record.version}`;
+        if (complete.has(key))
+            return;
+        if (active.has(key))
+            invalidFacade(`Facade dependency cycle includes '${record.identity}'.`);
+        active.add(key);
+        for (const dependency of record.dependencies) {
+            visit(resolveIdentityFromStore(store, dependency.identity, record.language, dependency.range, record.identity));
+        }
+        active.delete(key);
+        complete.add(key);
+    }
+    for (const record of facades)
+        visit(record);
+}
+/**
+ * Lists all built-in public and internal facade modules in stable order.
+ * @returns {readonly StdlibFacadeRecord[]} Immutable facade definitions.
+ */
+export function listStdlibFacades() {
+    return stdlibFacadeRegistry.facades;
+}
+/**
+ * Resolves one built-in facade from parser-proved native module and symbol identities.
+ * @param {string} language - Source language.
+ * @param {string} nativeModule - Exact native module identity.
+ * @param {string} symbol - Exact imported or qualified symbol.
+ * @param {string} [range] - Compatible facade version range.
+ * @returns {StdlibFacadeRecord} Immutable facade definition.
+ */
+export function resolveStdlibFacade(language, nativeModule, symbol, range) {
+    return stdlibFacadeRegistry.resolveFacade(language, nativeModule, symbol, range);
+}
+/**
+ * Resolves a dependency-first, cycle-free facade module closure.
+ * @param {StdlibFacadeRecord[]} roots - Parser-selected facade roots.
+ * @param {Readonly<StdlibFacadeRegistry>} [registry] - Facade registry.
+ * @returns {StdlibFacadeRecord[]} Stable dependency-first closure.
+ */
+export function resolveStdlibFacadeClosure(roots, registry = stdlibFacadeRegistry) {
+    const active = new Set();
+    const complete = new Set();
+    /** @type {StdlibFacadeRecord[]} */
+    const result = [];
+    /**
+     * Visits one selected facade and its declared dependencies.
+     * @param {StdlibFacadeRecord} record - Facade to visit.
+     * @returns {void}
+     */
+    function visit(record) {
+        const key = `${record.language}\0${record.identity}\0${record.version}`;
+        if (complete.has(key))
+            return;
+        if (active.has(key))
+            invalidFacade(`Facade dependency cycle includes '${record.identity}'.`);
+        active.add(key);
+        for (const dependency of record.dependencies) {
+            visit(registry.resolveIdentity(dependency.identity, record.language, dependency.range));
+        }
+        active.delete(key);
+        complete.add(key);
+        result.push(record);
+    }
+    for (const root of roots)
+        visit(root);
+    return result;
+}
+/**
+ * Creates the detached, deterministic program descriptor for one selected facade closure.
+ * @param {import("./semantic/types.js").SemanticLanguage} language - Source language profile.
+ * @param {StdlibFacadeRecord[]} facades - Dependency-first selected facade records.
+ * @returns {import("./semantic/types.js").StdlibFacadeProgramDescriptor} Plain program descriptor.
+ */
+export function stdlibFacadeProgramDescriptor(language, facades) {
+    return {
+        language,
+        modules: facades.map((facade) => ({
+            dependencies: facade.dependencies.map((dependency) => ({ ...dependency })),
+            identity: facade.identity,
+            nativeModules: facade.nativeModules.map((module) => ({ ...module,
+                ...(module.kind == "builtin" ? { forms: [...module.forms] } : {}), symbols: [...module.symbols] })),
+            publicDeclarations: facade.publicDeclarations.map(detachPublicDeclaration),
+            requirements: facade.requirements.map((requirement) => ({ ...requirement, operations: [...requirement.operations] })),
+            runtimeProfile: facade.runtimeProfile,
+            sourceModule: facade.source.id,
+            version: facade.version,
+            visibility: facade.visibility
+        })),
+        schema: "SemantifoldStdlibFacades",
+        version: 1
+    };
+}
+/**
+ * Derives compiler-owned semantic capability authority from selected facade requirements.
+ * The initial executable qualification corpus intentionally targets one canonical module.
+ * @param {StdlibFacadeRecord[]} records - Selected facade closure.
+ * @returns {{contract: {contractVersion: string, identity: string}, input: import("./semantic/types.js").CapabilityAuthorityInput} | {contracts: {contractVersion: string, identity: string}[], input: import("./semantic/types.js").CapabilityAuthorityInput} | null} Authority input.
+ */
+export function facadeCapabilityAuthority(records) {
+    const requirements = records.flatMap((record) => record.requirements);
+    if (requirements.length == 0)
+        return null;
+    const identities = new Set(requirements.map(({ module }) => module));
+    const ranges = new Set(requirements.map(({ range }) => range));
+    const task037 = records.some(({ identity }) => identity.startsWith("semantifold.task037."));
+    if (task037) {
+        const requirementByModule = new Map();
+        for (const requirement of requirements) {
+            const current = requirementByModule.get(requirement.module);
+            if (current && current.range != requirement.range)
+                invalidFacade("Task 037 facade requirements disagree on a canonical range.");
+            const operations = new Set(current?.operations ?? []);
+            for (const operation of requirement.operations)
+                operations.add(operation);
+            requirementByModule.set(requirement.module, { operations, range: requirement.range });
+        }
+        const modules = [...requirementByModule.entries()].map(([identity, requirement]) => {
+            const contract = resolveStdlibModule(identity, requirement.range);
+            return {
+                capabilities: [{
+                        failures: contract.failures.map(({ name }) => ({ name })),
+                        name: canonicalCapabilityName(identity),
+                        operations: contract.operations.filter(({ name }) => requirement.operations.has(name)).map((operation) => ({
+                            effects: /** @type {["host"]} */ ([...operation.effects]),
+                            failures: operation.failures.map(detachCanonicalReference),
+                            name: operation.name,
+                            parameters: operation.parameters.map((parameter) => ({
+                                name: parameter.name,
+                                type: canonicalCapabilityParameterType(parameter.type)
+                            })),
+                            resourceFlow: detachResourceFlow(operation.resourceFlow),
+                            returnType: canonicalCapabilityType(operation.returnType)
+                        })),
+                        resources: contract.resources.map(({ name }) => ({ name }))
+                    }],
+                contractVersion: requirement.range,
+                identity
+            };
+        });
+        return {
+            contracts: modules.map(({ contractVersion, identity }) => ({ contractVersion, identity })),
+            input: { id: "semantifold.task037.blocking-tcp", modules, schema: "SemantifoldCapabilityAuthority", schemaVersion: 2 }
+        };
+    }
+    if (identities.size != 1 || ranges.size != 1) {
+        invalidFacade("The Task 036 qualification facade closure must resolve one canonical module and version range.");
+    }
+    const identity = requirements[0].module;
+    const contractVersion = requirements[0].range;
+    const contract = resolveStdlibModule(identity, contractVersion);
+    return {
+        contract: { contractVersion, identity },
+        input: {
+            capabilities: [{
+                    failures: contract.failures.map(({ name }) => ({ name })),
+                    name: "ResourceProbe",
+                    operations: contract.operations.map((operation) => ({
+                        effects: [...operation.effects],
+                        failures: [...operation.failures],
+                        name: operation.name,
+                        parameters: operation.parameters.map((parameter) => ({
+                            name: parameter.name,
+                            type: canonicalCapabilityParameterType(parameter.type)
+                        })),
+                        resourceFlow: /** @type {import("./semantic/types.js").CapabilityResourceFlowInput} */ ({ ...operation.resourceFlow }),
+                        returnType: canonicalCapabilityType(operation.returnType)
+                    })),
+                    resources: contract.resources.map(({ name }) => ({ name }))
+                }],
+            contractVersion,
+            id: identity,
+            schema: "SemantifoldCapabilityAuthority",
+            schemaVersion: 1
+        }
+    };
+}
+/**
+ * Converts one registry contract type to a capability-authority input type.
+ * @param {string | import("./semantic/stdlib.js").CanonicalDeclarationReference} type - Canonical contract type.
+ * @returns {import("./semantic/types.js").FunctionReturnTypeName | {kind: "OwnedResourceType", resource: string | import("./semantic/types.js").CapabilityDeclarationReferenceInput} | {kind: "OptionalType", valueType: import("./semantic/types.js").SemanticTypeName}} Semantic authority type.
+ */
+function canonicalCapabilityType(type) {
+    if (typeof type != "string")
+        return { kind: "OwnedResourceType", resource: detachCanonicalReference(type) };
+    if (type == "void" || type == "boolean" || type == "integer" || type == "string")
+        return type;
+    if (type.startsWith("optional:"))
+        return { kind: "OptionalType",
+            valueType: /** @type {import("./semantic/types.js").SemanticTypeName} */ (type.slice("optional:".length)) };
+    return { kind: "OwnedResourceType", resource: type };
+}
+/**
+ * Converts a non-void registry parameter type to capability-authority input.
+ * @param {string | import("./semantic/stdlib.js").CanonicalDeclarationReference} type - Canonical parameter type.
+ * @returns {import("./semantic/types.js").SemanticTypeName | {kind: "OwnedResourceType", resource: string} | {kind: "OptionalType", valueType: import("./semantic/types.js").SemanticTypeName}} Semantic parameter type.
+ */
+function canonicalCapabilityParameterType(type) {
+    const converted = canonicalCapabilityType(type);
+    if (converted == "void")
+        invalidFacade("Canonical facade requirement parameters cannot have void type.");
+    return /** @type {import("./semantic/types.js").SemanticTypeName | {kind: "OwnedResourceType", resource: string} | {kind: "OptionalType", valueType: import("./semantic/types.js").SemanticTypeName}} */ (converted);
+}
+/**
+ * Resolves one dependency identity from a validated registry store.
+ * @param {Map<string, Map<string, StdlibFacadeRecord>>} store - Records by language and identity.
+ * @param {string} identity - Facade identity.
+ * @param {string} language - Source language.
+ * @param {string | undefined} range - Compatible range.
+ * @param {string} [owner] - Depending facade for diagnostics.
+ * @returns {StdlibFacadeRecord} Highest compatible record.
+ */
+function resolveIdentityFromStore(store, identity, language, range, owner) {
+    const versions = store.get(`${language}\0${identity}`);
+    if (!versions) {
+        invalidFacade(owner ? `Facade '${owner}' depends on unknown facade '${identity}' for '${language}'.` :
+            `Unknown facade identity '${identity}' for '${language}'.`);
+    }
+    return selectFacadeVersion(/** @type {Map<string, StdlibFacadeRecord>} */ (versions), identity, language, range);
+}
+/**
+ * Resolves one exact native identity from a validated registry store.
+ * @param {Map<string, StdlibFacadeRecord[]>} store - Records by language and native module.
+ * @param {string} language - Source language.
+ * @param {string} nativeModule - Exact parser-owned native module identity.
+ * @param {string} symbol - Exact source-visible symbol.
+ * @param {string | undefined} range - Compatible range.
+ * @returns {StdlibFacadeRecord} Highest compatible record.
+ */
+function resolveNativeFacadeFromStore(store, language, nativeModule, symbol, range) {
+    if (!supportedLanguages.has(language) || typeof nativeModule != "string" || nativeModule.length == 0) {
+        unprovedIdentity(language, nativeModule);
+    }
+    const moduleRecords = store.get(`${language}\0${nativeModule}`);
+    if (!moduleRecords)
+        unprovedIdentity(language, nativeModule);
+    const symbolRecords = /** @type {StdlibFacadeRecord[]} */ (moduleRecords).filter((record) => record.nativeModules.some((module) => module.identity == nativeModule && module.symbols.includes(symbol)));
+    if (symbolRecords.length == 0)
+        unsupportedMember(language, nativeModule, symbol);
+    const identities = new Set(symbolRecords.map(({ identity }) => identity));
+    if (identities.size != 1)
+        invalidFacade(`Native facade identity '${nativeModule}#${symbol}' is ambiguous for '${language}'.`);
+    const versions = new Map(symbolRecords.map((record) => [record.version, record]));
+    return selectFacadeVersion(versions, symbolRecords[0].identity, language, range);
+}
+/**
+ * Selects the highest facade version satisfying a canonical range.
+ * @param {Map<string, StdlibFacadeRecord>} versions - Records by exact version.
+ * @param {string} identity - Facade identity.
+ * @param {string} language - Source language.
+ * @param {string | undefined} range - Compatible range.
+ * @returns {StdlibFacadeRecord} Selected record.
+ */
+function selectFacadeVersion(versions, identity, language, range) {
+    const parsedRange = range === undefined ? { lower: /** @type {[number, number, number]} */ ([0, 0, 0]), upper: null } :
+        parseStdlibVersionRange(range);
+    if (!parsedRange)
+        facadeVersionMalformed(language, String(range));
+    /** @type {[number, number, number] | undefined} */
+    let selected;
+    for (const version of versions.keys()) {
+        const parsed = /** @type {[number, number, number]} */ (parseStdlibVersion(version));
+        if (stdlibVersionSatisfies(parsed, parsedRange) && (!selected || compareStdlibVersions(parsed, selected) > 0))
+            selected = parsed;
+    }
+    if (!selected)
+        facadeVersionIncompatible(language, identity);
+    return /** @type {StdlibFacadeRecord} */ (versions.get(selected.join(".")));
+}
+/**
+ * Validates and detaches one executable facade record.
+ * @param {unknown} candidate - Candidate record.
+ * @returns {StdlibFacadeRecord} Detached frozen record.
+ */
+function validateFacadeRecord(candidate) {
+    if (!isPlainObject(candidate))
+        invalidFacade("Every facade record must be a plain object.");
+    requireKeys(candidate, ["dependencies", "identity", "language", "nativeModules", "publicDeclarations", "requirements",
+        "runtimeProfile", "source", "version", "visibility"], "facade record");
+    const identity = requireString(candidate.identity, "Facade identity");
+    const language = requireString(candidate.language, "Facade language");
+    const version = requireString(candidate.version, "Facade version");
+    const runtimeProfile = requireString(candidate.runtimeProfile, "Facade runtime profile");
+    const visibility = candidate.visibility;
+    if (!facadeIdentityPattern.test(identity))
+        invalidFacade(`Facade identity '${identity}' is invalid.`);
+    if (!supportedLanguages.has(language))
+        invalidFacade(`Facade language '${language}' is outside the adopted cohort.`);
+    if (!parseStdlibVersion(version))
+        invalidFacade(`Facade version '${version}' is invalid.`);
+    if (!/^[a-z][a-z0-9.-]*$/u.test(runtimeProfile))
+        invalidFacade(`Facade runtime profile '${runtimeProfile}' is invalid.`);
+    if (visibility != "public" && visibility != "internal")
+        invalidFacade(`Facade '${identity}' has invalid visibility.`);
+    const source = validateSource(candidate.source, identity, language);
+    const publicDeclarations = validatePublicDeclarations(candidate.publicDeclarations, identity);
+    const nativeModules = validateNativeModules(candidate.nativeModules, identity, publicDeclarations);
+    const requirements = validateRequirements(candidate.requirements, identity);
+    const dependencies = validateDependencies(candidate.dependencies, identity);
+    if (visibility == "public" && (publicDeclarations.length == 0 || nativeModules.length == 0)) {
+        invalidFacade(`Public facade '${identity}' requires declarations and native identities.`);
+    }
+    if (visibility == "internal" && nativeModules.length > 0)
+        invalidFacade(`Internal facade '${identity}' cannot expose native identities.`);
+    return deepFreeze({
+        dependencies,
+        identity,
+        language: /** @type {import("./semantic/types.js").SemanticLanguage} */ (language),
+        nativeModules,
+        publicDeclarations,
+        requirements,
+        runtimeProfile,
+        source,
+        version,
+        visibility: /** @type {"internal" | "public"} */ (visibility)
+    });
+}
+/**
+ * Validates one compiler-owned executable facade source.
+ * @param {unknown} candidate - Candidate source descriptor.
+ * @param {string} identity - Owning facade identity.
+ * @param {string} language - Facade source language.
+ * @returns {{content: string, filename: string, id: string}} Validated source descriptor.
+ */
+function validateSource(candidate, identity, language) {
+    if (!isPlainObject(candidate))
+        invalidFacade(`Facade '${identity}' requires an executable source descriptor.`);
+    requireKeys(candidate, ["content", "filename", "id"], `facade '${identity}' source`);
+    const content = requireString(candidate.content, `Facade '${identity}' source content`);
+    const filename = requireString(candidate.filename, `Facade '${identity}' source filename`);
+    const id = requireString(candidate.id, `Facade '${identity}' source module identity`);
+    if (content.length == 0 || !isSafeArtifactPath(filename) || !filename.startsWith(`__semantifold_facades__/${language}/`) ||
+        !moduleIdPattern.test(id) || !id.startsWith(`semantifold.facade.${language}.`)) {
+        invalidFacade(`Facade '${identity}' has an invalid compiler-owned source descriptor.`);
+    }
+    return { content, filename, id };
+}
+/**
+ * Validates one facade's closed public declaration surface.
+ * @param {unknown} candidate - Candidate declarations.
+ * @param {string} identity - Owning facade identity.
+ * @returns {StdlibFacadePublicDeclaration[]} Validated declarations.
+ */
+function validatePublicDeclarations(candidate, identity) {
+    if (!isDenseArray(candidate))
+        invalidFacade(`Facade '${identity}' public declarations must be a dense array.`);
+    const names = new Set();
+    return candidate.map((value) => {
+        if (!isPlainObject(value))
+            invalidFacade(`Facade '${identity}' public declarations must be plain objects.`);
+        const name = requireString(value.name, `Facade '${identity}' declaration name`);
+        if (!declarationNamePattern.test(name) || names.has(name)) {
+            invalidFacade(`Facade '${identity}' has an invalid or duplicate public declaration.`);
+        }
+        names.add(name);
+        if (value.kind == "class")
+            return validatePublicClass(value, identity, name);
+        requireKeys(value, ["effects", "failures", "forms", "kind", "name", "ownership", "parameters", "returnType"], `facade '${identity}' public declaration`);
+        if (value.kind != "function")
+            invalidFacade(`Facade '${identity}' has an invalid public declaration kind.`);
+        if (!isDenseArray(value.effects) || !value.effects.every((effect) => effect == "host") || new Set(value.effects).size != value.effects.length ||
+            !isDenseArray(value.failures) || !value.failures.every((failure) => typeof failure == "string" && declarationNamePattern.test(failure)) ||
+            !isDenseArray(value.forms) || value.forms.length == 0 || !value.forms.every((form) => typeof form == "string" && ["direct-call", "unqualified-call", "receiver-call"].includes(form)) ||
+            new Set(value.forms).size != value.forms.length ||
+            value.ownership != "not-applicable" ||
+            !isDenseArray(value.parameters))
+            invalidFacade(`Facade '${identity}' declaration '${name}' has an invalid public contract.`);
+        const parameters = validateFacadeParameters(value.parameters, identity, name);
+        const returnType = requireString(value.returnType, `Facade '${identity}' return type`);
+        if (!isFacadeType(returnType, true))
+            invalidFacade(`Facade '${identity}' declaration '${name}' has an invalid return type.`);
+        return {
+            effects: /** @type {string[]} */ ([...value.effects]),
+            failures: /** @type {string[]} */ ([...value.failures]),
+            forms: /** @type {("direct-call" | "unqualified-call" | "receiver-call")[]} */ ([...value.forms]),
+            kind: /** @type {const} */ ("function"),
+            name,
+            ownership: /** @type {const} */ ("not-applicable"),
+            parameters,
+            returnType
+        };
+    });
+}
+/**
+ * Validates the exact native module and symbol identities selecting a facade.
+ * @param {unknown} candidate - Candidate native modules.
+ * @param {string} identity - Owning facade identity.
+ * @param {StdlibFacadePublicDeclaration[]} declarations - Validated public surface.
+ * @returns {({identity: string, kind: "module", symbols: string[]} | {forms: ("unqualified-call" | "receiver-call")[], identity: string, kind: "builtin", symbols: string[]})[]} Validated native identities.
+ */
+function validateNativeModules(candidate, identity, declarations) {
+    if (!isDenseArray(candidate))
+        invalidFacade(`Facade '${identity}' native modules must be a dense array.`);
+    const modules = new Set();
+    const publicNames = new Set(declarations.map(({ name }) => name));
+    return candidate.map((value) => {
+        if (!isPlainObject(value))
+            invalidFacade(`Facade '${identity}' native modules must be plain objects.`);
+        const builtin = value.kind == "builtin";
+        requireKeys(value, builtin ? ["forms", "identity", "kind", "symbols"] : ["identity", "kind", "symbols"], `facade '${identity}' native module`);
+        const moduleIdentity = requireString(value.identity, `Facade '${identity}' native module identity`);
+        if (value.kind != "module" && value.kind != "builtin" || modules.has(moduleIdentity) ||
+            !isDenseArray(value.symbols) || value.symbols.length == 0 ||
+            !value.symbols.every((symbol) => typeof symbol == "string" && publicNames.has(symbol)) ||
+            new Set(value.symbols).size != value.symbols.length) {
+            invalidFacade(`Facade '${identity}' has an invalid native module declaration.`);
+        }
+        if (builtin && (!isDenseArray(value.forms) || value.forms.length == 0 ||
+            !value.forms.every((form) => form == "unqualified-call" || form == "receiver-call") ||
+            new Set(value.forms).size != value.forms.length))
+            invalidFacade(`Facade '${identity}' has invalid builtin forms.`);
+        modules.add(moduleIdentity);
+        return builtin
+            ? { forms: /** @type {("unqualified-call" | "receiver-call")[]} */ ([... /** @type {unknown[]} */(value.forms)]), identity: moduleIdentity,
+                kind: /** @type {const} */ ("builtin"), symbols: /** @type {string[]} */ ([...value.symbols]) }
+            : { identity: moduleIdentity, kind: /** @type {const} */ ("module"), symbols: /** @type {string[]} */ ([...value.symbols]) };
+    });
+}
+/**
+ * Validates canonical-only facade capability requirements.
+ * @param {unknown} candidate - Candidate requirements.
+ * @param {string} identity - Owning facade identity.
+ * @returns {{module: string, operations: string[], range: string}[]} Validated requirements.
+ */
+function validateRequirements(candidate, identity) {
+    if (!isDenseArray(candidate))
+        invalidFacade(`Facade '${identity}' requirements must be a dense array.`);
+    const modules = new Set();
+    return candidate.map((value) => {
+        if (!isPlainObject(value))
+            invalidFacade(`Facade '${identity}' requirements must be plain objects.`);
+        requireKeys(value, ["module", "operations", "range"], `facade '${identity}' requirement`);
+        const module = requireString(value.module, `Facade '${identity}' canonical module`);
+        const range = requireString(value.range, `Facade '${identity}' canonical range`);
+        if (modules.has(module) || !parseStdlibVersionRange(range) || !isDenseArray(value.operations) || value.operations.length == 0 ||
+            !value.operations.every((operation) => typeof operation == "string" && declarationNamePattern.test(operation)) ||
+            new Set(value.operations).size != value.operations.length)
+            invalidFacade(`Facade '${identity}' has an invalid canonical requirement.`);
+        const contract = resolveStdlibModule(module, range);
+        const declared = new Set(contract.operations.map(({ name }) => name));
+        if (! /** @type {string[]} */(value.operations).every((operation) => declared.has(operation))) {
+            invalidFacade(`Facade '${identity}' requires an undeclared canonical operation.`);
+        }
+        modules.add(module);
+        return { module, operations: /** @type {string[]} */ ([...value.operations]), range };
+    });
+}
+/**
+ * Validates versioned same-language facade dependencies.
+ * @param {unknown} candidate - Candidate dependencies.
+ * @param {string} identity - Owning facade identity.
+ * @returns {{identity: string, range: string}[]} Validated dependencies.
+ */
+function validateDependencies(candidate, identity) {
+    if (!isDenseArray(candidate))
+        invalidFacade(`Facade '${identity}' dependencies must be a dense array.`);
+    const identities = new Set();
+    return candidate.map((value) => {
+        if (!isPlainObject(value))
+            invalidFacade(`Facade '${identity}' dependencies must be plain objects.`);
+        requireKeys(value, ["identity", "range"], `facade '${identity}' dependency`);
+        const dependencyIdentity = requireString(value.identity, `Facade '${identity}' dependency identity`);
+        const range = requireString(value.range, `Facade '${identity}' dependency range`);
+        if (!facadeIdentityPattern.test(dependencyIdentity) || dependencyIdentity == identity || identities.has(dependencyIdentity) ||
+            !parseStdlibVersionRange(range))
+            invalidFacade(`Facade '${identity}' has an invalid dependency.`);
+        identities.add(dependencyIdentity);
+        return { identity: dependencyIdentity, range };
+    });
+}
+/**
+ * Builds the bounded original-five qualification facade definitions.
+ * @returns {unknown[]} Unvalidated built-in qualification facade definitions.
+ */
+function builtinFacadeRecords() {
+    return ["php", "ruby", "javascript", "typescript", "java"].flatMap((language) => builtinLanguageFacades(language))
+        .concat(builtinTask037RubyFacades());
+}
+/**
+ * Builds one source language's public, internal, and unreachable qualification facades.
+ * @param {string} language - Source language.
+ * @returns {unknown[]} Language facade definitions.
+ */
+function builtinLanguageFacades(language) {
+    const names = facadeNames(language);
+    const base = `semantifold.task036.${language}`;
+    const sourceBase = `semantifold.facade.${language}`;
+    const sourceDirectory = `__semantifold_facades__/${language}`;
+    const probeFilename = language == "java" ? `${sourceDirectory}/semantifold/facade/java/probe/Probe.java` :
+        `${sourceDirectory}/probe.${names.extension}`;
+    const runnerFilename = language == "java" ? `${sourceDirectory}/semantifold/facade/java/proberunner/ProbeRunner.java` :
+        `${sourceDirectory}/probe-runner.${names.extension}`;
+    const unusedFilename = language == "java" ? `${sourceDirectory}/semantifold/facade/java/unused/Unused.java` :
+        `${sourceDirectory}/unused.${names.extension}`;
+    return [{
+            dependencies: [{ identity: `${base}.probe-runner`, range: "1" }],
+            identity: `${base}.probe`,
+            language,
+            nativeModules: [{ identity: names.nativeModule, kind: "module", symbols: [names.publicName] }],
+            publicDeclarations: [publicDeclaration(names.publicName)],
+            requirements: [],
+            runtimeProfile: `${language}-task036-v1`,
+            source: { content: names.probeSource, filename: probeFilename, id: `${sourceBase}.probe` },
+            version: "1.0.0",
+            visibility: "public"
+        }, {
+            dependencies: [],
+            identity: `${base}.probe-runner`,
+            language,
+            nativeModules: [],
+            publicDeclarations: [],
+            requirements: [{ module: "semantifold.task034.resource-probe", operations: ["probeEffect", "probeTrace"], range: "1" }],
+            runtimeProfile: `${language}-task036-v1`,
+            source: { content: names.runnerSource, filename: runnerFilename, id: `${sourceBase}.probe_runner` },
+            version: "1.0.0",
+            visibility: "internal"
+        }, {
+            dependencies: [],
+            identity: `${base}.unused`,
+            language,
+            nativeModules: [{ identity: names.unusedNativeModule, kind: "module", symbols: [names.unusedName] }],
+            publicDeclarations: [publicDeclaration(names.unusedName)],
+            requirements: [{ module: "semantifold.task034.resource-probe", operations: ["probeTrace"], range: "1" }],
+            runtimeProfile: `${language}-task036-v1`,
+            source: { content: names.unusedSource, filename: unusedFilename, id: `${sourceBase}.unused` },
+            version: "1.0.0",
+            visibility: "public"
+        }];
+}
+/**
+ * Builds the common bounded qualification function declaration.
+ * @param {string} name - Source-visible function name.
+ * @returns {StdlibFacadePublicDeclaration} Public facade declaration.
+ */
+function publicDeclaration(name) {
+    return {
+        effects: ["host"], failures: [], forms: ["direct-call"], kind: "function", name,
+        ownership: "not-applicable", parameters: [{ name: "label", type: "string" }], returnType: "string"
+    };
+}
+/**
+ * Builds the exact Ruby Task 037 socket and output compatibility facades.
+ * @returns {unknown[]} Unvalidated facade records.
+ */
+function builtinTask037RubyFacades() {
+    return [{
+            dependencies: [],
+            identity: "semantifold.task037.ruby.socket",
+            language: "ruby",
+            nativeModules: [{ identity: "socket", kind: "module", symbols: ["TCPSocket"] }],
+            publicDeclarations: [{
+                    constructor: {
+                        effects: ["host"], failures: ["InvalidHost", "InvalidPort", "ConnectionFailure"], ownership: "acquired",
+                        parameters: [{ name: "host", type: "string" }, { name: "port", type: "integer" }]
+                    },
+                    forms: ["constructor-call"],
+                    kind: "class",
+                    methods: [{
+                            effects: ["host"], failures: ["ReadFailure", "DecodeFailure", "ResourceClosed"], forms: ["receiver-call"],
+                            name: "gets", ownership: "borrowed", parameters: [], returnType: "optional:string"
+                        }, {
+                            effects: ["host"], failures: ["CloseFailure", "ResourceClosed"], forms: ["receiver-call"],
+                            name: "close", ownership: "consumed", parameters: [], returnType: "void"
+                        }],
+                    name: "TCPSocket",
+                    ownership: "owned-reference"
+                }],
+            requirements: [
+                { module: "semantifold.socket-client", operations: ["v1_connect"], range: "1" },
+                { module: "semantifold.text-stream", operations: ["v1_read_line"], range: "1" },
+                { module: "semantifold.resource", operations: ["v1_close"], range: "1" }
+            ],
+            runtimeProfile: "ruby-task037-socket-v1",
+            source: {
+                content: `module SemantifoldTask037Socket
+  class TCPSocket
+    # @param host [String]
+    # @param port [Integer]
+    def initialize(host, port)
+      @resource = v1_connect(host, port)
+    end
+
+    # @return [String?]
+    def gets
+      return v1_read_line(@resource)
+    end
+
+    # @return [void]
+    def close
+      v1_close(@resource)
+    end
+  end
+end
+`,
+                filename: "__semantifold_facades__/ruby/socket.rb",
+                id: "semantifold.facade.ruby.socket"
+            },
+            version: "1.0.0",
+            visibility: "public"
+        }, {
+            dependencies: [],
+            identity: "semantifold.task037.ruby.output",
+            language: "ruby",
+            nativeModules: [{ forms: ["unqualified-call", "receiver-call"], identity: "ruby:Kernel", kind: "builtin", symbols: ["puts"] }],
+            publicDeclarations: [{
+                    effects: ["host"], failures: ["WriteFailure"], forms: ["unqualified-call", "receiver-call"], kind: "function",
+                    name: "puts", ownership: "not-applicable", parameters: [{ name: "text", type: "string" }], returnType: "void"
+                }],
+            requirements: [{ module: "semantifold.output", operations: ["v1_write_line"], range: "1" }],
+            runtimeProfile: "ruby-task037-output-v1",
+            source: {
+                content: `module SemantifoldTask037Output
+  module_function
+  # @param text [String]
+  # @return [void]
+  def puts(text)
+    v1_write_line(text)
+    return
+  end
+end
+`,
+                filename: "__semantifold_facades__/ruby/output.rb",
+                id: "semantifold.facade.ruby.output"
+            },
+            version: "1.0.0",
+            visibility: "public"
+        }];
+}
+/**
+ * Validates one public facade class descriptor.
+ * @param {Record<string, unknown>} value - Candidate class.
+ * @param {string} identity - Owning facade.
+ * @param {string} name - Validated class name.
+ * @returns {StdlibFacadeClassDeclaration} Detached class descriptor.
+ */
+function validatePublicClass(value, identity, name) {
+    requireKeys(value, ["constructor", "forms", "kind", "methods", "name", "ownership"], `facade '${identity}' public class`);
+    if (!isDenseArray(value.forms) || value.forms.length != 1 || value.forms[0] != "constructor-call" ||
+        value.ownership != "owned-reference" || !isPlainObject(value.constructor) || !isDenseArray(value.methods)) {
+        invalidFacade(`Facade '${identity}' class '${name}' has an invalid public contract.`);
+    }
+    const constructor = /** @type {Record<string, unknown>} */ (value.constructor);
+    requireKeys(constructor, ["effects", "failures", "ownership", "parameters"], `facade '${identity}' constructor`);
+    if (constructor.ownership != "acquired" || !validFacadeEffects(constructor.effects) ||
+        !validFacadeFailures(constructor.failures))
+        invalidFacade(`Facade '${identity}' class '${name}' has an invalid constructor.`);
+    const parameters = validateFacadeParameters(constructor.parameters, identity, `${name}.new`);
+    const methodNames = new Set();
+    const methods = value.methods.map((method) => {
+        if (!isPlainObject(method))
+            invalidFacade(`Facade '${identity}' class '${name}' has an invalid method.`);
+        requireKeys(method, ["effects", "failures", "forms", "name", "ownership", "parameters", "returnType"], `facade '${identity}' class method`);
+        const methodName = requireString(method.name, `Facade '${identity}' method name`);
+        const returnType = requireString(method.returnType, `Facade '${identity}' method return type`);
+        if (!declarationNamePattern.test(methodName) || methodNames.has(methodName) || !validFacadeEffects(method.effects) ||
+            !validFacadeFailures(method.failures) || !isDenseArray(method.forms) || method.forms.length != 1 ||
+            method.forms[0] != "receiver-call" || method.ownership != "borrowed" && method.ownership != "consumed" ||
+            !isFacadeType(returnType, true))
+            invalidFacade(`Facade '${identity}' class '${name}' has an invalid method.`);
+        methodNames.add(methodName);
+        return {
+            effects: /** @type {string[]} */ ([... /** @type {unknown[]} */(method.effects)]),
+            failures: /** @type {string[]} */ ([... /** @type {unknown[]} */(method.failures)]),
+            forms: /** @type {["receiver-call"]} */ (["receiver-call"]),
+            name: methodName,
+            ownership: /** @type {"borrowed" | "consumed"} */ (method.ownership),
+            parameters: validateFacadeParameters(method.parameters, identity, `${name}.${methodName}`),
+            returnType
+        };
+    });
+    return {
+        constructor: {
+            effects: /** @type {string[]} */ ([... /** @type {unknown[]} */(constructor.effects)]),
+            failures: /** @type {string[]} */ ([... /** @type {unknown[]} */(constructor.failures)]),
+            ownership: "acquired",
+            parameters
+        },
+        forms: ["constructor-call"],
+        kind: "class",
+        methods,
+        name,
+        ownership: "owned-reference"
+    };
+}
+/**
+ * Validates facade parameters shared by functions, constructors, and methods.
+ * @param {unknown} candidate - Candidate parameters.
+ * @param {string} identity - Owning facade.
+ * @param {string} callable - Callable name.
+ * @returns {{name: string, type: string}[]} Detached parameters.
+ */
+function validateFacadeParameters(candidate, identity, callable) {
+    if (!isDenseArray(candidate))
+        invalidFacade(`Facade '${identity}' declaration '${callable}' has invalid parameters.`);
+    const names = new Set();
+    return candidate.map((parameter) => {
+        if (!isPlainObject(parameter))
+            invalidFacade(`Facade '${identity}' declaration '${callable}' has an invalid parameter.`);
+        requireKeys(parameter, ["name", "type"], `facade '${identity}' declaration parameter`);
+        const name = requireString(parameter.name, `Facade '${identity}' parameter name`);
+        const type = requireString(parameter.type, `Facade '${identity}' parameter type`);
+        if (!declarationNamePattern.test(name) || names.has(name) || !isFacadeType(type, false)) {
+            invalidFacade(`Facade '${identity}' declaration '${callable}' has an invalid parameter.`);
+        }
+        names.add(name);
+        return { name, type };
+    });
+}
+/**
+ * Checks one facade effect list.
+ * @param {unknown} candidate - Candidate effects.
+ * @returns {boolean} Whether effects are exact.
+ */
+function validFacadeEffects(candidate) {
+    return isDenseArray(candidate) && candidate.every((effect) => effect == "host") && new Set(candidate).size == candidate.length;
+}
+/**
+ * Checks one facade failure list.
+ * @param {unknown} candidate - Candidate failures.
+ * @returns {candidate is string[]} Whether failures are exact.
+ */
+function validFacadeFailures(candidate) {
+    return isDenseArray(candidate) && candidate.every((failure) => typeof failure == "string" && declarationNamePattern.test(failure)) &&
+        new Set(candidate).size == candidate.length;
+}
+/**
+ * Checks one facade type spelling.
+ * @param {string} type - Candidate type.
+ * @param {boolean} allowVoid - Whether void is valid in this position.
+ * @returns {boolean} Whether the type is canonical.
+ */
+function isFacadeType(type, allowVoid) {
+    if (canonicalTypes.has(type))
+        return allowVoid || type != "void";
+    const optional = /^optional:(boolean|integer|string)$/u.exec(type);
+    return optional !== null;
+}
+/**
+ * Detaches one descriptor for the public program record.
+ * @param {StdlibFacadePublicDeclaration} declaration - Registry declaration.
+ * @returns {StdlibFacadePublicDeclaration} Detached declaration.
+ */
+function detachPublicDeclaration(declaration) {
+    if (declaration.kind == "function")
+        return { ...declaration, effects: [...declaration.effects], failures: [...declaration.failures],
+            forms: [...declaration.forms], parameters: declaration.parameters.map((parameter) => ({ ...parameter })) };
+    return { ...declaration,
+        constructor: { ...declaration.constructor, effects: [...declaration.constructor.effects], failures: [...declaration.constructor.failures],
+            parameters: declaration.constructor.parameters.map((parameter) => ({ ...parameter })) },
+        forms: [...declaration.forms],
+        methods: declaration.methods.map((method) => ({ ...method, effects: [...method.effects], failures: [...method.failures],
+            forms: [...method.forms], parameters: method.parameters.map((parameter) => ({ ...parameter })) })) };
+}
+/**
+ * Detaches a local or dependency-qualified contract reference.
+ * @param {string | import("./semantic/stdlib.js").CanonicalDeclarationReference} reference - Contract reference.
+ * @returns {string | import("./semantic/types.js").CapabilityDeclarationReferenceInput} Detached reference.
+ */
+function detachCanonicalReference(reference) {
+    return typeof reference == "string" ? reference : { module: reference.module, name: reference.name };
+}
+/**
+ * Detaches a canonical resource flow for authority construction.
+ * @param {object} flow - Canonical resource flow.
+ * @returns {import("./semantic/types.js").CapabilityResourceFlowInput} Detached flow.
+ */
+function detachResourceFlow(flow) {
+    const candidate = /** @type {Record<string, unknown>} */ (flow);
+    if (candidate.kind == "none")
+        return { kind: "none" };
+    if (candidate.kind == "acquire")
+        return { kind: "acquire", resource: detachCanonicalReference(
+            /** @type {string | import("./semantic/stdlib.js").CanonicalDeclarationReference} */ (candidate.resource)) };
+    return {
+        kind: /** @type {"borrow" | "close"} */ (candidate.kind),
+        parameterIndex: /** @type {number} */ (candidate.parameterIndex),
+        terminalFailure: detachCanonicalReference(
+        /** @type {string | import("./semantic/stdlib.js").CanonicalDeclarationReference} */ (candidate.terminalFailure))
+    };
+}
+/**
+ * Maps one canonical module identity to its closed capability name.
+ * @param {string} identity - Canonical identity.
+ * @returns {string} Capability name.
+ */
+function canonicalCapabilityName(identity) {
+    /** @type {Readonly<Record<string, string>>} */
+    const names = {
+        "semantifold.output": "Output",
+        "semantifold.resource": "Resource",
+        "semantifold.socket-client": "SocketClient",
+        "semantifold.task034.resource-probe": "ResourceProbe",
+        "semantifold.text-stream": "TextStream"
+    };
+    return names[identity] ?? invalidFacade(`Facade requirements name unknown canonical module '${identity}'.`);
+}
+/**
+ * Builds executable source and native identity spellings for one original-five language.
+ * @param {string} language - Source language.
+ * @returns {FacadeSourceNames} Facade source definitions.
+ */
+function facadeNames(language) {
+    if (language == "php")
+        return {
+            extension: "php", nativeModule: "Semantifold\\Task036\\Probe", publicName: "compatibility_probe",
+            unusedName: "unused_probe", unusedNativeModule: "Semantifold\\Task036\\Unused",
+            probeSource: `<?php
+declare(strict_types=1);
+namespace Semantifold\\Facade\\Php\\Probe;
+use function Semantifold\\Facade\\Php\\ProbeRunner\\run_compatibility_probe;
+require_once __DIR__ . "/probe-runner.php";
+function compatibility_probe(string $label): string { return run_compatibility_probe($label); }
+`,
+            runnerSource: `<?php
+declare(strict_types=1);
+namespace Semantifold\\Facade\\Php\\ProbeRunner;
+function run_compatibility_probe(string $label): string {
+    try {
+        /**
+         * @var int $effect
+         * @semantifold-immutable
+         */
+        $effect = probeEffect($label, 1, false);
+        return probeTrace();
+    }
+    catch (ProbeOperationFailure $error) { return $error->getMessage(); }
+}
+`,
+            unusedSource: `<?php
+declare(strict_types=1);
+namespace Semantifold\\Facade\\Php\\Unused;
+function unused_probe(string $label): string { return probeTrace(); }
+`
+        };
+    if (language == "ruby")
+        return {
+            extension: "rb", nativeModule: "semantifold/task036/probe", publicName: "compatibility_probe",
+            unusedName: "unused_probe", unusedNativeModule: "semantifold/task036/unused",
+            probeSource: `require_relative "probe-runner"
+module SemantifoldTask036Probe
+  module_function
+  # @param label [String]
+  # @return [String]
+  def compatibility_probe(label)
+    return SemantifoldTask036ProbeRunner.run_compatibility_probe(label)
+  end
+end
+`,
+            runnerSource: `module SemantifoldTask036ProbeRunner
+  module_function
+  # @param label [String]
+  # @return [String]
+  def run_compatibility_probe(label)
+    begin
+      # @type [Integer]
+      # @semantifold-immutable
+      effect = probeEffect(label, 1, false)
+      return probeTrace
+    rescue ProbeOperationFailure => error
+      return error.message
+    end
+  end
+end
+`,
+            unusedSource: `module SemantifoldTask036Unused
+  module_function
+  # @param label [String]
+  # @return [String]
+  def unused_probe(label)
+    return probeTrace
+  end
+end
+`
+        };
+    if (language == "java")
+        return {
+            extension: "java", nativeModule: "semantifold.task036.Probe", publicName: "compatibilityProbe",
+            unusedName: "unusedProbe", unusedNativeModule: "semantifold.task036.Unused",
+            probeSource: `package semantifold.facade.java.probe;
+import semantifold.facade.java.proberunner.ProbeRunner;
+public final class Probe {
+  public static String compatibilityProbe(String label) { return ProbeRunner.runCompatibilityProbe(label); }
+}
+`,
+            runnerSource: `package semantifold.facade.java.proberunner;
+public final class ProbeRunner {
+  public static String runCompatibilityProbe(String label) {
+    try { final int effect = probeEffect(label, 1, false); return probeTrace(); }
+    catch (ProbeOperationFailure error) { return error.getMessage(); }
+  }
+}
+`,
+            unusedSource: `package semantifold.facade.java.unused;
+public final class Unused {
+  public static String unusedProbe(String label) { return probeTrace(); }
+}
+`
+        };
+    const typed = language == "typescript";
+    const extension = typed ? "ts" : "js";
+    const parameter = typed ? "label: string" : "label";
+    const result = typed ? ": string" : "";
+    const documentation = typed ? "" : `/**
+ * @param {string} label
+ * @returns {string}
+ */
+`;
+    return {
+        extension, nativeModule: "semantifold:task036/probe", publicName: "compatibilityProbe",
+        unusedName: "unusedProbe", unusedNativeModule: "semantifold:task036/unused",
+        probeSource: `import {runCompatibilityProbe} from "./probe-runner.js"
+${documentation}export function compatibilityProbe(${parameter})${result} { return runCompatibilityProbe(label) }
+`,
+        runnerSource: `${documentation}export function runCompatibilityProbe(${parameter})${result} {
+  try { ${typed ? "const effect: number" : "/** @type {number} */ const effect"} = probeEffect(label, 1, false); return probeTrace() }
+  catch (error) { if (!(error instanceof ProbeOperationFailure)) { throw error } return error.message }
+}
+`,
+        unusedSource: `${documentation}export function unusedProbe(${parameter})${result} { return probeTrace() }
+`
+    };
+}
+/**
+ * Requires a closed exact key set.
+ * @param {Record<string, unknown>} value - Plain candidate object.
+ * @param {string[]} keys - Expected keys.
+ * @param {string} subject - Diagnostic subject.
+ * @returns {void}
+ */
+function requireKeys(value, keys, subject) {
+    if (Object.keys(value).sort().join(",") != [...keys].sort().join(","))
+        invalidFacade(`Invalid ${subject} fields.`);
+}
+/**
+ * Requires one non-empty string.
+ * @param {unknown} value - Candidate value.
+ * @param {string} subject - Diagnostic subject.
+ * @returns {string} Validated string.
+ */
+function requireString(value, subject) {
+    if (typeof value != "string" || value.length == 0)
+        invalidFacade(`${subject} must be a non-empty string.`);
+    return /** @type {string} */ (value);
+}
+/**
+ * Checks for an ordinary object with no custom prototype.
+ * @param {unknown} value - Candidate value.
+ * @returns {value is Record<string, unknown>} Whether the candidate is plain.
+ */
+function isPlainObject(value) {
+    return value !== null && typeof value == "object" && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype;
+}
+/**
+ * Recursively freezes one detached facade registry value.
+ * @template {object} T
+ * @param {T} value - Detached object.
+ * @returns {Readonly<T>} Frozen value.
+ */
+function deepFreeze(value) {
+    for (const child of Object.values(value))
+        if (child && typeof child == "object" && !Object.isFrozen(child))
+            deepFreeze(child);
+    return Object.freeze(value);
+}
+/**
+ * Throws a stable invalid-registry diagnostic.
+ * @param {string} message - Failure detail.
+ * @returns {never} Always throws.
+ */
+function invalidFacade(message) {
+    throw new SemantifoldDiagnostic({ code: "STDLIB_FACADE_INVALID", language: "stdlib", message });
+}
+/**
+ * Throws when parser evidence does not name a registered native module.
+ * @param {string} language - Source language.
+ * @param {unknown} nativeModule - Unproved module identity.
+ * @returns {never} Always throws.
+ */
+function unprovedIdentity(language, nativeModule) {
+    throw new SemantifoldDiagnostic({
+        code: "STDLIB_FACADE_IDENTITY_UNPROVED",
+        language: supportedLanguages.has(language) ? language : "stdlib",
+        message: `Native standard-library module '${String(nativeModule)}' is not a registered '${language}' facade identity.`
+    });
+}
+/**
+ * Throws when a native module member is outside its public facade surface.
+ * @param {string} language - Source language.
+ * @param {string} nativeModule - Exact native module.
+ * @param {string} symbol - Unsupported member.
+ * @returns {never} Always throws.
+ */
+function unsupportedMember(language, nativeModule, symbol) {
+    throw new SemantifoldDiagnostic({
+        code: "STDLIB_FACADE_MEMBER_UNSUPPORTED",
+        language,
+        message: `Native standard-library symbol '${nativeModule}#${symbol}' is outside the registered facade surface.`
+    });
+}
+/**
+ * Throws for a malformed facade version range.
+ * @param {string} language - Source language.
+ * @param {string} range - Malformed range.
+ * @returns {never} Always throws.
+ */
+function facadeVersionMalformed(language, range) {
+    throw new SemantifoldDiagnostic({
+        code: "STDLIB_FACADE_VERSION_MALFORMED", language,
+        message: `Facade version range '${range}' is not canonical.`
+    });
+}
+/**
+ * Throws when no registered facade version satisfies a range.
+ * @param {string} language - Source language.
+ * @param {string} identity - Facade identity.
+ * @returns {never} Always throws.
+ */
+function facadeVersionIncompatible(language, identity) {
+    throw new SemantifoldDiagnostic({
+        code: "STDLIB_FACADE_VERSION_INCOMPATIBLE", language,
+        message: `No registered version of facade '${identity}' satisfies the required compatibility range.`
+    });
+}
+export const stdlibFacadeRegistry = createStdlibFacadeRegistry();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stdlib-facades.js","sourceRoot":"","sources":["../../src/stdlib-facades.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,EAAC,YAAY,EAAC,MAAM,YAAY,CAAA;AACvC,OAAO,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAA;AACrD,OAAO,EAAC,qBAAqB,EAAC,MAAM,iBAAiB,CAAA;AACrD,OAAO,EACL,qBAAqB,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,sBAAsB,EAChH,MAAM,sBAAsB,CAAA;AAE7B,MAAM,qBAAqB,GAAG,qBAAqB,CAAA;AACnD,MAAM,eAAe,GAAG,4CAA4C,CAAA;AACpE,MAAM,sBAAsB,GAAG,2BAA2B,CAAA;AAC1D,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,CAAC,CAAC,CAAA;AACvF,MAAM,cAAc,GAAG,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAA;AAExE;;;;;;;;;;GAUG;AACH;;;;;;;;GAQG;AACH,8GAA8G;AAC9G;;;;;;;;;;;;GAYG;AACH;;;;;;;;;;GAUG;AACH;;;;;;GAMG;AAEH;;;;GAIG;AACH,MAAM,UAAU,0BAA0B,CAAC,OAAO,GAAG,oBAAoB,EAAE;IACzE,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;QAAE,aAAa,CAAC,gDAAgD,CAAC,CAAA;IAC3F,mCAAmC;IACnC,MAAM,OAAO,GAAG,EAAE,CAAA;IAClB,2DAA2D;IAC3D,MAAM,UAAU,GAAG,IAAI,GAAG,EAAE,CAAA;IAC5B,gDAAgD;IAChD,MAAM,cAAc,GAAG,IAAI,GAAG,EAAE,CAAA;IAChC,MAAM,SAAS,GAAG,IAAI,GAAG,EAAE,CAAA;IAC3B,MAAM,eAAe,GAAG,IAAI,GAAG,EAAE,CAAA;IAEjC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QACvD,MAAM,MAAM,GAAG,oBAAoB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAA;QACnD,MAAM,WAAW,GAAG,GAAG,MAAM,CAAC,QAAQ,KAAK,MAAM,CAAC,QAAQ,EAAE,CAAA;QAC5D,MAAM,QAAQ,GAAG,UAAU,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,IAAI,GAAG,EAAE,CAAA;QAEzD,IAAI,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC;YAAE,aAAa,CAAC,qBAAqB,MAAM,CAAC,QAAQ,cAAc,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAA;QAC9I,IAAI,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,WAAW,EAAE,CAAC;YACtF,aAAa,CAAC,4CAA4C,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAA;QACjF,CAAC;QACD,IAAI,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,WAAW,EAAE,CAAC;YAC9G,aAAa,CAAC,qCAAqC,MAAM,CAAC,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAA;QAChF,CAAC;QACD,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;QACpC,UAAU,CAAC,GAAG,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAA;QACrC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,WAAW,CAAC,CAAA;QAC5C,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAA;QACxD,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;QAEpB,KAAK,MAAM,YAAY,IAAI,MAAM,CAAC,aAAa,EAAE,CAAC;YAChD,MAAM,SAAS,GAAG,GAAG,MAAM,CAAC,QAAQ,KAAK,YAAY,CAAC,QAAQ,EAAE,CAAA;YAChE,MAAM,aAAa,GAAG,cAAc,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,CAAA;YAEzD,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;YAC1B,cAAc,CAAC,GAAG,CAAC,SAAS,EAAE,aAAa,CAAC,CAAA;QAC9C,CAAC;IACH,CAAC;IAED,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,KAAK,MAAM,UAAU,IAAI,MAAM,CAAC,YAAY,EAAE,CAAC;YAC7C,wBAAwB,CAAC,UAAU,EAAE,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAA;QAC/G,CAAC;IACH,CAAC;IACD,8BAA8B,CAAC,OAAO,EAAE,UAAU,CAAC,CAAA;IAEnD,OAAO,MAAM,CAAC,MAAM,CAAC,mCAAmC,CAAC,CAAC;QACxD,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC;QAC/B,aAAa,CAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK;YACjD,OAAO,4BAA4B,CAAC,cAAc,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,CAAC,CAAA;QAC5F,CAAC;QACD,eAAe,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK;YACvC,OAAO,wBAAwB,CAAC,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAA;QACxE,CAAC;QACD,aAAa,CAAC,QAAQ,EAAE,YAAY,EAAE,KAAK;YACzC,MAAM,OAAO,GAAG,cAAc,CAAC,GAAG,CAAC,GAAG,QAAQ,KAAK,YAAY,EAAE,CAAC,CAAA;YAElE,IAAI,CAAC,OAAO;gBAAE,gBAAgB,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAA;YACtD,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,mCAAmC,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,EAAC,QAAQ,EAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAA;YAEvG,IAAI,UAAU,CAAC,IAAI,IAAI,CAAC;gBAAE,aAAa,CAAC,yBAAyB,YAAY,uBAAuB,QAAQ,IAAI,CAAC,CAAA;YACjH,OAAO,mBAAmB,CAAC,IAAI,GAAG,CAAC,mCAAmC,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC;YACzH,iCAAiC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAA;QAC7E,CAAC;KACF,CAAC,CAAC,CAAA;AACL,CAAC;AAED;;;;;GAKG;AACH,SAAS,8BAA8B,CAAC,OAAO,EAAE,KAAK;IACpD,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,CAAA;IACxB,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAE,CAAA;IAE1B;;;;OAIG;IACH,SAAS,KAAK,CAAC,MAAM;QACnB,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,QAAQ,KAAK,MAAM,CAAC,QAAQ,KAAK,MAAM,CAAC,OAAO,EAAE,CAAA;QAEvE,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,OAAM;QAC7B,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,aAAa,CAAC,qCAAqC,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAA;QAC5F,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QACf,KAAK,MAAM,UAAU,IAAI,MAAM,CAAC,YAAY,EAAE,CAAC;YAC7C,KAAK,CAAC,wBAAwB,CAAC,KAAK,EAAE,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAA;QACjH,CAAC;QACD,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;QAClB,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;IACnB,CAAC;IAED,KAAK,MAAM,MAAM,IAAI,OAAO;QAAE,KAAK,CAAC,MAAM,CAAC,CAAA;AAC7C,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB;IAC/B,OAAO,oBAAoB,CAAC,OAAO,CAAA;AACrC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK;IACvE,OAAO,oBAAoB,CAAC,aAAa,CAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,CAAC,CAAA;AAClF,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,0BAA0B,CAAC,KAAK,EAAE,QAAQ,GAAG,oBAAoB;IAC/E,MAAM,MAAM,GAAG,IAAI,GAAG,EAAE,CAAA;IACxB,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAE,CAAA;IAC1B,mCAAmC;IACnC,MAAM,MAAM,GAAG,EAAE,CAAA;IAEjB;;;;OAIG;IACH,SAAS,KAAK,CAAC,MAAM;QACnB,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,QAAQ,KAAK,MAAM,CAAC,QAAQ,KAAK,MAAM,CAAC,OAAO,EAAE,CAAA;QAEvE,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,OAAM;QAC7B,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,aAAa,CAAC,qCAAqC,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAA;QAC5F,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QACf,KAAK,MAAM,UAAU,IAAI,MAAM,CAAC,YAAY,EAAE,CAAC;YAC7C,KAAK,CAAC,QAAQ,CAAC,eAAe,CAAC,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC,CAAA;QACzF,CAAC;QACD,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;QAClB,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QACjB,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;IACrB,CAAC;IAED,KAAK,MAAM,IAAI,IAAI,KAAK;QAAE,KAAK,CAAC,IAAI,CAAC,CAAA;IACrC,OAAO,MAAM,CAAA;AACf,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,6BAA6B,CAAC,QAAQ,EAAE,OAAO;IAC7D,OAAO;QACL,QAAQ;QACR,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;YAChC,YAAY,EAAE,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,EAAC,GAAG,UAAU,EAAC,CAAC,CAAC;YACxE,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,EAAC,GAAG,MAAM;gBAC7D,GAAG,CAAC,MAAM,CAAC,IAAI,IAAI,SAAS,CAAC,CAAC,CAAC,EAAC,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC,CAAC;YAClG,kBAAkB,EAAE,MAAM,CAAC,kBAAkB,CAAC,GAAG,CAAC,uBAAuB,CAAC;YAC1E,YAAY,EAAE,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,EAAC,GAAG,WAAW,EAAE,UAAU,EAAE,CAAC,GAAG,WAAW,CAAC,UAAU,CAAC,EAAC,CAAC,CAAC;YACnH,cAAc,EAAE,MAAM,CAAC,cAAc;YACrC,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE;YAC9B,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,UAAU,EAAE,MAAM,CAAC,UAAU;SAC9B,CAAC,CAAC;QACH,MAAM,EAAE,0BAA0B;QAClC,OAAO,EAAE,CAAC;KACX,CAAA;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,yBAAyB,CAAC,OAAO;IAC/C,MAAM,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,CAAA;IAErE,IAAI,YAAY,CAAC,MAAM,IAAI,CAAC;QAAE,OAAO,IAAI,CAAA;IACzC,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,EAAC,MAAM,EAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAA;IAClE,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,EAAC,KAAK,EAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAA;IAE5D,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,EAAC,QAAQ,EAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC,sBAAsB,CAAC,CAAC,CAAA;IAEzF,IAAI,OAAO,EAAE,CAAC;QACZ,MAAM,mBAAmB,GAAG,IAAI,GAAG,EAAE,CAAA;QAErC,KAAK,MAAM,WAAW,IAAI,YAAY,EAAE,CAAC;YACvC,MAAM,OAAO,GAAG,mBAAmB,CAAC,GAAG,CAAC,WAAW,CAAC,MAAM,CAAC,CAAA;YAE3D,IAAI,OAAO,IAAI,OAAO,CAAC,KAAK,IAAI,WAAW,CAAC,KAAK;gBAAE,aAAa,CAAC,6DAA6D,CAAC,CAAA;YAC/H,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,OAAO,EAAE,UAAU,IAAI,EAAE,CAAC,CAAA;YAErD,KAAK,MAAM,SAAS,IAAI,WAAW,CAAC,UAAU;gBAAE,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;YACzE,mBAAmB,CAAC,GAAG,CAAC,WAAW,CAAC,MAAM,EAAE,EAAC,UAAU,EAAE,KAAK,EAAE,WAAW,CAAC,KAAK,EAAC,CAAC,CAAA;QACrF,CAAC;QACD,MAAM,OAAO,GAAG,CAAC,GAAG,mBAAmB,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,WAAW,CAAC,EAAE,EAAE;YACjF,MAAM,QAAQ,GAAG,mBAAmB,CAAC,QAAQ,EAAE,WAAW,CAAC,KAAK,CAAC,CAAA;YAEjE,OAAO;gBACL,YAAY,EAAE,CAAC;wBACb,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,CAAC,EAAC,IAAI,EAAC,CAAC,CAAC;wBACrD,IAAI,EAAE,uBAAuB,CAAC,QAAQ,CAAC;wBACvC,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,WAAW,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;4BACvG,OAAO,EAAE,uBAAuB,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC;4BACzD,QAAQ,EAAE,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,wBAAwB,CAAC;4BAC1D,IAAI,EAAE,SAAS,CAAC,IAAI;4BACpB,UAAU,EAAE,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;gCACnD,IAAI,EAAE,SAAS,CAAC,IAAI;gCACpB,IAAI,EAAE,gCAAgC,CAAC,SAAS,CAAC,IAAI,CAAC;6BACvD,CAAC,CAAC;4BACH,YAAY,EAAE,kBAAkB,CAAC,SAAS,CAAC,YAAY,CAAC;4BACxD,UAAU,EAAE,uBAAuB,CAAC,SAAS,CAAC,UAAU,CAAC;yBAC1D,CAAC,CAAC;wBACH,SAAS,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,CAAC,EAAC,IAAI,EAAC,CAAC,CAAC;qBACxD,CAAC;gBACF,eAAe,EAAE,WAAW,CAAC,KAAK;gBAClC,QAAQ;aACT,CAAA;QACH,CAAC,CAAC,CAAA;QAEF,OAAO;YACL,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,EAAC,eAAe,EAAE,QAAQ,EAAC,EAAE,EAAE,CAAC,CAAC,EAAC,eAAe,EAAE,QAAQ,EAAC,CAAC,CAAC;YACtF,KAAK,EAAE,EAAC,EAAE,EAAE,kCAAkC,EAAE,OAAO,EAAE,MAAM,EAAE,gCAAgC,EAAE,aAAa,EAAE,CAAC,EAAC;SACrH,CAAA;IACH,CAAC;IACD,IAAI,UAAU,CAAC,IAAI,IAAI,CAAC,IAAI,MAAM,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC;QAC7C,aAAa,CAAC,gGAAgG,CAAC,CAAA;IACjH,CAAC;IACD,MAAM,QAAQ,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,MAAM,CAAA;IACvC,MAAM,eAAe,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,KAAK,CAAA;IAC7C,MAAM,QAAQ,GAAG,mBAAmB,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAA;IAE/D,OAAO;QACL,QAAQ,EAAE,EAAC,eAAe,EAAE,QAAQ,EAAC;QACrC,KAAK,EAAE;YACL,YAAY,EAAE,CAAC;oBACb,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,CAAC,EAAC,IAAI,EAAC,CAAC,CAAC;oBACrD,IAAI,EAAE,eAAe;oBACrB,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;wBAClD,OAAO,EAAE,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC;wBAC/B,QAAQ,EAAE,CAAC,GAAG,SAAS,CAAC,QAAQ,CAAC;wBACjC,IAAI,EAAE,SAAS,CAAC,IAAI;wBACpB,UAAU,EAAE,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;4BACnD,IAAI,EAAE,SAAS,CAAC,IAAI;4BACpB,IAAI,EAAE,gCAAgC,CAAC,SAAS,CAAC,IAAI,CAAC;yBACvD,CAAC,CAAC;wBACH,YAAY,EAAE,wEAAwE,CAAC,CAAC,EAAC,GAAG,SAAS,CAAC,YAAY,EAAC,CAAC;wBACpH,UAAU,EAAE,uBAAuB,CAAC,SAAS,CAAC,UAAU,CAAC;qBAC1D,CAAC,CAAC;oBACH,SAAS,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,CAAC,EAAC,IAAI,EAAC,CAAC,CAAC;iBACxD,CAAC;YACF,eAAe;YACf,EAAE,EAAE,QAAQ;YACZ,MAAM,EAAE,gCAAgC;YACxC,aAAa,EAAE,CAAC;SACjB;KACF,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,uBAAuB,CAAC,IAAI;IACnC,IAAI,OAAO,IAAI,IAAI,QAAQ;QAAE,OAAO,EAAC,IAAI,EAAE,mBAAmB,EAAE,QAAQ,EAAE,wBAAwB,CAAC,IAAI,CAAC,EAAC,CAAA;IACzG,IAAI,IAAI,IAAI,MAAM,IAAI,IAAI,IAAI,SAAS,IAAI,IAAI,IAAI,SAAS,IAAI,IAAI,IAAI,QAAQ;QAAE,OAAO,IAAI,CAAA;IAC7F,IAAI,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC;QAAE,OAAO,EAAC,IAAI,EAAE,cAAc;YAC5D,SAAS,EAAE,6DAA6D,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,EAAC,CAAA;IAC5G,OAAO,EAAC,IAAI,EAAE,mBAAmB,EAAE,QAAQ,EAAE,IAAI,EAAC,CAAA;AACpD,CAAC;AAED;;;;GAIG;AACH,SAAS,gCAAgC,CAAC,IAAI;IAC5C,MAAM,SAAS,GAAG,uBAAuB,CAAC,IAAI,CAAC,CAAA;IAE/C,IAAI,SAAS,IAAI,MAAM;QAAE,aAAa,CAAC,gEAAgE,CAAC,CAAA;IACxG,OAAO,iMAAiM,CAAC,CAAC,SAAS,CAAC,CAAA;AACtN,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,wBAAwB,CAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK;IACvE,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,QAAQ,KAAK,QAAQ,EAAE,CAAC,CAAA;IAEtD,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,WAAW,KAAK,gCAAgC,QAAQ,UAAU,QAAQ,IAAI,CAAC,CAAC;YACpG,4BAA4B,QAAQ,UAAU,QAAQ,IAAI,CAAC,CAAA;IAC/D,CAAC;IACD,OAAO,mBAAmB,CAAC,8CAA8C,CAAC,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAA;AAClH,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,4BAA4B,CAAC,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK;IAChF,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,OAAO,YAAY,IAAI,QAAQ,IAAI,YAAY,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;QACrG,gBAAgB,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAA;IAC1C,CAAC;IACD,MAAM,aAAa,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,QAAQ,KAAK,YAAY,EAAE,CAAC,CAAA;IAE/D,IAAI,CAAC,aAAa;QAAE,gBAAgB,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAA;IAC5D,MAAM,aAAa,GAAG,mCAAmC,CAAC,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAChI,MAAM,CAAC,QAAQ,IAAI,YAAY,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IAEtE,IAAI,aAAa,CAAC,MAAM,IAAI,CAAC;QAAE,iBAAiB,CAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,CAAA;IAChF,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,EAAC,QAAQ,EAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAA;IAEvE,IAAI,UAAU,CAAC,IAAI,IAAI,CAAC;QAAE,aAAa,CAAC,2BAA2B,YAAY,IAAI,MAAM,uBAAuB,QAAQ,IAAI,CAAC,CAAA;IAC7H,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,CAAA;IAEjF,OAAO,mBAAmB,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAA;AAClF,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK;IAC9D,MAAM,WAAW,GAAG,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAC,KAAK,EAAE,uCAAuC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC,CAAC;QACnH,uBAAuB,CAAC,KAAK,CAAC,CAAA;IAEhC,IAAI,CAAC,WAAW;QAAE,sBAAsB,CAAC,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;IACjE,mDAAmD;IACnD,IAAI,QAAQ,CAAA;IAEZ,KAAK,MAAM,OAAO,IAAI,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC;QACtC,MAAM,MAAM,GAAG,uCAAuC,CAAC,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAA;QAEpF,IAAI,sBAAsB,CAAC,MAAM,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC,QAAQ,IAAI,qBAAqB,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;YAAE,QAAQ,GAAG,MAAM,CAAA;IAClI,CAAC;IACD,IAAI,CAAC,QAAQ;QAAE,yBAAyB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;IAE5D,OAAO,iCAAiC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;AAC7E,CAAC;AAED;;;;GAIG;AACH,SAAS,oBAAoB,CAAC,SAAS;IACrC,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC;QAAE,aAAa,CAAC,6CAA6C,CAAC,CAAA;IAC3F,WAAW,CAAC,SAAS,EAAE,CAAC,cAAc,EAAE,UAAU,EAAE,UAAU,EAAE,eAAe,EAAE,oBAAoB,EAAE,cAAc;QACnH,gBAAgB,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,CAAC,EAAE,eAAe,CAAC,CAAA;IACxE,MAAM,QAAQ,GAAG,aAAa,CAAC,SAAS,CAAC,QAAQ,EAAE,iBAAiB,CAAC,CAAA;IACrE,MAAM,QAAQ,GAAG,aAAa,CAAC,SAAS,CAAC,QAAQ,EAAE,iBAAiB,CAAC,CAAA;IACrE,MAAM,OAAO,GAAG,aAAa,CAAC,SAAS,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAA;IAClE,MAAM,cAAc,GAAG,aAAa,CAAC,SAAS,CAAC,cAAc,EAAE,wBAAwB,CAAC,CAAA;IACxF,MAAM,UAAU,GAAG,SAAS,CAAC,UAAU,CAAA;IAEvC,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,QAAQ,CAAC;QAAE,aAAa,CAAC,oBAAoB,QAAQ,eAAe,CAAC,CAAA;IACrG,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,QAAQ,CAAC;QAAE,aAAa,CAAC,oBAAoB,QAAQ,kCAAkC,CAAC,CAAA;IACpH,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;QAAE,aAAa,CAAC,mBAAmB,OAAO,eAAe,CAAC,CAAA;IAC1F,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,cAAc,CAAC;QAAE,aAAa,CAAC,2BAA2B,cAAc,eAAe,CAAC,CAAA;IACxH,IAAI,UAAU,IAAI,QAAQ,IAAI,UAAU,IAAI,UAAU;QAAE,aAAa,CAAC,WAAW,QAAQ,2BAA2B,CAAC,CAAA;IACrH,MAAM,MAAM,GAAG,cAAc,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAA;IACnE,MAAM,kBAAkB,GAAG,0BAA0B,CAAC,SAAS,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAA;IAC7F,MAAM,aAAa,GAAG,qBAAqB,CAAC,SAAS,CAAC,aAAa,EAAE,QAAQ,EAAE,kBAAkB,CAAC,CAAA;IAClG,MAAM,YAAY,GAAG,oBAAoB,CAAC,SAAS,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAA;IAC3E,MAAM,YAAY,GAAG,oBAAoB,CAAC,SAAS,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAA;IAE3E,IAAI,UAAU,IAAI,QAAQ,IAAI,CAAC,kBAAkB,CAAC,MAAM,IAAI,CAAC,IAAI,aAAa,CAAC,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC;QAC5F,aAAa,CAAC,kBAAkB,QAAQ,gDAAgD,CAAC,CAAA;IAC3F,CAAC;IACD,IAAI,UAAU,IAAI,UAAU,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC;QAAE,aAAa,CAAC,oBAAoB,QAAQ,oCAAoC,CAAC,CAAA;IAEzI,OAAO,UAAU,CAAC;QAChB,YAAY;QACZ,QAAQ;QACR,QAAQ,EAAE,6DAA6D,CAAC,CAAC,QAAQ,CAAC;QAClF,aAAa;QACb,kBAAkB;QAClB,YAAY;QACZ,cAAc;QACd,MAAM;QACN,OAAO;QACP,UAAU,EAAE,oCAAoC,CAAC,CAAC,UAAU,CAAC;KAC9D,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAS,cAAc,CAAC,SAAS,EAAE,QAAQ,EAAE,QAAQ;IACnD,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC;QAAE,aAAa,CAAC,WAAW,QAAQ,6CAA6C,CAAC,CAAA;IAC9G,WAAW,CAAC,SAAS,EAAE,CAAC,SAAS,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,WAAW,QAAQ,UAAU,CAAC,CAAA;IACpF,MAAM,OAAO,GAAG,aAAa,CAAC,SAAS,CAAC,OAAO,EAAE,WAAW,QAAQ,kBAAkB,CAAC,CAAA;IACvF,MAAM,QAAQ,GAAG,aAAa,CAAC,SAAS,CAAC,QAAQ,EAAE,WAAW,QAAQ,mBAAmB,CAAC,CAAA;IAC1F,MAAM,EAAE,GAAG,aAAa,CAAC,SAAS,CAAC,EAAE,EAAE,WAAW,QAAQ,0BAA0B,CAAC,CAAA;IAErF,IAAI,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,2BAA2B,QAAQ,GAAG,CAAC;QACtH,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,sBAAsB,QAAQ,GAAG,CAAC,EAAE,CAAC;QACjF,aAAa,CAAC,WAAW,QAAQ,oDAAoD,CAAC,CAAA;IACxF,CAAC;IACD,OAAO,EAAC,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAC,CAAA;AAChC,CAAC;AAED;;;;;GAKG;AACH,SAAS,0BAA0B,CAAC,SAAS,EAAE,QAAQ;IACrD,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC;QAAE,aAAa,CAAC,WAAW,QAAQ,8CAA8C,CAAC,CAAA;IAC9G,MAAM,KAAK,GAAG,IAAI,GAAG,EAAE,CAAA;IACvB,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QAC7B,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC;YAAE,aAAa,CAAC,WAAW,QAAQ,8CAA8C,CAAC,CAAA;QAC3G,MAAM,IAAI,GAAG,aAAa,CAAC,KAAK,CAAC,IAAI,EAAE,WAAW,QAAQ,oBAAoB,CAAC,CAAA;QAE/E,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YAC1D,aAAa,CAAC,WAAW,QAAQ,mDAAmD,CAAC,CAAA;QACvF,CAAC;QACD,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QACf,IAAI,KAAK,CAAC,IAAI,IAAI,OAAO;YAAE,OAAO,mBAAmB,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAA;QAC5E,WAAW,CAAC,KAAK,EAAE,CAAC,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,CAAC,EAC1G,WAAW,QAAQ,sBAAsB,CAAC,CAAA;QAC5C,IAAI,KAAK,CAAC,IAAI,IAAI,UAAU;YAAE,aAAa,CAAC,WAAW,QAAQ,2CAA2C,CAAC,CAAA;QAC3G,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,IAAI,MAAM,CAAC,IAAI,IAAI,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM;YAC3I,CAAC,YAAY,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,OAAO,IAAI,QAAQ,IAAI,sBAAsB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACvI,CAAC,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CACnF,OAAO,IAAI,IAAI,QAAQ,IAAI,CAAC,aAAa,EAAE,kBAAkB,EAAE,eAAe,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YACjG,IAAI,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM;YAC/C,KAAK,CAAC,SAAS,IAAI,gBAAgB;YACnC,CAAC,YAAY,CAAC,KAAK,CAAC,UAAU,CAAC;YAAE,aAAa,CAAC,WAAW,QAAQ,kBAAkB,IAAI,mCAAmC,CAAC,CAAA;QAC9H,MAAM,UAAU,GAAG,wBAAwB,CAAC,KAAK,CAAC,UAAU,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAA;QAC7E,MAAM,UAAU,GAAG,aAAa,CAAC,KAAK,CAAC,UAAU,EAAE,WAAW,QAAQ,eAAe,CAAC,CAAA;QAEtF,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,IAAI,CAAC;YAAE,aAAa,CAAC,WAAW,QAAQ,kBAAkB,IAAI,+BAA+B,CAAC,CAAA;QAC5H,OAAO;YACL,OAAO,EAAE,uBAAuB,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;YACrD,QAAQ,EAAE,uBAAuB,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC;YACvD,KAAK,EAAE,uEAAuE,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;YACjG,IAAI,EAAE,oBAAoB,CAAC,CAAC,UAAU,CAAC;YACvC,IAAI;YACJ,SAAS,EAAE,oBAAoB,CAAC,CAAC,gBAAgB,CAAC;YAClD,UAAU;YACV,UAAU;SACX,CAAA;IACH,CAAC,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAS,qBAAqB,CAAC,SAAS,EAAE,QAAQ,EAAE,YAAY;IAC9D,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC;QAAE,aAAa,CAAC,WAAW,QAAQ,yCAAyC,CAAC,CAAA;IACzG,MAAM,OAAO,GAAG,IAAI,GAAG,EAAE,CAAA;IACzB,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAC/D,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QAC7B,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC;YAAE,aAAa,CAAC,WAAW,QAAQ,yCAAyC,CAAC,CAAA;QACtG,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,IAAI,SAAS,CAAA;QAEvC,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,CAAC,EACrG,WAAW,QAAQ,iBAAiB,CAAC,CAAA;QACvC,MAAM,cAAc,GAAG,aAAa,CAAC,KAAK,CAAC,QAAQ,EAAE,WAAW,QAAQ,0BAA0B,CAAC,CAAA;QAEnG,IAAI,KAAK,CAAC,IAAI,IAAI,QAAQ,IAAI,KAAK,CAAC,IAAI,IAAI,SAAS,IAAI,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC;YAClF,CAAC,YAAY,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,IAAI,CAAC;YACzD,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,OAAO,MAAM,IAAI,QAAQ,IAAI,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YACtF,IAAI,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;YACtD,aAAa,CAAC,WAAW,QAAQ,6CAA6C,CAAC,CAAA;QACjF,CAAC;QACD,IAAI,OAAO,IAAI,CAAC,CAAC,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC;YACnE,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,IAAI,kBAAkB,IAAI,IAAI,IAAI,eAAe,CAAC;YACnF,IAAI,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC;YAAE,aAAa,CAAC,WAAW,QAAQ,8BAA8B,CAAC,CAAA;QACpH,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAA;QAC3B,OAAO,OAAO;YACZ,CAAC,CAAC,EAAC,KAAK,EAAE,uDAAuD,CAAC,CAAC,CAAC,IAAG,wBAAyB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,cAAc;gBACvI,IAAI,EAAE,oBAAoB,CAAC,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,uBAAuB,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,EAAC;YAChG,CAAC,CAAC,EAAC,QAAQ,EAAE,cAAc,EAAE,IAAI,EAAE,oBAAoB,CAAC,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,uBAAuB,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,EAAC,CAAA;IAC9H,CAAC,CAAC,CAAA;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAS,oBAAoB,CAAC,SAAS,EAAE,QAAQ;IAC/C,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC;QAAE,aAAa,CAAC,WAAW,QAAQ,uCAAuC,CAAC,CAAA;IACvG,MAAM,OAAO,GAAG,IAAI,GAAG,EAAE,CAAA;IACzB,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QAC7B,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC;YAAE,aAAa,CAAC,WAAW,QAAQ,uCAAuC,CAAC,CAAA;QACpG,WAAW,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,WAAW,QAAQ,eAAe,CAAC,CAAA;QACzF,MAAM,MAAM,GAAG,aAAa,CAAC,KAAK,CAAC,MAAM,EAAE,WAAW,QAAQ,oBAAoB,CAAC,CAAA;QACnF,MAAM,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,KAAK,EAAE,WAAW,QAAQ,mBAAmB,CAAC,CAAA;QAEhF,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,uBAAuB,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM,IAAI,CAAC;YAC3H,CAAC,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,OAAO,SAAS,IAAI,QAAQ,IAAI,sBAAsB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAC9G,IAAI,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,IAAI,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM;YAAE,aAAa,CAAC,WAAW,QAAQ,yCAAyC,CAAC,CAAA;QACxI,MAAM,QAAQ,GAAG,mBAAmB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;QACnD,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;QAEnE,IAAI,EAAC,uBAAwB,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,KAAK,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC;YAC9F,aAAa,CAAC,WAAW,QAAQ,+CAA+C,CAAC,CAAA;QACnF,CAAC;QACD,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;QACnB,OAAO,EAAC,MAAM,EAAE,UAAU,EAAE,uBAAuB,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC,EAAE,KAAK,EAAC,CAAA;IACrF,CAAC,CAAC,CAAA;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAS,oBAAoB,CAAC,SAAS,EAAE,QAAQ;IAC/C,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC;QAAE,aAAa,CAAC,WAAW,QAAQ,uCAAuC,CAAC,CAAA;IACvG,MAAM,UAAU,GAAG,IAAI,GAAG,EAAE,CAAA;IAC5B,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QAC7B,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC;YAAE,aAAa,CAAC,WAAW,QAAQ,uCAAuC,CAAC,CAAA;QACpG,WAAW,CAAC,KAAK,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,EAAE,WAAW,QAAQ,cAAc,CAAC,CAAA;QAC5E,MAAM,kBAAkB,GAAG,aAAa,CAAC,KAAK,CAAC,QAAQ,EAAE,WAAW,QAAQ,uBAAuB,CAAC,CAAA;QACpG,MAAM,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,KAAK,EAAE,WAAW,QAAQ,oBAAoB,CAAC,CAAA;QAEjF,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,kBAAkB,IAAI,QAAQ,IAAI,UAAU,CAAC,GAAG,CAAC,kBAAkB,CAAC;YACzH,CAAC,uBAAuB,CAAC,KAAK,CAAC;YAAE,aAAa,CAAC,WAAW,QAAQ,8BAA8B,CAAC,CAAA;QACnG,UAAU,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAA;QAClC,OAAO,EAAC,QAAQ,EAAE,kBAAkB,EAAE,KAAK,EAAC,CAAA;IAC9C,CAAC,CAAC,CAAA;AACJ,CAAC;AAED;;;GAGG;AACH,SAAS,oBAAoB;IAC3B,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,sBAAsB,CAAC,QAAQ,CAAC,CAAC;SAC/G,MAAM,CAAC,yBAAyB,EAAE,CAAC,CAAA;AACxC,CAAC;AAED;;;;GAIG;AACH,SAAS,sBAAsB,CAAC,QAAQ;IACtC,MAAM,KAAK,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAA;IACnC,MAAM,IAAI,GAAG,uBAAuB,QAAQ,EAAE,CAAA;IAC9C,MAAM,UAAU,GAAG,sBAAsB,QAAQ,EAAE,CAAA;IACnD,MAAM,eAAe,GAAG,2BAA2B,QAAQ,EAAE,CAAA;IAC7D,MAAM,aAAa,GAAG,QAAQ,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,eAAe,2CAA2C,CAAC,CAAC;QACxG,GAAG,eAAe,UAAU,KAAK,CAAC,SAAS,EAAE,CAAA;IAC/C,MAAM,cAAc,GAAG,QAAQ,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,eAAe,uDAAuD,CAAC,CAAC;QACrH,GAAG,eAAe,iBAAiB,KAAK,CAAC,SAAS,EAAE,CAAA;IACtD,MAAM,cAAc,GAAG,QAAQ,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,eAAe,6CAA6C,CAAC,CAAC;QAC3G,GAAG,eAAe,WAAW,KAAK,CAAC,SAAS,EAAE,CAAA;IAEhD,OAAO,CAAC;YACN,YAAY,EAAE,CAAC,EAAC,QAAQ,EAAE,GAAG,IAAI,eAAe,EAAE,KAAK,EAAE,GAAG,EAAC,CAAC;YAC9D,QAAQ,EAAE,GAAG,IAAI,QAAQ;YACzB,QAAQ;YACR,aAAa,EAAE,CAAC,EAAC,QAAQ,EAAE,KAAK,CAAC,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,EAAC,CAAC;YAC5F,kBAAkB,EAAE,CAAC,iBAAiB,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;YACzD,YAAY,EAAE,EAAE;YAChB,cAAc,EAAE,GAAG,QAAQ,aAAa;YACxC,MAAM,EAAE,EAAC,OAAO,EAAE,KAAK,CAAC,WAAW,EAAE,QAAQ,EAAE,aAAa,EAAE,EAAE,EAAE,GAAG,UAAU,QAAQ,EAAC;YACxF,OAAO,EAAE,OAAO;YAChB,UAAU,EAAE,QAAQ;SACrB,EAAE;YACD,YAAY,EAAE,EAAE;YAChB,QAAQ,EAAE,GAAG,IAAI,eAAe;YAChC,QAAQ;YACR,aAAa,EAAE,EAAE;YACjB,kBAAkB,EAAE,EAAE;YACtB,YAAY,EAAE,CAAC,EAAC,MAAM,EAAE,oCAAoC,EAAE,UAAU,EAAE,CAAC,aAAa,EAAE,YAAY,CAAC,EAAE,KAAK,EAAE,GAAG,EAAC,CAAC;YACrH,cAAc,EAAE,GAAG,QAAQ,aAAa;YACxC,MAAM,EAAE,EAAC,OAAO,EAAE,KAAK,CAAC,YAAY,EAAE,QAAQ,EAAE,cAAc,EAAE,EAAE,EAAE,GAAG,UAAU,eAAe,EAAC;YACjG,OAAO,EAAE,OAAO;YAChB,UAAU,EAAE,UAAU;SACvB,EAAE;YACD,YAAY,EAAE,EAAE;YAChB,QAAQ,EAAE,GAAG,IAAI,SAAS;YAC1B,QAAQ;YACR,aAAa,EAAE,CAAC,EAAC,QAAQ,EAAE,KAAK,CAAC,kBAAkB,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,EAAC,CAAC;YAClG,kBAAkB,EAAE,CAAC,iBAAiB,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;YACzD,YAAY,EAAE,CAAC,EAAC,MAAM,EAAE,oCAAoC,EAAE,UAAU,EAAE,CAAC,YAAY,CAAC,EAAE,KAAK,EAAE,GAAG,EAAC,CAAC;YACtG,cAAc,EAAE,GAAG,QAAQ,aAAa;YACxC,MAAM,EAAE,EAAC,OAAO,EAAE,KAAK,CAAC,YAAY,EAAE,QAAQ,EAAE,cAAc,EAAE,EAAE,EAAE,GAAG,UAAU,SAAS,EAAC;YAC3F,OAAO,EAAE,OAAO;YAChB,UAAU,EAAE,QAAQ;SACrB,CAAC,CAAA;AACJ,CAAC;AAED;;;;GAIG;AACH,SAAS,iBAAiB,CAAC,IAAI;IAC7B,OAAO;QACL,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI;QAC/E,SAAS,EAAE,gBAAgB,EAAE,UAAU,EAAE,CAAC,EAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAC,CAAC,EAAE,UAAU,EAAE,QAAQ;KACjG,CAAA;AACH,CAAC;AAED;;;GAGG;AACH,SAAS,yBAAyB;IAChC,OAAO,CAAC;YACN,YAAY,EAAE,EAAE;YAChB,QAAQ,EAAE,iCAAiC;YAC3C,QAAQ,EAAE,MAAM;YAChB,aAAa,EAAE,CAAC,EAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,WAAW,CAAC,EAAC,CAAC;YAC7E,kBAAkB,EAAE,CAAC;oBACnB,WAAW,EAAE;wBACX,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,aAAa,EAAE,aAAa,EAAE,mBAAmB,CAAC,EAAE,SAAS,EAAE,UAAU;wBACvG,UAAU,EAAE,CAAC,EAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAC,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAC,CAAC;qBAC9E;oBACD,KAAK,EAAE,CAAC,kBAAkB,CAAC;oBAC3B,IAAI,EAAE,OAAO;oBACb,OAAO,EAAE,CAAC;4BACR,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,aAAa,EAAE,eAAe,EAAE,gBAAgB,CAAC,EAAE,KAAK,EAAE,CAAC,eAAe,CAAC;4BACzG,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,EAAE,EAAE,UAAU,EAAE,iBAAiB;yBACnF,EAAE;4BACD,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,cAAc,EAAE,gBAAgB,CAAC,EAAE,KAAK,EAAE,CAAC,eAAe,CAAC;4BACzF,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,EAAE,EAAE,UAAU,EAAE,MAAM;yBACzE,CAAC;oBACF,IAAI,EAAE,WAAW;oBACjB,SAAS,EAAE,iBAAiB;iBAC7B,CAAC;YACF,YAAY,EAAE;gBACZ,EAAC,MAAM,EAAE,2BAA2B,EAAE,UAAU,EAAE,CAAC,YAAY,CAAC,EAAE,KAAK,EAAE,GAAG,EAAC;gBAC7E,EAAC,MAAM,EAAE,yBAAyB,EAAE,UAAU,EAAE,CAAC,cAAc,CAAC,EAAE,KAAK,EAAE,GAAG,EAAC;gBAC7E,EAAC,MAAM,EAAE,sBAAsB,EAAE,UAAU,EAAE,CAAC,UAAU,CAAC,EAAE,KAAK,EAAE,GAAG,EAAC;aACvE;YACD,cAAc,EAAE,wBAAwB;YACxC,MAAM,EAAE;gBACN,OAAO,EAAE;;;;;;;;;;;;;;;;;;;CAmBd;gBACK,QAAQ,EAAE,wCAAwC;gBAClD,EAAE,EAAE,gCAAgC;aACrC;YACD,OAAO,EAAE,OAAO;YAChB,UAAU,EAAE,QAAQ;SACrB,EAAE;YACD,YAAY,EAAE,EAAE;YAChB,QAAQ,EAAE,iCAAiC;YAC3C,QAAQ,EAAE,MAAM;YAChB,aAAa,EAAE,CAAC,EAAC,KAAK,EAAE,CAAC,kBAAkB,EAAE,eAAe,CAAC,EAAE,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,EAAC,CAAC;YAC5H,kBAAkB,EAAE,CAAC;oBACnB,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,cAAc,CAAC,EAAE,KAAK,EAAE,CAAC,kBAAkB,EAAE,eAAe,CAAC,EAAE,IAAI,EAAE,UAAU;oBAC7G,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,gBAAgB,EAAE,UAAU,EAAE,CAAC,EAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAC,CAAC,EAAE,UAAU,EAAE,MAAM;iBAC5G,CAAC;YACF,YAAY,EAAE,CAAC,EAAC,MAAM,EAAE,oBAAoB,EAAE,UAAU,EAAE,CAAC,eAAe,CAAC,EAAE,KAAK,EAAE,GAAG,EAAC,CAAC;YACzF,cAAc,EAAE,wBAAwB;YACxC,MAAM,EAAE;gBACN,OAAO,EAAE;;;;;;;;;CASd;gBACK,QAAQ,EAAE,wCAAwC;gBAClD,EAAE,EAAE,gCAAgC;aACrC;YACD,OAAO,EAAE,OAAO;YAChB,UAAU,EAAE,QAAQ;SACrB,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAS,mBAAmB,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI;IAChD,WAAW,CAAC,KAAK,EAAE,CAAC,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,EACjF,WAAW,QAAQ,gBAAgB,CAAC,CAAA;IACtC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,kBAAkB;QAC/F,KAAK,CAAC,SAAS,IAAI,iBAAiB,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;QAC5G,aAAa,CAAC,WAAW,QAAQ,YAAY,IAAI,mCAAmC,CAAC,CAAA;IACvF,CAAC;IACD,MAAM,WAAW,GAAG,sCAAsC,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAA;IAE9E,WAAW,CAAC,WAAW,EAAE,CAAC,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,CAAC,EAAE,WAAW,QAAQ,eAAe,CAAC,CAAA;IAChH,IAAI,WAAW,CAAC,SAAS,IAAI,UAAU,IAAI,CAAC,kBAAkB,CAAC,WAAW,CAAC,OAAO,CAAC;QACjF,CAAC,mBAAmB,CAAC,WAAW,CAAC,QAAQ,CAAC;QAAE,aAAa,CAAC,WAAW,QAAQ,YAAY,IAAI,+BAA+B,CAAC,CAAA;IAC/H,MAAM,UAAU,GAAG,wBAAwB,CAAC,WAAW,CAAC,UAAU,EAAE,QAAQ,EAAE,GAAG,IAAI,MAAM,CAAC,CAAA;IAC5F,MAAM,WAAW,GAAG,IAAI,GAAG,EAAE,CAAA;IAC7B,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;QAC3C,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC;YAAE,aAAa,CAAC,WAAW,QAAQ,YAAY,IAAI,0BAA0B,CAAC,CAAA;QACxG,WAAW,CAAC,MAAM,EAAE,CAAC,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,CAAC,EACnG,WAAW,QAAQ,gBAAgB,CAAC,CAAA;QACtC,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,EAAE,WAAW,QAAQ,eAAe,CAAC,CAAA;QACjF,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,UAAU,EAAE,WAAW,QAAQ,sBAAsB,CAAC,CAAA;QAE9F,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,OAAO,CAAC;YAChH,CAAC,mBAAmB,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC;YAChG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,eAAe,IAAI,MAAM,CAAC,SAAS,IAAI,UAAU,IAAI,MAAM,CAAC,SAAS,IAAI,UAAU;YACtG,CAAC,YAAY,CAAC,UAAU,EAAE,IAAI,CAAC;YAAE,aAAa,CAAC,WAAW,QAAQ,YAAY,IAAI,0BAA0B,CAAC,CAAA;QAC/G,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;QAC3B,OAAO;YACL,OAAO,EAAE,uBAAuB,CAAC,CAAC,CAAC,IAAG,wBAAyB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;YACjF,QAAQ,EAAE,uBAAuB,CAAC,CAAC,CAAC,IAAG,wBAAyB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YACnF,KAAK,EAAE,gCAAgC,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC;YAC3D,IAAI,EAAE,UAAU;YAChB,SAAS,EAAE,sCAAsC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC;YACpE,UAAU,EAAE,wBAAwB,CAAC,MAAM,CAAC,UAAU,EAAE,QAAQ,EAAE,GAAG,IAAI,IAAI,UAAU,EAAE,CAAC;YAC1F,UAAU;SACX,CAAA;IACH,CAAC,CAAC,CAAA;IAEF,OAAO;QACL,WAAW,EAAE;YACX,OAAO,EAAE,uBAAuB,CAAC,CAAC,CAAC,IAAG,wBAAyB,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;YACtF,QAAQ,EAAE,uBAAuB,CAAC,CAAC,CAAC,IAAG,wBAAyB,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC;YACxF,SAAS,EAAE,UAAU;YACrB,UAAU;SACX;QACD,KAAK,EAAE,CAAC,kBAAkB,CAAC;QAC3B,IAAI,EAAE,OAAO;QACb,OAAO;QACP,IAAI;QACJ,SAAS,EAAE,iBAAiB;KAC7B,CAAA;AACH,CAAC;AAED;;;;;;GAMG;AACH,SAAS,wBAAwB,CAAC,SAAS,EAAE,QAAQ,EAAE,QAAQ;IAC7D,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC;QAAE,aAAa,CAAC,WAAW,QAAQ,kBAAkB,QAAQ,2BAA2B,CAAC,CAAA;IACrH,MAAM,KAAK,GAAG,IAAI,GAAG,EAAE,CAAA;IAEvB,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE;QACjC,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC;YAAE,aAAa,CAAC,WAAW,QAAQ,kBAAkB,QAAQ,6BAA6B,CAAC,CAAA;QACxH,WAAW,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,QAAQ,yBAAyB,CAAC,CAAA;QACtF,MAAM,IAAI,GAAG,aAAa,CAAC,SAAS,CAAC,IAAI,EAAE,WAAW,QAAQ,kBAAkB,CAAC,CAAA;QACjF,MAAM,IAAI,GAAG,aAAa,CAAC,SAAS,CAAC,IAAI,EAAE,WAAW,QAAQ,kBAAkB,CAAC,CAAA;QAEjF,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC;YACxF,aAAa,CAAC,WAAW,QAAQ,kBAAkB,QAAQ,6BAA6B,CAAC,CAAA;QAC3F,CAAC;QACD,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QACf,OAAO,EAAC,IAAI,EAAE,IAAI,EAAC,CAAA;IACrB,CAAC,CAAC,CAAA;AACJ,CAAC;AAED;;;;GAIG;AACH,SAAS,kBAAkB,CAAC,SAAS;IACnC,OAAO,YAAY,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,IAAI,MAAM,CAAC,IAAI,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC,IAAI,IAAI,SAAS,CAAC,MAAM,CAAA;AAChI,CAAC;AAED;;;;GAIG;AACH,SAAS,mBAAmB,CAAC,SAAS;IACpC,OAAO,YAAY,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,OAAO,IAAI,QAAQ,IAAI,sBAAsB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAChI,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC,IAAI,IAAI,SAAS,CAAC,MAAM,CAAA;AAC/C,CAAC;AAED;;;;;GAKG;AACH,SAAS,YAAY,CAAC,IAAI,EAAE,SAAS;IACnC,IAAI,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC;QAAE,OAAO,SAAS,IAAI,IAAI,IAAI,MAAM,CAAA;IAChE,MAAM,QAAQ,GAAG,sCAAsC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAElE,OAAO,QAAQ,KAAK,IAAI,CAAA;AAC1B,CAAC;AAED;;;;GAIG;AACH,SAAS,uBAAuB,CAAC,WAAW;IAC1C,IAAI,WAAW,CAAC,IAAI,IAAI,UAAU;QAAE,OAAO,EAAC,GAAG,WAAW,EAAE,OAAO,EAAE,CAAC,GAAG,WAAW,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,WAAW,CAAC,QAAQ,CAAC;YAChI,KAAK,EAAE,CAAC,GAAG,WAAW,CAAC,KAAK,CAAC,EAAE,UAAU,EAAE,WAAW,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,EAAC,GAAG,SAAS,EAAC,CAAC,CAAC,EAAC,CAAA;IACzG,OAAO,EAAC,GAAG,WAAW;QACpB,WAAW,EAAE,EAAC,GAAG,WAAW,CAAC,WAAW,EAAE,OAAO,EAAE,CAAC,GAAG,WAAW,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,WAAW,CAAC,WAAW,CAAC,QAAQ,CAAC;YACtI,UAAU,EAAE,WAAW,CAAC,WAAW,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,EAAC,GAAG,SAAS,EAAC,CAAC,CAAC,EAAC;QACtF,KAAK,EAAE,CAAC,GAAG,WAAW,CAAC,KAAK,CAAC;QAC7B,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,EAAC,GAAG,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC;YACpH,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,EAAC,GAAG,SAAS,EAAC,CAAC,CAAC,EAAC,CAAC,CAAC,EAAC,CAAA;AACtG,CAAC;AAED;;;;GAIG;AACH,SAAS,wBAAwB,CAAC,SAAS;IACzC,OAAO,OAAO,SAAS,IAAI,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,IAAI,EAAC,CAAA;AACpG,CAAC;AAED;;;;GAIG;AACH,SAAS,kBAAkB,CAAC,IAAI;IAC9B,MAAM,SAAS,GAAG,sCAAsC,CAAC,CAAC,IAAI,CAAC,CAAA;IAE/D,IAAI,SAAS,CAAC,IAAI,IAAI,MAAM;QAAE,OAAO,EAAC,IAAI,EAAE,MAAM,EAAC,CAAA;IACnD,IAAI,SAAS,CAAC,IAAI,IAAI,SAAS;QAAE,OAAO,EAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,wBAAwB;YAC1F,oFAAoF,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,EAAC,CAAA;IAC7G,OAAO;QACL,IAAI,EAAE,iCAAiC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC;QACxD,cAAc,EAAE,qBAAqB,CAAC,CAAC,SAAS,CAAC,cAAc,CAAC;QAChE,eAAe,EAAE,wBAAwB;QACvC,oFAAoF,CAAC,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC;KACpH,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,uBAAuB,CAAC,QAAQ;IACvC,+CAA+C;IAC/C,MAAM,KAAK,GAAG;QACZ,oBAAoB,EAAE,QAAQ;QAC9B,sBAAsB,EAAE,UAAU;QAClC,2BAA2B,EAAE,cAAc;QAC3C,oCAAoC,EAAE,eAAe;QACrD,yBAAyB,EAAE,YAAY;KACxC,CAAA;IAED,OAAO,KAAK,CAAC,QAAQ,CAAC,IAAI,aAAa,CAAC,sDAAsD,QAAQ,IAAI,CAAC,CAAA;AAC7G,CAAC;AAED;;;;GAIG;AACH,SAAS,WAAW,CAAC,QAAQ;IAC3B,IAAI,QAAQ,IAAI,KAAK;QAAE,OAAO;YAC5B,SAAS,EAAE,KAAK,EAAE,YAAY,EAAE,6BAA6B,EAAE,UAAU,EAAE,qBAAqB;YAChG,UAAU,EAAE,cAAc,EAAE,kBAAkB,EAAE,8BAA8B;YAC9E,WAAW,EAAE;;;;;;CAMhB;YACG,YAAY,EAAE;;;;;;;;;;;;;;CAcjB;YACG,YAAY,EAAE;;;;CAIjB;SACE,CAAA;IACD,IAAI,QAAQ,IAAI,MAAM;QAAE,OAAO;YAC7B,SAAS,EAAE,IAAI,EAAE,YAAY,EAAE,2BAA2B,EAAE,UAAU,EAAE,qBAAqB;YAC7F,UAAU,EAAE,cAAc,EAAE,kBAAkB,EAAE,4BAA4B;YAC5E,WAAW,EAAE;;;;;;;;;CAShB;YACG,YAAY,EAAE;;;;;;;;;;;;;;;CAejB;YACG,YAAY,EAAE;;;;;;;;CAQjB;SACE,CAAA;IACD,IAAI,QAAQ,IAAI,MAAM;QAAE,OAAO;YAC7B,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,2BAA2B,EAAE,UAAU,EAAE,oBAAoB;YAC9F,UAAU,EAAE,aAAa,EAAE,kBAAkB,EAAE,4BAA4B;YAC3E,WAAW,EAAE;;;;;CAKhB;YACG,YAAY,EAAE;;;;;;;CAOjB;YACG,YAAY,EAAE;;;;CAIjB;SACE,CAAA;IACD,MAAM,KAAK,GAAG,QAAQ,IAAI,YAAY,CAAA;IACtC,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAA;IACrC,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,OAAO,CAAA;IACnD,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAA;IACtC,MAAM,aAAa,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;;;;CAIpC,CAAA;IAEC,OAAO;QACL,SAAS,EAAE,YAAY,EAAE,2BAA2B,EAAE,UAAU,EAAE,oBAAoB;QACtF,UAAU,EAAE,aAAa,EAAE,kBAAkB,EAAE,4BAA4B;QAC3E,WAAW,EAAE;EACf,aAAa,sCAAsC,SAAS,IAAI,MAAM;CACvE;QACG,YAAY,EAAE,GAAG,aAAa,yCAAyC,SAAS,IAAI,MAAM;UACpF,KAAK,CAAC,CAAC,CAAC,sBAAsB,CAAC,CAAC,CAAC,oCAAoC;;;CAG9E;QACG,YAAY,EAAE,GAAG,aAAa,+BAA+B,SAAS,IAAI,MAAM;CACnF;KACE,CAAA;AACH,CAAC;AAED;;;;;;GAMG;AACH,SAAS,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,OAAO;IACvC,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC;QAAE,aAAa,CAAC,WAAW,OAAO,UAAU,CAAC,CAAA;AACpH,CAAC;AAED;;;;;GAKG;AACH,SAAS,aAAa,CAAC,KAAK,EAAE,OAAO;IACnC,IAAI,OAAO,KAAK,IAAI,QAAQ,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC;QAAE,aAAa,CAAC,GAAG,OAAO,8BAA8B,CAAC,CAAA;IAC1G,OAAO,qBAAqB,CAAC,CAAC,KAAK,CAAC,CAAA;AACtC,CAAC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,KAAK;IAC1B,OAAO,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,IAAI,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,SAAS,CAAA;AAChI,CAAC;AAED;;;;;GAKG;AACH,SAAS,UAAU,CAAC,KAAK;IACvB,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC;QAAE,IAAI,KAAK,IAAI,OAAO,KAAK,IAAI,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,UAAU,CAAC,KAAK,CAAC,CAAA;IAC7H,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;AAC7B,CAAC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,OAAO;IAC5B,MAAM,IAAI,qBAAqB,CAAC,EAAC,IAAI,EAAE,uBAAuB,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAC,CAAC,CAAA;AAC/F,CAAC;AAED;;;;;GAKG;AACH,SAAS,gBAAgB,CAAC,QAAQ,EAAE,YAAY;IAC9C,MAAM,IAAI,qBAAqB,CAAC;QAC9B,IAAI,EAAE,iCAAiC;QACvC,QAAQ,EAAE,kBAAkB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ;QAChE,OAAO,EAAE,mCAAmC,MAAM,CAAC,YAAY,CAAC,0BAA0B,QAAQ,oBAAoB;KACvH,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAS,iBAAiB,CAAC,QAAQ,EAAE,YAAY,EAAE,MAAM;IACvD,MAAM,IAAI,qBAAqB,CAAC;QAC9B,IAAI,EAAE,kCAAkC;QACxC,QAAQ;QACR,OAAO,EAAE,mCAAmC,YAAY,IAAI,MAAM,6CAA6C;KAChH,CAAC,CAAA;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAS,sBAAsB,CAAC,QAAQ,EAAE,KAAK;IAC7C,MAAM,IAAI,qBAAqB,CAAC;QAC9B,IAAI,EAAE,iCAAiC,EAAE,QAAQ;QACjD,OAAO,EAAE,yBAAyB,KAAK,qBAAqB;KAC7D,CAAC,CAAA;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAS,yBAAyB,CAAC,QAAQ,EAAE,QAAQ;IACnD,MAAM,IAAI,qBAAqB,CAAC;QAC9B,IAAI,EAAE,oCAAoC,EAAE,QAAQ;QACpD,OAAO,EAAE,oCAAoC,QAAQ,+CAA+C;KACrG,CAAC,CAAA;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,oBAAoB,GAAG,0BAA0B,EAAE,CAAA","sourcesContent":["// @ts-check\n\nimport {isDenseArray} from \"./array.js\"\nimport {isSafeArtifactPath} from \"./artifact-path.js\"\nimport {SemantifoldDiagnostic} from \"./diagnostic.js\"\nimport {\n  compareStdlibVersions, parseStdlibVersion, parseStdlibVersionRange, resolveStdlibModule, stdlibVersionSatisfies\n} from \"./semantic/stdlib.js\"\n\nconst facadeIdentityPattern = /^[a-z][a-z0-9.-]*$/u\nconst moduleIdPattern = /^[a-z][a-z0-9_]*(?:[.-][a-z][a-z0-9_]*)*$/u\nconst declarationNamePattern = /^[A-Za-z_][A-Za-z0-9_]*$/u\nconst supportedLanguages = new Set([\"php\", \"ruby\", \"javascript\", \"typescript\", \"java\"])\nconst canonicalTypes = new Set([\"boolean\", \"integer\", \"string\", \"void\"])\n\n/**\n * @typedef StdlibFacadeFunctionDeclaration\n * @property {\"function\"} kind - Closed public declaration kind.\n * @property {string} name - Exact source-visible symbol.\n * @property {{name: string, type: string}[]} parameters - Ordered source signature.\n * @property {string} returnType - Canonical result type.\n * @property {string[]} effects - Closed public effects.\n * @property {string[]} failures - Escaping canonical failure names.\n * @property {(\"direct-call\" | \"unqualified-call\" | \"receiver-call\")[]} forms - Accepted source call forms.\n * @property {\"not-applicable\"} ownership - Initial scalar qualification ownership.\n */\n/**\n * @typedef StdlibFacadeClassDeclaration\n * @property {\"class\"} kind - Closed public declaration kind.\n * @property {string} name - Exact source-visible class symbol.\n * @property {[\"constructor-call\"]} forms - Accepted construction form.\n * @property {\"owned-reference\"} ownership - Class instance ownership.\n * @property {{effects: string[], failures: string[], ownership: \"acquired\", parameters: {name: string, type: string}[]}} constructor - Constructor contract.\n * @property {{effects: string[], failures: string[], forms: [\"receiver-call\"], name: string, ownership: \"borrowed\" | \"consumed\", parameters: {name: string, type: string}[], returnType: string}[]} methods - Public instance methods.\n */\n/** @typedef {StdlibFacadeFunctionDeclaration | StdlibFacadeClassDeclaration} StdlibFacadePublicDeclaration */\n/**\n * @typedef StdlibFacadeRecord\n * @property {{identity: string, range: string}[]} dependencies - Facade-module dependencies.\n * @property {string} identity - Versioned facade identity.\n * @property {import(\"./semantic/types.js\").SemanticLanguage} language - Source language.\n * @property {({identity: string, kind: \"module\", symbols: string[]} | {forms: (\"unqualified-call\" | \"receiver-call\")[], identity: string, kind: \"builtin\", symbols: string[]})[]} nativeModules - Exact source native identities.\n * @property {StdlibFacadePublicDeclaration[]} publicDeclarations - Public source surface.\n * @property {{module: string, operations: string[], range: string}[]} requirements - Canonical-only requirements.\n * @property {string} runtimeProfile - Exact compatible source/runtime profile.\n * @property {{content: string, filename: string, id: string}} source - Executable compiler-owned source module.\n * @property {string} version - Exact facade version.\n * @property {\"internal\" | \"public\"} visibility - Native-selectable visibility.\n */\n/**\n * @typedef FacadeSourceNames\n * @property {string} extension - Source filename extension.\n * @property {string} nativeModule - Public native stdlib module identity.\n * @property {string} publicName - Public native symbol.\n * @property {string} unusedName - Unused-elimination fixture symbol.\n * @property {string} unusedNativeModule - Unused-elimination fixture module.\n * @property {string} probeSource - Public executable facade source.\n * @property {string} runnerSource - Internal canonical runner source.\n * @property {string} unusedSource - Unused executable facade source.\n */\n/**\n * @typedef StdlibFacadeRegistry\n * @property {readonly StdlibFacadeRecord[]} facades - Stable immutable facade records.\n * @property {(language: string, nativeModule: string, symbol: string, range?: string) => StdlibFacadeRecord} resolveFacade - Exact native identity resolver.\n * @property {(identity: string, language: string, range?: string) => StdlibFacadeRecord} resolveIdentity - Facade dependency resolver.\n * @property {(language: string, nativeModule: string, range?: string) => StdlibFacadeRecord} resolveModule - Exact native module resolver.\n */\n\n/**\n * Creates a detached immutable source-language facade registry.\n * @param {unknown} records - Optional facade definitions; built-in qualification definitions by default.\n * @returns {Readonly<StdlibFacadeRegistry>} Validated facade registry.\n */\nexport function createStdlibFacadeRegistry(records = builtinFacadeRecords()) {\n  if (!isDenseArray(records)) invalidFacade(\"Facade records must be an ordered dense array.\")\n  /** @type {StdlibFacadeRecord[]} */\n  const facades = []\n  /** @type {Map<string, Map<string, StdlibFacadeRecord>>} */\n  const byIdentity = new Map()\n  /** @type {Map<string, StdlibFacadeRecord[]>} */\n  const byNativeModule = new Map()\n  const sourceIds = new Map()\n  const sourceFilenames = new Map()\n\n  for (let index = 0; index < records.length; index += 1) {\n    const record = validateFacadeRecord(records[index])\n    const identityKey = `${record.language}\\0${record.identity}`\n    const versions = byIdentity.get(identityKey) ?? new Map()\n\n    if (versions.has(record.version)) invalidFacade(`Duplicate facade '${record.identity}' version '${record.version}' for '${record.language}'.`)\n    if (sourceIds.has(record.source.id) && sourceIds.get(record.source.id) != identityKey) {\n      invalidFacade(`Duplicate facade source module identity '${record.source.id}'.`)\n    }\n    if (sourceFilenames.has(record.source.filename) && sourceFilenames.get(record.source.filename) != identityKey) {\n      invalidFacade(`Duplicate facade source filename '${record.source.filename}'.`)\n    }\n    versions.set(record.version, record)\n    byIdentity.set(identityKey, versions)\n    sourceIds.set(record.source.id, identityKey)\n    sourceFilenames.set(record.source.filename, identityKey)\n    facades.push(record)\n\n    for (const nativeModule of record.nativeModules) {\n      const nativeKey = `${record.language}\\0${nativeModule.identity}`\n      const nativeRecords = byNativeModule.get(nativeKey) ?? []\n\n      nativeRecords.push(record)\n      byNativeModule.set(nativeKey, nativeRecords)\n    }\n  }\n\n  for (const record of facades) {\n    for (const dependency of record.dependencies) {\n      resolveIdentityFromStore(byIdentity, dependency.identity, record.language, dependency.range, record.identity)\n    }\n  }\n  validateFacadeDependencyCycles(facades, byIdentity)\n\n  return Object.freeze(/** @type {StdlibFacadeRegistry} */ ({\n    facades: Object.freeze(facades),\n    resolveFacade(language, nativeModule, symbol, range) {\n      return resolveNativeFacadeFromStore(byNativeModule, language, nativeModule, symbol, range)\n    },\n    resolveIdentity(identity, language, range) {\n      return resolveIdentityFromStore(byIdentity, identity, language, range)\n    },\n    resolveModule(language, nativeModule, range) {\n      const records = byNativeModule.get(`${language}\\0${nativeModule}`)\n\n      if (!records) unprovedIdentity(language, nativeModule)\n      const identities = new Set(/** @type {StdlibFacadeRecord[]} */ (records).map(({identity}) => identity))\n\n      if (identities.size != 1) invalidFacade(`Native facade module '${nativeModule}' is ambiguous for '${language}'.`)\n      return selectFacadeVersion(new Map(/** @type {StdlibFacadeRecord[]} */ (records).map((record) => [record.version, record])),\n        /** @type {StdlibFacadeRecord} */ (records[0]).identity, language, range)\n    }\n  }))\n}\n\n/**\n * Rejects cycles after every versioned dependency has resolved successfully.\n * @param {StdlibFacadeRecord[]} facades - Validated facade records.\n * @param {Map<string, Map<string, StdlibFacadeRecord>>} store - Records by language and identity.\n * @returns {void}\n */\nfunction validateFacadeDependencyCycles(facades, store) {\n  const active = new Set()\n  const complete = new Set()\n\n  /**\n   * Visits one exact selected facade version.\n   * @param {StdlibFacadeRecord} record - Facade record.\n   * @returns {void}\n   */\n  function visit(record) {\n    const key = `${record.language}\\0${record.identity}\\0${record.version}`\n\n    if (complete.has(key)) return\n    if (active.has(key)) invalidFacade(`Facade dependency cycle includes '${record.identity}'.`)\n    active.add(key)\n    for (const dependency of record.dependencies) {\n      visit(resolveIdentityFromStore(store, dependency.identity, record.language, dependency.range, record.identity))\n    }\n    active.delete(key)\n    complete.add(key)\n  }\n\n  for (const record of facades) visit(record)\n}\n\n/**\n * Lists all built-in public and internal facade modules in stable order.\n * @returns {readonly StdlibFacadeRecord[]} Immutable facade definitions.\n */\nexport function listStdlibFacades() {\n  return stdlibFacadeRegistry.facades\n}\n\n/**\n * Resolves one built-in facade from parser-proved native module and symbol identities.\n * @param {string} language - Source language.\n * @param {string} nativeModule - Exact native module identity.\n * @param {string} symbol - Exact imported or qualified symbol.\n * @param {string} [range] - Compatible facade version range.\n * @returns {StdlibFacadeRecord} Immutable facade definition.\n */\nexport function resolveStdlibFacade(language, nativeModule, symbol, range) {\n  return stdlibFacadeRegistry.resolveFacade(language, nativeModule, symbol, range)\n}\n\n/**\n * Resolves a dependency-first, cycle-free facade module closure.\n * @param {StdlibFacadeRecord[]} roots - Parser-selected facade roots.\n * @param {Readonly<StdlibFacadeRegistry>} [registry] - Facade registry.\n * @returns {StdlibFacadeRecord[]} Stable dependency-first closure.\n */\nexport function resolveStdlibFacadeClosure(roots, registry = stdlibFacadeRegistry) {\n  const active = new Set()\n  const complete = new Set()\n  /** @type {StdlibFacadeRecord[]} */\n  const result = []\n\n  /**\n   * Visits one selected facade and its declared dependencies.\n   * @param {StdlibFacadeRecord} record - Facade to visit.\n   * @returns {void}\n   */\n  function visit(record) {\n    const key = `${record.language}\\0${record.identity}\\0${record.version}`\n\n    if (complete.has(key)) return\n    if (active.has(key)) invalidFacade(`Facade dependency cycle includes '${record.identity}'.`)\n    active.add(key)\n    for (const dependency of record.dependencies) {\n      visit(registry.resolveIdentity(dependency.identity, record.language, dependency.range))\n    }\n    active.delete(key)\n    complete.add(key)\n    result.push(record)\n  }\n\n  for (const root of roots) visit(root)\n  return result\n}\n\n/**\n * Creates the detached, deterministic program descriptor for one selected facade closure.\n * @param {import(\"./semantic/types.js\").SemanticLanguage} language - Source language profile.\n * @param {StdlibFacadeRecord[]} facades - Dependency-first selected facade records.\n * @returns {import(\"./semantic/types.js\").StdlibFacadeProgramDescriptor} Plain program descriptor.\n */\nexport function stdlibFacadeProgramDescriptor(language, facades) {\n  return {\n    language,\n    modules: facades.map((facade) => ({\n      dependencies: facade.dependencies.map((dependency) => ({...dependency})),\n      identity: facade.identity,\n      nativeModules: facade.nativeModules.map((module) => ({...module,\n        ...(module.kind == \"builtin\" ? {forms: [...module.forms]} : {}), symbols: [...module.symbols]})),\n      publicDeclarations: facade.publicDeclarations.map(detachPublicDeclaration),\n      requirements: facade.requirements.map((requirement) => ({...requirement, operations: [...requirement.operations]})),\n      runtimeProfile: facade.runtimeProfile,\n      sourceModule: facade.source.id,\n      version: facade.version,\n      visibility: facade.visibility\n    })),\n    schema: \"SemantifoldStdlibFacades\",\n    version: 1\n  }\n}\n\n/**\n * Derives compiler-owned semantic capability authority from selected facade requirements.\n * The initial executable qualification corpus intentionally targets one canonical module.\n * @param {StdlibFacadeRecord[]} records - Selected facade closure.\n * @returns {{contract: {contractVersion: string, identity: string}, input: import(\"./semantic/types.js\").CapabilityAuthorityInput} | {contracts: {contractVersion: string, identity: string}[], input: import(\"./semantic/types.js\").CapabilityAuthorityInput} | null} Authority input.\n */\nexport function facadeCapabilityAuthority(records) {\n  const requirements = records.flatMap((record) => record.requirements)\n\n  if (requirements.length == 0) return null\n  const identities = new Set(requirements.map(({module}) => module))\n  const ranges = new Set(requirements.map(({range}) => range))\n\n  const task037 = records.some(({identity}) => identity.startsWith(\"semantifold.task037.\"))\n\n  if (task037) {\n    const requirementByModule = new Map()\n\n    for (const requirement of requirements) {\n      const current = requirementByModule.get(requirement.module)\n\n      if (current && current.range != requirement.range) invalidFacade(\"Task 037 facade requirements disagree on a canonical range.\")\n      const operations = new Set(current?.operations ?? [])\n\n      for (const operation of requirement.operations) operations.add(operation)\n      requirementByModule.set(requirement.module, {operations, range: requirement.range})\n    }\n    const modules = [...requirementByModule.entries()].map(([identity, requirement]) => {\n      const contract = resolveStdlibModule(identity, requirement.range)\n\n      return {\n        capabilities: [{\n          failures: contract.failures.map(({name}) => ({name})),\n          name: canonicalCapabilityName(identity),\n          operations: contract.operations.filter(({name}) => requirement.operations.has(name)).map((operation) => ({\n            effects: /** @type {[\"host\"]} */ ([...operation.effects]),\n            failures: operation.failures.map(detachCanonicalReference),\n            name: operation.name,\n            parameters: operation.parameters.map((parameter) => ({\n              name: parameter.name,\n              type: canonicalCapabilityParameterType(parameter.type)\n            })),\n            resourceFlow: detachResourceFlow(operation.resourceFlow),\n            returnType: canonicalCapabilityType(operation.returnType)\n          })),\n          resources: contract.resources.map(({name}) => ({name}))\n        }],\n        contractVersion: requirement.range,\n        identity\n      }\n    })\n\n    return {\n      contracts: modules.map(({contractVersion, identity}) => ({contractVersion, identity})),\n      input: {id: \"semantifold.task037.blocking-tcp\", modules, schema: \"SemantifoldCapabilityAuthority\", schemaVersion: 2}\n    }\n  }\n  if (identities.size != 1 || ranges.size != 1) {\n    invalidFacade(\"The Task 036 qualification facade closure must resolve one canonical module and version range.\")\n  }\n  const identity = requirements[0].module\n  const contractVersion = requirements[0].range\n  const contract = resolveStdlibModule(identity, contractVersion)\n\n  return {\n    contract: {contractVersion, identity},\n    input: {\n      capabilities: [{\n        failures: contract.failures.map(({name}) => ({name})),\n        name: \"ResourceProbe\",\n        operations: contract.operations.map((operation) => ({\n          effects: [...operation.effects],\n          failures: [...operation.failures],\n          name: operation.name,\n          parameters: operation.parameters.map((parameter) => ({\n            name: parameter.name,\n            type: canonicalCapabilityParameterType(parameter.type)\n          })),\n          resourceFlow: /** @type {import(\"./semantic/types.js\").CapabilityResourceFlowInput} */ ({...operation.resourceFlow}),\n          returnType: canonicalCapabilityType(operation.returnType)\n        })),\n        resources: contract.resources.map(({name}) => ({name}))\n      }],\n      contractVersion,\n      id: identity,\n      schema: \"SemantifoldCapabilityAuthority\",\n      schemaVersion: 1\n    }\n  }\n}\n\n/**\n * Converts one registry contract type to a capability-authority input type.\n * @param {string | import(\"./semantic/stdlib.js\").CanonicalDeclarationReference} type - Canonical contract type.\n * @returns {import(\"./semantic/types.js\").FunctionReturnTypeName | {kind: \"OwnedResourceType\", resource: string | import(\"./semantic/types.js\").CapabilityDeclarationReferenceInput} | {kind: \"OptionalType\", valueType: import(\"./semantic/types.js\").SemanticTypeName}} Semantic authority type.\n */\nfunction canonicalCapabilityType(type) {\n  if (typeof type != \"string\") return {kind: \"OwnedResourceType\", resource: detachCanonicalReference(type)}\n  if (type == \"void\" || type == \"boolean\" || type == \"integer\" || type == \"string\") return type\n  if (type.startsWith(\"optional:\")) return {kind: \"OptionalType\",\n    valueType: /** @type {import(\"./semantic/types.js\").SemanticTypeName} */ (type.slice(\"optional:\".length))}\n  return {kind: \"OwnedResourceType\", resource: type}\n}\n\n/**\n * Converts a non-void registry parameter type to capability-authority input.\n * @param {string | import(\"./semantic/stdlib.js\").CanonicalDeclarationReference} type - Canonical parameter type.\n * @returns {import(\"./semantic/types.js\").SemanticTypeName | {kind: \"OwnedResourceType\", resource: string} | {kind: \"OptionalType\", valueType: import(\"./semantic/types.js\").SemanticTypeName}} Semantic parameter type.\n */\nfunction canonicalCapabilityParameterType(type) {\n  const converted = canonicalCapabilityType(type)\n\n  if (converted == \"void\") invalidFacade(\"Canonical facade requirement parameters cannot have void type.\")\n  return /** @type {import(\"./semantic/types.js\").SemanticTypeName | {kind: \"OwnedResourceType\", resource: string} | {kind: \"OptionalType\", valueType: import(\"./semantic/types.js\").SemanticTypeName}} */ (converted)\n}\n\n/**\n * Resolves one dependency identity from a validated registry store.\n * @param {Map<string, Map<string, StdlibFacadeRecord>>} store - Records by language and identity.\n * @param {string} identity - Facade identity.\n * @param {string} language - Source language.\n * @param {string | undefined} range - Compatible range.\n * @param {string} [owner] - Depending facade for diagnostics.\n * @returns {StdlibFacadeRecord} Highest compatible record.\n */\nfunction resolveIdentityFromStore(store, identity, language, range, owner) {\n  const versions = store.get(`${language}\\0${identity}`)\n\n  if (!versions) {\n    invalidFacade(owner ? `Facade '${owner}' depends on unknown facade '${identity}' for '${language}'.` :\n      `Unknown facade identity '${identity}' for '${language}'.`)\n  }\n  return selectFacadeVersion(/** @type {Map<string, StdlibFacadeRecord>} */ (versions), identity, language, range)\n}\n\n/**\n * Resolves one exact native identity from a validated registry store.\n * @param {Map<string, StdlibFacadeRecord[]>} store - Records by language and native module.\n * @param {string} language - Source language.\n * @param {string} nativeModule - Exact parser-owned native module identity.\n * @param {string} symbol - Exact source-visible symbol.\n * @param {string | undefined} range - Compatible range.\n * @returns {StdlibFacadeRecord} Highest compatible record.\n */\nfunction resolveNativeFacadeFromStore(store, language, nativeModule, symbol, range) {\n  if (!supportedLanguages.has(language) || typeof nativeModule != \"string\" || nativeModule.length == 0) {\n    unprovedIdentity(language, nativeModule)\n  }\n  const moduleRecords = store.get(`${language}\\0${nativeModule}`)\n\n  if (!moduleRecords) unprovedIdentity(language, nativeModule)\n  const symbolRecords = /** @type {StdlibFacadeRecord[]} */ (moduleRecords).filter((record) => record.nativeModules.some((module) =>\n    module.identity == nativeModule && module.symbols.includes(symbol)))\n\n  if (symbolRecords.length == 0) unsupportedMember(language, nativeModule, symbol)\n  const identities = new Set(symbolRecords.map(({identity}) => identity))\n\n  if (identities.size != 1) invalidFacade(`Native facade identity '${nativeModule}#${symbol}' is ambiguous for '${language}'.`)\n  const versions = new Map(symbolRecords.map((record) => [record.version, record]))\n\n  return selectFacadeVersion(versions, symbolRecords[0].identity, language, range)\n}\n\n/**\n * Selects the highest facade version satisfying a canonical range.\n * @param {Map<string, StdlibFacadeRecord>} versions - Records by exact version.\n * @param {string} identity - Facade identity.\n * @param {string} language - Source language.\n * @param {string | undefined} range - Compatible range.\n * @returns {StdlibFacadeRecord} Selected record.\n */\nfunction selectFacadeVersion(versions, identity, language, range) {\n  const parsedRange = range === undefined ? {lower: /** @type {[number, number, number]} */ ([0, 0, 0]), upper: null} :\n    parseStdlibVersionRange(range)\n\n  if (!parsedRange) facadeVersionMalformed(language, String(range))\n  /** @type {[number, number, number] | undefined} */\n  let selected\n\n  for (const version of versions.keys()) {\n    const parsed = /** @type {[number, number, number]} */ (parseStdlibVersion(version))\n\n    if (stdlibVersionSatisfies(parsed, parsedRange) && (!selected || compareStdlibVersions(parsed, selected) > 0)) selected = parsed\n  }\n  if (!selected) facadeVersionIncompatible(language, identity)\n\n  return /** @type {StdlibFacadeRecord} */ (versions.get(selected.join(\".\")))\n}\n\n/**\n * Validates and detaches one executable facade record.\n * @param {unknown} candidate - Candidate record.\n * @returns {StdlibFacadeRecord} Detached frozen record.\n */\nfunction validateFacadeRecord(candidate) {\n  if (!isPlainObject(candidate)) invalidFacade(\"Every facade record must be a plain object.\")\n  requireKeys(candidate, [\"dependencies\", \"identity\", \"language\", \"nativeModules\", \"publicDeclarations\", \"requirements\",\n    \"runtimeProfile\", \"source\", \"version\", \"visibility\"], \"facade record\")\n  const identity = requireString(candidate.identity, \"Facade identity\")\n  const language = requireString(candidate.language, \"Facade language\")\n  const version = requireString(candidate.version, \"Facade version\")\n  const runtimeProfile = requireString(candidate.runtimeProfile, \"Facade runtime profile\")\n  const visibility = candidate.visibility\n\n  if (!facadeIdentityPattern.test(identity)) invalidFacade(`Facade identity '${identity}' is invalid.`)\n  if (!supportedLanguages.has(language)) invalidFacade(`Facade language '${language}' is outside the adopted cohort.`)\n  if (!parseStdlibVersion(version)) invalidFacade(`Facade version '${version}' is invalid.`)\n  if (!/^[a-z][a-z0-9.-]*$/u.test(runtimeProfile)) invalidFacade(`Facade runtime profile '${runtimeProfile}' is invalid.`)\n  if (visibility != \"public\" && visibility != \"internal\") invalidFacade(`Facade '${identity}' has invalid visibility.`)\n  const source = validateSource(candidate.source, identity, language)\n  const publicDeclarations = validatePublicDeclarations(candidate.publicDeclarations, identity)\n  const nativeModules = validateNativeModules(candidate.nativeModules, identity, publicDeclarations)\n  const requirements = validateRequirements(candidate.requirements, identity)\n  const dependencies = validateDependencies(candidate.dependencies, identity)\n\n  if (visibility == \"public\" && (publicDeclarations.length == 0 || nativeModules.length == 0)) {\n    invalidFacade(`Public facade '${identity}' requires declarations and native identities.`)\n  }\n  if (visibility == \"internal\" && nativeModules.length > 0) invalidFacade(`Internal facade '${identity}' cannot expose native identities.`)\n\n  return deepFreeze({\n    dependencies,\n    identity,\n    language: /** @type {import(\"./semantic/types.js\").SemanticLanguage} */ (language),\n    nativeModules,\n    publicDeclarations,\n    requirements,\n    runtimeProfile,\n    source,\n    version,\n    visibility: /** @type {\"internal\" | \"public\"} */ (visibility)\n  })\n}\n\n/**\n * Validates one compiler-owned executable facade source.\n * @param {unknown} candidate - Candidate source descriptor.\n * @param {string} identity - Owning facade identity.\n * @param {string} language - Facade source language.\n * @returns {{content: string, filename: string, id: string}} Validated source descriptor.\n */\nfunction validateSource(candidate, identity, language) {\n  if (!isPlainObject(candidate)) invalidFacade(`Facade '${identity}' requires an executable source descriptor.`)\n  requireKeys(candidate, [\"content\", \"filename\", \"id\"], `facade '${identity}' source`)\n  const content = requireString(candidate.content, `Facade '${identity}' source content`)\n  const filename = requireString(candidate.filename, `Facade '${identity}' source filename`)\n  const id = requireString(candidate.id, `Facade '${identity}' source module identity`)\n\n  if (content.length == 0 || !isSafeArtifactPath(filename) || !filename.startsWith(`__semantifold_facades__/${language}/`) ||\n    !moduleIdPattern.test(id) || !id.startsWith(`semantifold.facade.${language}.`)) {\n    invalidFacade(`Facade '${identity}' has an invalid compiler-owned source descriptor.`)\n  }\n  return {content, filename, id}\n}\n\n/**\n * Validates one facade's closed public declaration surface.\n * @param {unknown} candidate - Candidate declarations.\n * @param {string} identity - Owning facade identity.\n * @returns {StdlibFacadePublicDeclaration[]} Validated declarations.\n */\nfunction validatePublicDeclarations(candidate, identity) {\n  if (!isDenseArray(candidate)) invalidFacade(`Facade '${identity}' public declarations must be a dense array.`)\n  const names = new Set()\n  return candidate.map((value) => {\n    if (!isPlainObject(value)) invalidFacade(`Facade '${identity}' public declarations must be plain objects.`)\n    const name = requireString(value.name, `Facade '${identity}' declaration name`)\n\n    if (!declarationNamePattern.test(name) || names.has(name)) {\n      invalidFacade(`Facade '${identity}' has an invalid or duplicate public declaration.`)\n    }\n    names.add(name)\n    if (value.kind == \"class\") return validatePublicClass(value, identity, name)\n    requireKeys(value, [\"effects\", \"failures\", \"forms\", \"kind\", \"name\", \"ownership\", \"parameters\", \"returnType\"],\n      `facade '${identity}' public declaration`)\n    if (value.kind != \"function\") invalidFacade(`Facade '${identity}' has an invalid public declaration kind.`)\n    if (!isDenseArray(value.effects) || !value.effects.every((effect) => effect == \"host\") || new Set(value.effects).size != value.effects.length ||\n      !isDenseArray(value.failures) || !value.failures.every((failure) => typeof failure == \"string\" && declarationNamePattern.test(failure)) ||\n      !isDenseArray(value.forms) || value.forms.length == 0 || !value.forms.every((form) =>\n        typeof form == \"string\" && [\"direct-call\", \"unqualified-call\", \"receiver-call\"].includes(form)) ||\n      new Set(value.forms).size != value.forms.length ||\n      value.ownership != \"not-applicable\" ||\n      !isDenseArray(value.parameters)) invalidFacade(`Facade '${identity}' declaration '${name}' has an invalid public contract.`)\n    const parameters = validateFacadeParameters(value.parameters, identity, name)\n    const returnType = requireString(value.returnType, `Facade '${identity}' return type`)\n\n    if (!isFacadeType(returnType, true)) invalidFacade(`Facade '${identity}' declaration '${name}' has an invalid return type.`)\n    return {\n      effects: /** @type {string[]} */ ([...value.effects]),\n      failures: /** @type {string[]} */ ([...value.failures]),\n      forms: /** @type {(\"direct-call\" | \"unqualified-call\" | \"receiver-call\")[]} */ ([...value.forms]),\n      kind: /** @type {const} */ (\"function\"),\n      name,\n      ownership: /** @type {const} */ (\"not-applicable\"),\n      parameters,\n      returnType\n    }\n  })\n}\n\n/**\n * Validates the exact native module and symbol identities selecting a facade.\n * @param {unknown} candidate - Candidate native modules.\n * @param {string} identity - Owning facade identity.\n * @param {StdlibFacadePublicDeclaration[]} declarations - Validated public surface.\n * @returns {({identity: string, kind: \"module\", symbols: string[]} | {forms: (\"unqualified-call\" | \"receiver-call\")[], identity: string, kind: \"builtin\", symbols: string[]})[]} Validated native identities.\n */\nfunction validateNativeModules(candidate, identity, declarations) {\n  if (!isDenseArray(candidate)) invalidFacade(`Facade '${identity}' native modules must be a dense array.`)\n  const modules = new Set()\n  const publicNames = new Set(declarations.map(({name}) => name))\n  return candidate.map((value) => {\n    if (!isPlainObject(value)) invalidFacade(`Facade '${identity}' native modules must be plain objects.`)\n    const builtin = value.kind == \"builtin\"\n\n    requireKeys(value, builtin ? [\"forms\", \"identity\", \"kind\", \"symbols\"] : [\"identity\", \"kind\", \"symbols\"],\n      `facade '${identity}' native module`)\n    const moduleIdentity = requireString(value.identity, `Facade '${identity}' native module identity`)\n\n    if (value.kind != \"module\" && value.kind != \"builtin\" || modules.has(moduleIdentity) ||\n      !isDenseArray(value.symbols) || value.symbols.length == 0 ||\n      !value.symbols.every((symbol) => typeof symbol == \"string\" && publicNames.has(symbol)) ||\n      new Set(value.symbols).size != value.symbols.length) {\n      invalidFacade(`Facade '${identity}' has an invalid native module declaration.`)\n    }\n    if (builtin && (!isDenseArray(value.forms) || value.forms.length == 0 ||\n      !value.forms.every((form) => form == \"unqualified-call\" || form == \"receiver-call\") ||\n      new Set(value.forms).size != value.forms.length)) invalidFacade(`Facade '${identity}' has invalid builtin forms.`)\n    modules.add(moduleIdentity)\n    return builtin\n      ? {forms: /** @type {(\"unqualified-call\" | \"receiver-call\")[]} */ ([.../** @type {unknown[]} */ (value.forms)]), identity: moduleIdentity,\n        kind: /** @type {const} */ (\"builtin\"), symbols: /** @type {string[]} */ ([...value.symbols])}\n      : {identity: moduleIdentity, kind: /** @type {const} */ (\"module\"), symbols: /** @type {string[]} */ ([...value.symbols])}\n  })\n}\n\n/**\n * Validates canonical-only facade capability requirements.\n * @param {unknown} candidate - Candidate requirements.\n * @param {string} identity - Owning facade identity.\n * @returns {{module: string, operations: string[], range: string}[]} Validated requirements.\n */\nfunction validateRequirements(candidate, identity) {\n  if (!isDenseArray(candidate)) invalidFacade(`Facade '${identity}' requirements must be a dense array.`)\n  const modules = new Set()\n  return candidate.map((value) => {\n    if (!isPlainObject(value)) invalidFacade(`Facade '${identity}' requirements must be plain objects.`)\n    requireKeys(value, [\"module\", \"operations\", \"range\"], `facade '${identity}' requirement`)\n    const module = requireString(value.module, `Facade '${identity}' canonical module`)\n    const range = requireString(value.range, `Facade '${identity}' canonical range`)\n\n    if (modules.has(module) || !parseStdlibVersionRange(range) || !isDenseArray(value.operations) || value.operations.length == 0 ||\n      !value.operations.every((operation) => typeof operation == \"string\" && declarationNamePattern.test(operation)) ||\n      new Set(value.operations).size != value.operations.length) invalidFacade(`Facade '${identity}' has an invalid canonical requirement.`)\n    const contract = resolveStdlibModule(module, range)\n    const declared = new Set(contract.operations.map(({name}) => name))\n\n    if (!/** @type {string[]} */ (value.operations).every((operation) => declared.has(operation))) {\n      invalidFacade(`Facade '${identity}' requires an undeclared canonical operation.`)\n    }\n    modules.add(module)\n    return {module, operations: /** @type {string[]} */ ([...value.operations]), range}\n  })\n}\n\n/**\n * Validates versioned same-language facade dependencies.\n * @param {unknown} candidate - Candidate dependencies.\n * @param {string} identity - Owning facade identity.\n * @returns {{identity: string, range: string}[]} Validated dependencies.\n */\nfunction validateDependencies(candidate, identity) {\n  if (!isDenseArray(candidate)) invalidFacade(`Facade '${identity}' dependencies must be a dense array.`)\n  const identities = new Set()\n  return candidate.map((value) => {\n    if (!isPlainObject(value)) invalidFacade(`Facade '${identity}' dependencies must be plain objects.`)\n    requireKeys(value, [\"identity\", \"range\"], `facade '${identity}' dependency`)\n    const dependencyIdentity = requireString(value.identity, `Facade '${identity}' dependency identity`)\n    const range = requireString(value.range, `Facade '${identity}' dependency range`)\n\n    if (!facadeIdentityPattern.test(dependencyIdentity) || dependencyIdentity == identity || identities.has(dependencyIdentity) ||\n      !parseStdlibVersionRange(range)) invalidFacade(`Facade '${identity}' has an invalid dependency.`)\n    identities.add(dependencyIdentity)\n    return {identity: dependencyIdentity, range}\n  })\n}\n\n/**\n * Builds the bounded original-five qualification facade definitions.\n * @returns {unknown[]} Unvalidated built-in qualification facade definitions.\n */\nfunction builtinFacadeRecords() {\n  return [\"php\", \"ruby\", \"javascript\", \"typescript\", \"java\"].flatMap((language) => builtinLanguageFacades(language))\n    .concat(builtinTask037RubyFacades())\n}\n\n/**\n * Builds one source language's public, internal, and unreachable qualification facades.\n * @param {string} language - Source language.\n * @returns {unknown[]} Language facade definitions.\n */\nfunction builtinLanguageFacades(language) {\n  const names = facadeNames(language)\n  const base = `semantifold.task036.${language}`\n  const sourceBase = `semantifold.facade.${language}`\n  const sourceDirectory = `__semantifold_facades__/${language}`\n  const probeFilename = language == \"java\" ? `${sourceDirectory}/semantifold/facade/java/probe/Probe.java` :\n    `${sourceDirectory}/probe.${names.extension}`\n  const runnerFilename = language == \"java\" ? `${sourceDirectory}/semantifold/facade/java/proberunner/ProbeRunner.java` :\n    `${sourceDirectory}/probe-runner.${names.extension}`\n  const unusedFilename = language == \"java\" ? `${sourceDirectory}/semantifold/facade/java/unused/Unused.java` :\n    `${sourceDirectory}/unused.${names.extension}`\n\n  return [{\n    dependencies: [{identity: `${base}.probe-runner`, range: \"1\"}],\n    identity: `${base}.probe`,\n    language,\n    nativeModules: [{identity: names.nativeModule, kind: \"module\", symbols: [names.publicName]}],\n    publicDeclarations: [publicDeclaration(names.publicName)],\n    requirements: [],\n    runtimeProfile: `${language}-task036-v1`,\n    source: {content: names.probeSource, filename: probeFilename, id: `${sourceBase}.probe`},\n    version: \"1.0.0\",\n    visibility: \"public\"\n  }, {\n    dependencies: [],\n    identity: `${base}.probe-runner`,\n    language,\n    nativeModules: [],\n    publicDeclarations: [],\n    requirements: [{module: \"semantifold.task034.resource-probe\", operations: [\"probeEffect\", \"probeTrace\"], range: \"1\"}],\n    runtimeProfile: `${language}-task036-v1`,\n    source: {content: names.runnerSource, filename: runnerFilename, id: `${sourceBase}.probe_runner`},\n    version: \"1.0.0\",\n    visibility: \"internal\"\n  }, {\n    dependencies: [],\n    identity: `${base}.unused`,\n    language,\n    nativeModules: [{identity: names.unusedNativeModule, kind: \"module\", symbols: [names.unusedName]}],\n    publicDeclarations: [publicDeclaration(names.unusedName)],\n    requirements: [{module: \"semantifold.task034.resource-probe\", operations: [\"probeTrace\"], range: \"1\"}],\n    runtimeProfile: `${language}-task036-v1`,\n    source: {content: names.unusedSource, filename: unusedFilename, id: `${sourceBase}.unused`},\n    version: \"1.0.0\",\n    visibility: \"public\"\n  }]\n}\n\n/**\n * Builds the common bounded qualification function declaration.\n * @param {string} name - Source-visible function name.\n * @returns {StdlibFacadePublicDeclaration} Public facade declaration.\n */\nfunction publicDeclaration(name) {\n  return {\n    effects: [\"host\"], failures: [], forms: [\"direct-call\"], kind: \"function\", name,\n    ownership: \"not-applicable\", parameters: [{name: \"label\", type: \"string\"}], returnType: \"string\"\n  }\n}\n\n/**\n * Builds the exact Ruby Task 037 socket and output compatibility facades.\n * @returns {unknown[]} Unvalidated facade records.\n */\nfunction builtinTask037RubyFacades() {\n  return [{\n    dependencies: [],\n    identity: \"semantifold.task037.ruby.socket\",\n    language: \"ruby\",\n    nativeModules: [{identity: \"socket\", kind: \"module\", symbols: [\"TCPSocket\"]}],\n    publicDeclarations: [{\n      constructor: {\n        effects: [\"host\"], failures: [\"InvalidHost\", \"InvalidPort\", \"ConnectionFailure\"], ownership: \"acquired\",\n        parameters: [{name: \"host\", type: \"string\"}, {name: \"port\", type: \"integer\"}]\n      },\n      forms: [\"constructor-call\"],\n      kind: \"class\",\n      methods: [{\n        effects: [\"host\"], failures: [\"ReadFailure\", \"DecodeFailure\", \"ResourceClosed\"], forms: [\"receiver-call\"],\n        name: \"gets\", ownership: \"borrowed\", parameters: [], returnType: \"optional:string\"\n      }, {\n        effects: [\"host\"], failures: [\"CloseFailure\", \"ResourceClosed\"], forms: [\"receiver-call\"],\n        name: \"close\", ownership: \"consumed\", parameters: [], returnType: \"void\"\n      }],\n      name: \"TCPSocket\",\n      ownership: \"owned-reference\"\n    }],\n    requirements: [\n      {module: \"semantifold.socket-client\", operations: [\"v1_connect\"], range: \"1\"},\n      {module: \"semantifold.text-stream\", operations: [\"v1_read_line\"], range: \"1\"},\n      {module: \"semantifold.resource\", operations: [\"v1_close\"], range: \"1\"}\n    ],\n    runtimeProfile: \"ruby-task037-socket-v1\",\n    source: {\n      content: `module SemantifoldTask037Socket\n  class TCPSocket\n    # @param host [String]\n    # @param port [Integer]\n    def initialize(host, port)\n      @resource = v1_connect(host, port)\n    end\n\n    # @return [String?]\n    def gets\n      return v1_read_line(@resource)\n    end\n\n    # @return [void]\n    def close\n      v1_close(@resource)\n    end\n  end\nend\n`,\n      filename: \"__semantifold_facades__/ruby/socket.rb\",\n      id: \"semantifold.facade.ruby.socket\"\n    },\n    version: \"1.0.0\",\n    visibility: \"public\"\n  }, {\n    dependencies: [],\n    identity: \"semantifold.task037.ruby.output\",\n    language: \"ruby\",\n    nativeModules: [{forms: [\"unqualified-call\", \"receiver-call\"], identity: \"ruby:Kernel\", kind: \"builtin\", symbols: [\"puts\"]}],\n    publicDeclarations: [{\n      effects: [\"host\"], failures: [\"WriteFailure\"], forms: [\"unqualified-call\", \"receiver-call\"], kind: \"function\",\n      name: \"puts\", ownership: \"not-applicable\", parameters: [{name: \"text\", type: \"string\"}], returnType: \"void\"\n    }],\n    requirements: [{module: \"semantifold.output\", operations: [\"v1_write_line\"], range: \"1\"}],\n    runtimeProfile: \"ruby-task037-output-v1\",\n    source: {\n      content: `module SemantifoldTask037Output\n  module_function\n  # @param text [String]\n  # @return [void]\n  def puts(text)\n    v1_write_line(text)\n    return\n  end\nend\n`,\n      filename: \"__semantifold_facades__/ruby/output.rb\",\n      id: \"semantifold.facade.ruby.output\"\n    },\n    version: \"1.0.0\",\n    visibility: \"public\"\n  }]\n}\n\n/**\n * Validates one public facade class descriptor.\n * @param {Record<string, unknown>} value - Candidate class.\n * @param {string} identity - Owning facade.\n * @param {string} name - Validated class name.\n * @returns {StdlibFacadeClassDeclaration} Detached class descriptor.\n */\nfunction validatePublicClass(value, identity, name) {\n  requireKeys(value, [\"constructor\", \"forms\", \"kind\", \"methods\", \"name\", \"ownership\"],\n    `facade '${identity}' public class`)\n  if (!isDenseArray(value.forms) || value.forms.length != 1 || value.forms[0] != \"constructor-call\" ||\n    value.ownership != \"owned-reference\" || !isPlainObject(value.constructor) || !isDenseArray(value.methods)) {\n    invalidFacade(`Facade '${identity}' class '${name}' has an invalid public contract.`)\n  }\n  const constructor = /** @type {Record<string, unknown>} */ (value.constructor)\n\n  requireKeys(constructor, [\"effects\", \"failures\", \"ownership\", \"parameters\"], `facade '${identity}' constructor`)\n  if (constructor.ownership != \"acquired\" || !validFacadeEffects(constructor.effects) ||\n    !validFacadeFailures(constructor.failures)) invalidFacade(`Facade '${identity}' class '${name}' has an invalid constructor.`)\n  const parameters = validateFacadeParameters(constructor.parameters, identity, `${name}.new`)\n  const methodNames = new Set()\n  const methods = value.methods.map((method) => {\n    if (!isPlainObject(method)) invalidFacade(`Facade '${identity}' class '${name}' has an invalid method.`)\n    requireKeys(method, [\"effects\", \"failures\", \"forms\", \"name\", \"ownership\", \"parameters\", \"returnType\"],\n      `facade '${identity}' class method`)\n    const methodName = requireString(method.name, `Facade '${identity}' method name`)\n    const returnType = requireString(method.returnType, `Facade '${identity}' method return type`)\n\n    if (!declarationNamePattern.test(methodName) || methodNames.has(methodName) || !validFacadeEffects(method.effects) ||\n      !validFacadeFailures(method.failures) || !isDenseArray(method.forms) || method.forms.length != 1 ||\n      method.forms[0] != \"receiver-call\" || method.ownership != \"borrowed\" && method.ownership != \"consumed\" ||\n      !isFacadeType(returnType, true)) invalidFacade(`Facade '${identity}' class '${name}' has an invalid method.`)\n    methodNames.add(methodName)\n    return {\n      effects: /** @type {string[]} */ ([.../** @type {unknown[]} */ (method.effects)]),\n      failures: /** @type {string[]} */ ([.../** @type {unknown[]} */ (method.failures)]),\n      forms: /** @type {[\"receiver-call\"]} */ ([\"receiver-call\"]),\n      name: methodName,\n      ownership: /** @type {\"borrowed\" | \"consumed\"} */ (method.ownership),\n      parameters: validateFacadeParameters(method.parameters, identity, `${name}.${methodName}`),\n      returnType\n    }\n  })\n\n  return {\n    constructor: {\n      effects: /** @type {string[]} */ ([.../** @type {unknown[]} */ (constructor.effects)]),\n      failures: /** @type {string[]} */ ([.../** @type {unknown[]} */ (constructor.failures)]),\n      ownership: \"acquired\",\n      parameters\n    },\n    forms: [\"constructor-call\"],\n    kind: \"class\",\n    methods,\n    name,\n    ownership: \"owned-reference\"\n  }\n}\n\n/**\n * Validates facade parameters shared by functions, constructors, and methods.\n * @param {unknown} candidate - Candidate parameters.\n * @param {string} identity - Owning facade.\n * @param {string} callable - Callable name.\n * @returns {{name: string, type: string}[]} Detached parameters.\n */\nfunction validateFacadeParameters(candidate, identity, callable) {\n  if (!isDenseArray(candidate)) invalidFacade(`Facade '${identity}' declaration '${callable}' has invalid parameters.`)\n  const names = new Set()\n\n  return candidate.map((parameter) => {\n    if (!isPlainObject(parameter)) invalidFacade(`Facade '${identity}' declaration '${callable}' has an invalid parameter.`)\n    requireKeys(parameter, [\"name\", \"type\"], `facade '${identity}' declaration parameter`)\n    const name = requireString(parameter.name, `Facade '${identity}' parameter name`)\n    const type = requireString(parameter.type, `Facade '${identity}' parameter type`)\n\n    if (!declarationNamePattern.test(name) || names.has(name) || !isFacadeType(type, false)) {\n      invalidFacade(`Facade '${identity}' declaration '${callable}' has an invalid parameter.`)\n    }\n    names.add(name)\n    return {name, type}\n  })\n}\n\n/**\n * Checks one facade effect list.\n * @param {unknown} candidate - Candidate effects.\n * @returns {boolean} Whether effects are exact.\n */\nfunction validFacadeEffects(candidate) {\n  return isDenseArray(candidate) && candidate.every((effect) => effect == \"host\") && new Set(candidate).size == candidate.length\n}\n\n/**\n * Checks one facade failure list.\n * @param {unknown} candidate - Candidate failures.\n * @returns {candidate is string[]} Whether failures are exact.\n */\nfunction validFacadeFailures(candidate) {\n  return isDenseArray(candidate) && candidate.every((failure) => typeof failure == \"string\" && declarationNamePattern.test(failure)) &&\n    new Set(candidate).size == candidate.length\n}\n\n/**\n * Checks one facade type spelling.\n * @param {string} type - Candidate type.\n * @param {boolean} allowVoid - Whether void is valid in this position.\n * @returns {boolean} Whether the type is canonical.\n */\nfunction isFacadeType(type, allowVoid) {\n  if (canonicalTypes.has(type)) return allowVoid || type != \"void\"\n  const optional = /^optional:(boolean|integer|string)$/u.exec(type)\n\n  return optional !== null\n}\n\n/**\n * Detaches one descriptor for the public program record.\n * @param {StdlibFacadePublicDeclaration} declaration - Registry declaration.\n * @returns {StdlibFacadePublicDeclaration} Detached declaration.\n */\nfunction detachPublicDeclaration(declaration) {\n  if (declaration.kind == \"function\") return {...declaration, effects: [...declaration.effects], failures: [...declaration.failures],\n    forms: [...declaration.forms], parameters: declaration.parameters.map((parameter) => ({...parameter}))}\n  return {...declaration,\n    constructor: {...declaration.constructor, effects: [...declaration.constructor.effects], failures: [...declaration.constructor.failures],\n      parameters: declaration.constructor.parameters.map((parameter) => ({...parameter}))},\n    forms: [...declaration.forms],\n    methods: declaration.methods.map((method) => ({...method, effects: [...method.effects], failures: [...method.failures],\n      forms: [...method.forms], parameters: method.parameters.map((parameter) => ({...parameter}))}))}\n}\n\n/**\n * Detaches a local or dependency-qualified contract reference.\n * @param {string | import(\"./semantic/stdlib.js\").CanonicalDeclarationReference} reference - Contract reference.\n * @returns {string | import(\"./semantic/types.js\").CapabilityDeclarationReferenceInput} Detached reference.\n */\nfunction detachCanonicalReference(reference) {\n  return typeof reference == \"string\" ? reference : {module: reference.module, name: reference.name}\n}\n\n/**\n * Detaches a canonical resource flow for authority construction.\n * @param {object} flow - Canonical resource flow.\n * @returns {import(\"./semantic/types.js\").CapabilityResourceFlowInput} Detached flow.\n */\nfunction detachResourceFlow(flow) {\n  const candidate = /** @type {Record<string, unknown>} */ (flow)\n\n  if (candidate.kind == \"none\") return {kind: \"none\"}\n  if (candidate.kind == \"acquire\") return {kind: \"acquire\", resource: detachCanonicalReference(\n    /** @type {string | import(\"./semantic/stdlib.js\").CanonicalDeclarationReference} */ (candidate.resource))}\n  return {\n    kind: /** @type {\"borrow\" | \"close\"} */ (candidate.kind),\n    parameterIndex: /** @type {number} */ (candidate.parameterIndex),\n    terminalFailure: detachCanonicalReference(\n      /** @type {string | import(\"./semantic/stdlib.js\").CanonicalDeclarationReference} */ (candidate.terminalFailure))\n  }\n}\n\n/**\n * Maps one canonical module identity to its closed capability name.\n * @param {string} identity - Canonical identity.\n * @returns {string} Capability name.\n */\nfunction canonicalCapabilityName(identity) {\n  /** @type {Readonly<Record<string, string>>} */\n  const names = {\n    \"semantifold.output\": \"Output\",\n    \"semantifold.resource\": \"Resource\",\n    \"semantifold.socket-client\": \"SocketClient\",\n    \"semantifold.task034.resource-probe\": \"ResourceProbe\",\n    \"semantifold.text-stream\": \"TextStream\"\n  }\n\n  return names[identity] ?? invalidFacade(`Facade requirements name unknown canonical module '${identity}'.`)\n}\n\n/**\n * Builds executable source and native identity spellings for one original-five language.\n * @param {string} language - Source language.\n * @returns {FacadeSourceNames} Facade source definitions.\n */\nfunction facadeNames(language) {\n  if (language == \"php\") return {\n    extension: \"php\", nativeModule: \"Semantifold\\\\Task036\\\\Probe\", publicName: \"compatibility_probe\",\n    unusedName: \"unused_probe\", unusedNativeModule: \"Semantifold\\\\Task036\\\\Unused\",\n    probeSource: `<?php\ndeclare(strict_types=1);\nnamespace Semantifold\\\\Facade\\\\Php\\\\Probe;\nuse function Semantifold\\\\Facade\\\\Php\\\\ProbeRunner\\\\run_compatibility_probe;\nrequire_once __DIR__ . \"/probe-runner.php\";\nfunction compatibility_probe(string $label): string { return run_compatibility_probe($label); }\n`,\n    runnerSource: `<?php\ndeclare(strict_types=1);\nnamespace Semantifold\\\\Facade\\\\Php\\\\ProbeRunner;\nfunction run_compatibility_probe(string $label): string {\n    try {\n        /**\n         * @var int $effect\n         * @semantifold-immutable\n         */\n        $effect = probeEffect($label, 1, false);\n        return probeTrace();\n    }\n    catch (ProbeOperationFailure $error) { return $error->getMessage(); }\n}\n`,\n    unusedSource: `<?php\ndeclare(strict_types=1);\nnamespace Semantifold\\\\Facade\\\\Php\\\\Unused;\nfunction unused_probe(string $label): string { return probeTrace(); }\n`\n  }\n  if (language == \"ruby\") return {\n    extension: \"rb\", nativeModule: \"semantifold/task036/probe\", publicName: \"compatibility_probe\",\n    unusedName: \"unused_probe\", unusedNativeModule: \"semantifold/task036/unused\",\n    probeSource: `require_relative \"probe-runner\"\nmodule SemantifoldTask036Probe\n  module_function\n  # @param label [String]\n  # @return [String]\n  def compatibility_probe(label)\n    return SemantifoldTask036ProbeRunner.run_compatibility_probe(label)\n  end\nend\n`,\n    runnerSource: `module SemantifoldTask036ProbeRunner\n  module_function\n  # @param label [String]\n  # @return [String]\n  def run_compatibility_probe(label)\n    begin\n      # @type [Integer]\n      # @semantifold-immutable\n      effect = probeEffect(label, 1, false)\n      return probeTrace\n    rescue ProbeOperationFailure => error\n      return error.message\n    end\n  end\nend\n`,\n    unusedSource: `module SemantifoldTask036Unused\n  module_function\n  # @param label [String]\n  # @return [String]\n  def unused_probe(label)\n    return probeTrace\n  end\nend\n`\n  }\n  if (language == \"java\") return {\n    extension: \"java\", nativeModule: \"semantifold.task036.Probe\", publicName: \"compatibilityProbe\",\n    unusedName: \"unusedProbe\", unusedNativeModule: \"semantifold.task036.Unused\",\n    probeSource: `package semantifold.facade.java.probe;\nimport semantifold.facade.java.proberunner.ProbeRunner;\npublic final class Probe {\n  public static String compatibilityProbe(String label) { return ProbeRunner.runCompatibilityProbe(label); }\n}\n`,\n    runnerSource: `package semantifold.facade.java.proberunner;\npublic final class ProbeRunner {\n  public static String runCompatibilityProbe(String label) {\n    try { final int effect = probeEffect(label, 1, false); return probeTrace(); }\n    catch (ProbeOperationFailure error) { return error.getMessage(); }\n  }\n}\n`,\n    unusedSource: `package semantifold.facade.java.unused;\npublic final class Unused {\n  public static String unusedProbe(String label) { return probeTrace(); }\n}\n`\n  }\n  const typed = language == \"typescript\"\n  const extension = typed ? \"ts\" : \"js\"\n  const parameter = typed ? \"label: string\" : \"label\"\n  const result = typed ? \": string\" : \"\"\n  const documentation = typed ? \"\" : `/**\n * @param {string} label\n * @returns {string}\n */\n`\n\n  return {\n    extension, nativeModule: \"semantifold:task036/probe\", publicName: \"compatibilityProbe\",\n    unusedName: \"unusedProbe\", unusedNativeModule: \"semantifold:task036/unused\",\n    probeSource: `import {runCompatibilityProbe} from \"./probe-runner.js\"\n${documentation}export function compatibilityProbe(${parameter})${result} { return runCompatibilityProbe(label) }\n`,\n    runnerSource: `${documentation}export function runCompatibilityProbe(${parameter})${result} {\n  try { ${typed ? \"const effect: number\" : \"/** @type {number} */ const effect\"} = probeEffect(label, 1, false); return probeTrace() }\n  catch (error) { if (!(error instanceof ProbeOperationFailure)) { throw error } return error.message }\n}\n`,\n    unusedSource: `${documentation}export function unusedProbe(${parameter})${result} { return probeTrace() }\n`\n  }\n}\n\n/**\n * Requires a closed exact key set.\n * @param {Record<string, unknown>} value - Plain candidate object.\n * @param {string[]} keys - Expected keys.\n * @param {string} subject - Diagnostic subject.\n * @returns {void}\n */\nfunction requireKeys(value, keys, subject) {\n  if (Object.keys(value).sort().join(\",\") != [...keys].sort().join(\",\")) invalidFacade(`Invalid ${subject} fields.`)\n}\n\n/**\n * Requires one non-empty string.\n * @param {unknown} value - Candidate value.\n * @param {string} subject - Diagnostic subject.\n * @returns {string} Validated string.\n */\nfunction requireString(value, subject) {\n  if (typeof value != \"string\" || value.length == 0) invalidFacade(`${subject} must be a non-empty string.`)\n  return /** @type {string} */ (value)\n}\n\n/**\n * Checks for an ordinary object with no custom prototype.\n * @param {unknown} value - Candidate value.\n * @returns {value is Record<string, unknown>} Whether the candidate is plain.\n */\nfunction isPlainObject(value) {\n  return value !== null && typeof value == \"object\" && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype\n}\n\n/**\n * Recursively freezes one detached facade registry value.\n * @template {object} T\n * @param {T} value - Detached object.\n * @returns {Readonly<T>} Frozen value.\n */\nfunction deepFreeze(value) {\n  for (const child of Object.values(value)) if (child && typeof child == \"object\" && !Object.isFrozen(child)) deepFreeze(child)\n  return Object.freeze(value)\n}\n\n/**\n * Throws a stable invalid-registry diagnostic.\n * @param {string} message - Failure detail.\n * @returns {never} Always throws.\n */\nfunction invalidFacade(message) {\n  throw new SemantifoldDiagnostic({code: \"STDLIB_FACADE_INVALID\", language: \"stdlib\", message})\n}\n\n/**\n * Throws when parser evidence does not name a registered native module.\n * @param {string} language - Source language.\n * @param {unknown} nativeModule - Unproved module identity.\n * @returns {never} Always throws.\n */\nfunction unprovedIdentity(language, nativeModule) {\n  throw new SemantifoldDiagnostic({\n    code: \"STDLIB_FACADE_IDENTITY_UNPROVED\",\n    language: supportedLanguages.has(language) ? language : \"stdlib\",\n    message: `Native standard-library module '${String(nativeModule)}' is not a registered '${language}' facade identity.`\n  })\n}\n\n/**\n * Throws when a native module member is outside its public facade surface.\n * @param {string} language - Source language.\n * @param {string} nativeModule - Exact native module.\n * @param {string} symbol - Unsupported member.\n * @returns {never} Always throws.\n */\nfunction unsupportedMember(language, nativeModule, symbol) {\n  throw new SemantifoldDiagnostic({\n    code: \"STDLIB_FACADE_MEMBER_UNSUPPORTED\",\n    language,\n    message: `Native standard-library symbol '${nativeModule}#${symbol}' is outside the registered facade surface.`\n  })\n}\n\n/**\n * Throws for a malformed facade version range.\n * @param {string} language - Source language.\n * @param {string} range - Malformed range.\n * @returns {never} Always throws.\n */\nfunction facadeVersionMalformed(language, range) {\n  throw new SemantifoldDiagnostic({\n    code: \"STDLIB_FACADE_VERSION_MALFORMED\", language,\n    message: `Facade version range '${range}' is not canonical.`\n  })\n}\n\n/**\n * Throws when no registered facade version satisfies a range.\n * @param {string} language - Source language.\n * @param {string} identity - Facade identity.\n * @returns {never} Always throws.\n */\nfunction facadeVersionIncompatible(language, identity) {\n  throw new SemantifoldDiagnostic({\n    code: \"STDLIB_FACADE_VERSION_INCOMPATIBLE\", language,\n    message: `No registered version of facade '${identity}' satisfies the required compatibility range.`\n  })\n}\n\nexport const stdlibFacadeRegistry = createStdlibFacadeRegistry()\n"]}