@narrative.io/jsonforms-provider-protocols 3.0.0-beta.12 → 3.0.0-beta.13

package/dist/core/initFormData.d.ts

@@ -2,9 +2,16 @@
  * Initialize a form data object from a JSON Schema.
  * Resolves $ref, const, default, oneOf/discriminator, and typed empty values.
  *
+ * Optional fields (not listed in the parent schema's `required` array) that
+ * have no `const`, no single-value `enum`, and no `default` are omitted
+ * entirely from the result. This avoids seeding values (e.g. `null` for
+ * `type: "integer"`) that fail AJV's type check and surface spurious errors
+ * on untouched fields. Required fields retain legacy typed-empty seeding
+ * (`""`, `null`, `false`, `[]`) so that "is required" surfaces cleanly.
+ *
  * @param schema - The full JSON Schema (must include $defs if $refs are used)
  * @param seed   - Optional existing data to merge (seed values take priority)
- * @returns A data object with all schema-defined fields initialized
+ * @returns A data object with schema-defined fields initialized
  */
 export declare function initFormDataFromSchema(schema: Record<string, unknown>, seed?: Record<string, unknown>): Record<string, unknown>;
 //# sourceMappingURL=initFormData.d.ts.map

package/dist/core/initFormData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initFormData.d.ts","sourceRoot":"","sources":["../../src/core/initFormData.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAyBzB"}
+{"version":3,"file":"initFormData.d.ts","sourceRoot":"","sources":["../../src/core/initFormData.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA0BzB"}

package/dist/core/initFormData.js

@@ -1,18 +1,19 @@
 function initFormDataFromSchema(schema, seed) {
-  const result = initProperty(schema, schema, seed);
-  if (result && typeof result === "object" && !Array.isArray(result) && seed && typeof seed === "object") {
+  const result = initProperty(schema, schema, seed, true);
+  const base = result && typeof result === "object" && !Array.isArray(result) ? result : {};
+  if (seed && typeof seed === "object") {
     const schemaKeys = new Set(
       Object.keys(
         resolveRef(schema, schema)?.properties ?? {}
       )
     );
     for (const key of Object.keys(seed)) {
-      if (!schemaKeys.has(key) && !(key in result)) {
-        result[key] = seed[key];
+      if (!schemaKeys.has(key) && !(key in base)) {
+        base[key] = seed[key];
       }
     }
   }
-  return result ?? {};
+  return base;
 }
 function resolveRef(property, root, seen) {
   if (!property || typeof property !== "object") return property;
@@ -38,12 +39,11 @@ function resolvePointer(obj, pointer) {
   }
   return current;
 }
-function initProperty(property, root, seed) {
-  if (!property || typeof property !== "object") return null;
-  const resolved = resolveRef(property, root);
-  if (Array.isArray(resolved.oneOf)) {
-    return initOneOf(resolved, root, seed);
+function initProperty(property, root, seed, required) {
+  if (!property || typeof property !== "object") {
+    return required ? null : void 0;
   }
+  const resolved = resolveRef(property, root);
   const type = resolved.type;
   if (seed !== void 0 && seed !== null && type !== "object") {
     return seed;
@@ -57,9 +57,22 @@ function initProperty(property, root, seed) {
   if ("default" in resolved) {
     return resolved.default;
   }
+  if (Array.isArray(resolved.oneOf)) {
+    if (!required) return void 0;
+    return initOneOf(resolved, root, seed);
+  }
+  if (type === "object") {
+    const obj = initObject(
+      resolved,
+      root,
+      seed,
+      required
+    );
+    if (!required && Object.keys(obj).length === 0) return void 0;
+    return obj;
+  }
+  if (!required) return void 0;
   switch (type) {
-    case "object":
-      return initObject(resolved, root, seed);
     case "array":
       return seed !== void 0 && seed !== null ? seed : [];
     case "string":
@@ -68,20 +81,26 @@ function initProperty(property, root, seed) {
       return false;
     case "number":
     case "integer":
-      return null;
     default:
       return null;
   }
 }
-function initObject(schema, root, seed) {
+function initObject(schema, root, seed, parentRequired) {
   const properties = schema.properties;
   if (!properties) {
     return seed && typeof seed === "object" ? { ...seed } : {};
   }
+  const requiredSet = new Set(
+    Array.isArray(schema.required) ? schema.required : []
+  );
   const result = {};
   for (const [key, propSchema] of Object.entries(properties)) {
     const seedValue = seed && typeof seed === "object" ? seed[key] : void 0;
-    result[key] = initProperty(propSchema, root, seedValue);
+    const effectiveRequired = parentRequired && requiredSet.has(key);
+    const value = initProperty(propSchema, root, seedValue, effectiveRequired);
+    if (value !== void 0) {
+      result[key] = value;
+    }
   }
   return result;
 }
@@ -91,7 +110,7 @@ function initOneOf(schema, root, seed) {
   const first = variants[0];
   if (!first) return null;
   const firstVariant = resolveRef(first, root);
-  return initProperty(firstVariant, root, seed);
+  return initProperty(firstVariant, root, seed, true);
 }
 export {
   initFormDataFromSchema

package/dist/core/initFormData.js.map

@@ -1 +1 @@
-{"version":3,"file":"initFormData.js","sources":["../../src/core/initFormData.ts"],"sourcesContent":["/**\n * Initialize a form data object from a JSON Schema.\n * Resolves $ref, const, default, oneOf/discriminator, and typed empty values.\n *\n * @param schema - The full JSON Schema (must include $defs if $refs are used)\n * @param seed   - Optional existing data to merge (seed values take priority)\n * @returns A data object with all schema-defined fields initialized\n */\nexport function initFormDataFromSchema(\n  schema: Record<string, unknown>,\n  seed?: Record<string, unknown>,\n): Record<string, unknown> {\n  const result = initProperty(schema, schema, seed) as Record<string, unknown>;\n\n  // If result is an object and seed has extra keys not in schema, preserve them\n  if (\n    result &&\n    typeof result === \"object\" &&\n    !Array.isArray(result) &&\n    seed &&\n    typeof seed === \"object\"\n  ) {\n    const schemaKeys = new Set(\n      Object.keys(\n        (resolveRef(schema, schema) as Record<string, unknown>)?.properties ??\n          {},\n      ),\n    );\n    for (const key of Object.keys(seed)) {\n      if (!schemaKeys.has(key) && !(key in result)) {\n        result[key] = seed[key];\n      }\n    }\n  }\n\n  return result ?? {};\n}\n\n/**\n * Resolve a $ref pointer against the root schema's $defs.\n * Supports nested $ref chains.\n */\nfunction resolveRef(\n  property: Record<string, unknown>,\n  root: Record<string, unknown>,\n  seen?: Set<string>,\n): Record<string, unknown> {\n  if (!property || typeof property !== \"object\") return property;\n\n  const ref = property.$ref as string | undefined;\n  if (!ref) return property;\n\n  // Guard against circular refs\n  const visited = seen ?? new Set<string>();\n  if (visited.has(ref)) return property;\n  visited.add(ref);\n\n  const resolved = resolvePointer(root, ref);\n  if (!resolved) return property;\n\n  // Continue resolving if the result itself has a $ref\n  return resolveRef(resolved as Record<string, unknown>, root, visited);\n}\n\n/**\n * Resolve a JSON pointer like \"#/$defs/Price\" against an object.\n */\nfunction resolvePointer(\n  obj: Record<string, unknown>,\n  pointer: string,\n): unknown {\n  if (!pointer.startsWith(\"#/\")) return undefined;\n  const parts = pointer.slice(2).split(\"/\");\n  let current: unknown = obj;\n  for (const part of parts) {\n    if (current && typeof current === \"object\" && part in current) {\n      current = (current as Record<string, unknown>)[part];\n    } else {\n      return undefined;\n    }\n  }\n  return current;\n}\n\n/**\n * Initialize a single property value based on its schema definition.\n */\nfunction initProperty(\n  property: Record<string, unknown>,\n  root: Record<string, unknown>,\n  seed?: unknown,\n): unknown {\n  if (!property || typeof property !== \"object\") return null;\n\n  // Resolve $ref first\n  const resolved = resolveRef(property, root);\n\n  // Handle oneOf with discriminator — pick first variant\n  if (Array.isArray(resolved.oneOf)) {\n    return initOneOf(resolved, root, seed);\n  }\n\n  // Priority 1: seed wins (for object types, we merge recursively below)\n  // For non-object types, return seed directly if present\n  const type = resolved.type as string | undefined;\n  if (seed !== undefined && seed !== null && type !== \"object\") {\n    return seed;\n  }\n\n  // Priority 2: const\n  if (\"const\" in resolved) {\n    return resolved.const;\n  }\n\n  // Priority 3: single-value enum\n  if (\n    Array.isArray(resolved.enum) &&\n    (resolved.enum as unknown[]).length === 1\n  ) {\n    return (resolved.enum as unknown[])[0];\n  }\n\n  // Priority 4: default\n  if (\"default\" in resolved) {\n    return resolved.default;\n  }\n\n  // Priority 5: typed empty values\n  switch (type) {\n    case \"object\":\n      return initObject(resolved, root, seed as Record<string, unknown>);\n    case \"array\":\n      return seed !== undefined && seed !== null ? seed : [];\n    case \"string\":\n      return \"\";\n    case \"boolean\":\n      return false;\n    case \"number\":\n    case \"integer\":\n      return null;\n    default:\n      return null;\n  }\n}\n\n/**\n * Initialize an object type by recursing into its properties.\n */\nfunction initObject(\n  schema: Record<string, unknown>,\n  root: Record<string, unknown>,\n  seed?: Record<string, unknown>,\n): Record<string, unknown> {\n  const properties = schema.properties as\n    | Record<string, Record<string, unknown>>\n    | undefined;\n  if (!properties) {\n    // Object with no defined properties — return seed or empty object\n    return seed && typeof seed === \"object\" ? { ...seed } : {};\n  }\n\n  const result: Record<string, unknown> = {};\n\n  for (const [key, propSchema] of Object.entries(properties)) {\n    const seedValue = seed && typeof seed === \"object\" ? seed[key] : undefined;\n    result[key] = initProperty(propSchema, root, seedValue);\n  }\n\n  return result;\n}\n\n/**\n * Handle oneOf schemas — pick the first variant and initialize it.\n */\nfunction initOneOf(\n  schema: Record<string, unknown>,\n  root: Record<string, unknown>,\n  seed?: unknown,\n): unknown {\n  const variants = schema.oneOf as Record<string, unknown>[];\n  if (!variants || variants.length === 0) return null;\n\n  const first = variants[0];\n  if (!first) return null;\n\n  // Pick first variant, resolve its $ref if needed\n  const firstVariant = resolveRef(first, root);\n  return initProperty(firstVariant, root, seed);\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"initFormData.js","sources":["../../src/core/initFormData.ts"],"sourcesContent":["/**\n * Initialize a form data object from a JSON Schema.\n * Resolves $ref, const, default, oneOf/discriminator, and typed empty values.\n *\n * Optional fields (not listed in the parent schema's `required` array) that\n * have no `const`, no single-value `enum`, and no `default` are omitted\n * entirely from the result. This avoids seeding values (e.g. `null` for\n * `type: \"integer\"`) that fail AJV's type check and surface spurious errors\n * on untouched fields. Required fields retain legacy typed-empty seeding\n * (`\"\"`, `null`, `false`, `[]`) so that \"is required\" surfaces cleanly.\n *\n * @param schema - The full JSON Schema (must include $defs if $refs are used)\n * @param seed   - Optional existing data to merge (seed values take priority)\n * @returns A data object with schema-defined fields initialized\n */\nexport function initFormDataFromSchema(\n  schema: Record<string, unknown>,\n  seed?: Record<string, unknown>,\n): Record<string, unknown> {\n  const result = initProperty(schema, schema, seed, true) as\n    | Record<string, unknown>\n    | undefined;\n\n  const base =\n    result && typeof result === \"object\" && !Array.isArray(result)\n      ? result\n      : {};\n\n  // Preserve seed keys not described by the schema's properties.\n  if (seed && typeof seed === \"object\") {\n    const schemaKeys = new Set(\n      Object.keys(\n        (resolveRef(schema, schema) as Record<string, unknown>)?.properties ??\n          {},\n      ),\n    );\n    for (const key of Object.keys(seed)) {\n      if (!schemaKeys.has(key) && !(key in base)) {\n        base[key] = seed[key];\n      }\n    }\n  }\n\n  return base;\n}\n\n/**\n * Resolve a $ref pointer against the root schema's $defs.\n * Supports nested $ref chains.\n */\nfunction resolveRef(\n  property: Record<string, unknown>,\n  root: Record<string, unknown>,\n  seen?: Set<string>,\n): Record<string, unknown> {\n  if (!property || typeof property !== \"object\") return property;\n\n  const ref = property.$ref as string | undefined;\n  if (!ref) return property;\n\n  const visited = seen ?? new Set<string>();\n  if (visited.has(ref)) return property;\n  visited.add(ref);\n\n  const resolved = resolvePointer(root, ref);\n  if (!resolved) return property;\n\n  return resolveRef(resolved as Record<string, unknown>, root, visited);\n}\n\n/**\n * Resolve a JSON pointer like \"#/$defs/Price\" against an object.\n */\nfunction resolvePointer(\n  obj: Record<string, unknown>,\n  pointer: string,\n): unknown {\n  if (!pointer.startsWith(\"#/\")) return undefined;\n  const parts = pointer.slice(2).split(\"/\");\n  let current: unknown = obj;\n  for (const part of parts) {\n    if (current && typeof current === \"object\" && part in current) {\n      current = (current as Record<string, unknown>)[part];\n    } else {\n      return undefined;\n    }\n  }\n  return current;\n}\n\n/**\n * Initialize a single property value based on its schema definition.\n * Returns `undefined` when the property is optional and has nothing\n * concrete to seed — the caller then omits the key from its result.\n */\nfunction initProperty(\n  property: Record<string, unknown>,\n  root: Record<string, unknown>,\n  seed: unknown,\n  required: boolean,\n): unknown {\n  if (!property || typeof property !== \"object\") {\n    return required ? null : undefined;\n  }\n\n  const resolved = resolveRef(property, root);\n  const type = resolved.type as string | undefined;\n\n  // Priority 1: seed wins for non-object types.\n  if (seed !== undefined && seed !== null && type !== \"object\") {\n    return seed;\n  }\n\n  // Priority 2: const (schema-invariant — always set).\n  if (\"const\" in resolved) {\n    return resolved.const;\n  }\n\n  // Priority 3: single-value enum (same reasoning — only one valid value).\n  if (\n    Array.isArray(resolved.enum) &&\n    (resolved.enum as unknown[]).length === 1\n  ) {\n    return (resolved.enum as unknown[])[0];\n  }\n\n  // Priority 4: default (explicit author intent — always honored).\n  if (\"default\" in resolved) {\n    return resolved.default;\n  }\n\n  // Priority 5: oneOf. For required fields, materialize the first variant\n  // so the discriminator and shape are present. For optional fields, leave\n  // undefined so the user isn't forced into a variant they haven't chosen.\n  if (Array.isArray(resolved.oneOf)) {\n    if (!required) return undefined;\n    return initOneOf(resolved, root, seed);\n  }\n\n  // Priority 6: objects recurse. The `required` flag propagates downward:\n  // inside an optional ancestor, nested required primitives also collapse,\n  // so an optional object with nested required fields stays absent instead\n  // of materializing a shell that AJV would flag.\n  if (type === \"object\") {\n    const obj = initObject(\n      resolved,\n      root,\n      seed as Record<string, unknown>,\n      required,\n    );\n    if (!required && Object.keys(obj).length === 0) return undefined;\n    return obj;\n  }\n\n  // Priority 7: optional primitives — omit.\n  if (!required) return undefined;\n\n  // Priority 8: required primitives — legacy typed empty.\n  switch (type) {\n    case \"array\":\n      return seed !== undefined && seed !== null ? seed : [];\n    case \"string\":\n      return \"\";\n    case \"boolean\":\n      return false;\n    case \"number\":\n    case \"integer\":\n    default:\n      return null;\n  }\n}\n\n/**\n * Initialize an object type by recursing into its properties.\n * Keys whose initialization returns `undefined` are omitted.\n *\n * `parentRequired` controls how schema.required propagates: a child is\n * treated as required only if both its parent is required AND it appears in\n * the parent's required array. Inside an optional ancestor the whole\n * subtree collapses (except for author-forced values: const, default,\n * single-value enum, or seeded values).\n */\nfunction initObject(\n  schema: Record<string, unknown>,\n  root: Record<string, unknown>,\n  seed: Record<string, unknown> | undefined,\n  parentRequired: boolean,\n): Record<string, unknown> {\n  const properties = schema.properties as\n    | Record<string, Record<string, unknown>>\n    | undefined;\n  if (!properties) {\n    return seed && typeof seed === \"object\" ? { ...seed } : {};\n  }\n\n  const requiredSet = new Set<string>(\n    Array.isArray(schema.required) ? (schema.required as string[]) : [],\n  );\n\n  const result: Record<string, unknown> = {};\n\n  for (const [key, propSchema] of Object.entries(properties)) {\n    const seedValue = seed && typeof seed === \"object\" ? seed[key] : undefined;\n    const effectiveRequired = parentRequired && requiredSet.has(key);\n    const value = initProperty(propSchema, root, seedValue, effectiveRequired);\n    if (value !== undefined) {\n      result[key] = value;\n    }\n  }\n\n  return result;\n}\n\n/**\n * Handle oneOf schemas — pick the first variant and initialize it.\n * The variant is treated as required so its own required discriminator\n * and structure seed cleanly.\n */\nfunction initOneOf(\n  schema: Record<string, unknown>,\n  root: Record<string, unknown>,\n  seed?: unknown,\n): unknown {\n  const variants = schema.oneOf as Record<string, unknown>[];\n  if (!variants || variants.length === 0) return null;\n\n  const first = variants[0];\n  if (!first) return null;\n\n  const firstVariant = resolveRef(first, root);\n  return initProperty(firstVariant, root, seed, true);\n}\n"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narrative.io/jsonforms-provider-protocols",
-	"version": "3.0.0-beta.12",
+	"version": "3.0.0-beta.13",
 	"description": "Dynamic data provider capabilities for JSONForms with Vue 3 integration",
 	"type": "module",
 	"author": "Narrative I/O",

package/src/core/initFormData.ts

@@ -2,24 +2,32 @@
  * Initialize a form data object from a JSON Schema.
  * Resolves $ref, const, default, oneOf/discriminator, and typed empty values.
  *
+ * Optional fields (not listed in the parent schema's `required` array) that
+ * have no `const`, no single-value `enum`, and no `default` are omitted
+ * entirely from the result. This avoids seeding values (e.g. `null` for
+ * `type: "integer"`) that fail AJV's type check and surface spurious errors
+ * on untouched fields. Required fields retain legacy typed-empty seeding
+ * (`""`, `null`, `false`, `[]`) so that "is required" surfaces cleanly.
+ *
  * @param schema - The full JSON Schema (must include $defs if $refs are used)
  * @param seed   - Optional existing data to merge (seed values take priority)
- * @returns A data object with all schema-defined fields initialized
+ * @returns A data object with schema-defined fields initialized
  */
 export function initFormDataFromSchema(
   schema: Record<string, unknown>,
   seed?: Record<string, unknown>,
 ): Record<string, unknown> {
-  const result = initProperty(schema, schema, seed) as Record<string, unknown>;
+  const result = initProperty(schema, schema, seed, true) as
+    | Record<string, unknown>
+    | undefined;
 
-  // If result is an object and seed has extra keys not in schema, preserve them
-  if (
-    result &&
-    typeof result === "object" &&
-    !Array.isArray(result) &&
-    seed &&
-    typeof seed === "object"
-  ) {
+  const base =
+    result && typeof result === "object" && !Array.isArray(result)
+      ? result
+      : {};
+
+  // Preserve seed keys not described by the schema's properties.
+  if (seed && typeof seed === "object") {
     const schemaKeys = new Set(
       Object.keys(
         (resolveRef(schema, schema) as Record<string, unknown>)?.properties ??
@@ -27,13 +35,13 @@ export function initFormDataFromSchema(
       ),
     );
     for (const key of Object.keys(seed)) {
-      if (!schemaKeys.has(key) && !(key in result)) {
-        result[key] = seed[key];
+      if (!schemaKeys.has(key) && !(key in base)) {
+        base[key] = seed[key];
       }
     }
   }
 
-  return result ?? {};
+  return base;
 }
 
 /**
@@ -50,7 +58,6 @@ function resolveRef(
   const ref = property.$ref as string | undefined;
   if (!ref) return property;
 
-  // Guard against circular refs
   const visited = seen ?? new Set<string>();
   if (visited.has(ref)) return property;
   visited.add(ref);
@@ -58,7 +65,6 @@ function resolveRef(
   const resolved = resolvePointer(root, ref);
   if (!resolved) return property;
 
-  // Continue resolving if the result itself has a $ref
   return resolveRef(resolved as Record<string, unknown>, root, visited);
 }
 
@@ -84,35 +90,33 @@ function resolvePointer(
 
 /**
  * Initialize a single property value based on its schema definition.
+ * Returns `undefined` when the property is optional and has nothing
+ * concrete to seed — the caller then omits the key from its result.
  */
 function initProperty(
   property: Record<string, unknown>,
   root: Record<string, unknown>,
-  seed?: unknown,
+  seed: unknown,
+  required: boolean,
 ): unknown {
-  if (!property || typeof property !== "object") return null;
-
-  // Resolve $ref first
-  const resolved = resolveRef(property, root);
-
-  // Handle oneOf with discriminator — pick first variant
-  if (Array.isArray(resolved.oneOf)) {
-    return initOneOf(resolved, root, seed);
+  if (!property || typeof property !== "object") {
+    return required ? null : undefined;
   }
 
-  // Priority 1: seed wins (for object types, we merge recursively below)
-  // For non-object types, return seed directly if present
+  const resolved = resolveRef(property, root);
   const type = resolved.type as string | undefined;
+
+  // Priority 1: seed wins for non-object types.
   if (seed !== undefined && seed !== null && type !== "object") {
     return seed;
   }
 
-  // Priority 2: const
+  // Priority 2: const (schema-invariant — always set).
   if ("const" in resolved) {
     return resolved.const;
   }
 
-  // Priority 3: single-value enum
+  // Priority 3: single-value enum (same reasoning — only one valid value).
   if (
     Array.isArray(resolved.enum) &&
     (resolved.enum as unknown[]).length === 1
@@ -120,15 +124,39 @@ function initProperty(
     return (resolved.enum as unknown[])[0];
   }
 
-  // Priority 4: default
+  // Priority 4: default (explicit author intent — always honored).
   if ("default" in resolved) {
     return resolved.default;
   }
 
-  // Priority 5: typed empty values
+  // Priority 5: oneOf. For required fields, materialize the first variant
+  // so the discriminator and shape are present. For optional fields, leave
+  // undefined so the user isn't forced into a variant they haven't chosen.
+  if (Array.isArray(resolved.oneOf)) {
+    if (!required) return undefined;
+    return initOneOf(resolved, root, seed);
+  }
+
+  // Priority 6: objects recurse. The `required` flag propagates downward:
+  // inside an optional ancestor, nested required primitives also collapse,
+  // so an optional object with nested required fields stays absent instead
+  // of materializing a shell that AJV would flag.
+  if (type === "object") {
+    const obj = initObject(
+      resolved,
+      root,
+      seed as Record<string, unknown>,
+      required,
+    );
+    if (!required && Object.keys(obj).length === 0) return undefined;
+    return obj;
+  }
+
+  // Priority 7: optional primitives — omit.
+  if (!required) return undefined;
+
+  // Priority 8: required primitives — legacy typed empty.
   switch (type) {
-    case "object":
-      return initObject(resolved, root, seed as Record<string, unknown>);
     case "array":
       return seed !== undefined && seed !== null ? seed : [];
     case "string":
@@ -137,7 +165,6 @@ function initProperty(
       return false;
     case "number":
     case "integer":
-      return null;
     default:
       return null;
   }
@@ -145,25 +172,40 @@ function initProperty(
 
 /**
  * Initialize an object type by recursing into its properties.
+ * Keys whose initialization returns `undefined` are omitted.
+ *
+ * `parentRequired` controls how schema.required propagates: a child is
+ * treated as required only if both its parent is required AND it appears in
+ * the parent's required array. Inside an optional ancestor the whole
+ * subtree collapses (except for author-forced values: const, default,
+ * single-value enum, or seeded values).
  */
 function initObject(
   schema: Record<string, unknown>,
   root: Record<string, unknown>,
-  seed?: Record<string, unknown>,
+  seed: Record<string, unknown> | undefined,
+  parentRequired: boolean,
 ): Record<string, unknown> {
   const properties = schema.properties as
     | Record<string, Record<string, unknown>>
     | undefined;
   if (!properties) {
-    // Object with no defined properties — return seed or empty object
     return seed && typeof seed === "object" ? { ...seed } : {};
   }
 
+  const requiredSet = new Set<string>(
+    Array.isArray(schema.required) ? (schema.required as string[]) : [],
+  );
+
   const result: Record<string, unknown> = {};
 
   for (const [key, propSchema] of Object.entries(properties)) {
     const seedValue = seed && typeof seed === "object" ? seed[key] : undefined;
-    result[key] = initProperty(propSchema, root, seedValue);
+    const effectiveRequired = parentRequired && requiredSet.has(key);
+    const value = initProperty(propSchema, root, seedValue, effectiveRequired);
+    if (value !== undefined) {
+      result[key] = value;
+    }
   }
 
   return result;
@@ -171,6 +213,8 @@ function initObject(
 
 /**
  * Handle oneOf schemas — pick the first variant and initialize it.
+ * The variant is treated as required so its own required discriminator
+ * and structure seed cleanly.
  */
 function initOneOf(
   schema: Record<string, unknown>,
@@ -183,7 +227,6 @@ function initOneOf(
   const first = variants[0];
   if (!first) return null;
 
-  // Pick first variant, resolve its $ref if needed
   const firstVariant = resolveRef(first, root);
-  return initProperty(firstVariant, root, seed);
+  return initProperty(firstVariant, root, seed, true);
 }