@reasonlayer/sdk 0.0.1-rc.3

package/dist/selector-schema.js

@@ -0,0 +1,780 @@
+/**
+ * Proves that selector-produced review drafts satisfy their decision schemas.
+ *
+ * Reviews are the first consumer. The same type-erasure hole exists for code
+ * step inputs and the workflow output; this module can grow to check every
+ * step input and the workflow output. Move it to @reasonlayer/protocol if the
+ * backend ever needs to validate manually uploaded IR.
+ */
+import { validateAgainstSchema } from "@reasonlayer/protocol";
+const UNSUPPORTED_KEYWORDS = [
+    "$ref",
+    "$defs",
+    "$dynamicRef",
+    "definitions",
+    "allOf",
+    "oneOf",
+    "not",
+    "if",
+    "then",
+    "else",
+    "prefixItems",
+    "contains",
+    "patternProperties",
+    "propertyNames",
+    "dependentRequired",
+    "dependentSchemas",
+    "unevaluatedItems",
+    "unevaluatedProperties",
+];
+const METADATA_KEYWORDS = new Set([
+    "$schema",
+    "$id",
+    "$comment",
+    "title",
+    "description",
+    "default",
+    "examples",
+    "deprecated",
+    "readOnly",
+    "writeOnly",
+]);
+function unprovable(location, detail) {
+    return `compatibility cannot be proven at ${location}: ${detail}; reshape the selection or simplify the schema`;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasOwn(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key);
+}
+function schemaRecord(value) {
+    return isRecord(value) ? value : undefined;
+}
+function schemaBranches(schema) {
+    if (Array.isArray(schema["anyOf"])) {
+        const branches = schema["anyOf"].map(schemaRecord);
+        return branches.every((branch) => branch !== undefined)
+            ? branches
+            : undefined;
+    }
+    const type = schema["type"];
+    if (Array.isArray(type) && type.every((entry) => typeof entry === "string")) {
+        return type.map((entry) => ({ ...schema, type: entry }));
+    }
+    return undefined;
+}
+function unsupportedIssue(schema, location, side) {
+    for (const keyword of UNSUPPORTED_KEYWORDS) {
+        if (keyword in schema) {
+            return unprovable(location, `${side} schema uses unsupported "${keyword}"`);
+        }
+    }
+    if ("anyOf" in schema) {
+        if (schemaBranches(schema) === undefined) {
+            return unprovable(location, `${side} schema has an invalid "anyOf"`);
+        }
+        const sibling = Object.keys(schema).find((key) => key !== "anyOf" && !METADATA_KEYWORDS.has(key));
+        if (sibling) {
+            return unprovable(location, `${side} schema combines "anyOf" with unsupported sibling constraint "${sibling}"`);
+        }
+    }
+    const type = schema["type"];
+    if (Array.isArray(type) &&
+        (type.length === 0 || !type.every((entry) => typeof entry === "string"))) {
+        return unprovable(location, `${side} schema has an invalid "type" array`);
+    }
+    const values = schema["enum"];
+    if ("enum" in schema && (!Array.isArray(values) || values.length === 0)) {
+        return unprovable(location, `${side} schema has an invalid "enum"`);
+    }
+    const nested = [];
+    const properties = schema["properties"];
+    if (isRecord(properties)) {
+        for (const [key, value] of Object.entries(properties)) {
+            const child = schemaRecord(value);
+            if (child)
+                nested.push([`${location}.${key}`, child]);
+        }
+    }
+    const additional = schemaRecord(schema["additionalProperties"]);
+    if (additional)
+        nested.push([`${location}.*`, additional]);
+    const items = schema["items"];
+    if (Array.isArray(items)) {
+        for (const [index, value] of items.entries()) {
+            const child = schemaRecord(value);
+            if (child)
+                nested.push([`${location}[${index}]`, child]);
+        }
+    }
+    else {
+        const child = schemaRecord(items);
+        if (child)
+            nested.push([`${location}[]`, child]);
+    }
+    if (Array.isArray(schema["anyOf"])) {
+        for (const [index, value] of schema["anyOf"].entries()) {
+            const child = schemaRecord(value);
+            if (child)
+                nested.push([`${location} (branch ${index + 1})`, child]);
+        }
+    }
+    for (const [childLocation, child] of nested) {
+        const issue = unsupportedIssue(child, childLocation, side);
+        if (issue)
+            return issue;
+    }
+    return undefined;
+}
+function schemaType(schema) {
+    const type = schema["type"];
+    if (typeof type === "string")
+        return type;
+    if ("const" in schema)
+        return valueType(schema["const"]);
+    const values = schema["enum"];
+    if (Array.isArray(values) && values.length > 0) {
+        const types = new Set(values.map(valueType));
+        if (types.size === 1)
+            return [...types][0];
+    }
+    return undefined;
+}
+function valueType(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    switch (typeof value) {
+        case "string":
+        case "boolean":
+            return typeof value;
+        case "number":
+            return Number.isInteger(value) ? "integer" : "number";
+        case "object":
+            return "object";
+        default:
+            return undefined;
+    }
+}
+function typeLabel(schema) {
+    const type = schemaType(schema);
+    return type ? `an ${type}` : "the declared schema";
+}
+function selectorLabel(selector) {
+    switch (selector.kind) {
+        case "input":
+            return pathLabel("input", selector.path);
+        case "step":
+            return pathLabel(`steps.${selector.stepId}`, selector.path);
+        case "variable":
+            return pathLabel(`variables.${selector.name}`, selector.path);
+        case "mapItem":
+            return pathLabel("mapItem", selector.path);
+        default:
+            return "input";
+    }
+}
+function pathLabel(root, path) {
+    return path.reduce((label, segment) => (/^(0|[1-9]\d*)$/.test(segment) ? `${label}[${segment}]` : `${label}.${segment}`), root);
+}
+function propertiesOf(schema) {
+    const raw = schema["properties"];
+    if (raw === undefined)
+        return Object.create(null);
+    if (!isRecord(raw))
+        return undefined;
+    const entries = Object.entries(raw).map(([key, value]) => [key, schemaRecord(value)]);
+    if (entries.some(([, value]) => value === undefined))
+        return undefined;
+    return Object.assign(Object.create(null), Object.fromEntries(entries));
+}
+function requiredOf(schema) {
+    const raw = schema["required"];
+    if (raw === undefined)
+        return [];
+    return Array.isArray(raw) && raw.every((entry) => typeof entry === "string") ? raw : undefined;
+}
+function semanticKeywords(schema) {
+    return Object.keys(schema).filter((key) => !METADATA_KEYWORDS.has(key));
+}
+function unsupportedExtraKeyword(schema, allowed, location, side) {
+    const allowedSet = new Set(allowed);
+    const keyword = semanticKeywords(schema).find((key) => !allowedSet.has(key));
+    return keyword
+        ? unprovable(location, `${side} schema uses unsupported keyword "${keyword}"`)
+        : undefined;
+}
+function compatibilityKeywordIssue(schema, location, side) {
+    const unsupported = unsupportedIssue(schema, location, side);
+    if (unsupported)
+        return unsupported;
+    const branches = schemaBranches(schema);
+    if (branches) {
+        for (const [index, branch] of branches.entries()) {
+            const issue = compatibilityKeywordIssue(branch, `${location} (branch ${index + 1})`, side);
+            if (issue)
+                return issue;
+        }
+        return undefined;
+    }
+    const type = schemaType(schema);
+    const allowed = type === "object"
+        ? ["type", "properties", "required", "additionalProperties", "const", "enum"]
+        : type === "array"
+            ? ["type", "items", "const", "enum"]
+            : ["type", "const", "enum"];
+    const extra = unsupportedExtraKeyword(schema, allowed, location, side);
+    if (extra)
+        return extra;
+    if (type === "object") {
+        const properties = propertiesOf(schema);
+        const required = requiredOf(schema);
+        if (!properties || !required) {
+            return unprovable(location, `${side} object schema has invalid properties or required fields`);
+        }
+        const additional = schema["additionalProperties"];
+        if (additional !== undefined &&
+            additional !== true &&
+            additional !== false &&
+            !schemaRecord(additional)) {
+            return unprovable(location, `${side} object schema has invalid additionalProperties`);
+        }
+        for (const [key, property] of Object.entries(properties)) {
+            const issue = compatibilityKeywordIssue(property, `${location}.${key}`, side);
+            if (issue)
+                return issue;
+        }
+        const additionalSchema = schemaRecord(additional);
+        if (additionalSchema) {
+            const issue = compatibilityKeywordIssue(additionalSchema, `${location}.*`, side);
+            if (issue)
+                return issue;
+        }
+    }
+    if (type === "array") {
+        const items = schema["items"];
+        if (Array.isArray(items)) {
+            return unprovable(location, `${side} schema uses tuple-form "items"`);
+        }
+        const itemSchema = schemaRecord(items);
+        if (itemSchema) {
+            const issue = compatibilityKeywordIssue(itemSchema, `${location}[]`, side);
+            if (issue)
+                return issue;
+        }
+    }
+    return undefined;
+}
+function walkSchema(schema, path, label) {
+    if (path.length === 0)
+        return { schema, issues: [] };
+    const unsupported = unsupportedIssue(schema, label, "source");
+    if (unsupported)
+        return { issues: [unsupported] };
+    const branches = schemaBranches(schema);
+    if (branches) {
+        const walked = branches.map((branch) => walkSchema(branch, path, label));
+        const issue = walked.find((result) => result.issues.length > 0);
+        if (issue)
+            return { issues: issue.issues };
+        return {
+            schema: { anyOf: walked.map((result) => result.schema) },
+            issues: [],
+        };
+    }
+    const [segment, ...rest] = path;
+    const type = schemaType(schema);
+    if (type === "object") {
+        const properties = propertiesOf(schema);
+        const required = requiredOf(schema);
+        if (!properties || !required) {
+            return { issues: [unprovable(label, "source object schema has invalid properties or required fields")] };
+        }
+        let property = hasOwn(properties, segment) ? properties[segment] : undefined;
+        if (!property && !required.includes(segment)) {
+            return {
+                issues: [`${pathLabel(label, path.slice(0, 1))}: schema has no property "${segment}"`],
+            };
+        }
+        if (property && !required.includes(segment)) {
+            return {
+                issues: [unprovable(pathLabel(label, [segment]), `source property "${segment}" is optional`)],
+            };
+        }
+        if (!property) {
+            property = schemaRecord(schema["additionalProperties"]);
+            if (!property) {
+                return {
+                    issues: [
+                        unprovable(pathLabel(label, [segment]), `source property "${segment}" has no declared value schema`),
+                    ],
+                };
+            }
+        }
+        return walkSchema(property, rest, pathLabel(label, [segment]));
+    }
+    if (type === "array") {
+        if (!/^(0|[1-9]\d*)$/.test(segment)) {
+            return { issues: [`${label}: array schema cannot select property "${segment}"`] };
+        }
+        const index = Number(segment);
+        const minItems = schema["minItems"];
+        if (typeof minItems !== "number" || !Number.isInteger(minItems) || minItems <= index) {
+            return {
+                issues: [
+                    unprovable(pathLabel(label, [segment]), `source array does not guarantee that index ${segment} exists`),
+                ],
+            };
+        }
+        const items = schema["items"];
+        if (Array.isArray(items)) {
+            return { issues: [unprovable(label, "source schema uses tuple-form \"items\"")] };
+        }
+        const itemSchema = schemaRecord(items);
+        if (!itemSchema) {
+            return { issues: [unprovable(label, "source array schema does not declare its items")] };
+        }
+        return walkSchema(itemSchema, rest, pathLabel(label, [segment]));
+    }
+    return {
+        issues: [`${label}: cannot select property "${segment}" from ${type ? `a ${type}` : "this schema"}`],
+    };
+}
+/** Resolve a wire-reference selector to its declared source schema. */
+export function resolveSelectorSchema(selector, context) {
+    let source;
+    switch (selector.kind) {
+        case "input":
+            source = context.inputSchema;
+            break;
+        case "step":
+            source = hasOwn(context.stepSchemas, selector.stepId)
+                ? context.stepSchemas[selector.stepId]
+                : undefined;
+            if (!source) {
+                return { issues: [unprovable(selectorLabel(selector), "the referenced step has no output schema")] };
+            }
+            break;
+        case "variable":
+            source =
+                context.variableSchemas && hasOwn(context.variableSchemas, selector.name)
+                    ? context.variableSchemas[selector.name]
+                    : undefined;
+            if (!source) {
+                return { issues: [unprovable(selectorLabel(selector), "the variable has no declared schema")] };
+            }
+            break;
+        case "mapItem":
+            source = context.mapItemSchema;
+            if (!source) {
+                return { issues: [unprovable(selectorLabel(selector), "the map item schema is unavailable")] };
+            }
+            break;
+        case "literal":
+        case "object":
+        case "array":
+            return {
+                issues: [unprovable("input", "a composed selector has no single declared source schema")],
+            };
+    }
+    const root = selector.kind === "step"
+        ? `steps.${selector.stepId}`
+        : selector.kind === "variable"
+            ? `variables.${selector.name}`
+            : selector.kind;
+    return walkSchema(source, selector.path, root);
+}
+function unionOf(schemas) {
+    return schemas.length === 1 ? schemas[0] : { anyOf: schemas };
+}
+/** Synthesize the schema a composed selector produces at run time. */
+function synthesizeSelectorSchema(selector, context) {
+    switch (selector.kind) {
+        case "input":
+        case "step":
+        case "variable":
+        case "mapItem":
+            return resolveSelectorSchema(selector, context);
+        case "literal":
+            // lower() only emits scalar or null literals; containers become object/array selectors.
+            return { schema: { const: selector.value }, issues: [] };
+        case "object": {
+            const properties = {};
+            for (const [key, field] of Object.entries(selector.fields)) {
+                const resolved = synthesizeSelectorSchema(field, context);
+                if (!resolved.schema)
+                    return resolved;
+                properties[key] = resolved.schema;
+            }
+            return {
+                schema: {
+                    type: "object",
+                    properties,
+                    required: Object.keys(selector.fields),
+                    additionalProperties: false,
+                },
+                issues: [],
+            };
+        }
+        case "array": {
+            const items = selector.items.map((item) => synthesizeSelectorSchema(item, context));
+            const failed = items.find((item) => !item.schema);
+            if (failed)
+                return failed;
+            return {
+                schema: { type: "array", items: unionOf(items.map((item) => item.schema)) },
+                issues: [],
+            };
+        }
+    }
+}
+/** Resolve the item schema of an array-valued selector, composed or referenced. */
+export function resolveSelectorArrayItemSchema(selector, context) {
+    if (selector.kind === "array") {
+        const items = selector.items.map((item) => synthesizeSelectorSchema(item, context));
+        const failed = items.find((item) => !item.schema);
+        if (failed)
+            return failed;
+        return { schema: unionOf(items.map((item) => item.schema)), issues: [] };
+    }
+    if (selector.kind === "object") {
+        return { issues: ["the composed value is an object, but map over expects an array"] };
+    }
+    if (selector.kind === "literal") {
+        return {
+            issues: [
+                `the literal ${JSON.stringify(selector.value)} is not an array, but map over expects an array`,
+            ],
+        };
+    }
+    const resolved = resolveSelectorSchema(selector, context);
+    if (!resolved.schema)
+        return resolved;
+    const location = selectorLabel(selector);
+    const extract = (schema) => {
+        const unsupported = unsupportedIssue(schema, location, "source");
+        if (unsupported)
+            return { issues: [unsupported] };
+        const branches = schemaBranches(schema);
+        if (branches) {
+            const items = branches.map(extract);
+            const failed = items.find((item) => !item.schema);
+            if (failed)
+                return failed;
+            return { schema: { anyOf: items.map((item) => item.schema) }, issues: [] };
+        }
+        if (schemaType(schema) !== "array") {
+            return { issues: [`${location} is ${typeLabel(schema)}, but map over expects an array`] };
+        }
+        if (Array.isArray(schema["items"])) {
+            return { issues: [unprovable(location, "source schema uses tuple-form \"items\"")] };
+        }
+        const itemSchema = schemaRecord(schema["items"]);
+        return itemSchema
+            ? { schema: itemSchema, issues: [] }
+            : { issues: [unprovable(location, "source array schema does not declare its items")] };
+    };
+    return extract(resolved.schema);
+}
+function deepEqual(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (Array.isArray(left) && Array.isArray(right)) {
+        return left.length === right.length && left.every((value, index) => deepEqual(value, right[index]));
+    }
+    if (isRecord(left) && isRecord(right)) {
+        const leftKeys = Object.keys(left).sort();
+        const rightKeys = Object.keys(right).sort();
+        return (leftKeys.length === rightKeys.length &&
+            leftKeys.every((key, index) => key === rightKeys[index] && deepEqual(left[key], right[key])));
+    }
+    return false;
+}
+function valuesAllowedBy(schema) {
+    if ("const" in schema)
+        return [schema["const"]];
+    return Array.isArray(schema["enum"]) ? schema["enum"] : undefined;
+}
+function schemaAccepts(schema, value) {
+    try {
+        validateAgainstSchema(value, schema, "value");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function finiteSourceCompatible(source, target, location) {
+    let candidates = valuesAllowedBy(source);
+    if (!candidates)
+        return undefined;
+    const enumValues = source["enum"];
+    if ("const" in source && Array.isArray(enumValues)) {
+        candidates = candidates.filter((candidate) => enumValues.some((enumValue) => deepEqual(candidate, enumValue)));
+    }
+    const declaredTypes = typeof source["type"] === "string"
+        ? [source["type"]]
+        : Array.isArray(source["type"])
+            ? source["type"]
+            : undefined;
+    if (declaredTypes) {
+        candidates = candidates.filter((candidate) => {
+            const candidateType = valueType(candidate);
+            return declaredTypes.some((declaredType) => declaredType === candidateType ||
+                (declaredType === "number" && candidateType === "integer"));
+        });
+    }
+    // Container const/enum equality is validator-dependent. Fall back to the
+    // structural checker rather than treating the listed container as exhaustive;
+    // remove this fallback if the shared validator guarantees JSON container equality.
+    if (candidates.some((candidate) => candidate !== null && typeof candidate === "object")) {
+        return undefined;
+    }
+    const outside = candidates.find((value) => !schemaAccepts(target, value));
+    return outside === undefined
+        ? []
+        : [`${location} allows ${JSON.stringify(outside)}, which the output schema does not allow`];
+}
+function primitiveCompatible(source, target, location) {
+    const sourceValues = valuesAllowedBy(source);
+    const targetValues = valuesAllowedBy(target);
+    if (targetValues) {
+        if (!sourceValues)
+            return [`${location} can contain values outside the output schema's allowed values`];
+        const outside = sourceValues.find((sourceValue) => !targetValues.some((targetValue) => deepEqual(sourceValue, targetValue)));
+        return outside === undefined
+            ? []
+            : [`${location} allows ${JSON.stringify(outside)}, which the output schema does not allow`];
+    }
+    const sourceType = schemaType(source);
+    const targetType = schemaType(target);
+    if (!sourceType)
+        return [unprovable(location, "source schema does not declare a type")];
+    if (!targetType)
+        return [unprovable(location, "output schema does not declare a type")];
+    if (sourceType === targetType || (sourceType === "integer" && targetType === "number"))
+        return [];
+    return [`${location} is ${typeLabel(source)}, but output expects ${typeLabel(target)}`];
+}
+function satisfies(source, target, location) {
+    // `{}` is the accept-all target. It is also schemaToJson's error sentinel;
+    // conversion already records a compile error, so this vacuous pass cannot hide success.
+    if (semanticKeywords(target).length === 0)
+        return [];
+    const targetKeywordIssue = compatibilityKeywordIssue(target, location, "output");
+    if (targetKeywordIssue)
+        return [targetKeywordIssue];
+    const sourceKeywordIssue = compatibilityKeywordIssue(source, location, "source");
+    if (sourceKeywordIssue)
+        return [sourceKeywordIssue];
+    const finiteCompatibility = finiteSourceCompatible(source, target, location);
+    if (finiteCompatibility)
+        return finiteCompatibility;
+    const sourceBranches = schemaBranches(source);
+    if (sourceBranches) {
+        return sourceBranches.flatMap((branch, index) => satisfies(branch, target, `${location} (source branch ${index + 1})`));
+    }
+    const targetBranches = schemaBranches(target);
+    if (targetBranches) {
+        if (targetBranches.length === 0) {
+            return [`${location} cannot satisfy an output schema that allows no values`];
+        }
+        const attempts = targetBranches.map((branch) => satisfies(source, branch, location));
+        if (attempts.some((issues) => issues.length === 0))
+            return [];
+        return attempts.sort((left, right) => left.length - right.length)[0] ?? [];
+    }
+    const sourceType = schemaType(source);
+    const targetType = schemaType(target);
+    if (targetType === "object") {
+        if (sourceType !== "object") {
+            return [`${location} is ${typeLabel(source)}, but output expects an object`];
+        }
+        const sourceKeywordIssue = unsupportedExtraKeyword(source, ["type", "properties", "required", "additionalProperties"], location, "source");
+        if (sourceKeywordIssue)
+            return [sourceKeywordIssue];
+        const targetKeywordIssue = unsupportedExtraKeyword(target, ["type", "properties", "required", "additionalProperties"], location, "output");
+        if (targetKeywordIssue)
+            return [targetKeywordIssue];
+        const sourceProperties = propertiesOf(source);
+        const targetProperties = propertiesOf(target);
+        const sourceRequired = requiredOf(source);
+        const targetRequired = requiredOf(target);
+        if (!sourceProperties || !targetProperties || !sourceRequired || !targetRequired) {
+            return [unprovable(location, "object schema properties or required fields are invalid")];
+        }
+        const sourceAdditional = source["additionalProperties"];
+        const targetAdditional = target["additionalProperties"];
+        if (sourceAdditional !== undefined &&
+            sourceAdditional !== true &&
+            sourceAdditional !== false &&
+            !schemaRecord(sourceAdditional)) {
+            return [unprovable(location, "source object schema has invalid additionalProperties")];
+        }
+        if (targetAdditional !== undefined &&
+            targetAdditional !== true &&
+            targetAdditional !== false &&
+            !schemaRecord(targetAdditional)) {
+            return [unprovable(location, "output object schema has invalid additionalProperties")];
+        }
+        const sourceAdditionalSchema = schemaRecord(sourceAdditional);
+        const targetAdditionalSchema = schemaRecord(targetAdditional);
+        const targetAdditionalAcceptsAll = targetAdditionalSchema !== undefined && semanticKeywords(targetAdditionalSchema).length === 0;
+        const issues = [];
+        for (const key of targetRequired) {
+            if (!sourceRequired.includes(key))
+                issues.push(`missing required field "${key}"`);
+        }
+        for (const [key, targetProperty] of Object.entries(targetProperties)) {
+            if (semanticKeywords(targetProperty).length === 0)
+                continue;
+            const sourceProperty = hasOwn(sourceProperties, key) ? sourceProperties[key] : undefined;
+            if (sourceProperty) {
+                issues.push(...satisfies(sourceProperty, targetProperty, `${location}.${key}`));
+            }
+            else if (sourceAdditionalSchema) {
+                issues.push(...satisfies(sourceAdditionalSchema, targetProperty, `${location}.${key}`));
+            }
+            else if (sourceAdditional !== false || sourceRequired.includes(key)) {
+                issues.push(unprovable(`${location}.${key}`, `source property "${key}" has no declared value schema`));
+            }
+        }
+        for (const [key, sourceProperty] of Object.entries(sourceProperties)) {
+            if (hasOwn(targetProperties, key))
+                continue;
+            if (targetAdditional === false) {
+                issues.push(`field "${key}" is not allowed by the strict output schema`);
+            }
+            else if (targetAdditionalSchema && !targetAdditionalAcceptsAll) {
+                issues.push(...satisfies(sourceProperty, targetAdditionalSchema, `${location}.${key}`));
+            }
+        }
+        if (targetAdditional === false) {
+            if (sourceAdditional !== false) {
+                issues.push(`${location} may contain fields not allowed by the strict output schema`);
+            }
+        }
+        else if (targetAdditionalSchema && !targetAdditionalAcceptsAll) {
+            if (sourceAdditionalSchema) {
+                issues.push(...satisfies(sourceAdditionalSchema, targetAdditionalSchema, `${location}.*`));
+            }
+            else if (sourceAdditional !== false) {
+                issues.push(unprovable(`${location}.*`, "source object allows undeclared fields without a value schema"));
+            }
+        }
+        return issues;
+    }
+    if (targetType === "array") {
+        if (sourceType !== "array") {
+            return [`${location} is ${typeLabel(source)}, but output expects an array`];
+        }
+        const sourceKeywordIssue = unsupportedExtraKeyword(source, ["type", "items"], location, "source");
+        if (sourceKeywordIssue)
+            return [sourceKeywordIssue];
+        const targetKeywordIssue = unsupportedExtraKeyword(target, ["type", "items"], location, "output");
+        if (targetKeywordIssue)
+            return [targetKeywordIssue];
+        const sourceItems = schemaRecord(source["items"]);
+        const targetItems = schemaRecord(target["items"]);
+        if (!sourceItems || !targetItems) {
+            return [unprovable(location, "array schema does not declare a single item schema")];
+        }
+        return satisfies(sourceItems, targetItems, `${location}[]`);
+    }
+    return primitiveCompatible(source, target, location);
+}
+function checkSelector(selector, target, context, location) {
+    const targetUnsupported = unsupportedIssue(target, location, "output");
+    if (targetUnsupported)
+        return [targetUnsupported];
+    if (selector.kind === "literal") {
+        try {
+            validateAgainstSchema(selector.value, target, location);
+            return [];
+        }
+        catch (error) {
+            return [error.message.replace(`${location} does not match schema — `, `${location}: `)];
+        }
+    }
+    if (selector.kind === "input" ||
+        selector.kind === "step" ||
+        selector.kind === "variable" ||
+        selector.kind === "mapItem") {
+        const resolved = resolveSelectorSchema(selector, context);
+        if (!resolved.schema)
+            return resolved.issues;
+        return satisfies(resolved.schema, target, location);
+    }
+    if (semanticKeywords(target).length === 0)
+        return [];
+    const targetBranches = schemaBranches(target);
+    if (targetBranches) {
+        if (targetBranches.length === 0) {
+            return [`${location} cannot satisfy an output schema that allows no values`];
+        }
+        const attempts = targetBranches.map((branch) => checkSelector(selector, branch, context, location));
+        if (attempts.some((issues) => issues.length === 0))
+            return [];
+        return attempts.sort((left, right) => left.length - right.length)[0] ?? [];
+    }
+    if (selector.kind === "object") {
+        if (schemaType(target) !== "object") {
+            return [`${location} is an object, but output expects ${typeLabel(target)}`];
+        }
+        const targetKeywordIssue = unsupportedExtraKeyword(target, ["type", "properties", "required", "additionalProperties"], location, "output");
+        if (targetKeywordIssue)
+            return [targetKeywordIssue];
+        const properties = propertiesOf(target);
+        const required = requiredOf(target);
+        if (!properties || !required) {
+            return [unprovable(location, "output object schema properties or required fields are invalid")];
+        }
+        const additional = target["additionalProperties"];
+        if (additional !== undefined &&
+            additional !== true &&
+            additional !== false &&
+            !schemaRecord(additional)) {
+            return [unprovable(location, "output object schema has invalid additionalProperties")];
+        }
+        const issues = [];
+        for (const key of required) {
+            if (!hasOwn(selector.fields, key))
+                issues.push(`missing required field "${key}"`);
+        }
+        for (const [key, field] of Object.entries(selector.fields)) {
+            const property = hasOwn(properties, key) ? properties[key] : undefined;
+            if (property) {
+                issues.push(...checkSelector(field, property, context, `${location}.${key}`));
+            }
+            else if (target["additionalProperties"] === false) {
+                issues.push(`field "${key}" is not allowed by the strict output schema`);
+            }
+            else {
+                const additional = schemaRecord(target["additionalProperties"]);
+                if (additional)
+                    issues.push(...checkSelector(field, additional, context, `${location}.${key}`));
+            }
+        }
+        return issues;
+    }
+    if (selector.kind === "array") {
+        if (schemaType(target) !== "array") {
+            return [`${location} is an array, but output expects ${typeLabel(target)}`];
+        }
+        const targetKeywordIssue = unsupportedExtraKeyword(target, ["type", "items"], location, "output");
+        if (targetKeywordIssue)
+            return [targetKeywordIssue];
+        const items = schemaRecord(target["items"]);
+        if (!items)
+            return [unprovable(location, "output array schema does not declare a single item schema")];
+        return selector.items.flatMap((item, index) => checkSelector(item, items, context, `${location}[${index}]`));
+    }
+    const exhaustive = selector;
+    return exhaustive;
+}
+/** Returns mismatch descriptions; an empty array means compatibility was proven. */
+export function checkSelectorSatisfiesSchema(selector, target, context) {
+    return checkSelector(selector, target, context, "input");
+}