@skmtc/core 0.0.926 → 0.0.929

package/esm/oas/array/array-types.d.ts

@@ -1,69 +1,4 @@
 import * as v from 'valibot';
-import { type OasSchemaData } from '../schema/schema-types.js';
-import { type OasSchemaRefData } from '../ref/ref-types.js';
-/**
- * Valibot schema for validating OpenAPI array data objects.
- *
- * This comprehensive schema validates OpenAPI array schemas according to the OpenAPI v3
- * specification, including item type definitions, length constraints, uniqueness requirements,
- * and enumeration values. It uses lazy evaluation to handle recursive schema references,
- * allowing for complex nested array structures and self-referential schemas.
- *
- * The schema supports both direct schema definitions and reference objects for the items
- * property, enabling flexible array type definitions that can reference other schemas
- * in the document or define inline item types.
- *
- * @example Validating a simple array schema
- * ```typescript
- * import { oasArrayData } from '@skmtc/core/oas/array';
- * import * as v from 'valibot';
- *
- * const schema = {
- *   type: 'array',
- *   items: {
- *     type: 'string'
- *   },
- *   description: 'List of user names',
- *   minItems: 1,
- *   maxItems: 100
- * };
- *
- * const validated = v.parse(oasArrayData, schema);
- * console.log(validated.minItems); // 1
- * ```
- *
- * @example Validating array with reference items
- * ```typescript
- * const refArraySchema = {
- *   type: 'array',
- *   items: {
- *     $ref: '#/components/schemas/User'
- *   },
- *   title: 'User List',
- *   uniqueItems: true,
- *   default: []
- * };
- *
- * const result = v.parse(oasArrayData, refArraySchema);
- * console.log(result.uniqueItems); // true
- * ```
- *
- * @example Validating constrained arrays
- * ```typescript
- * const constrainedArray = {
- *   type: 'array',
- *   items: { type: 'number' },
- *   minItems: 2,
- *   maxItems: 10,
- *   uniqueItems: true,
- *   enums: [[1, 2, 3], [4, 5, 6]]
- * };
- *
- * const validated = v.parse(oasArrayData, constrainedArray);
- * console.log(validated.maxItems); // 10
- * ```
- */
-export declare const oasArrayData: v.GenericSchema<OasArrayData>;
 /**
  * Valibot schema for array data without the items property.
  *
@@ -108,115 +43,6 @@ export declare const oasArrayData: v.GenericSchema<OasArrayData>;
  * ```
  */
 export declare const oasArrayDataWithoutItems: v.GenericSchema<OasArrayDataWithoutItems>;
-/**
- * Data type for OpenAPI array schema objects.
- *
- * Represents the complete structure of OpenAPI array schemas as processed by the SKMTC
- * pipeline. This type includes all standard OpenAPI array schema properties including
- * item type specifications, length constraints, uniqueness requirements, and metadata
- * fields. It's used throughout the array processing pipeline for type-safe handling
- * of array schema definitions.
- *
- * ## Usage in SKMTC Pipeline
- *
- * This type is used by:
- * - Schema parsers to validate incoming array schema data
- * - Array processors to transform OpenAPI schemas into OAS objects
- * - Code generators to access array constraints and generate validation code
- * - Type generators to create appropriate array type definitions
- *
- * @example Basic string array schema
- * ```typescript
- * import type { OasArrayData } from '@skmtc/core/oas/array';
- *
- * const tagListSchema: OasArrayData = {
- *   type: 'array',
- *   items: {
- *     type: 'string',
- *     minLength: 1,
- *     maxLength: 50
- *   },
- *   title: 'Tag List',
- *   description: 'Collection of tags for categorization',
- *   minItems: 0,
- *   maxItems: 20,
- *   uniqueItems: true,
- *   default: []
- * };
- * ```
- *
- * @example Array of referenced objects
- * ```typescript
- * const userListSchema: OasArrayData = {
- *   type: 'array',
- *   items: {
- *     $ref: '#/components/schemas/User'
- *   },
- *   title: 'User Collection',
- *   description: 'List of user objects',
- *   minItems: 1,
- *   default: []
- * };
- * ```
- *
- * @example Complex nested array schema
- * ```typescript
- * const matrixSchema: OasArrayData = {
- *   type: 'array',
- *   items: {
- *     type: 'array',
- *     items: {
- *       type: 'number'
- *     },
- *     minItems: 3,
- *     maxItems: 3
- *   },
- *   title: '3x3 Matrix',
- *   description: 'Two-dimensional number array representing a 3x3 matrix',
- *   minItems: 3,
- *   maxItems: 3
- * };
- * ```
- *
- * @example Enum array with constraints
- * ```typescript
- * const statusListSchema: OasArrayData = {
- *   type: 'array',
- *   items: {
- *     type: 'string',
- *     enum: ['active', 'inactive', 'pending']
- *   },
- *   title: 'Status List',
- *   description: 'Multiple status values',
- *   uniqueItems: true,
- *   enums: [
- *     ['active'],
- *     ['active', 'pending'],
- *     ['inactive', 'pending']
- *   ]
- * };
- * ```
- */
-export type OasArrayData = {
-    /** Type identifier (always 'array') */
-    type: 'array';
-    /** Schema definition for array items (can be direct schema or reference) */
-    items: OasSchemaData | OasSchemaRefData;
-    /** Human-readable title for the array schema */
-    title?: string;
-    /** Detailed description explaining the array's purpose and contents */
-    description?: string;
-    /** Default value used when no explicit array is provided */
-    default?: unknown[];
-    /** Maximum number of items allowed in the array */
-    maxItems?: number;
-    /** Minimum number of items required in the array */
-    minItems?: number;
-    /** Whether all items in the array must be unique */
-    uniqueItems?: boolean;
-    /** Array of valid enumeration values for the entire array */
-    enums?: unknown[];
-};
 /**
  * Array schema data without the items property.
  *
@@ -279,5 +105,11 @@ export type OasArrayDataWithoutItems = {
     uniqueItems?: boolean;
     /** Array of valid enumeration values for the entire array */
     enums?: unknown[];
+    /** Whether the array is read-only */
+    readOnly?: boolean;
+    /** Whether the array is write-only */
+    writeOnly?: boolean;
+    /** Whether the array is deprecated */
+    deprecated?: boolean;
 };
 //# sourceMappingURL=array-types.d.ts.map

package/esm/oas/array/array-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array-types.d.ts","sourceRoot":"","sources":["../../../src/oas/array/array-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAE,KAAK,aAAa,EAAiB,MAAM,2BAA2B,CAAA;AAC7E,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,qBAAqB,CAAA;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,aAAa,CAAC,YAAY,CAUrD,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,wBAAwB,EAAE,CAAC,CAAC,aAAa,CAAC,wBAAwB,CAS7E,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwFG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,uCAAuC;IACvC,IAAI,EAAE,OAAO,CAAA;IACb,4EAA4E;IAC5E,KAAK,EAAE,aAAa,GAAG,gBAAgB,CAAA;IACvC,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,OAAO,EAAE,CAAA;IACnB,mDAAmD;IACnD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,6DAA6D;IAC7D,KAAK,CAAC,EAAE,OAAO,EAAE,CAAA;CAClB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,uCAAuC;IACvC,IAAI,EAAE,OAAO,CAAA;IACb,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,OAAO,EAAE,CAAA;IACnB,mDAAmD;IACnD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,6DAA6D;IAC7D,KAAK,CAAC,EAAE,OAAO,EAAE,CAAA;CAClB,CAAA"}
+{"version":3,"file":"array-types.d.ts","sourceRoot":"","sources":["../../../src/oas/array/array-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,wBAAwB,EAAE,CAAC,CAAC,aAAa,CAAC,wBAAwB,CAY7E,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,uCAAuC;IACvC,IAAI,EAAE,OAAO,CAAA;IACb,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,OAAO,EAAE,CAAA;IACnB,mDAAmD;IACnD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,6DAA6D;IAC7D,KAAK,CAAC,EAAE,OAAO,EAAE,CAAA;IACjB,qCAAqC;IACrC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,sCAAsC;IACtC,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,sCAAsC;IACtC,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA"}

package/esm/oas/array/array-types.js

@@ -1,79 +1,4 @@
 import * as v from 'valibot';
-import { oasSchemaData } from '../schema/schema-types.js';
-import { oasSchemaRefData } from '../ref/ref-types.js';
-/**
- * Valibot schema for validating OpenAPI array data objects.
- *
- * This comprehensive schema validates OpenAPI array schemas according to the OpenAPI v3
- * specification, including item type definitions, length constraints, uniqueness requirements,
- * and enumeration values. It uses lazy evaluation to handle recursive schema references,
- * allowing for complex nested array structures and self-referential schemas.
- *
- * The schema supports both direct schema definitions and reference objects for the items
- * property, enabling flexible array type definitions that can reference other schemas
- * in the document or define inline item types.
- *
- * @example Validating a simple array schema
- * ```typescript
- * import { oasArrayData } from '@skmtc/core/oas/array';
- * import * as v from 'valibot';
- *
- * const schema = {
- *   type: 'array',
- *   items: {
- *     type: 'string'
- *   },
- *   description: 'List of user names',
- *   minItems: 1,
- *   maxItems: 100
- * };
- *
- * const validated = v.parse(oasArrayData, schema);
- * console.log(validated.minItems); // 1
- * ```
- *
- * @example Validating array with reference items
- * ```typescript
- * const refArraySchema = {
- *   type: 'array',
- *   items: {
- *     $ref: '#/components/schemas/User'
- *   },
- *   title: 'User List',
- *   uniqueItems: true,
- *   default: []
- * };
- *
- * const result = v.parse(oasArrayData, refArraySchema);
- * console.log(result.uniqueItems); // true
- * ```
- *
- * @example Validating constrained arrays
- * ```typescript
- * const constrainedArray = {
- *   type: 'array',
- *   items: { type: 'number' },
- *   minItems: 2,
- *   maxItems: 10,
- *   uniqueItems: true,
- *   enums: [[1, 2, 3], [4, 5, 6]]
- * };
- *
- * const validated = v.parse(oasArrayData, constrainedArray);
- * console.log(validated.maxItems); // 10
- * ```
- */
-export const oasArrayData = v.object({
-    type: v.literal('array'),
-    items: v.lazy(() => v.union([v.lazy(() => oasSchemaData), oasSchemaRefData])),
-    title: v.optional(v.string()),
-    description: v.optional(v.string()),
-    default: v.optional(v.array(v.unknown())),
-    maxItems: v.optional(v.number()),
-    minItems: v.optional(v.number()),
-    uniqueItems: v.optional(v.boolean()),
-    enums: v.optional(v.array(v.unknown()))
-});
 /**
  * Valibot schema for array data without the items property.
  *
@@ -125,5 +50,8 @@ export const oasArrayDataWithoutItems = v.object({
     maxItems: v.optional(v.number()),
     minItems: v.optional(v.number()),
     uniqueItems: v.optional(v.boolean()),
-    enums: v.optional(v.array(v.unknown()))
+    enums: v.optional(v.array(v.unknown())),
+    readOnly: v.optional(v.boolean()),
+    writeOnly: v.optional(v.boolean()),
+    deprecated: v.optional(v.boolean())
 });

package/esm/oas/array/toArray.d.ts

@@ -73,58 +73,6 @@ type ToParsedArrayArgs<Nullable extends boolean | undefined> = {
     enums: Nullable extends true ? (unknown[] | null)[] | undefined : unknown[] | undefined;
     defaultValue: Nullable extends true ? unknown[] | null | undefined : unknown[] | undefined;
 };
-/**
- * Creates an OAS array instance from pre-parsed array schema components.
- *
- * This function is the final step in the array transformation pipeline, taking
- * already-parsed nullable, example, enum, and default values and combining them
- * with the remaining array properties to create the complete OasArray instance.
- *
- * The function handles type-safe nullable parsing, items schema resolution,
- * and specification extension processing. It uses Valibot for schema validation
- * and maintains proper type relationships between nullable flags and value types.
- *
- * @template Nullable - Boolean type indicating if the array can be null
- * @param args - Pre-parsed array components
- * @param args.value - OpenAPI array object without parsed fields
- * @param args.context - Parse context for tracing and utilities
- * @param args.nullable - Parsed nullable flag
- * @param args.example - Parsed example value (type-safe with nullable)
- * @param args.enums - Parsed enumeration constraints (type-safe with nullable)
- * @param args.defaultValue - Parsed default value (type-safe with nullable)
- * @returns Complete OAS array instance with all properties
- *
- * @example Type-safe nullable array
- * ```typescript
- * const nullableArray = toParsedArray({
- *   context: parseContext,
- *   nullable: true,
- *   example: [1, 2, 3], // Can be null due to nullable: true
- *   enums: [[1], [2], null], // Null allowed in enums
- *   defaultValue: null,
- *   value: {
- *     type: 'array',
- *     items: { type: 'number' },
- *     maxItems: 5
- *   }
- * });
- * ```
- *
- * @example Non-nullable array
- * ```typescript
- * const regularArray = toParsedArray({
- *   context: parseContext,
- *   nullable: false,
- *   example: ['a', 'b'], // Cannot be null
- *   enums: [['x'], ['y']], // No null values allowed
- *   defaultValue: [],
- *   value: {
- *     type: 'array',
- *     items: { type: 'string' }
- *   }
- * });
- * ```
- */
 export declare const toParsedArray: <Nullable extends boolean | undefined>({ context, nullable, example, enums, defaultValue, value }: ToParsedArrayArgs<Nullable>) => OasArray<Nullable>;
 export {};
 //# sourceMappingURL=toArray.d.ts.map

package/esm/oas/array/toArray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toArray.d.ts","sourceRoot":"","sources":["../../../src/oas/array/toArray.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAQjE,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,SAAS,CAAC,iBAAiB,CAAA;IAClC,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,eAAO,MAAM,OAAO,GAAI,oBAAoB,WAAW,KAAG,QAmCzD,CAAA;AAED,KAAK,iBAAiB,CAAC,QAAQ,SAAS,OAAO,GAAG,SAAS,IAAI;IAC7D,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,iBAAiB,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC,CAAA;IACtF,OAAO,EAAE,YAAY,CAAA;IACrB,QAAQ,EAAE,QAAQ,CAAA;IAClB,OAAO,EAAE,QAAQ,SAAS,IAAI,GAAG,OAAO,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;IACrF,KAAK,EAAE,QAAQ,SAAS,IAAI,GAAG,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;IACvF,YAAY,EAAE,QAAQ,SAAS,IAAI,GAAG,OAAO,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;CAC3F,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,eAAO,MAAM,aAAa,GAAI,QAAQ,SAAS,OAAO,GAAG,SAAS,EAAE,4DAOjE,iBAAiB,CAAC,QAAQ,CAAC,KAAG,QAAQ,CAAC,QAAQ,CAyCjD,CAAA"}
+{"version":3,"file":"toArray.d.ts","sourceRoot":"","sources":["../../../src/oas/array/toArray.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAOjE,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,SAAS,CAAC,iBAAiB,CAAA;IAClC,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,eAAO,MAAM,OAAO,GAAI,oBAAoB,WAAW,KAAG,QA8CzD,CAAA;AAED,KAAK,iBAAiB,CAAC,QAAQ,SAAS,OAAO,GAAG,SAAS,IAAI;IAC7D,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,iBAAiB,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC,CAAA;IACtF,OAAO,EAAE,YAAY,CAAA;IACrB,QAAQ,EAAE,QAAQ,CAAA;IAClB,OAAO,EAAE,QAAQ,SAAS,IAAI,GAAG,OAAO,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;IACrF,KAAK,EAAE,QAAQ,SAAS,IAAI,GAAG,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;IACvF,YAAY,EAAE,QAAQ,SAAS,IAAI,GAAG,OAAO,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;CAC3F,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,QAAQ,SAAS,OAAO,GAAG,SAAS,EAAE,4DAOjE,iBAAiB,CAAC,QAAQ,CAAC,KAAG,QAAQ,CAAC,QAAQ,CAkDjD,CAAA"}

package/esm/oas/array/toArray.js

@@ -2,11 +2,10 @@ import { OasArray } from './Array.js';
 import { toSchemaV3 } from '../schema/toSchemasV3.js';
 import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
 import { parseNullable } from '../_helpers/parseNullable.js';
-import { parseExample } from '../_helpers/parseExample.js';
 import { parseEnum } from '../_helpers/parseEnum.js';
 import * as v from 'valibot';
 import { oasArrayDataWithoutItems } from './array-types.js';
-import { parseDefault } from '../_helpers/parseDefault.js';
+import { tracer } from '../../helpers/tracer.js';
 /**
  * Transforms an OpenAPI v3 array schema object into an internal OAS array representation.
  *
@@ -71,23 +70,28 @@ export const toArray = ({ value, context }) => {
         value,
         context
     });
-    const { example, value: valueWithoutExample } = parseExample({
-        value: valueWithoutNullable,
-        nullable,
-        valibotSchema: v.array(v.any()),
-        context
+    const { example: unparsedExample, ...valueWithoutExample } = valueWithoutNullable;
+    const example = parseExample({
+        example: unparsedExample,
+        context,
+        parent: valueWithoutNullable,
+        nullable
     });
-    const { enum: enums, value: valueWithoutEnums } = parseEnum({
-        value: valueWithoutExample,
+    const { enum: unparsedEnums, ...valueWithoutEnums } = valueWithoutExample;
+    const enums = parseEnum({
+        value: unparsedEnums,
         nullable,
-        valibotSchema: v.array(v.any()),
-        context
+        parent: valueWithoutExample,
+        context,
+        check: Array.isArray,
+        toMessage: item => `Removed invalid enum. Expected "array", got: ${item}`
     });
-    const { default: defaultValue, value: valueWithoutDefault } = parseDefault({
-        value: valueWithoutEnums,
-        nullable,
-        valibotSchema: v.array(v.any()),
-        context
+    const { default: unparsedDefaultValue, ...valueWithoutDefault } = valueWithoutEnums;
+    const defaultValue = parseDefault({
+        defaultValue: unparsedDefaultValue,
+        context,
+        parent: valueWithoutEnums,
+        nullable
     });
     return toParsedArray({
         context,
@@ -98,64 +102,14 @@ export const toArray = ({ value, context }) => {
         value: valueWithoutDefault
     });
 };
-/**
- * Creates an OAS array instance from pre-parsed array schema components.
- *
- * This function is the final step in the array transformation pipeline, taking
- * already-parsed nullable, example, enum, and default values and combining them
- * with the remaining array properties to create the complete OasArray instance.
- *
- * The function handles type-safe nullable parsing, items schema resolution,
- * and specification extension processing. It uses Valibot for schema validation
- * and maintains proper type relationships between nullable flags and value types.
- *
- * @template Nullable - Boolean type indicating if the array can be null
- * @param args - Pre-parsed array components
- * @param args.value - OpenAPI array object without parsed fields
- * @param args.context - Parse context for tracing and utilities
- * @param args.nullable - Parsed nullable flag
- * @param args.example - Parsed example value (type-safe with nullable)
- * @param args.enums - Parsed enumeration constraints (type-safe with nullable)
- * @param args.defaultValue - Parsed default value (type-safe with nullable)
- * @returns Complete OAS array instance with all properties
- *
- * @example Type-safe nullable array
- * ```typescript
- * const nullableArray = toParsedArray({
- *   context: parseContext,
- *   nullable: true,
- *   example: [1, 2, 3], // Can be null due to nullable: true
- *   enums: [[1], [2], null], // Null allowed in enums
- *   defaultValue: null,
- *   value: {
- *     type: 'array',
- *     items: { type: 'number' },
- *     maxItems: 5
- *   }
- * });
- * ```
- *
- * @example Non-nullable array
- * ```typescript
- * const regularArray = toParsedArray({
- *   context: parseContext,
- *   nullable: false,
- *   example: ['a', 'b'], // Cannot be null
- *   enums: [['x'], ['y']], // No null values allowed
- *   defaultValue: [],
- *   value: {
- *     type: 'array',
- *     items: { type: 'string' }
- *   }
- * });
- * ```
- */
 export const toParsedArray = ({ context, nullable, example, enums, defaultValue, value }) => {
     // We only want parse non-items fields here since items is handled below
     const { items, ...rest } = value;
     // Parse the object without items field
-    const parsed = v.parse(oasArrayDataWithoutItems, rest);
-    const { type: _type, title, description, uniqueItems, maxItems, minItems, ...skipped } = parsed;
+    if (!v.is(oasArrayDataWithoutItems, rest)) {
+        v.parse(oasArrayDataWithoutItems, rest);
+    }
+    const { type: _type, title, description, uniqueItems, maxItems, minItems, readOnly, writeOnly, deprecated, ...skipped } = rest;
     const extensionFields = toSpecificationExtensionsV3({
         skipped,
         parent: value,
@@ -171,12 +125,53 @@ export const toParsedArray = ({ context, nullable, example, enums, defaultValue,
         description,
         nullable,
         defaultValue,
-        items: context.trace('items', () => toSchemaV3({ schema: items, context })),
+        items: tracer(context.stackTrail, 'items', () => toSchemaV3({ schema: items, context })),
         extensionFields,
         example,
         uniqueItems,
         maxItems,
         minItems,
-        enums
+        enums,
+        readOnly,
+        writeOnly,
+        deprecated
     });
 };
+const parseExample = ({ example, context, parent, nullable }) => {
+    if (example === undefined) {
+        return undefined;
+    }
+    if (nullable && example === null) {
+        return example;
+    }
+    if (!Array.isArray(example)) {
+        context.logIssue({
+            key: 'example',
+            level: 'warning',
+            message: `Removed invalid example. Expected "array", got: ${example}`,
+            parent,
+            type: 'INVALID_EXAMPLE'
+        });
+        return undefined;
+    }
+    return example;
+};
+const parseDefault = ({ defaultValue, context, parent, nullable }) => {
+    if (defaultValue === undefined) {
+        return undefined;
+    }
+    if (nullable && defaultValue === null) {
+        return defaultValue;
+    }
+    if (!Array.isArray(defaultValue)) {
+        context.logIssue({
+            key: 'default',
+            level: 'warning',
+            message: `Invalid default: ${defaultValue}`,
+            parent,
+            type: 'INVALID_DEFAULT'
+        });
+        return undefined;
+    }
+    return defaultValue;
+};