@typed-sql/compiler 1.0.0 → 2.0.0-rc.1

package/dist/packages/compiler/src/manifest.js

@@ -0,0 +1,628 @@
+import { createHash } from "node:crypto";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { calculateSchemaHash, calculateTypePolicyHash } from "@typed-sql/schema";
+import { compileSource } from "./compiler.js";
+import { extractDynamicQueries, extractStaticQueries } from "./scanner.js";
+export const QUERY_MANIFEST_FORMAT_VERSION = 1;
+export const QUERY_FINGERPRINT_ALGORITHM = "typed-sql-v1";
+const sha256 = (value) => createHash("sha256").update(value).digest("hex");
+const compareText = (left, right) => (left < right ? -1 : left > right ? 1 : 0);
+function portableRelative(rootDir, file) {
+    const root = resolve(rootDir);
+    const path = relative(root, isAbsolute(file) ? resolve(file) : resolve(root, file))
+        .split(sep)
+        .join("/");
+    if (path.length === 0 || isAbsolute(path))
+        throw new TypeError(`Cannot make ${file} relative to ${rootDir}`);
+    return path;
+}
+function isPortableRelativePath(path) {
+    return (path.length > 0 &&
+        !path.startsWith("/") &&
+        !path.startsWith("\\") &&
+        !/^[A-Za-z]:[\\/]/u.test(path) &&
+        !path.includes("\0"));
+}
+function columnDescription(column) {
+    return {
+        name: column.name,
+        tsType: column.tsType,
+        nullable: column.nullable,
+        ...(column.databaseType === undefined ? {} : { databaseType: column.databaseType }),
+    };
+}
+function parameterDescription(parameter) {
+    return {
+        index: parameter.index,
+        tsType: parameter.tsType,
+        nullable: parameter.nullable,
+        ...(parameter.databaseType === undefined ? {} : { databaseType: parameter.databaseType }),
+    };
+}
+function choiceDescriptions(choices) {
+    return Object.fromEntries(Object.entries(choices)
+        .map(([condition, enabled]) => [`sha256:${sha256(condition)}`, enabled])
+        .sort(([left], [right]) => compareText(left, right)));
+}
+function manifestDiagnostic(diagnostic) {
+    return { code: diagnostic.code, severity: diagnostic.severity, range: diagnostic.range };
+}
+function manifestSemantics(semantics) {
+    const evidence = (items) => items.map((item) => ({ kind: item.kind, range: item.range }));
+    const fact = (value) => ({
+        value: value.value,
+        evidence: evidence(value.evidence),
+    });
+    return {
+        version: semantics.version,
+        operation: fact(semantics.operation),
+        dependencies: semantics.dependencies,
+        cardinality: { ...semantics.cardinality, evidence: evidence(semantics.cardinality.evidence) },
+        volatility: fact(semantics.volatility),
+        locking: fact(semantics.locking),
+        connectionAffinity: fact(semantics.connectionAffinity),
+        capabilities: semantics.capabilities,
+    };
+}
+function entryId(dialect, location, identity) {
+    return `sha256:${sha256(`${dialect}\0${location.file}\0${location.range.start}\0${identity}`)}`;
+}
+function inRange(diagnostic, range) {
+    return diagnostic.range.start >= range.start && diagnostic.range.start < range.end;
+}
+function sourceEntries(file, source, options) {
+    const compilation = compileSource({
+        source,
+        dialect: options.dialect,
+        schema: options.schema,
+        ...(options.typePolicy === undefined ? {} : { typePolicy: options.typePolicy }),
+        ...(options.maxStructuralVariants === undefined ? {} : { maxStructuralVariants: options.maxStructuralVariants }),
+    });
+    const extracted = extractStaticQueries(source, (index) => options.dialect.placeholder(index), [
+        options.dialect.sqlModule,
+    ]);
+    const compiledByStart = new Map(compilation.queries.map((query) => [query.query.range.start, query]));
+    const entries = extracted.map((query) => {
+        const location = { file, range: query.range };
+        const compiled = compiledByStart.get(query.range.start);
+        if (compiled === undefined) {
+            const diagnostics = compilation.diagnostics.filter((diagnostic) => inRange(diagnostic, query.range));
+            return {
+                id: entryId(options.dialect.id, location, `unresolved\0${query.sql}`),
+                source: location,
+                status: "unresolved",
+                reason: "diagnostic",
+                diagnostics: diagnostics.map(manifestDiagnostic),
+            };
+        }
+        return {
+            id: entryId(options.dialect.id, location, compiled.fingerprint),
+            source: location,
+            status: "resolved",
+            structural: compiled.structural === true,
+            fingerprint: compiled.fingerprint,
+            rowType: compiled.rowType,
+            parameterType: compiled.parameterType,
+            diagnostics: compilation.diagnostics
+                .filter((diagnostic) => inRange(diagnostic, query.range))
+                .map(manifestDiagnostic),
+            variants: compiled.variants.map((variant) => ({
+                fingerprint: variant.fingerprint,
+                choices: choiceDescriptions(variant.choices),
+                rowType: variant.rowType,
+                parameterType: variant.parameterType,
+                columns: variant.columns.map(columnDescription),
+                parameters: variant.parameters.map(parameterDescription),
+                semantics: manifestSemantics(variant.semantics),
+            })),
+            semantics: manifestSemantics(compiled.semantics),
+        };
+    });
+    for (const dynamic of extractDynamicQueries(source, [options.dialect.sqlModule])) {
+        const location = { file, range: dynamic.range };
+        entries.push({
+            id: entryId(options.dialect.id, location, "dynamic"),
+            source: location,
+            status: "unresolved",
+            reason: "dynamic",
+            diagnostics: [
+                {
+                    code: "TSQ005",
+                    severity: "info",
+                    range: dynamic.range,
+                },
+            ],
+        });
+    }
+    return entries.sort((left, right) => left.source.range.start - right.source.range.start);
+}
+function compatiblePrevious(previous, compilerVersion, dialect, schemaHash, typePolicyHash) {
+    return (previous?.formatVersion === QUERY_MANIFEST_FORMAT_VERSION &&
+        previous.compilerVersion === compilerVersion &&
+        previous.fingerprintAlgorithm === QUERY_FINGERPRINT_ALGORITHM &&
+        previous.dialect.id === dialect.id &&
+        previous.dialect.grammarVersion === dialect.grammarVersion &&
+        previous.schemaHash === schemaHash &&
+        previous.typePolicyHash === typePolicyHash);
+}
+export function buildQueryManifest(options) {
+    if (options.compilerVersion.length === 0)
+        throw new TypeError("compilerVersion must be a non-empty string");
+    if (options.schema.dialect !== options.dialect.id) {
+        throw new TypeError(`Dialect ${options.dialect.id} cannot build a manifest for ${options.schema.dialect}`);
+    }
+    const schemaHash = calculateSchemaHash(options.schema);
+    const typePolicyHash = calculateTypePolicyHash(options.typePolicy ?? {});
+    const inputs = options.sources
+        .map((input) => ({ input, file: portableRelative(options.rootDir, input.file), hash: sha256(input.source) }))
+        .sort((left, right) => compareText(left.file, right.file));
+    const duplicate = inputs.find((input, index) => input.file === inputs[index - 1]?.file);
+    if (duplicate !== undefined)
+        throw new TypeError(`Duplicate manifest source ${duplicate.file}`);
+    const mayReuse = compatiblePrevious(options.previous, options.compilerVersion, options.dialect, schemaHash, typePolicyHash);
+    const previousSources = new Map(options.previous?.sources.map((source) => [source.file, source.hash]) ?? []);
+    const previousEntries = new Map();
+    for (const entry of options.previous?.queries ?? []) {
+        const entries = previousEntries.get(entry.source.file);
+        previousEntries.set(entry.source.file, entries === undefined ? [entry] : [...entries, entry]);
+    }
+    let analyzedFiles = 0;
+    let reusedFiles = 0;
+    const queries = inputs.flatMap(({ input, file, hash }) => {
+        if (mayReuse && previousSources.get(file) === hash) {
+            reusedFiles += 1;
+            return previousEntries.get(file) ?? [];
+        }
+        analyzedFiles += 1;
+        return sourceEntries(file, input.source, options);
+    });
+    queries.sort((left, right) => compareText(left.source.file, right.source.file) || left.source.range.start - right.source.range.start);
+    const projects = [
+        ...new Set((options.projects ?? []).map((project) => portableRelative(options.rootDir, project))),
+    ].sort();
+    const manifest = {
+        formatVersion: QUERY_MANIFEST_FORMAT_VERSION,
+        compilerVersion: options.compilerVersion,
+        fingerprintAlgorithm: QUERY_FINGERPRINT_ALGORITHM,
+        dialect: { id: options.dialect.id, grammarVersion: options.dialect.grammarVersion },
+        schemaHash,
+        typePolicyHash,
+        projects,
+        sources: inputs.map(({ file, hash }) => ({ file, hash })),
+        queries,
+    };
+    return {
+        manifest,
+        stats: {
+            analyzedFiles,
+            reusedFiles,
+            resolvedQueries: queries.filter((query) => query.status === "resolved").length,
+            unresolvedQueries: queries.filter((query) => query.status === "unresolved").length,
+        },
+    };
+}
+function canonicalize(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    if (typeof value !== "object" || value === null)
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .sort(([left], [right]) => compareText(left, right))
+        .map(([key, item]) => [key, canonicalize(item)]));
+}
+export function serializeQueryManifest(manifest) {
+    return `${JSON.stringify(canonicalize(manifest), null, 2)}\n`;
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertString(value, description) {
+    if (typeof value !== "string")
+        throw new TypeError(`${description} must be a string`);
+}
+function assertRange(value, description) {
+    if (!record(value))
+        throw new TypeError(`${description} must be a source range`);
+    for (const property of ["start", "end", "line", "column"]) {
+        const minimum = property === "line" || property === "column" ? 1 : 0;
+        if (!Number.isSafeInteger(value[property]) || value[property] < minimum) {
+            throw new TypeError(`${description}.${property} must be a safe integer greater than or equal to ${minimum}`);
+        }
+    }
+    if (value.end < value.start)
+        throw new TypeError(`${description}.end must not precede start`);
+}
+function assertDiagnostics(value, description) {
+    if (!Array.isArray(value))
+        throw new TypeError(`${description} must be an array`);
+    for (const diagnostic of value) {
+        if (!record(diagnostic))
+            throw new TypeError(`${description} entries must be objects`);
+        assertString(diagnostic.code, `${description} code`);
+        if (!["error", "warning", "info"].includes(diagnostic.severity)) {
+            throw new TypeError(`${description} severity is unsupported`);
+        }
+        assertRange(diagnostic.range, `${description} range`);
+    }
+}
+function assertEvidence(value, description) {
+    if (!Array.isArray(value))
+        throw new TypeError(`${description} must be an array`);
+    for (const evidence of value) {
+        if (!record(evidence) || !["syntax", "schema", "conservative"].includes(evidence.kind)) {
+            throw new TypeError(`${description} contains unsupported evidence`);
+        }
+        assertRange(evidence.range, `${description} range`);
+    }
+}
+function assertFact(value, allowed, description) {
+    if (!record(value) || typeof value.value !== "string" || !allowed.includes(value.value)) {
+        throw new TypeError(`${description} contains an unsupported value`);
+    }
+    assertEvidence(value.evidence, `${description} evidence`);
+}
+function assertSemantics(value, description) {
+    if (!record(value) || value.version !== 1)
+        throw new TypeError(`${description} must use semantics version 1`);
+    assertFact(value.operation, ["read", "write", "ddl", "transaction-control", "unknown"], `${description} operation`);
+    assertFact(value.volatility, ["immutable", "stable", "volatile", "unknown"], `${description} volatility`);
+    assertFact(value.locking, ["none", "row", "table", "unknown"], `${description} locking`);
+    assertFact(value.connectionAffinity, ["none", "transaction", "session", "unknown"], `${description} affinity`);
+    if (!record(value.cardinality) || (value.cardinality.minimum !== 0 && value.cardinality.minimum !== 1)) {
+        throw new TypeError(`${description} cardinality is invalid`);
+    }
+    if (![0, 1, "many", "unknown"].includes(value.cardinality.maximum)) {
+        throw new TypeError(`${description} cardinality maximum is invalid`);
+    }
+    assertEvidence(value.cardinality.evidence, `${description} cardinality evidence`);
+    if (!Array.isArray(value.dependencies))
+        throw new TypeError(`${description} dependencies must be an array`);
+    for (const dependency of value.dependencies) {
+        if (!record(dependency))
+            throw new TypeError(`${description} dependencies must contain objects`);
+        for (const property of ["kind", "access", "name", "certainty"]) {
+            assertString(dependency[property], `${description} dependency ${property}`);
+        }
+        if (!["relation", "column", "function", "type", "sequence", "unknown"].includes(dependency.kind) ||
+            !["read", "write", "execute", "reference", "unknown"].includes(dependency.access) ||
+            !["resolved", "syntactic"].includes(dependency.certainty)) {
+            throw new TypeError(`${description} dependency classification is unsupported`);
+        }
+        if (dependency.schema !== undefined)
+            assertString(dependency.schema, `${description} dependency schema`);
+        if (dependency.parent !== undefined)
+            assertString(dependency.parent, `${description} dependency parent`);
+        assertRange(dependency.range, `${description} dependency range`);
+    }
+    if (!Array.isArray(value.capabilities) || value.capabilities.some((capability) => typeof capability !== "string")) {
+        throw new TypeError(`${description} capabilities must contain strings`);
+    }
+}
+function assertVariant(value, description) {
+    if (!record(value))
+        throw new TypeError(`${description} must be an object`);
+    assertString(value.fingerprint, `${description}.fingerprint`);
+    assertString(value.rowType, `${description}.rowType`);
+    assertString(value.parameterType, `${description}.parameterType`);
+    if (!/^sha256:[a-f\d]{64}$/u.test(value.fingerprint)) {
+        throw new TypeError(`${description}.fingerprint must use SHA-256`);
+    }
+    if (!record(value.choices) ||
+        Object.entries(value.choices).some(([choice, enabled]) => !/^sha256:[a-f\d]{64}$/u.test(choice) || typeof enabled !== "boolean")) {
+        throw new TypeError(`${description}.choices must contain booleans`);
+    }
+    if (!Array.isArray(value.columns) || !Array.isArray(value.parameters)) {
+        throw new TypeError(`${description} columns and parameters must be arrays`);
+    }
+    for (const column of value.columns) {
+        if (!record(column) || typeof column.nullable !== "boolean") {
+            throw new TypeError(`${description} columns are invalid`);
+        }
+        assertString(column.name, `${description} column name`);
+        assertString(column.tsType, `${description} column tsType`);
+        if (column.databaseType !== undefined)
+            assertString(column.databaseType, `${description} column databaseType`);
+    }
+    for (const parameter of value.parameters) {
+        if (!record(parameter) ||
+            !Number.isSafeInteger(parameter.index) ||
+            parameter.index < 1 ||
+            typeof parameter.nullable !== "boolean") {
+            throw new TypeError(`${description} parameters are invalid`);
+        }
+        assertString(parameter.tsType, `${description} parameter tsType`);
+        if (parameter.databaseType !== undefined) {
+            assertString(parameter.databaseType, `${description} parameter databaseType`);
+        }
+    }
+    assertSemantics(value.semantics, `${description} semantics`);
+}
+export function parseQueryManifest(value) {
+    if (!record(value))
+        throw new TypeError("Query manifest must be an object");
+    if (value.formatVersion !== QUERY_MANIFEST_FORMAT_VERSION) {
+        throw new TypeError(`Unsupported query manifest format ${String(value.formatVersion)}; this release supports format ${QUERY_MANIFEST_FORMAT_VERSION}`);
+    }
+    if (typeof value.compilerVersion !== "string" || value.compilerVersion.length === 0) {
+        throw new TypeError("Query manifest compilerVersion must be a non-empty string");
+    }
+    if (value.fingerprintAlgorithm !== QUERY_FINGERPRINT_ALGORITHM) {
+        throw new TypeError(`Unsupported query fingerprint algorithm ${String(value.fingerprintAlgorithm)}`);
+    }
+    if (!record(value.dialect) ||
+        typeof value.dialect.id !== "string" ||
+        value.dialect.id.length === 0 ||
+        typeof value.dialect.grammarVersion !== "string" ||
+        value.dialect.grammarVersion.length === 0) {
+        throw new TypeError("Query manifest dialect must contain id and grammarVersion");
+    }
+    if (typeof value.schemaHash !== "string" ||
+        !/^[a-f\d]{64}$/u.test(value.schemaHash) ||
+        typeof value.typePolicyHash !== "string" ||
+        !/^[a-f\d]{64}$/u.test(value.typePolicyHash)) {
+        throw new TypeError("Query manifest schemaHash and typePolicyHash must be strings");
+    }
+    if (!Array.isArray(value.projects) || !Array.isArray(value.sources) || !Array.isArray(value.queries)) {
+        throw new TypeError("Query manifest projects, sources, and queries must be arrays");
+    }
+    if (value.projects.some((project) => typeof project !== "string" || !isPortableRelativePath(project))) {
+        throw new TypeError("Query manifest projects must contain relative paths");
+    }
+    for (const source of value.sources) {
+        if (!record(source) ||
+            typeof source.file !== "string" ||
+            !isPortableRelativePath(source.file) ||
+            typeof source.hash !== "string" ||
+            !/^[a-f\d]{64}$/u.test(source.hash)) {
+            throw new TypeError("Query manifest sources must contain relative file paths and hashes");
+        }
+    }
+    for (const query of value.queries) {
+        if (!record(query) ||
+            typeof query.id !== "string" ||
+            !/^sha256:[a-f\d]{64}$/u.test(query.id) ||
+            !record(query.source)) {
+            throw new TypeError("Query manifest entries must contain id and source");
+        }
+        const location = query.source;
+        if (typeof location.file !== "string" || !isPortableRelativePath(location.file) || !record(location.range)) {
+            throw new TypeError("Query manifest entry sources must contain a relative file and range");
+        }
+        assertRange(location.range, "Query manifest source range");
+        if (query.status === "resolved") {
+            if (typeof query.fingerprint !== "string" ||
+                !/^sha256:[a-f\d]{64}$/u.test(query.fingerprint) ||
+                typeof query.rowType !== "string" ||
+                typeof query.parameterType !== "string" ||
+                typeof query.structural !== "boolean" ||
+                !Array.isArray(query.variants) ||
+                query.variants.length === 0) {
+                throw new TypeError("Resolved query manifest entries are incomplete");
+            }
+            assertDiagnostics(query.diagnostics, "Resolved query diagnostics");
+            for (const [index, variant] of query.variants.entries()) {
+                assertVariant(variant, `Query manifest variant ${index}`);
+            }
+            assertSemantics(query.semantics, "Resolved query semantics");
+        }
+        else if (query.status === "unresolved") {
+            if (query.reason !== "diagnostic" && query.reason !== "dynamic") {
+                throw new TypeError("Unresolved query manifest entries are incomplete");
+            }
+            assertDiagnostics(query.diagnostics, "Unresolved query diagnostics");
+            if (query.diagnostics.length === 0)
+                throw new TypeError("Unresolved query diagnostics cannot be empty");
+        }
+        else
+            throw new TypeError(`Unsupported query manifest entry status ${String(query.status)}`);
+    }
+    return value;
+}
+/** Machine-readable public contract. Readers accept unknown object properties within format v1. */
+export const QUERY_MANIFEST_JSON_SCHEMA = Object.freeze({
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "urn:typed-sql:query-manifest:1",
+    title: "typed-sql query manifest",
+    type: "object",
+    $defs: {
+        relativePath: { type: "string", minLength: 1, pattern: "^(?!/|\\\\|[A-Za-z]:[\\\\/])(?!.*\\u0000).+$" },
+        hash: { type: "string", pattern: "^[a-f0-9]{64}$" },
+        fingerprint: { type: "string", pattern: "^sha256:[a-f0-9]{64}$" },
+        range: {
+            type: "object",
+            required: ["start", "end", "line", "column"],
+            properties: {
+                start: { type: "integer", minimum: 0 },
+                end: { type: "integer", minimum: 0 },
+                line: { type: "integer", minimum: 1 },
+                column: { type: "integer", minimum: 1 },
+            },
+        },
+        diagnostic: {
+            type: "object",
+            required: ["code", "range", "severity"],
+            properties: {
+                code: { type: "string" },
+                range: { $ref: "#/$defs/range" },
+                severity: { enum: ["error", "warning", "info"] },
+            },
+        },
+        evidence: {
+            type: "object",
+            required: ["kind", "range"],
+            properties: {
+                kind: { enum: ["syntax", "schema", "conservative"] },
+                range: { $ref: "#/$defs/range" },
+            },
+        },
+        fact: {
+            type: "object",
+            required: ["value", "evidence"],
+            properties: {
+                value: { type: "string" },
+                evidence: { type: "array", items: { $ref: "#/$defs/evidence" } },
+            },
+        },
+        dependency: {
+            type: "object",
+            required: ["kind", "access", "name", "certainty", "range"],
+            properties: {
+                kind: { enum: ["relation", "column", "function", "type", "sequence", "unknown"] },
+                access: { enum: ["read", "write", "execute", "reference", "unknown"] },
+                name: { type: "string" },
+                schema: { type: "string" },
+                parent: { type: "string" },
+                certainty: { enum: ["resolved", "syntactic"] },
+                range: { $ref: "#/$defs/range" },
+            },
+        },
+        semantics: {
+            type: "object",
+            required: [
+                "version",
+                "operation",
+                "dependencies",
+                "cardinality",
+                "volatility",
+                "locking",
+                "connectionAffinity",
+                "capabilities",
+            ],
+            properties: {
+                version: { const: 1 },
+                operation: { $ref: "#/$defs/fact" },
+                dependencies: { type: "array", items: { $ref: "#/$defs/dependency" } },
+                cardinality: {
+                    type: "object",
+                    required: ["minimum", "maximum", "evidence"],
+                    properties: {
+                        minimum: { enum: [0, 1] },
+                        maximum: { enum: [0, 1, "many", "unknown"] },
+                        evidence: { type: "array", items: { $ref: "#/$defs/evidence" } },
+                    },
+                },
+                volatility: { $ref: "#/$defs/fact" },
+                locking: { $ref: "#/$defs/fact" },
+                connectionAffinity: { $ref: "#/$defs/fact" },
+                capabilities: { type: "array", items: { type: "string" } },
+            },
+        },
+        column: {
+            type: "object",
+            required: ["name", "tsType", "nullable"],
+            properties: {
+                name: { type: "string" },
+                tsType: { type: "string" },
+                nullable: { type: "boolean" },
+                databaseType: { type: "string" },
+            },
+        },
+        parameter: {
+            type: "object",
+            required: ["index", "tsType", "nullable"],
+            properties: {
+                index: { type: "integer", minimum: 1 },
+                tsType: { type: "string" },
+                nullable: { type: "boolean" },
+                databaseType: { type: "string" },
+            },
+        },
+        variant: {
+            type: "object",
+            required: ["fingerprint", "choices", "rowType", "parameterType", "columns", "parameters", "semantics"],
+            properties: {
+                fingerprint: { $ref: "#/$defs/fingerprint" },
+                choices: {
+                    type: "object",
+                    propertyNames: { $ref: "#/$defs/fingerprint" },
+                    additionalProperties: { type: "boolean" },
+                },
+                rowType: { type: "string" },
+                parameterType: { type: "string" },
+                columns: { type: "array", items: { $ref: "#/$defs/column" } },
+                parameters: { type: "array", items: { $ref: "#/$defs/parameter" } },
+                semantics: { $ref: "#/$defs/semantics" },
+            },
+        },
+        location: {
+            type: "object",
+            required: ["file", "range"],
+            properties: { file: { $ref: "#/$defs/relativePath" }, range: { $ref: "#/$defs/range" } },
+        },
+        resolvedQuery: {
+            type: "object",
+            required: [
+                "id",
+                "source",
+                "status",
+                "structural",
+                "fingerprint",
+                "rowType",
+                "parameterType",
+                "diagnostics",
+                "variants",
+                "semantics",
+            ],
+            properties: {
+                id: { $ref: "#/$defs/fingerprint" },
+                source: { $ref: "#/$defs/location" },
+                status: { const: "resolved" },
+                structural: { type: "boolean" },
+                fingerprint: { $ref: "#/$defs/fingerprint" },
+                rowType: { type: "string" },
+                parameterType: { type: "string" },
+                diagnostics: { type: "array", items: { $ref: "#/$defs/diagnostic" } },
+                variants: { type: "array", minItems: 1, items: { $ref: "#/$defs/variant" } },
+                semantics: { $ref: "#/$defs/semantics" },
+            },
+        },
+        unresolvedQuery: {
+            type: "object",
+            required: ["id", "source", "status", "reason", "diagnostics"],
+            properties: {
+                id: { $ref: "#/$defs/fingerprint" },
+                source: { $ref: "#/$defs/location" },
+                status: { const: "unresolved" },
+                reason: { enum: ["diagnostic", "dynamic"] },
+                diagnostics: { type: "array", minItems: 1, items: { $ref: "#/$defs/diagnostic" } },
+            },
+        },
+    },
+    required: [
+        "formatVersion",
+        "compilerVersion",
+        "fingerprintAlgorithm",
+        "dialect",
+        "schemaHash",
+        "typePolicyHash",
+        "projects",
+        "sources",
+        "queries",
+    ],
+    properties: {
+        formatVersion: { const: QUERY_MANIFEST_FORMAT_VERSION },
+        compilerVersion: { type: "string", minLength: 1 },
+        fingerprintAlgorithm: { const: QUERY_FINGERPRINT_ALGORITHM },
+        dialect: {
+            type: "object",
+            required: ["id", "grammarVersion"],
+            properties: { id: { type: "string" }, grammarVersion: { type: "string" } },
+        },
+        schemaHash: { type: "string" },
+        typePolicyHash: { type: "string" },
+        projects: { type: "array", items: { $ref: "#/$defs/relativePath" } },
+        sources: {
+            type: "array",
+            items: {
+                type: "object",
+                required: ["file", "hash"],
+                properties: { file: { $ref: "#/$defs/relativePath" }, hash: { $ref: "#/$defs/hash" } },
+            },
+        },
+        queries: {
+            type: "array",
+            items: { oneOf: [{ $ref: "#/$defs/resolvedQuery" }, { $ref: "#/$defs/unresolvedQuery" }] },
+        },
+    },
+});
+//# sourceMappingURL=manifest.js.map