@magicvr/schema-ui-protocol 0.2.1 → 0.2.3

package/protocol/conformance/request-construction.js

@@ -0,0 +1,695 @@
+/**
+ * request-construction fixture adapter (schema-ui-docs v2.7.0).
+ *
+ * Builds HTTP request / navigation / modal outcomes from declarative mappings.
+ * Batch kinds are out of scope for MVP callers (Q1); this module still implements
+ * non-batch kinds used by stage3 execution.
+ */
+import { encodeRFC3986, serializeQueryNumber } from "./query-serialize.js";
+const PROTOCOL_URL_RE = /^\/(?!\/)[^\s\\]*$/;
+const UNSAFE_SEGMENTS = new Set(["__proto__", "constructor", "prototype"]);
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function fail(code, path) {
+    return { ok: false, code, path };
+}
+function isProtocolRelativeUrl(url) {
+    return PROTOCOL_URL_RE.test(url);
+}
+// safeDecode tolerates malformed percent-encoding: decodeURIComponent throws
+// URIError on inputs like "%zz" or a trailing "%", and an uncaught throw here
+// would crash the whole action path. The raw part is passed through unchanged
+// so a later encodeRFC3986 round-trip produces a valid URL (D4).
+function safeDecode(part) {
+    try {
+        return decodeURIComponent(part);
+    }
+    catch {
+        return part;
+    }
+}
+function splitUrl(url) {
+    const qIndex = url.indexOf("?");
+    if (qIndex < 0) {
+        return { path: url, query: new Map() };
+    }
+    const path = url.slice(0, qIndex);
+    const query = new Map();
+    const raw = url.slice(qIndex + 1);
+    if (raw.length === 0) {
+        return { path, query };
+    }
+    for (const part of raw.split("&")) {
+        if (part === "")
+            continue;
+        const eq = part.indexOf("=");
+        const key = eq < 0 ? part : part.slice(0, eq);
+        const value = eq < 0 ? "" : part.slice(eq + 1);
+        // Base query values in fixtures are already literal (not double-encoded).
+        query.set(safeDecode(key), safeDecode(value));
+    }
+    return { path, query };
+}
+function serializeQueryValue(value) {
+    if (value === null)
+        return "";
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    if (typeof value === "number")
+        return serializeQueryNumber(value);
+    if (typeof value === "string")
+        return value;
+    throw new Error("non-scalar query value");
+}
+function buildUrl(path, query) {
+    if (query.size === 0)
+        return path;
+    const keys = [...query.keys()].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    const parts = keys.map((key) => `${encodeRFC3986(key)}=${encodeRFC3986(query.get(key) ?? "")}`);
+    return `${path}?${parts.join("&")}`;
+}
+function extractPathParams(path) {
+    const params = [];
+    const re = /\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+    let match;
+    while ((match = re.exec(path)) !== null) {
+        params.push(match[1]);
+    }
+    return params;
+}
+function applyPathBindings(path, bindings, mappingPathPrefix) {
+    const needed = extractPathParams(path);
+    const provided = Object.keys(bindings);
+    for (const key of needed) {
+        if (!(key in bindings)) {
+            return { ok: false, code: "MISSING_PATH_BINDING", path: `${mappingPathPrefix}.${key}` };
+        }
+    }
+    for (const key of provided) {
+        if (!needed.includes(key)) {
+            return { ok: false, code: "EXTRA_PATH_BINDING", path: `${mappingPathPrefix}.${key}` };
+        }
+    }
+    let result = path;
+    for (const key of needed) {
+        result = result.replaceAll(`{${key}}`, encodeRFC3986(bindings[key]));
+    }
+    return { ok: true, path: result };
+}
+function resolveRowPath(expr, row, path) {
+    if (!expr.startsWith("$row.")) {
+        return { ok: false, code: "INVALID_MAPPING_VALUE", path };
+    }
+    const segments = expr.slice("$row.".length).split(".");
+    if (segments.some((s) => UNSAFE_SEGMENTS.has(s) || s === "")) {
+        return { ok: false, code: "UNSAFE_ROW_PATH", path };
+    }
+    let current = row;
+    for (const seg of segments) {
+        if (!isObject(current) || !Object.prototype.hasOwnProperty.call(current, seg)) {
+            return { ok: false, code: "UNRESOLVED_ROW_VALUE", path };
+        }
+        current = current[seg];
+    }
+    return { ok: true, value: current };
+}
+function resolveMappingValue(expr, row, path, opts) {
+    if (typeof expr !== "string") {
+        return { ok: true, value: expr };
+    }
+    if (!expr.startsWith("$")) {
+        return { ok: true, value: expr };
+    }
+    if (expr.startsWith("$row.")) {
+        const resolved = resolveRowPath(expr, row, path);
+        if (!resolved.ok)
+            return resolved;
+        if (resolved.value === null) {
+            if (opts.pathSlot) {
+                return { ok: false, code: "NULL_PATH_VALUE", path };
+            }
+            if (opts.allowNullAsTombstone) {
+                return { ok: true, value: null, tombstone: true };
+            }
+            return { ok: false, code: "NULL_PATH_VALUE", path };
+        }
+        if (opts.pathSlot) {
+            if (typeof resolved.value !== "string" &&
+                typeof resolved.value !== "number" &&
+                typeof resolved.value !== "boolean") {
+                return { ok: false, code: "INVALID_ROW_VALUE", path };
+            }
+            return { ok: true, value: String(resolved.value) };
+        }
+        // body/query scalars only (no nested objects/arrays for row body)
+        if (isObject(resolved.value) || Array.isArray(resolved.value)) {
+            return { ok: false, code: "INVALID_ROW_VALUE", path };
+        }
+        return { ok: true, value: resolved.value };
+    }
+    return { ok: false, code: "INVALID_MAPPING_VALUE", path };
+}
+function resolveRouteExpr(expr, route, path) {
+    const queryPrefix = "$context.route.query.";
+    const paramsPrefix = "$context.route.params.";
+    if (expr.startsWith(queryPrefix)) {
+        const key = expr.slice(queryPrefix.length);
+        const value = route.query?.[key];
+        if (value === undefined || value === null) {
+            return { ok: false, code: "UNRESOLVED_ROUTE_VALUE", path };
+        }
+        return { ok: true, value: String(value) };
+    }
+    if (expr.startsWith(paramsPrefix)) {
+        const key = expr.slice(paramsPrefix.length);
+        const value = route.params?.[key];
+        if (value === undefined || value === null) {
+            return { ok: false, code: "UNRESOLVED_ROUTE_VALUE", path };
+        }
+        return { ok: true, value: String(value) };
+    }
+    return { ok: false, code: "INVALID_MAPPING_VALUE", path };
+}
+function joinBase(base, url) {
+    if (!base)
+        return url;
+    if (!url.startsWith("/"))
+        return url;
+    return `${base.replace(/\/$/, "")}${url}`;
+}
+function checkConfirm(input) {
+    if (input.confirm === undefined)
+        return null;
+    if (input.confirmAccepted === false) {
+        return fail("CONFIRM_REJECTED", "confirm");
+    }
+    return null;
+}
+function applyIdempotency(action, invocationId, pathPrefix) {
+    const policy = action.retryPolicy;
+    if (policy === undefined || policy === "never") {
+        return { ok: true };
+    }
+    if (policy !== "idempotent") {
+        return { ok: false, code: "INVALID_RETRY_POLICY", path: `${pathPrefix}.retryPolicy` };
+    }
+    if (typeof invocationId !== "string" || invocationId.length === 0) {
+        return { ok: false, code: "MISSING_INVOCATION_ID", path: "invocationId" };
+    }
+    return { ok: true, headers: { "Idempotency-Key": invocationId } };
+}
+function buildDataRef(input) {
+    const dataRef = input.dataRef;
+    const url = dataRef.url;
+    if (typeof url !== "string" || !isProtocolRelativeUrl(url)) {
+        return fail("INVALID_PROTOCOL_URL", "dataRef.url");
+    }
+    const method = dataRef.method ?? "GET";
+    if (method !== "GET") {
+        return fail("DATA_REF_METHOD_NOT_READ_ONLY", "dataRef.method");
+    }
+    if (dataRef.requestInterceptor !== undefined) {
+        return fail("INTERCEPTOR_VIOLATION", "requestInterceptor");
+    }
+    // ADR-0039 (since 2.9): params may bind whole $context.route.query.* /
+    // $context.route.params.* values (any context). A missing route key (or an
+    // absent route input) is a tombstone: the parameter is deleted from the URL
+    // and the request still succeeds (ADR-0010 semantics, data-ref-route-* cases).
+    const route = input.route ?? {};
+    const { path, query } = splitUrl(url);
+    const params = dataRef.params ?? {};
+    for (const [key, value] of Object.entries(params)) {
+        if (typeof value === "string" && value.startsWith("$context.route.")) {
+            const resolved = resolveRouteExpr(value, route, "dataRef.params." + key);
+            if (!resolved.ok) {
+                // Missing route key / no route context: tombstone delete, keep going.
+                query.delete(key);
+                continue;
+            }
+            query.set(key, resolved.value);
+            continue;
+        }
+        if (value === null) {
+            query.delete(key);
+            continue;
+        }
+        query.set(key, serializeQueryValue(value));
+    }
+    return {
+        ok: true,
+        request: { method: "GET", url: buildUrl(path, query), body: null },
+    };
+}
+function isRelativeProtocolUrl(url) {
+    if (typeof url !== "string" || !url.startsWith("/") || url.startsWith("//")) {
+        return false;
+    }
+    const pathOnly = url.includes("?") ? url.slice(0, url.indexOf("?")) : url;
+    return isProtocolRelativeUrl(pathOnly) || isProtocolRelativeUrl(url);
+}
+function buildRowAction(input) {
+    const action = input.action;
+    const method = action.method;
+    const url = action.url;
+    if (!isRelativeProtocolUrl(url)) {
+        return fail("INVALID_PROTOCOL_URL", "action.url");
+    }
+    const mapping = input.requestMapping ?? {};
+    const row = input.row;
+    const { path: basePath, query } = splitUrl(url);
+    const pathMap = mapping.path ?? {};
+    const bindings = {};
+    for (const [key, expr] of Object.entries(pathMap)) {
+        const resolved = resolveMappingValue(expr, row, `requestMapping.path.${key}`, {
+            pathSlot: true,
+        });
+        if (!resolved.ok)
+            return resolved;
+        bindings[key] = String(resolved.value);
+    }
+    const bound = applyPathBindings(basePath, bindings, "requestMapping.path");
+    if (!bound.ok)
+        return bound;
+    const queryMap = mapping.query ?? {};
+    for (const [key, expr] of Object.entries(queryMap)) {
+        const resolved = resolveMappingValue(expr, row, `requestMapping.query.${key}`, {
+            allowNullAsTombstone: true,
+        });
+        if (!resolved.ok)
+            return resolved;
+        if (resolved.tombstone) {
+            query.delete(key);
+            continue;
+        }
+        query.set(key, serializeQueryValue(resolved.value));
+    }
+    let body = null;
+    const bodyMap = mapping.body;
+    if (bodyMap !== undefined) {
+        const out = {};
+        for (const [key, expr] of Object.entries(bodyMap)) {
+            const resolved = resolveMappingValue(expr, row, `requestMapping.body.${key}`, {});
+            if (!resolved.ok)
+                return resolved;
+            out[key] = resolved.value;
+        }
+        body = out;
+    }
+    const idem = applyIdempotency(action, input.invocationId, "action");
+    if (!idem.ok)
+        return idem;
+    return {
+        ok: true,
+        request: {
+            method,
+            url: buildUrl(bound.path, query),
+            body,
+            ...(idem.headers ? { headers: idem.headers } : {}),
+        },
+    };
+}
+function formFieldIncluded(proj) {
+    if (!proj)
+        return true;
+    if (proj.visible === false)
+        return false;
+    if (proj.disabled === true)
+        return false;
+    if (proj.uploadStatus === "error")
+        return false;
+    return Object.prototype.hasOwnProperty.call(proj, "value");
+}
+function buildFormAction(input) {
+    const action = input.action;
+    const method = action.method;
+    const url = action.url;
+    if (typeof url !== "string" || !isProtocolRelativeUrl(url)) {
+        return fail("INVALID_PROTOCOL_URL", "action.url");
+    }
+    if (method === "GET") {
+        return fail("FORM_GET_NOT_ALLOWED", "action.method");
+    }
+    const formValues = input.formValues ?? {};
+    const formProjection = input.formProjection;
+    const bodyMapping = action.bodyMapping;
+    let sourceValues = {};
+    if (formProjection) {
+        for (const [field, proj] of Object.entries(formProjection)) {
+            if (!formFieldIncluded(proj))
+                continue;
+            sourceValues[field] = proj.value;
+        }
+    }
+    else {
+        sourceValues = { ...formValues };
+    }
+    let body = {};
+    if (bodyMapping) {
+        for (const [source, target] of Object.entries(bodyMapping)) {
+            if (!Object.prototype.hasOwnProperty.call(sourceValues, source)) {
+                // When projection omits field (no value key) or formValues missing
+                return fail("UNRESOLVED_FORM_VALUE", `bodyMapping.${source}`);
+            }
+            body[target] = sourceValues[source];
+        }
+    }
+    else {
+        body = { ...sourceValues };
+    }
+    const idem = applyIdempotency(action, input.invocationId, "action");
+    if (!idem.ok)
+        return idem;
+    const finalUrl = joinBase(input.baseURL, url);
+    const result = {
+        ok: true,
+        request: {
+            method,
+            url: finalUrl,
+            body,
+            ...(idem.headers ? { headers: idem.headers } : {}),
+        },
+    };
+    if (input.baseURL) {
+        result.resolvedBase = "api.baseURL";
+    }
+    return result;
+}
+function buildRowNavigate(input) {
+    const action = input.action;
+    const url = action.url;
+    const mapping = input.navigateMapping;
+    if (!mapping || Object.keys(mapping).length === 0) {
+        return fail("EMPTY_NAVIGATE_MAPPING", "navigateMapping");
+    }
+    if (mapping.body !== undefined) {
+        return fail("NAVIGATE_BODY_NOT_ALLOWED", "navigateMapping.body");
+    }
+    const row = input.row;
+    const { path: basePath, query } = splitUrl(url);
+    const pathMap = mapping.path ?? {};
+    const bindings = {};
+    for (const [key, expr] of Object.entries(pathMap)) {
+        const resolved = resolveMappingValue(expr, row, `navigateMapping.path.${key}`, {
+            pathSlot: true,
+        });
+        if (!resolved.ok)
+            return resolved;
+        bindings[key] = String(resolved.value);
+    }
+    const bound = applyPathBindings(basePath, bindings, "navigateMapping.path");
+    if (!bound.ok)
+        return bound;
+    const queryMap = mapping.query ?? {};
+    for (const [key, expr] of Object.entries(queryMap)) {
+        if (typeof expr === "string" && expr.startsWith("$") && !expr.startsWith("$row.")) {
+            return fail("INVALID_MAPPING_VALUE", `navigateMapping.query.${key}`);
+        }
+        const resolved = resolveMappingValue(expr, row, `navigateMapping.query.${key}`, {
+            allowNullAsTombstone: true,
+        });
+        if (!resolved.ok)
+            return resolved;
+        if (resolved.tombstone) {
+            query.delete(key);
+            continue;
+        }
+        query.set(key, serializeQueryValue(resolved.value));
+    }
+    return {
+        ok: true,
+        navigation: { url: buildUrl(bound.path, query) },
+    };
+}
+function buildRecordSource(input) {
+    const rs = input.recordSource;
+    if (rs.ref !== undefined) {
+        return fail("RECORD_SOURCE_REF_NOT_ALLOWED", "recordSource");
+    }
+    if (rs.method === undefined) {
+        return fail("MISSING_RECORD_SOURCE_METHOD", "recordSource.method");
+    }
+    if (rs.method !== "GET") {
+        return fail("RECORD_SOURCE_METHOD_NOT_GET", "recordSource.method");
+    }
+    const responseMapping = rs.responseMapping;
+    if (!responseMapping || Object.keys(responseMapping).length === 0) {
+        return fail("EMPTY_RESPONSE_MAPPING", "recordSource.responseMapping");
+    }
+    const url = rs.url;
+    // D-001 P0: recordSource must be a strict relative protocol URL (single
+    // slash, no `//`), matching rowAction/upload validation. `//host` would be
+    // resolved as a protocol-relative external URL, and authFetch would attach
+    // the Bearer access token to the external request.
+    if (typeof url !== "string" || !isRelativeProtocolUrl(url)) {
+        return fail("INVALID_PROTOCOL_URL", "recordSource.url");
+    }
+    const route = input.route ?? {};
+    const { path: basePath, query } = splitUrl(url);
+    const pathMap = rs.path ?? {};
+    const bindings = {};
+    for (const [key, expr] of Object.entries(pathMap)) {
+        if (typeof expr !== "string") {
+            return fail("INVALID_MAPPING_VALUE", `recordSource.path.${key}`);
+        }
+        const resolved = resolveRouteExpr(expr, route, `recordSource.path.${key}`);
+        if (!resolved.ok)
+            return resolved;
+        bindings[key] = resolved.value;
+    }
+    const bound = applyPathBindings(basePath, bindings, "recordSource.path");
+    if (!bound.ok)
+        return bound;
+    const queryMap = rs.query ?? {};
+    for (const [key, value] of Object.entries(queryMap)) {
+        query.set(key, serializeQueryValue(value));
+    }
+    const finalUrl = joinBase(input.baseURL, buildUrl(bound.path, query));
+    const result = {
+        ok: true,
+        request: { method: "GET", url: finalUrl, body: null },
+    };
+    if (input.baseURL) {
+        result.resolvedBase = "api.baseURL";
+    }
+    return result;
+}
+function buildPageTriggerRequest(input) {
+    const confirm = checkConfirm(input);
+    if (confirm)
+        return confirm;
+    const action = input.action;
+    const method = action.method;
+    const url = action.url;
+    if (method === "GET") {
+        return fail("PAGE_TRIGGER_METHOD_NOT_ALLOWED", "action.method");
+    }
+    // W4 P1-2: same strict relative-protocol check as every other builder
+    // (rejects `//`, backslash, whitespace — `/\\evil.com` would otherwise be
+    // parsed by the browser as the external host `//evil.com`).
+    if (!isRelativeProtocolUrl(url)) {
+        return fail("INVALID_PROTOCOL_URL", "action.url");
+    }
+    if (extractPathParams(url).length > 0) {
+        return fail("UNBOUND_URL_TEMPLATE", "action.url");
+    }
+    return {
+        ok: true,
+        request: { method, url, body: null },
+    };
+}
+function buildPageTriggerNavigate(input) {
+    const confirm = checkConfirm(input);
+    if (confirm)
+        return confirm;
+    const action = input.action;
+    const url = action.url;
+    // W4 P1-2: same strict relative-protocol check as buildPageTriggerRequest.
+    if (!isRelativeProtocolUrl(url)) {
+        return fail("INVALID_PROTOCOL_URL", "action.url");
+    }
+    if (extractPathParams(url).length > 0) {
+        return fail("UNBOUND_URL_TEMPLATE", "action.url");
+    }
+    const finalUrl = joinBase(input.appRouteRoot, url);
+    const result = {
+        ok: true,
+        navigation: { url: finalUrl },
+    };
+    if (input.appRouteRoot) {
+        result.resolvedBase = "app.routeRoot";
+    }
+    return result;
+}
+function buildPageTriggerModal(input) {
+    const confirm = checkConfirm(input);
+    if (confirm)
+        return confirm;
+    const action = input.action;
+    return {
+        ok: true,
+        modalOpen: { modalId: String(action.modalId) },
+    };
+}
+function buildOutcomeNavigate(input) {
+    const url = input.url;
+    // W4 P1-2: navigation outcomes must stay inside the app — reject absolute
+    // URLs (open-redirect surface) and protocol-relative/backslash smuggling.
+    // `input.appRouteRoot` is applied on top of a validated relative path.
+    if (!isRelativeProtocolUrl(url)) {
+        return fail("INVALID_PROTOCOL_URL", "navigation.url");
+    }
+    const finalUrl = joinBase(input.appRouteRoot, url);
+    return {
+        ok: true,
+        navigation: { url: finalUrl },
+        resolvedBase: "app.routeRoot",
+    };
+}
+// --- Batch request (ADR-0022 D3/D5 · I-PROTO-FULL-001 include) ---
+function isScalarSelectionKey(value) {
+    if (typeof value === "string") {
+        return value !== "";
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value);
+    }
+    return typeof value === "boolean";
+}
+/** D3 invariants: scalar keys only, dedupe preserving order, count = keys.length. */
+export function normalizeSelection(keys) {
+    const seen = new Set();
+    const out = [];
+    for (const key of keys) {
+        if (!isScalarSelectionKey(key)) {
+            continue;
+        }
+        // Strings and numbers do not interconvert ("1" and 1 are distinct keys).
+        const token = `${typeof key}:${String(key)}`;
+        if (seen.has(token)) {
+            continue;
+        }
+        seen.add(token);
+        out.push(key);
+    }
+    return { keys: out, count: out.length };
+}
+function buildBatchRequest(input) {
+    const confirm = checkConfirm(input);
+    if (confirm)
+        return confirm;
+    const action = input.action;
+    const method = action.method;
+    const url = action.url;
+    if (method === "GET") {
+        return fail("PAGE_TRIGGER_METHOD_NOT_ALLOWED", "action.method");
+    }
+    if (typeof url !== "string" || !isProtocolRelativeUrl(url)) {
+        return fail("INVALID_PROTOCOL_URL", "action.url");
+    }
+    const batchMapping = input.batchMapping;
+    if (!batchMapping) {
+        return fail("EMPTY_BATCH_MAPPING", "batchMapping");
+    }
+    const selection = input.selection;
+    const rawKeys = Array.isArray(selection?.keys) ? selection.keys : [];
+    // D3/V274/V281: normalize before any request (ignores host-provided count).
+    const normalized = normalizeSelection(rawKeys);
+    if (normalized.count === 0) {
+        return fail("EMPTY_SELECTION", "selection");
+    }
+    const { path: basePath, query } = splitUrl(url);
+    // path: literals only; bindings must exactly match url placeholders (V267).
+    const pathMap = batchMapping.path ?? {};
+    const bindings = {};
+    for (const [key, expr] of Object.entries(pathMap)) {
+        if (typeof expr === "string" && expr.startsWith("$")) {
+            return fail("INVALID_MAPPING_VALUE", `batchMapping.path.${key}`);
+        }
+        bindings[key] = String(expr);
+    }
+    const bound = applyPathBindings(basePath, bindings, "batchMapping.path");
+    if (!bound.ok)
+        return bound;
+    // query: literals or $selection.count (scalar); $selection.keys is body-only.
+    const queryMap = batchMapping.query ?? {};
+    for (const [key, expr] of Object.entries(queryMap)) {
+        if (expr === "$selection.keys") {
+            return fail("SELECTION_KEYS_BODY_ONLY", `batchMapping.query.${key}`);
+        }
+        const resolved = resolveBatchValue(expr, normalized, `batchMapping.query.${key}`, {
+            scalarOnly: true,
+        });
+        if (!resolved.ok)
+            return resolved;
+        query.set(key, serializeQueryValue(resolved.value));
+    }
+    // body: flat map; values are literals, $selection.keys (array) or
+    // $selection.count (scalar).
+    let body = null;
+    const bodyMap = batchMapping.body;
+    if (bodyMap !== undefined) {
+        const out = {};
+        for (const [key, expr] of Object.entries(bodyMap)) {
+            const resolved = resolveBatchValue(expr, normalized, `batchMapping.body.${key}`, {});
+            if (!resolved.ok)
+                return resolved;
+            out[key] = resolved.value;
+        }
+        body = out;
+    }
+    return {
+        ok: true,
+        request: { method, url: buildUrl(bound.path, query), body },
+        selectionAfterSuccessReload: { keys: [], count: 0 },
+    };
+}
+function resolveBatchValue(expr, selection, path, opts) {
+    if (typeof expr !== "string" || !expr.includes("$")) {
+        if (expr === null) {
+            return { ok: true, value: null };
+        }
+        return { ok: true, value: expr };
+    }
+    if (expr === "$selection.keys") {
+        if (opts.scalarOnly) {
+            return { ok: false, code: "INVALID_QUERY_VALUE", path };
+        }
+        return { ok: true, value: [...selection.keys] };
+    }
+    if (expr === "$selection.count") {
+        return { ok: true, value: selection.count };
+    }
+    return { ok: false, code: "INVALID_MAPPING_VALUE", path };
+}
+/**
+ * Run one request-construction fixture case.
+ * Batch kinds return a structured error; stage3 excludes them via Q1.
+ */
+export function constructRequest(input) {
+    const kind = input.kind;
+    switch (kind) {
+        case "dataRef":
+            return buildDataRef(input);
+        case "rowAction":
+            return buildRowAction(input);
+        case "formAction":
+            return buildFormAction(input);
+        case "rowNavigate":
+            return buildRowNavigate(input);
+        case "recordSource":
+            return buildRecordSource(input);
+        case "pageTriggerRequest":
+            return buildPageTriggerRequest(input);
+        case "pageTriggerNavigate":
+            return buildPageTriggerNavigate(input);
+        case "pageTriggerModal":
+            return buildPageTriggerModal(input);
+        case "outcomeNavigate":
+            return buildOutcomeNavigate(input);
+        case "batchRequest":
+            return buildBatchRequest(input);
+        default:
+            return fail("INVALID_MAPPING_VALUE", "kind");
+    }
+}