@amritk/generate-validators 0.12.1 → 0.13.0

package/dist/generators/generate-validator-function.js

@@ -1,5 +1,5 @@
 import { regexFlagsFor, regexLiteral } from "@amritk/helpers/escape-regex-pattern";
-import { getMjstInstanceOf, getMjstPrimitive } from "@amritk/helpers/mjst-extension";
+import { getMjstInstanceOf, getMjstPrimitive, MJST_EXTENSION_KEY } from "@amritk/helpers/mjst-extension";
 import { multipleOfFailExpr, multipleOfPassExpr } from "@amritk/helpers/multiple-of-check";
 import { refToName } from "@amritk/helpers/ref-to-name";
 import { safeAccessor } from "@amritk/helpers/safe-accessor";
@@ -8,6 +8,8 @@ import { maxLengthFailExpr, maxLengthPassExpr, minLengthFailExpr, minLengthPassE
 import { unknownKeyCheck } from "@amritk/helpers/unknown-key-check";
 import { assertGeneratableRefs } from "./assert-generatable-refs.js";
 import { assertUnevaluatedGeneratable, UNPROVABLE_COVERAGE_MESSAGE } from "./assert-unevaluated-generatable.js";
+import { declaresKeywordOutside } from "./enforced-keywords.js";
+import { tupleShapeOf } from "./tuple-shape.js";
 import { unevaluatedItemsExpr, unevaluatedPropertiesExpr } from "./unevaluated-match.js";
 const validatorName = (typeName) => `validate${typeName}`;
 const propertyRead = (objVar, key) => safeAccessor(objVar, key);
@@ -54,16 +56,15 @@ const schemaIsScalarOnly = (schema) => {
   return types.length > 0 && types.every((x) => typeof x === "string" && SCALAR_ITEM_TYPES.has(x));
 };
 const arrayItemsAreScalarOnly = (schema) => {
-  const prefix = schema["prefixItems"];
-  if (Array.isArray(prefix)) {
-    if (!prefix.every((p) => schemaIsScalarOnly(p)))
+  const { tuple, tail, tailIsClosed } = tupleShapeOf(schema);
+  if (tuple !== void 0) {
+    if (!tuple.every((p) => schemaIsScalarOnly(p)))
       return false;
-    const tail = "items" in schema ? schema["items"] : schema["additionalItems"];
-    if (tail === false)
+    if (tailIsClosed)
       return true;
     return schemaIsScalarOnly(tail);
   }
-  return schemaIsScalarOnly(schema["items"]);
+  return schemaIsScalarOnly(tail);
 };
 const wrongTypeCondition = (accessor, type) => {
   switch (type) {
@@ -86,6 +87,7 @@ const wrongTypeCondition = (accessor, type) => {
   }
 };
 const declaresObjectType = (schema) => hasType(schema) && schema.type === "object";
+const objectRootIsSelfContained = (schema) => !hasRef(schema) && !hasConst(schema) && !hasEnum(schema) && getMjstInstanceOf(schema) === void 0 && getMjstPrimitive(schema) === void 0;
 const getTypeArray = (schema) => {
   if (!isSchemaObject(schema) || !("type" in schema) || !Array.isArray(schema.type))
     return null;
@@ -107,6 +109,15 @@ const patternPropertySources = (schema) => {
     return [];
   return Object.keys(patterns);
 };
+const readsObjBinding = (text) => /\bobj\b/.test(text);
+const withHoisted = (hoisted, text) => {
+  const kept = hoisted.filter((entry) => text.includes(entry.reference)).map((entry) => entry.declaration);
+  const reads = text.replaceAll("(input: unknown", "(");
+  const body = /\binput\b/.test(reads) ? text : text.replaceAll("(input: unknown", "(_input: unknown");
+  return kept.length > 0 ? `${kept.join("\n")}
+
+${body}` : body;
+};
 const generateStrictKeyChecks = (schema, ctx) => {
   if (!isSchemaObject(schema))
     return [];
@@ -114,20 +125,27 @@ const generateStrictKeyChecks = (schema, ctx) => {
     return [];
   const known = Object.keys(hasProperties(schema) ? schema.properties : {});
   const d = ctx.depth;
-  const check = unknownKeyCheck(known, `_knownKeys${ctx.hoisted.length}`);
-  ctx.hoisted.push(...check.declarations);
+  const knownKeysName = `_knownKeys${ctx.hoisted.length}`;
+  const check = unknownKeyCheck(known, knownKeysName);
+  const unknownTest = check.isUnknown(`_key${d}`);
+  for (const declaration of check.declarations) {
+    ctx.hoisted.push({ declaration, reference: unknownTest });
+  }
   const patterns = patternPropertySources(schema);
   let patternGuard = "";
   if (patterns.length > 0) {
     const patternsName = `_patterns${ctx.hoisted.length}`;
     const compiled = patterns.map((p) => `new RegExp(${JSON.stringify(p)}, ${JSON.stringify(regexFlagsFor(p))})`);
-    ctx.hoisted.push(`const ${patternsName} = [${compiled.join(", ")}]`);
     patternGuard = ` && !${patternsName}.some((re) => re.test(_key${d}))`;
+    ctx.hoisted.push({
+      declaration: `const ${patternsName} = [${compiled.join(", ")}]`,
+      reference: patternGuard
+    });
   }
   return [
     `  for (const _key${d} in ${ctx.objVar}) {`,
-    `    if (${check.isUnknown(`_key${d}`)}${patternGuard}) {`,
-    `      errors.push({ message: 'must NOT have additional properties', path: \`${ctx.pathPrefix}/\${_key${d}}\` })`,
+    `    if (${unknownTest}${patternGuard}) {`,
+    `      errors.push({ message: 'must NOT have additional properties', path: \`${ctx.pathPrefix}/\${escapePointer(_key${d})}\` })`,
     `    }`,
     `  }`
   ];
@@ -179,172 +197,109 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
     return lines;
   return [`  const ${protoLocalName(key, ctx.depth)} = ${propertyRead(ctx.objVar, key)}`, ...lines];
 };
-const generatePropertyCheckLines = (key, propSchema, isRequired, suffix, ctx) => {
-  if (!isSchemaObject(propSchema)) {
-    if (isRequired && propSchema === true) {
-      const parentPath2 = ctx.depth === 0 ? "_path" : `\`${ctx.pathPrefix}\``;
-      return [
-        `  if (${missingCheck(ctx.objVar, key)}) {`,
-        `    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath2} })`,
-        `  }`
-      ];
-    }
-    return [];
+const singleIfBlock = (lines) => {
+  if (lines.length < 3)
+    return null;
+  const opener = /^ {2}if \((.*)\) \{$/.exec(lines[0]);
+  if (opener === null || lines[lines.length - 1] !== "  }")
+    return null;
+  for (let i = 1; i < lines.length - 1; i++) {
+    if (!lines[i].startsWith("    "))
+      return null;
   }
-  const raw = PROTOTYPE_MEMBERS.has(key) ? protoLocalName(key, ctx.depth) : propertyRead(ctx.objVar, key);
-  const path = `\`${ctx.pathPrefix}/${pointerSegment(key)}\``;
-  const parentPath = ctx.depth === 0 ? "_path" : `\`${ctx.pathPrefix}\``;
+  return { condition: opener[1], body: lines.slice(1, -1) };
+};
+const generateKeywordChecks = (key, raw, path, schema, suffix, ctx, presence) => {
+  if (!isSchemaObject(schema))
+    return [];
   const lines = [];
-  if (hasRef(propSchema)) {
-    const ref = propSchema.$ref;
-    const vName = validatorName(refToName(ref, suffix));
-    const siblings = [
-      ...generateConstraintChecks(key, raw, path, propSchema, suffix, ctx),
-      ...generateCombinatorChecks(key, raw, path, propSchema, suffix, ctx)
-    ];
-    const delegate = [
-      `    const _r = ${vName}(${raw}, ${path})`,
-      `    if (_r !== true) errors.push(..._r.errors)`,
-      ...siblings
-    ];
-    if (isRequired) {
-      lines.push(`  if (${missingCheck(ctx.objVar, key)}) {`);
-      lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
-      lines.push(`  } else {`);
-      lines.push(...delegate);
-      lines.push(`  }`);
-    } else {
-      lines.push(`  if (${raw} !== undefined) {`);
+  if (hasRef(schema)) {
+    const vName = validatorName(refToName(schema.$ref, suffix));
+    const delegate = [`  const _r = ${vName}(${raw}, ${path})`, `  if (_r !== true) errors.push(..._r.errors)`];
+    if (presence === "")
       lines.push(...delegate);
-      lines.push(`  }`);
-    }
-    return lines;
+    else
+      lines.push(`  if (${raw} !== undefined) {`, ...delegate.map((line) => `  ${line}`), `  }`);
   }
-  const instanceOf = getMjstInstanceOf(propSchema);
+  const instanceOf = getMjstInstanceOf(schema);
   if (instanceOf) {
-    if (isRequired) {
-      lines.push(`  if (${missingCheck(ctx.objVar, key)}) {`);
-      lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
-      lines.push(`  } else if (!(${raw} instanceof ${instanceOf})) {`);
-      lines.push(`    errors.push({ message: 'must be ${instanceOf}', path: ${path} })`);
-      lines.push(`  }`);
-    } else {
-      lines.push(`  if (${raw} !== undefined && !(${raw} instanceof ${instanceOf})) {`);
-      lines.push(`    errors.push({ message: 'must be ${instanceOf}', path: ${path} })`);
-      lines.push(`  }`);
-    }
-    return lines;
+    lines.push(`  if (${presence}!(${raw} instanceof ${instanceOf})) {`);
+    lines.push(`    errors.push({ message: 'must be ${instanceOf}', path: ${path} })`);
+    lines.push(`  }`);
   }
-  const primitive = getMjstPrimitive(propSchema);
+  const primitive = getMjstPrimitive(schema);
   if (primitive) {
-    if (isRequired) {
-      lines.push(`  if (${missingCheck(ctx.objVar, key)}) {`);
-      lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
-      lines.push(`  } else if (typeof ${raw} !== "${primitive}") {`);
-      lines.push(`    errors.push({ message: 'must be ${primitive}', path: ${path} })`);
-      lines.push(`  }`);
-    } else {
-      lines.push(`  if (${raw} !== undefined && typeof ${raw} !== "${primitive}") {`);
-      lines.push(`    errors.push({ message: 'must be ${primitive}', path: ${path} })`);
-      lines.push(`  }`);
-    }
-    return lines;
+    lines.push(`  if (${presence}typeof ${raw} !== "${primitive}") {`);
+    lines.push(`    errors.push({ message: 'must be ${primitive}', path: ${path} })`);
+    lines.push(`  }`);
   }
-  if (hasConst(propSchema)) {
-    const mismatch = constMismatchCondition(raw, propSchema.const);
-    const msg = JSON.stringify(`must be ${JSON.stringify(propSchema.const)}`);
-    if (isRequired) {
-      lines.push(`  if (${missingCheck(ctx.objVar, key)}) {`);
-      lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
-      lines.push(`  } else if (${mismatch}) {`);
-      lines.push(`    errors.push({ message: ${msg}, path: ${path} })`);
-      lines.push(`  }`);
-    } else {
-      lines.push(`  if (${raw} !== undefined && ${mismatch}) {`);
-      lines.push(`    errors.push({ message: ${msg}, path: ${path} })`);
-      lines.push(`  }`);
-    }
-    return lines;
+  if (hasConst(schema)) {
+    const mismatch = constMismatchCondition(raw, schema.const);
+    const msg = JSON.stringify(`must be ${JSON.stringify(schema.const)}`);
+    lines.push(`  if (${presence}${mismatch}) {`);
+    lines.push(`    errors.push({ message: ${msg}, path: ${path} })`);
+    lines.push(`  }`);
   }
-  if (hasEnum(propSchema)) {
-    const member = enumMembershipExpr(propSchema.enum, raw);
-    const label = propSchema.enum.map((v) => JSON.stringify(v)).join(", ");
-    if (isRequired) {
-      lines.push(`  if (${missingCheck(ctx.objVar, key)}) {`);
-      lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
-      lines.push(`  } else if (!${member}) {`);
-      lines.push(`    errors.push({ message: ${JSON.stringify(`must be one of: ${label}`)}, path: ${path} })`);
-      lines.push(`  }`);
-    } else {
-      lines.push(`  if (${raw} !== undefined && !${member}) {`);
-      lines.push(`    errors.push({ message: ${JSON.stringify(`must be one of: ${label}`)}, path: ${path} })`);
-      lines.push(`  }`);
-    }
-    return lines;
+  if (hasEnum(schema)) {
+    const label = schema.enum.map((v) => JSON.stringify(v)).join(", ");
+    lines.push(`  if (${presence}!${enumMembershipExpr(schema.enum, raw)}) {`);
+    lines.push(`    errors.push({ message: ${JSON.stringify(`must be one of: ${label}`)}, path: ${path} })`);
+    lines.push(`  }`);
   }
-  const typeArray = getTypeArray(propSchema);
-  if (typeArray) {
-    const allWrong = typeArray.map((t) => wrongTypeCondition(raw, t)).filter((c) => c !== "").map((c) => `(${c})`).join(" && ");
-    const label = typeArray.map((t) => typeofString(t)).join(" or ");
-    if (isRequired) {
-      lines.push(`  if (${missingCheck(ctx.objVar, key)}) {`);
-      lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
+  if (instanceOf === void 0 && primitive === void 0) {
+    if (hasType(schema)) {
+      const t = schema.type;
+      const wrongType = wrongTypeCondition(raw, t);
+      if (wrongType) {
+        lines.push(`  if (${presence === "" ? wrongType : `${presence}(${wrongType})`}) {`);
+        lines.push(`    errors.push({ message: 'must be ${typeofString(t)}', path: ${path} })`);
+        lines.push(`  }`);
+      }
+    }
+    const typeArray = getTypeArray(schema);
+    if (typeArray) {
+      const allWrong = typeArray.map((t) => wrongTypeCondition(raw, t)).filter((c) => c !== "").map((c) => `(${c})`).join(" && ");
       if (allWrong) {
-        lines.push(`  } else if (${allWrong}) {`);
+        const label = typeArray.map((t) => typeofString(t)).join(" or ");
+        lines.push(`  if (${presence === "" ? allWrong : `${presence}(${allWrong})`}) {`);
         lines.push(`    errors.push({ message: ${JSON.stringify(`must be ${label}`)}, path: ${path} })`);
+        lines.push(`  }`);
       }
-      lines.push(`  }`);
-    } else if (allWrong) {
-      lines.push(`  if (${raw} !== undefined && (${allWrong})) {`);
-      lines.push(`    errors.push({ message: ${JSON.stringify(`must be ${label}`)}, path: ${path} })`);
-      lines.push(`  }`);
     }
-    lines.push(...generateConstraintChecks(key, raw, path, propSchema, suffix, ctx));
-    return lines;
   }
-  if (hasType(propSchema)) {
-    const t = propSchema.type;
-    const wrongType = wrongTypeCondition(raw, t);
-    const typLabel = typeofString(t);
-    if (isRequired) {
-      lines.push(`  if (${missingCheck(ctx.objVar, key)}) {`);
-      lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
-      if (wrongType) {
-        lines.push(`  } else if (${wrongType}) {`);
-        lines.push(`    errors.push({ message: 'must be ${typLabel}', path: ${path} })`);
-      }
-      lines.push(`  }`);
-    } else if (wrongType) {
-      lines.push(`  if (${raw} !== undefined && (${wrongType})) {`);
-      lines.push(`    errors.push({ message: 'must be ${typLabel}', path: ${path} })`);
-      lines.push(`  }`);
-    }
-    lines.push(...generateConstraintChecks(key, raw, path, propSchema, suffix, ctx));
+  lines.push(...generateConstraintChecks(key, raw, path, schema, suffix, ctx));
+  const combinators = generateCombinatorChecks(key, raw, path, schema, suffix, ctx);
+  if (combinators.length > 0) {
+    if (presence === "")
+      lines.push(...combinators);
+    else
+      lines.push(`  if (${raw} !== undefined) {`, ...combinators.map((line) => `  ${line}`), `  }`);
   }
-  const extraLines = hasType(propSchema) ? generateCombinatorChecks(key, raw, path, propSchema, suffix, ctx) : [
-    ...generateConstraintChecks(key, raw, path, propSchema, suffix, ctx),
-    ...generateCombinatorChecks(key, raw, path, propSchema, suffix, ctx)
+  return lines;
+};
+const generatePropertyCheckLines = (key, propSchema, isRequired, suffix, ctx) => {
+  const parentPath = ctx.depth === 0 ? "_path" : `\`${ctx.pathPrefix}\``;
+  const missing = [
+    `  if (${missingCheck(ctx.objVar, key)}) {`,
+    `    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`
   ];
-  if (hasType(propSchema)) {
-    if (extraLines.length > 0) {
-      lines.push(`  if (${raw} !== undefined) {`);
-      lines.push(...extraLines);
-      lines.push(`  }`);
-    }
-  } else if (isRequired) {
-    lines.push(`  if (${missingCheck(ctx.objVar, key)}) {`);
-    lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
-    if (extraLines.length > 0) {
-      lines.push(`  } else {`);
-      lines.push(...extraLines);
-    }
-    lines.push(`  }`);
-  } else if (extraLines.length > 0) {
-    lines.push(`  if (${raw} !== undefined) {`);
-    lines.push(...extraLines);
-    lines.push(`  }`);
+  if (!isSchemaObject(propSchema)) {
+    if (isRequired && propSchema === true)
+      return [...missing, `  }`];
+    return [];
   }
-  return lines;
+  const raw = PROTOTYPE_MEMBERS.has(key) ? protoLocalName(key, ctx.depth) : propertyRead(ctx.objVar, key);
+  const path = `\`${ctx.pathPrefix}/${pointerSegment(key)}\``;
+  if (isRequired) {
+    const valueLines = generateKeywordChecks(key, raw, path, propSchema, suffix, ctx, "");
+    if (valueLines.length === 0)
+      return [...missing, `  }`];
+    const single = singleIfBlock(valueLines);
+    if (single !== null)
+      return [...missing, `  } else if (${single.condition}) {`, ...single.body, `  }`];
+    return [...missing, `  } else {`, ...valueLines.map((line) => `  ${line}`), `  }`];
+  }
+  return generateKeywordChecks(key, raw, path, propSchema, suffix, ctx, `${raw} !== undefined && `);
 };
 const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
   if (!isSchemaObject(propSchema))
@@ -359,7 +314,7 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
       lines.push(`    errors.push({ message: ${msg}, path: ${path} })`);
       lines.push(`  }`);
     }
-    if (hasMinLength(propSchema)) {
+    if (hasMinLength(propSchema) && propSchema.minLength > 0) {
       lines.push(`  if (typeof ${raw} === 'string' && ${minLengthFailExpr(raw, propSchema.minLength)}) {`);
       lines.push(`    errors.push({ message: 'must have at least ${propSchema.minLength} characters', path: ${path} })`);
       lines.push(`  }`);
@@ -401,13 +356,13 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
       lines.push(`  }`);
     }
   }
-  if (hasItems(propSchema)) {
-    const itemSchema = propSchema.items;
-    const prefix = sp["prefixItems"];
-    const firstTailIndex = Array.isArray(prefix) ? prefix.length : 0;
+  const { tuple, tail, tailIsClosed } = tupleShapeOf(sp);
+  if (tail !== void 0) {
+    const itemSchema = tail;
+    const firstTailIndex = tuple !== void 0 ? tuple.length : 0;
     const iv = `_i${ctx.depth}`;
     const itemPath = `\`${path.slice(1, -1)}/\${${iv}}\``;
-    if (hasRef(itemSchema)) {
+    if (hasRef(itemSchema) && !declaresKeywordOutside(itemSchema, ["$ref"])) {
       const vName = validatorName(refToName(itemSchema.$ref, suffix));
       lines.push(`  if (Array.isArray(${raw})) {`);
       lines.push(`    for (let ${iv} = ${firstTailIndex}; ${iv} < ${raw}.length; ${iv}++) {`);
@@ -428,8 +383,8 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
       }
     }
   }
-  if (hasMinItems(propSchema) || hasMaxItems(propSchema) || hasUniqueItems(propSchema) && propSchema.uniqueItems === true || "contains" in sp || Array.isArray(sp["prefixItems"]) || sp["items"] === false && !Array.isArray(sp["prefixItems"])) {
-    if (sp["items"] === false && !Array.isArray(sp["prefixItems"])) {
+  if (hasMinItems(propSchema) || hasMaxItems(propSchema) || hasUniqueItems(propSchema) && propSchema.uniqueItems === true || "contains" in sp || tuple !== void 0 || tail === false && tuple === void 0) {
+    if (tail === false && tuple === void 0) {
       lines.push(`  if (Array.isArray(${raw}) && ${raw}.length > 0) {`);
       lines.push(`    errors.push({ message: 'must NOT have more than 0 items', path: ${path} })`);
       lines.push(`  }`);
@@ -462,20 +417,19 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
       lines.push(`    }`);
       lines.push(`  }`);
     }
-    const prefix = sp["prefixItems"];
-    if (Array.isArray(prefix)) {
+    if (tuple !== void 0) {
       lines.push(`  if (Array.isArray(${raw})) {`);
-      for (let i = 0; i < prefix.length; i++) {
-        const itemChecks = generateValueChecks("", `${raw}[${i}]`, `\`${path.slice(1, -1)}/${i}\``, prefix[i], suffix, ctx);
+      for (let i = 0; i < tuple.length; i++) {
+        const itemChecks = generateValueChecks("", `${raw}[${i}]`, `\`${path.slice(1, -1)}/${i}\``, tuple[i], suffix, ctx, true);
         if (itemChecks.length > 0) {
           lines.push(`    if (${raw}.length > ${i}) {`);
           lines.push(...itemChecks.map((l) => `    ${l}`));
           lines.push(`    }`);
         }
       }
-      if (sp["items"] === false || sp["additionalItems"] === false) {
-        lines.push(`    if (${raw}.length > ${prefix.length}) {`);
-        lines.push(`      errors.push({ message: 'must NOT have more than ${prefix.length} items', path: ${path} })`);
+      if (tailIsClosed) {
+        lines.push(`    if (${raw}.length > ${tuple.length}) {`);
+        lines.push(`      errors.push({ message: 'must NOT have more than ${tuple.length} items', path: ${path} })`);
         lines.push(`    }`);
       }
       lines.push(`  }`);
@@ -503,68 +457,6 @@ const generateValueCheckLines = (_key, raw, path, propSchema, suffix, ctx, requi
   if (!isSchemaObject(propSchema))
     return [];
   const presence = required ? "" : `${raw} !== undefined && `;
-  if (hasRef(propSchema)) {
-    const vName = validatorName(refToName(propSchema.$ref, suffix));
-    if (required) {
-      lines.push(`  const _r = ${vName}(${raw}, ${path})`);
-      lines.push(`  if (_r !== true) errors.push(..._r.errors)`);
-    } else {
-      lines.push(`  if (${raw} !== undefined) {`);
-      lines.push(`    const _r = ${vName}(${raw}, ${path})`);
-      lines.push(`    if (_r !== true) errors.push(..._r.errors)`);
-      lines.push(`  }`);
-    }
-    return lines;
-  }
-  const instanceOf = getMjstInstanceOf(propSchema);
-  if (instanceOf) {
-    lines.push(`  if (${presence}!(${raw} instanceof ${instanceOf})) {`);
-    lines.push(`    errors.push({ message: 'must be ${instanceOf}', path: ${path} })`);
-    lines.push(`  }`);
-    return lines;
-  }
-  const primitive = getMjstPrimitive(propSchema);
-  if (primitive) {
-    lines.push(`  if (${presence}typeof ${raw} !== "${primitive}") {`);
-    lines.push(`    errors.push({ message: 'must be ${primitive}', path: ${path} })`);
-    lines.push(`  }`);
-    return lines;
-  }
-  if (hasConst(propSchema)) {
-    const mismatch = constMismatchCondition(raw, propSchema.const);
-    const msg = JSON.stringify(`must be ${JSON.stringify(propSchema.const)}`);
-    lines.push(`  if (${presence}${mismatch}) {`);
-    lines.push(`    errors.push({ message: ${msg}, path: ${path} })`);
-    lines.push(`  }`);
-    return lines;
-  }
-  if (hasEnum(propSchema)) {
-    const label = propSchema.enum.map((v) => JSON.stringify(v)).join(", ");
-    lines.push(`  if (${presence}!${enumMembershipExpr(propSchema.enum, raw)}) {`);
-    lines.push(`    errors.push({ message: ${JSON.stringify(`must be one of: ${label}`)}, path: ${path} })`);
-    lines.push(`  }`);
-    return lines;
-  }
-  if (hasType(propSchema)) {
-    const t = propSchema.type;
-    const wrongType = wrongTypeCondition(raw, t);
-    const typLabel = typeofString(t);
-    if (wrongType) {
-      lines.push(`  if (${presence}(${wrongType})) {`);
-      lines.push(`    errors.push({ message: 'must be ${typLabel}', path: ${path} })`);
-      lines.push(`  }`);
-    }
-  }
-  const typeArray = getTypeArray(propSchema);
-  if (typeArray) {
-    const allWrong = typeArray.map((t) => wrongTypeCondition(raw, t)).filter((c) => c !== "").map((c) => `(${c})`).join(" && ");
-    if (allWrong) {
-      const label = typeArray.map((t) => typeofString(t)).join(" or ");
-      lines.push(`  if (${presence}(${allWrong})) {`);
-      lines.push(`    errors.push({ message: ${JSON.stringify(`must be ${label}`)}, path: ${path} })`);
-      lines.push(`  }`);
-    }
-  }
   const valueCtx = {
     objVar: ctx.objVar,
     pathPrefix: path.slice(1, -1),
@@ -572,10 +464,10 @@ const generateValueCheckLines = (_key, raw, path, propSchema, suffix, ctx, requi
     hoisted: ctx.hoisted,
     rootSchema: ctx.rootSchema
   };
-  lines.push(...generateConstraintChecks("", raw, path, propSchema, suffix, valueCtx));
-  lines.push(...generateCombinatorChecks("", raw, path, propSchema, suffix, valueCtx));
+  lines.push(...generateKeywordChecks("", raw, path, propSchema, suffix, valueCtx, presence));
   return lines;
 };
+const NARROWABLE_REFERENCE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\[[A-Za-z_$][\w$]*\]|\[\d+\])*$/;
 const generateMatchesExpr = (raw, sub, suffix, ctx) => {
   if (sub === true)
     return "true";
@@ -583,12 +475,15 @@ const generateMatchesExpr = (raw, sub, suffix, ctx) => {
     return "false";
   if (!isSchemaObject(sub))
     return "true";
-  const checks = generateValueChecks("", raw, "`${_path}`", sub, suffix, ctx);
+  const value = NARROWABLE_REFERENCE.test(raw) ? raw : `_mv${ctx.depth}`;
+  const checks = generateValueChecks("", value, "`${_path}`", sub, suffix, ctx);
   if (checks.length === 0)
     return "true";
   const body = checks.join("\n").replaceAll("errors.push(", "_m.push(");
+  const binding = value === raw ? "" : `const ${value}: unknown = ${raw}
+`;
   return `((): boolean => { const _m: ValidationError[] = []
-${body}
+${binding}${body}
     return _m.length === 0 })()`;
 };
 const unevaluatedMatcher = (suffix, ctx) => (accessor, schema, depth) => generateMatchesExpr(accessor, schema, suffix, { ...ctx, depth: ctx.depth + depth + 1 });
@@ -636,9 +531,11 @@ const generateCombinatorChecks = (key, raw, path, schema, suffix, ctx) => {
   }
   if (hasAnyOf(schema) && schema.anyOf.length > 0) {
     const conds = schema.anyOf.map((b) => generateMatchesExpr(raw, b, suffix, ctx));
-    lines.push(`  if (!(${conds.join(" || ")})) {`);
-    lines.push(`    errors.push({ message: 'must match a schema in anyOf', path: ${path} })`);
-    lines.push(`  }`);
+    if (!conds.includes("true")) {
+      lines.push(`  if (!(${conds.join(" || ")})) {`);
+      lines.push(`    errors.push({ message: 'must match a schema in anyOf', path: ${path} })`);
+      lines.push(`  }`);
+    }
   }
   if (hasOneOf(schema) && schema.oneOf.length > 0) {
     const conds = schema.oneOf.map((b) => `(${generateMatchesExpr(raw, b, suffix, ctx)} ? 1 : 0)`);
@@ -649,9 +546,11 @@ const generateCombinatorChecks = (key, raw, path, schema, suffix, ctx) => {
   const not = schema["not"];
   if (not !== void 0 && (isSchemaObject(not) || typeof not === "boolean")) {
     const cond = generateMatchesExpr(raw, not, suffix, ctx);
-    lines.push(`  if (${cond}) {`);
-    lines.push(`    errors.push({ message: 'must NOT match the schema in not', path: ${path} })`);
-    lines.push(`  }`);
+    if (cond !== "false") {
+      lines.push(`  if (${cond}) {`);
+      lines.push(`    errors.push({ message: 'must NOT match the schema in not', path: ${path} })`);
+      lines.push(`  }`);
+    }
   }
   const ifSchema = schema["if"];
   if (ifSchema !== void 0 && (isSchemaObject(ifSchema) || typeof ifSchema === "boolean")) {
@@ -660,11 +559,18 @@ const generateCombinatorChecks = (key, raw, path, schema, suffix, ctx) => {
     const thenLines = thenSchema !== void 0 ? generateValueChecks(key, raw, path, thenSchema, suffix, ctx) : [];
     const elseLines = elseSchema !== void 0 ? generateValueChecks(key, raw, path, elseSchema, suffix, ctx) : [];
     if (thenLines.length > 0 || elseLines.length > 0) {
-      lines.push(`  if (${generateMatchesExpr(raw, ifSchema, suffix, ctx)}) {`);
-      lines.push(...thenLines);
-      lines.push(`  } else {`);
-      lines.push(...elseLines);
-      lines.push(`  }`);
+      const cond = generateMatchesExpr(raw, ifSchema, suffix, ctx);
+      if (cond === "true") {
+        lines.push(...thenLines);
+      } else if (cond === "false") {
+        lines.push(...elseLines);
+      } else {
+        lines.push(`  if (${cond}) {`);
+        lines.push(...thenLines);
+        lines.push(`  } else {`);
+        lines.push(...elseLines);
+        lines.push(`  }`);
+      }
     }
   }
   return lines;
@@ -680,7 +586,7 @@ const generatePatternAndAdditionalChecks = (schema, suffix, ctx) => {
   for (const [pattern, sub] of patternEntries) {
     const re = regexLiteral(pattern);
     const kv = `_pk${d}`;
-    const valueChecks = generateValueChecks(`\${${kv}}`, `${obj}[${kv}]`, `\`${ctx.pathPrefix}/\${${kv}}\``, sub, suffix, ctx);
+    const valueChecks = generateValueChecks(`\${${kv}}`, `${obj}[${kv}]`, `\`${ctx.pathPrefix}/\${escapePointer(${kv})}\``, sub, suffix, ctx);
     if (valueChecks.length === 0)
       continue;
     lines.push(`  for (const ${kv} in ${obj}) {`);
@@ -692,7 +598,7 @@ const generatePatternAndAdditionalChecks = (schema, suffix, ctx) => {
   if (hasAdditionalProperties(schema) && isSchemaObject(schema.additionalProperties)) {
     const additional = schema.additionalProperties;
     const kv = `_ak${d}`;
-    const valueChecks = generateValueChecks(`\${${kv}}`, `${obj}[${kv}]`, `\`${ctx.pathPrefix}/\${${kv}}\``, additional, suffix, ctx);
+    const valueChecks = generateValueChecks(`\${${kv}}`, `${obj}[${kv}]`, `\`${ctx.pathPrefix}/\${escapePointer(${kv})}\``, additional, suffix, ctx);
     if (valueChecks.length > 0) {
       const known = Object.keys(hasProperties(schema) ? schema.properties : {});
       lines.push(`  for (const ${kv} in ${obj}) {`);
@@ -746,10 +652,10 @@ const generateInlineObjectChecks = (key, propSchema, raw, suffix, ctx) => {
   ];
 };
 const generatePropertyNameChecks = (nameSchema, suffix, ctx) => {
-  const at = `\`${ctx.pathPrefix}/\${_name}\``;
+  const at = `\`${ctx.pathPrefix}/\${escapePointer(_name)}\``;
   const nameCtx = {
     objVar: ctx.objVar,
-    pathPrefix: `${ctx.pathPrefix}/\${_name}`,
+    pathPrefix: `${ctx.pathPrefix}/\${escapePointer(_name)}`,
     depth: ctx.depth + 1,
     hoisted: ctx.hoisted,
     rootSchema: ctx.rootSchema
@@ -777,6 +683,10 @@ const generateDependentRequiredChecks = (schema, ctx) => {
   }
   return lines;
 };
+const dependentSelfBinding = (objVar, depth) => {
+  const name = `_dep${depth}`;
+  return { name, declaration: `  const ${name}: unknown = ${objVar}` };
+};
 const generateDependentSchemasChecks = (schema, suffix, ctx) => {
   if (!isSchemaObject(schema))
     return [];
@@ -799,10 +709,12 @@ const generateDependentSchemasChecks = (schema, suffix, ctx) => {
     }
     if (!isSchemaObject(sub))
       continue;
-    const checks = generateValueChecks("", obj, objPath, sub, suffix, ctx);
+    const self = dependentSelfBinding(obj, ctx.depth);
+    const checks = generateValueChecks("", self.name, objPath, sub, suffix, ctx);
     if (checks.length === 0)
       continue;
     lines.push(`  if (${hasOwnCheck(obj, trigger)}) {`);
+    lines.push(`  ${self.declaration}`);
     lines.push(...checks.map((line) => `  ${line}`));
     lines.push(`  }`);
   }
@@ -841,10 +753,12 @@ const generateDependenciesChecks = (schema, suffix, ctx) => {
     }
     if (!isSchemaObject(value))
       continue;
-    const checks = generateValueChecks("", obj, objPath, value, suffix, ctx);
+    const self = dependentSelfBinding(obj, ctx.depth);
+    const checks = generateValueChecks("", self.name, objPath, value, suffix, ctx);
     if (checks.length === 0)
       continue;
     lines.push(`  if (${hasOwnCheck(obj, trigger)}) {`);
+    lines.push(`  ${self.declaration}`);
     lines.push(...checks.map((line) => `  ${line}`));
     lines.push(`  }`);
   }
@@ -993,15 +907,17 @@ const generateObjectValidator = (schema, typeName, suffix, rootSchema) => {
   if (hasPropertyNames(schema)) {
     propertyLines.push(...generatePropertyNameChecks(schema.propertyNames, suffix, ctx));
   }
-  propertyLines.push(...generateCombinatorChecks("", "obj", "`${_path}`", schema, suffix, ctx));
+  const objectCombinators = generateCombinatorChecks("", "_root", "`${_path}`", schema, suffix, ctx);
+  if (objectCombinators.length > 0) {
+    propertyLines.push(`  const _root: unknown = input`);
+    propertyLines.push(...objectCombinators);
+  }
   const body = (propertyLines.length > 0 ? "\n" + propertyLines.join("\n") + "\n" : "").replaceAll("errors.push(", "(errors ??= []).push(");
-  const hoistedBlock = ctx.hoisted.length > 0 ? `${ctx.hoisted.join("\n")}
-
-` : "";
   const guard = guardObjectConditions(schema, "input", "obj");
+  const objBinding = readsObjBinding(body) ? [`  const obj = input as Record<string, unknown>`] : [];
   const collectBody = (name, exported) => [
     `${exported ? "export " : ""}const ${name} = (input: unknown, _path = ''): ValidationResult => {`,
-    `  const obj = input as Record<string, unknown>`,
+    ...objBinding,
     `  if (typeof input !== 'object' || input === null || Array.isArray(input)) {`,
     `    return { valid: false, errors: [{ message: 'must be object', path: _path }] }`,
     `  }`,
@@ -1012,14 +928,15 @@ const generateObjectValidator = (schema, typeName, suffix, rootSchema) => {
     `}`
   ].join("\n");
   if (!guard) {
-    return `${hoistedBlock}${collectBody(vName, true)}`;
+    return withHoisted(ctx.hoisted, collectBody(vName, true));
   }
+  const guardText = guard.join("\n");
   const collectName = `${vName}Errors`;
-  return [
-    `${hoistedBlock}${collectBody(collectName, false)}`,
+  return withHoisted(ctx.hoisted, [
+    collectBody(collectName, false),
     ``,
     `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
-    `  const obj = input as Record<string, unknown>`,
+    ...readsObjBinding(guardText) ? [`  const obj = input as Record<string, unknown>`] : [],
     `  if (`,
     guard.map((condition) => `    ${condition}`).join(" &&\n"),
     `  ) {`,
@@ -1027,21 +944,49 @@ const generateObjectValidator = (schema, typeName, suffix, rootSchema) => {
     `  }`,
     `  return ${collectName}(input, _path)`,
     `}`
-  ].join("\n");
+  ].join("\n"));
 };
 const guardName = (typeName) => `is${typeName}`;
-const booleanLeafExpr = (schema, acc) => {
+const valueCanHaveType = (value, type) => {
+  switch (type) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number";
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "null":
+      return value === null;
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    default:
+      return true;
+  }
+};
+const booleanLeafExpr = (schema, acc, narrowable = true) => {
   if (!isSchemaObject(schema))
     return null;
-  if (hasRef(schema) || hasConst(schema) || hasOneOf(schema) || "anyOf" in schema || "allOf" in schema || "not" in schema || "if" in schema || "contains" in schema || "prefixItems" in schema || carriesUnevaluated(schema) || getMjstInstanceOf(schema) !== void 0 || getMjstPrimitive(schema) !== void 0) {
+  const typed = (type) => narrowable ? acc : `(${acc} as ${type})`;
+  if (hasRef(schema) || hasConst(schema) || hasOneOf(schema) || "anyOf" in schema || "allOf" in schema || "not" in schema || "if" in schema || "contains" in schema || "prefixItems" in schema || // A draft-07 tuple: the fixed positions live in an *array* `items` and the
+  // tail in `additionalItems`. Neither is expressible flat, and reading past
+  // them let the guard accept tuples `validateX` rejects.
+  Array.isArray(schema["items"]) || "additionalItems" in schema || carriesUnevaluated(schema) || getMjstInstanceOf(schema) !== void 0 || getMjstPrimitive(schema) !== void 0) {
     return null;
   }
-  if (hasEnum(schema)) {
+  if (!hasType(schema)) {
+    if (!hasEnum(schema))
+      return null;
+    if (declaresKeywordOutside(schema, ["enum"]))
+      return null;
     return enumMembershipExpr(schema.enum, acc);
   }
-  if (!hasType(schema))
-    return null;
   const t = schema.type;
+  const membership = hasEnum(schema) ? enumMembershipExpr(schema.enum.filter((member) => valueCanHaveType(member, t)), acc) : null;
+  const withMembership = (expr) => expr === null || membership === null ? expr : `${expr} && ${membership}`;
   switch (t) {
     // Each constraint is the exact negation of the validator's error condition,
     // so edge values — `NaN` above all, which compares `false` against every
@@ -1050,56 +995,61 @@ const booleanLeafExpr = (schema, acc) => {
     // condition is its negation; the length checks come from the same
     // `string-length-check` emitter the validator uses, for the same reason.
     case "string": {
+      const str = typed("string");
       const parts = [`typeof ${acc} === 'string'`];
       if (hasPattern(schema))
-        parts.push(`${regexLiteral(schema.pattern)}.test(${acc})`);
+        parts.push(`${regexLiteral(schema.pattern)}.test(${str})`);
       if (hasMinLength(schema))
-        parts.push(minLengthPassExpr(acc, schema.minLength));
+        parts.push(minLengthPassExpr(str, schema.minLength));
       if (hasMaxLength(schema))
-        parts.push(maxLengthPassExpr(acc, schema.maxLength));
-      return parts.join(" && ");
+        parts.push(maxLengthPassExpr(str, schema.maxLength));
+      return withMembership(parts.join(" && "));
     }
     case "number":
     case "integer": {
+      const num = typed("number");
       const parts = [`typeof ${acc} === 'number'`];
       if (t === "integer")
         parts.push(`Number.isInteger(${acc})`);
       if (hasMinimum(schema))
-        parts.push(`${acc} ${hasStrictExclusiveMinimum(schema) ? ">" : ">="} ${schema.minimum}`);
+        parts.push(`${num} ${hasStrictExclusiveMinimum(schema) ? ">" : ">="} ${schema.minimum}`);
       if (hasMaximum(schema))
-        parts.push(`${acc} ${hasStrictExclusiveMaximum(schema) ? "<" : "<="} ${schema.maximum}`);
+        parts.push(`${num} ${hasStrictExclusiveMaximum(schema) ? "<" : "<="} ${schema.maximum}`);
       if (hasExclusiveMinimum(schema))
-        parts.push(`${acc} > ${schema.exclusiveMinimum}`);
+        parts.push(`${num} > ${schema.exclusiveMinimum}`);
       if (hasExclusiveMaximum(schema))
-        parts.push(`${acc} < ${schema.exclusiveMaximum}`);
+        parts.push(`${num} < ${schema.exclusiveMaximum}`);
       if (hasMultipleOf(schema))
-        parts.push(multipleOfPassExpr(acc, schema.multipleOf));
-      return parts.join(" && ");
+        parts.push(multipleOfPassExpr(num, schema.multipleOf));
+      return withMembership(parts.join(" && "));
     }
     case "boolean":
-      return `typeof ${acc} === 'boolean'`;
+      return withMembership(`typeof ${acc} === 'boolean'`);
     case "null":
-      return `${acc} === null`;
+      return withMembership(`${acc} === null`);
     case "object": {
-      const parts = booleanObjectParts(schema, acc, `(${acc} as Record<string, unknown>)`);
-      return parts === null ? null : parts.join(" && ");
+      const parts = booleanObjectParts(schema, acc, `(${acc} as Record<string, unknown>)`, false);
+      return parts === null ? null : withMembership(parts.join(" && "));
     }
     case "array":
-      return booleanArrayExpr(schema, acc);
+      return withMembership(booleanArrayExpr(schema, acc, narrowable));
     default:
       return null;
   }
 };
-const booleanArrayExpr = (schema, acc) => {
+const booleanArrayExpr = (schema, acc, narrowable = true) => {
+  const arr = narrowable ? acc : `(${acc} as unknown[])`;
   const parts = [`Array.isArray(${acc})`];
   if (hasMinItems(schema))
-    parts.push(`${acc}.length >= ${schema.minItems}`);
+    parts.push(`${arr}.length >= ${schema.minItems}`);
   if (hasMaxItems(schema))
-    parts.push(`${acc}.length <= ${schema.maxItems}`);
+    parts.push(`${arr}.length <= ${schema.maxItems}`);
   if (hasUniqueItems(schema) && schema.uniqueItems === true) {
-    parts.push(arrayItemsAreScalarOnly(schema) ? `new Set((${acc} as unknown[]).map((_u) => JSON.stringify(_u))).size === ${acc}.length` : `allUnique(${acc} as unknown[])`);
+    parts.push(arrayItemsAreScalarOnly(schema) ? `new Set((${acc} as unknown[]).map((_u) => JSON.stringify(_u))).size === ${arr}.length` : `allUnique(${acc} as unknown[])`);
   }
   const base = parts.join(" && ");
+  if (schema["items"] === false)
+    return `${base} && ${arr}.length === 0`;
   if (!hasItems(schema))
     return base;
   const items = schema.items;
@@ -1112,9 +1062,13 @@ const booleanArrayExpr = (schema, acc) => {
     return null;
   return `${base} && Array.from(${acc} as unknown[]).every((_it) => (${itemExpr}))`;
 };
-const booleanObjectParts = (schema, raw, objAcc) => {
+const booleanObjectParts = (schema, raw, objAcc, narrowable = true) => {
   if (!isObjectSchema(schema))
     return null;
+  if (hasRef(schema) || hasConst(schema) || hasEnum(schema))
+    return null;
+  if (getMjstInstanceOf(schema) !== void 0 || getMjstPrimitive(schema) !== void 0)
+    return null;
   if (hasDependentRequired(schema) || hasPropertyNames(schema) || "dependentSchemas" in schema)
     return null;
   if (hasMinProperties(schema) || hasMaxProperties(schema) || "dependencies" in schema)
@@ -1144,11 +1098,16 @@ const booleanObjectParts = (schema, raw, objAcc) => {
     if (PROTOTYPE_MEMBERS.has(key))
       return null;
     const member = safeAccessor(objAcc, key);
-    const expr = booleanLeafExpr(propSchema, member);
+    const expr = booleanLeafExpr(propSchema, member, narrowable);
     if (expr === null)
       return null;
     parts.push(required.has(key) ? expr : `(${member} === undefined || (${expr}))`);
   }
+  for (const key of required) {
+    if (Object.hasOwn(properties, key))
+      continue;
+    parts.push(hasOwnCheck(objAcc, key));
+  }
   if (strict) {
     if (keys.length === 0) {
       parts.push(`Object.keys(${objAcc}).length === 0`);
@@ -1182,13 +1141,15 @@ const generateBooleanGuard = (schema, typeName, _suffix = "") => {
   const returns = typeDescribesEveryAcceptedValue(rewriteNullable(schema)) ? `input is ${typeName}` : "boolean";
   const fallback = `export const ${name} = (input: unknown): ${returns} => ${validatorName(typeName)}(input) === true`;
   const rewritten = rewriteNullable(schema);
-  if (declaresObjectType(rewritten)) {
+  if (declaresObjectType(rewritten) && objectRootIsSelfContained(rewritten)) {
     const parts = booleanObjectParts(rewritten, "input", "obj");
     if (parts === null)
       return fallback;
     return [
       `export const ${name} = (input: unknown): ${returns} => {`,
-      `  const obj = input as Record<string, unknown>`,
+      // Same unused-local as the validator's hot guard: a node with no property
+      // to read guards on the shape alone and never touches the narrowing.
+      ...readsObjBinding(parts.join("\n")) ? [`  const obj = input as Record<string, unknown>`] : [],
       `  return (`,
       parts.map((part) => `    ${part}`).join(" &&\n"),
       `  )`,
@@ -1212,7 +1173,10 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
     }
     return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join("\n");
   }
+  const generalRoot = () => generateGeneralRootValidator(schema, typeName, suffix, rootSchema);
   if (hasRef(schema)) {
+    if (declaresKeywordOutside(schema, ["$ref"]))
+      return generalRoot();
     const delegateName = validatorName(refToName(schema.$ref, suffix));
     return [
       `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
@@ -1222,6 +1186,8 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
   }
   const instanceOf = getMjstInstanceOf(schema);
   if (instanceOf) {
+    if (declaresKeywordOutside(schema, [MJST_EXTENSION_KEY, "type"]))
+      return generalRoot();
     return [
       `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
       `  if (!(input instanceof ${instanceOf})) {`,
@@ -1233,6 +1199,8 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
   }
   const primitive = getMjstPrimitive(schema);
   if (primitive) {
+    if (declaresKeywordOutside(schema, [MJST_EXTENSION_KEY, "type"]))
+      return generalRoot();
     return [
       `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
       `  if (typeof input !== "${primitive}") {`,
@@ -1243,6 +1211,8 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
     ].join("\n");
   }
   if (hasConst(schema)) {
+    if (declaresKeywordOutside(schema, ["const"]))
+      return generalRoot();
     const mismatch = constMismatchCondition("input", schema.const);
     const msg = JSON.stringify(`must be ${JSON.stringify(schema.const)}`);
     return [
@@ -1255,6 +1225,8 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
     ].join("\n");
   }
   if (hasEnum(schema)) {
+    if (declaresKeywordOutside(schema, ["enum"]))
+      return generalRoot();
     const label = schema.enum.map((v) => JSON.stringify(v)).join(", ");
     return [
       `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
@@ -1290,16 +1262,13 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
     checks.push(...generateConstraintChecks("", "input", rootPath, schema, suffix, ctx));
     checks.push(...generateCombinatorChecks("", "input", rootPath, schema, suffix, ctx));
     const body = checks.join("\n").replaceAll("errors.push(", "(errors ??= []).push(");
-    const hoistedBlock = ctx.hoisted.length > 0 ? `${ctx.hoisted.join("\n")}
-
-` : "";
-    return [
-      `${hoistedBlock}export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+    return withHoisted(ctx.hoisted, [
+      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
       `  let errors: ValidationError[] | undefined`,
       body,
       `  return errors !== undefined ? { valid: false, errors } : true`,
       `}`
-    ].join("\n");
+    ].join("\n"));
   }
   const rootTypeArray = getTypeArray(schema);
   if (rootTypeArray) {
@@ -1322,23 +1291,20 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
       ].join("\n");
     }
     const body = checks.join("\n").replaceAll("errors.push(", "(errors ??= []).push(");
-    const hoistedBlock = ctx.hoisted.length > 0 ? `${ctx.hoisted.join("\n")}
-
-` : "";
-    return [
-      `${hoistedBlock}export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+    return withHoisted(ctx.hoisted, [
+      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
       `  let errors: ValidationError[] | undefined`,
       body,
       `  return errors !== undefined ? { valid: false, errors } : true`,
       `}`
-    ].join("\n");
+    ].join("\n"));
   }
   if (hasType(schema)) {
     const t = schema.type;
     const wrongType = wrongTypeCondition("input", t);
     const typLabel = typeofString(t);
     const rootCtx = createRootContext(rootSchema);
-    const constraintLines = generateConstraintChecks("", "input", "`${_path}`", schema, suffix, rootCtx);
+    const constraintLines = generateConstraintChecks("", "_root", "`${_path}`", schema, suffix, rootCtx);
     if (!wrongType) {
       return [
         `export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`,
@@ -1356,50 +1322,42 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
         `}`
       ].join("\n");
     }
-    const hoistedBlock = rootCtx.hoisted.length > 0 ? `${rootCtx.hoisted.join("\n")}
-
-` : "";
-    return [
-      `${hoistedBlock}export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+    return withHoisted(rootCtx.hoisted, [
+      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
       `  if (${wrongType}) {`,
       `    return { valid: false, errors: [{ message: 'must be ${typLabel}', path: _path }] }`,
       `  }`,
+      `  const _root: unknown = input`,
       `  let errors: ValidationError[] | undefined`,
       constraintLines.join("\n").replaceAll("errors.push(", "(errors ??= []).push("),
       `  return errors !== undefined ? { valid: false, errors } : true`,
       `}`
-    ].join("\n");
+    ].join("\n"));
   }
   const typelessCtx = createRootContext(rootSchema);
   const typelessChecks = generateConstraintChecks("", "input", "`${_path}`", schema, suffix, typelessCtx);
   if (typelessChecks.length === 0) {
     return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join("\n");
   }
-  const typelessHoisted = typelessCtx.hoisted.length > 0 ? `${typelessCtx.hoisted.join("\n")}
-
-` : "";
-  return [
-    `${typelessHoisted}export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+  return withHoisted(typelessCtx.hoisted, [
+    `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
     `  let errors: ValidationError[] | undefined`,
     typelessChecks.join("\n").replaceAll("errors.push(", "(errors ??= []).push("),
     `  return errors !== undefined ? { valid: false, errors } : true`,
     `}`
-  ].join("\n");
+  ].join("\n"));
 };
-const generateUnevaluatedRootValidator = (schema, typeName, suffix, rootSchema) => {
+const generateGeneralRootValidator = (schema, typeName, suffix, rootSchema) => {
   const ctx = createRootContext(rootSchema);
   const checks = generateValueChecks("", "input", "`${_path}`", schema, suffix, ctx, true);
   const body = checks.join("\n").replaceAll("errors.push(", "(errors ??= []).push(");
-  const hoistedBlock = ctx.hoisted.length > 0 ? `${ctx.hoisted.join("\n")}
-
-` : "";
-  return [
-    `${hoistedBlock}export const ${validatorName(typeName)} = (input: unknown, _path = ''): ValidationResult => {`,
+  return withHoisted(ctx.hoisted, [
+    `export const ${validatorName(typeName)} = (input: unknown, _path = ''): ValidationResult => {`,
     `  let errors: ValidationError[] | undefined`,
     body,
     `  return errors !== undefined ? { valid: false, errors } : true`,
     `}`
-  ].join("\n");
+  ].join("\n"));
 };
 const SINGLE_SUBSCHEMA_KEYS = /* @__PURE__ */ new Set([
   "additionalProperties",
@@ -1462,9 +1420,9 @@ const generateValidatorFunction = (schema, typeName, suffix = "", rootSchema) =>
   const document = rootSchema ?? schema;
   assertUnevaluatedGeneratable(rewritten, typeName, document, unevaluatedMatcher(suffix, createRootContext(document)));
   if (carriesUnevaluated(rewritten)) {
-    return generateUnevaluatedRootValidator(rewritten, typeName, suffix, document);
+    return generateGeneralRootValidator(rewritten, typeName, suffix, document);
   }
-  if (declaresObjectType(rewritten)) {
+  if (declaresObjectType(rewritten) && objectRootIsSelfContained(rewritten)) {
     return generateObjectValidator(rewritten, typeName, suffix, document);
   }
   return generateScalarValidator(rewritten, typeName, suffix, document);