typesea 0.1.0 → 0.3.0

package/dist/schema/common.d.ts

@@ -1,30 +1,93 @@
 /**
  * @file schema/common.ts
  * @brief Private schema shape predicates.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
  */
 import type { ObjectKeyLookup } from "./types.js";
 /**
- * @brief is record.
+ * @brief Sentinel for a missing own data slot.
+ * @details `undefined` is a valid schema literal, so absence needs a distinct
+ * value that cannot collide with user-authored schema data.
+ */
+declare const missingDataProperty: unique symbol;
+/**
+ * @brief Test whether a schema field read observed the sentinel.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
+ * @param value Candidate field value returned by readOwnDataProperty.
+ * @returns True when the caller must treat the schema field as absent.
+ */
+export declare function isMissingDataProperty(value: unknown): value is typeof missingDataProperty;
+/**
+ * @brief Check that an object owns a concrete data descriptor.
+ * @param value Object whose descriptor table is being inspected.
+ * @param key Field name or symbol.
+ * @returns True only when the field exists directly on the object as data.
+ * @details Schema records are consumed across public boundaries. Descriptor
+ * reads avoid invoking accessors and avoid accepting prototype-backed fields.
+ */
+export declare function hasOwnDataProperty(value: object, key: PropertyKey): boolean;
+/**
+ * @brief Read one own schema data slot without consulting the prototype chain.
+ * @param value Object carrying a schema record.
+ * @param key Field name or symbol to read.
+ * @returns The stored value, or the missing-data sentinel.
+ * @details Callers must not use bracket reads on untrusted schema-like objects:
+ * a forged prototype getter could execute code or change validation meaning.
+ */
+export declare function readOwnDataProperty(value: object, key: PropertyKey): unknown;
+/**
+ * @brief Accept object records suitable for schema metadata traversal.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
+ * @param value Candidate schema record.
+ * @returns True for non-array objects whose own fields are all data slots.
  */
 export declare function isRecord(value: unknown): value is Readonly<Record<string, unknown>>;
 /**
- * @brief is unknown array.
+ * @brief Accept dense arrays whose slots can be read without side effects.
+ * @param value Candidate schema vector.
+ * @returns True for arrays with only own data descriptors and no holes.
+ * @details Schema vectors such as `checks`, `entries`, and `options` are arena
+ * metadata. Holes and inherited slots would make validation depend on array
+ * prototype state, so they are rejected at the boundary.
  */
 export declare function isUnknownArray(value: unknown): value is readonly unknown[];
 /**
- * @brief is plain reg exp.
+ * @brief Accept only unmodified RegExp instances in schema records.
+ * @param value Candidate pattern object.
+ * @returns True for a plain RegExp with no own behavioral overrides.
+ * @details Regex checks are copied into generated and interpreted validators.
+ * Rejecting own overrides prevents later mutation of `exec`, `test`, `source`,
+ * or `flags` from changing stored schema behavior.
  */
 export declare function isPlainRegExp(value: unknown): value is RegExp;
 /**
- * @brief is string array.
+ * @brief Validate a dense vector of object shape keys.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
+ * @param value Candidate key vector.
+ * @returns True when every slot is a string.
  */
 export declare function isStringArray(value: unknown): value is readonly string[];
 /**
- * @brief is object key lookup.
+ * @brief Validate the O(1) lookup table paired with object schema keys.
+ * @param value Candidate null or plain object lookup.
+ * @param keys Ordered key vector from the same object schema.
+ * @returns True when the lookup contains exactly the listed keys mapped to true.
+ * @details The lookup and key vector must agree so strict-object validation can
+ * reject extra keys without rebuilding a membership set at runtime.
  */
 export declare function isObjectKeyLookup(value: unknown, keys: readonly string[]): value is ObjectKeyLookup;
 /**
- * @brief includes string.
+ * @brief Linear membership check for short schema-owned string vectors.
+ * @param values Trusted frozen vector.
+ * @param value Candidate string.
+ * @returns True when the candidate appears in the vector.
+ * @details These vectors are small and validation-time only; a loop avoids
+ * allocating transient Set objects while preserving deterministic order.
  */
 export declare function includesString(values: readonly string[], value: string): boolean;
+export {};
 //# sourceMappingURL=common.d.ts.map

package/dist/schema/common.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/schema/common.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;GAEG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAKnF;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,OAAO,EAAE,CAE1E;AAyBD;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAO7D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,MAAM,EAAE,CAUxE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,SAAS,MAAM,EAAE,GACtB,KAAK,IAAI,eAAe,CAqB1B;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAOhF"}
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/schema/common.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;;;GAIG;AACH,QAAA,MAAM,mBAAmB,eAAwC,CAAC;AAElE;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACjC,KAAK,EAAE,OAAO,GACf,KAAK,IAAI,OAAO,mBAAmB,CAErC;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAC9B,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,WAAW,GACjB,OAAO,CAIT;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAC/B,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,WAAW,GACjB,OAAO,CAOT;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAKnF;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,OAAO,EAAE,CAI1E;AA2CD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAO7D;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,MAAM,EAAE,CAUxE;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC7B,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,SAAS,MAAM,EAAE,GACxB,KAAK,IAAI,eAAe,CAqB1B;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAOhF"}

package/dist/schema/common.js

@@ -1,9 +1,60 @@
 /**
  * @file schema/common.ts
  * @brief Private schema shape predicates.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
  */
 /**
- * @brief is record.
+ * @brief Sentinel for a missing own data slot.
+ * @details `undefined` is a valid schema literal, so absence needs a distinct
+ * value that cannot collide with user-authored schema data.
+ */
+const missingDataProperty = Symbol("typesea.missingDataProperty");
+/**
+ * @brief Test whether a schema field read observed the sentinel.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
+ * @param value Candidate field value returned by readOwnDataProperty.
+ * @returns True when the caller must treat the schema field as absent.
+ */
+export function isMissingDataProperty(value) {
+    return value === missingDataProperty;
+}
+/**
+ * @brief Check that an object owns a concrete data descriptor.
+ * @param value Object whose descriptor table is being inspected.
+ * @param key Field name or symbol.
+ * @returns True only when the field exists directly on the object as data.
+ * @details Schema records are consumed across public boundaries. Descriptor
+ * reads avoid invoking accessors and avoid accepting prototype-backed fields.
+ */
+export function hasOwnDataProperty(value, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor !== undefined &&
+        Object.prototype.hasOwnProperty.call(descriptor, "value");
+}
+/**
+ * @brief Read one own schema data slot without consulting the prototype chain.
+ * @param value Object carrying a schema record.
+ * @param key Field name or symbol to read.
+ * @returns The stored value, or the missing-data sentinel.
+ * @details Callers must not use bracket reads on untrusted schema-like objects:
+ * a forged prototype getter could execute code or change validation meaning.
+ */
+export function readOwnDataProperty(value, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor === undefined ||
+        !Object.prototype.hasOwnProperty.call(descriptor, "value")) {
+        return missingDataProperty;
+    }
+    return descriptor.value;
+}
+/**
+ * @brief Accept object records suitable for schema metadata traversal.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
+ * @param value Candidate schema record.
+ * @returns True for non-array objects whose own fields are all data slots.
  */
 export function isRecord(value) {
     return typeof value === "object" &&
@@ -12,14 +63,23 @@ export function isRecord(value) {
         hasOnlyDataProperties(value);
 }
 /**
- * @brief is unknown array.
+ * @brief Accept dense arrays whose slots can be read without side effects.
+ * @param value Candidate schema vector.
+ * @returns True for arrays with only own data descriptors and no holes.
+ * @details Schema vectors such as `checks`, `entries`, and `options` are arena
+ * metadata. Holes and inherited slots would make validation depend on array
+ * prototype state, so they are rejected at the boundary.
  */
 export function isUnknownArray(value) {
-    return Array.isArray(value) && hasOnlyDataProperties(value);
+    return Array.isArray(value) &&
+        hasOnlyDataProperties(value) &&
+        hasDenseDataSlots(value);
 }
 /**
- * @brief has only data properties.
- * @details Rejects accessor descriptors before schema internals read fields by key.
+ * @brief Reject accessor descriptors before schema internals read fields.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
+ * @param value Object whose own descriptor table is inspected.
  * @returns True when every own property is backed by a data slot.
  */
 function hasOnlyDataProperties(value) {
@@ -40,7 +100,27 @@ function hasOnlyDataProperties(value) {
     return true;
 }
 /**
- * @brief is plain reg exp.
+ * @brief Require array indexes from 0 to length - 1 to be own data slots.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
+ * @param value Candidate schema vector.
+ * @returns True when no sparse or prototype-backed index is present.
+ */
+function hasDenseDataSlots(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        if (!hasOwnDataProperty(value, String(index))) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @brief Accept only unmodified RegExp instances in schema records.
+ * @param value Candidate pattern object.
+ * @returns True for a plain RegExp with no own behavioral overrides.
+ * @details Regex checks are copied into generated and interpreted validators.
+ * Rejecting own overrides prevents later mutation of `exec`, `test`, `source`,
+ * or `flags` from changing stored schema behavior.
  */
 export function isPlainRegExp(value) {
     return value instanceof RegExp &&
@@ -51,7 +131,11 @@ export function isPlainRegExp(value) {
         !Object.prototype.hasOwnProperty.call(value, "flags");
 }
 /**
- * @brief is string array.
+ * @brief Validate a dense vector of object shape keys.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
+ * @param value Candidate key vector.
+ * @returns True when every slot is a string.
  */
 export function isStringArray(value) {
     if (!isUnknownArray(value)) {
@@ -65,7 +149,12 @@ export function isStringArray(value) {
     return true;
 }
 /**
- * @brief is object key lookup.
+ * @brief Validate the O(1) lookup table paired with object schema keys.
+ * @param value Candidate null or plain object lookup.
+ * @param keys Ordered key vector from the same object schema.
+ * @returns True when the lookup contains exactly the listed keys mapped to true.
+ * @details The lookup and key vector must agree so strict-object validation can
+ * reject extra keys without rebuilding a membership set at runtime.
  */
 export function isObjectKeyLookup(value, keys) {
     if (!isRecord(value)) {
@@ -77,7 +166,7 @@ export function isObjectKeyLookup(value, keys) {
     }
     for (let index = 0; index < keys.length; index += 1) {
         const key = keys[index];
-        if (key === undefined || value[key] !== true) {
+        if (key === undefined || readOwnDataProperty(value, key) !== true) {
             return false;
         }
     }
@@ -90,7 +179,12 @@ export function isObjectKeyLookup(value, keys) {
     return true;
 }
 /**
- * @brief includes string.
+ * @brief Linear membership check for short schema-owned string vectors.
+ * @param values Trusted frozen vector.
+ * @param value Candidate string.
+ * @returns True when the candidate appears in the vector.
+ * @details These vectors are small and validation-time only; a loop avoids
+ * allocating transient Set objects while preserving deterministic order.
  */
 export function includesString(values, value) {
     for (let index = 0; index < values.length; index += 1) {

package/dist/schema/freeze.d.ts

@@ -1,10 +1,14 @@
 /**
  * @file schema/freeze.ts
  * @brief Schema freezing and collection hardening.
+ * @details Freezing hardens builder output before execution engines or exporters rely on
+ * schema identity and shape stability.
  */
 import type { Schema } from "./types.js";
 /**
  * @brief freeze schema.
+ * @details Freezing hardens builder output before execution engines or exporters rely on
+ * schema identity and shape stability.
  */
 export declare function freezeSchema(schema: Schema): Schema;
 //# sourceMappingURL=freeze.d.ts.map

package/dist/schema/freeze.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"freeze.d.ts","sourceRoot":"","sources":["../../src/schema/freeze.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAGV,MAAM,EAGP,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEnD"}
+{"version":3,"file":"freeze.d.ts","sourceRoot":"","sources":["../../src/schema/freeze.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAGR,MAAM,EAGT,MAAM,YAAY,CAAC;AAEpB;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEnD"}

package/dist/schema/freeze.js

@@ -1,17 +1,23 @@
 /**
  * @file schema/freeze.ts
  * @brief Schema freezing and collection hardening.
+ * @details Freezing hardens builder output before execution engines or exporters rely on
+ * schema identity and shape stability.
  */
 import { SchemaTag, StringCheckTag } from "../kind/index.js";
 import { isPlainRegExp } from "./common.js";
 /**
  * @brief freeze schema.
+ * @details Freezing hardens builder output before execution engines or exporters rely on
+ * schema identity and shape stability.
  */
 export function freezeSchema(schema) {
     return freezeSchemaInner(schema, new WeakSet());
 }
 /**
  * @brief freeze schema inner.
+ * @details Freezing hardens builder output before execution engines or exporters rely on
+ * schema identity and shape stability.
  */
 function freezeSchemaInner(schema, frozen) {
     if (frozen.has(schema)) {
@@ -25,17 +31,38 @@ function freezeSchemaInner(schema, frozen) {
         case SchemaTag.Number:
             freezeArray(schema.checks, frozen);
             return Object.freeze(schema);
+        case SchemaTag.Date:
+            freezeArray(schema.checks, frozen);
+            return Object.freeze(schema);
         case SchemaTag.Array:
             freezeSchemaInner(schema.item, frozen);
+            freezeArray(schema.checks, frozen);
             return Object.freeze(schema);
         case SchemaTag.Tuple:
             freezeSchemaArray(schema.items, frozen);
+            if (schema.rest !== undefined) {
+                freezeSchemaInner(schema.rest, frozen);
+            }
             return Object.freeze(schema);
         case SchemaTag.Record:
             freezeSchemaInner(schema.value, frozen);
             return Object.freeze(schema);
+        case SchemaTag.Map:
+            freezeSchemaInner(schema.key, frozen);
+            freezeSchemaInner(schema.value, frozen);
+            return Object.freeze(schema);
+        case SchemaTag.Set:
+            freezeSchemaInner(schema.item, frozen);
+            return Object.freeze(schema);
+        case SchemaTag.Property:
+            freezeSchemaInner(schema.base, frozen);
+            freezeSchemaInner(schema.value, frozen);
+            return Object.freeze(schema);
         case SchemaTag.Object:
             freezeObjectEntries(schema.entries, frozen);
+            if (schema.catchall !== undefined) {
+                freezeSchemaInner(schema.catchall, frozen);
+            }
             Object.freeze(schema.keys);
             Object.freeze(schema.keyLookup);
             return Object.freeze(schema);
@@ -65,6 +92,7 @@ function freezeSchemaInner(schema, frozen) {
         case SchemaTag.BigInt:
         case SchemaTag.Symbol:
         case SchemaTag.Boolean:
+        case SchemaTag.InstanceOf:
         case SchemaTag.Literal:
         case SchemaTag.Lazy:
             return Object.freeze(schema);
@@ -72,6 +100,8 @@ function freezeSchemaInner(schema, frozen) {
 }
 /**
  * @brief freeze array.
+ * @details Freezing hardens builder output before execution engines or exporters rely on
+ * schema identity and shape stability.
  */
 function freezeArray(values, frozen) {
     for (let index = 0; index < values.length; index += 1) {
@@ -85,6 +115,8 @@ function freezeArray(values, frozen) {
 }
 /**
  * @brief freeze string checks.
+ * @details Freezing hardens builder output before execution engines or exporters rely on
+ * schema identity and shape stability.
  */
 function freezeStringChecks(values, frozen) {
     for (let index = 0; index < values.length; index += 1) {
@@ -102,6 +134,8 @@ function freezeStringChecks(values, frozen) {
 }
 /**
  * @brief freeze regex check.
+ * @details Freezing hardens builder output before execution engines or exporters rely on
+ * schema identity and shape stability.
  */
 function freezeRegexCheck(check) {
     const regex = check.regex;
@@ -125,6 +159,8 @@ function freezeRegexCheck(check) {
 }
 /**
  * @brief freeze schema array.
+ * @details Freezing hardens builder output before execution engines or exporters rely on
+ * schema identity and shape stability.
  */
 function freezeSchemaArray(values, frozen) {
     for (let index = 0; index < values.length; index += 1) {
@@ -137,6 +173,8 @@ function freezeSchemaArray(values, frozen) {
 }
 /**
  * @brief freeze object entries.
+ * @details Freezing hardens builder output before execution engines or exporters rely on
+ * schema identity and shape stability.
  */
 function freezeObjectEntries(entries, frozen) {
     for (let index = 0; index < entries.length; index += 1) {
@@ -150,6 +188,8 @@ function freezeObjectEntries(entries, frozen) {
 }
 /**
  * @brief freeze discriminated union cases.
+ * @details Freezing hardens builder output before execution engines or exporters rely on
+ * schema identity and shape stability.
  */
 function freezeDiscriminatedUnionCases(cases, frozen) {
     for (let index = 0; index < cases.length; index += 1) {

package/dist/schema/index.d.ts

@@ -1,11 +1,14 @@
 /**
  * @file schema/index.ts
  * @brief Schema module aggregate.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
  */
-export type { ArraySchema, BigIntSchema, BooleanSchema, BrandSchema, DiscriminatedUnionCase, DiscriminatedUnionSchema, IntersectionSchema, LazySchema, LiteralSchema, LiteralValue, NeverSchema, NullableSchema, NumberCheck, NumberGteCheck, NumberIntegerCheck, NumberLteCheck, NumberSchema, ObjectEntry, ObjectKeyLookup, ObjectSchema, OptionalSchema, RecordSchema, RefineSchema, Schema, StringCheck, StringMaxCheck, StringMinCheck, StringRegexCheck, StringSchema, StringUuidCheck, SymbolSchema, TupleSchema, UndefinedableSchema, UnionSchema, UnknownSchema } from "./types.js";
-export { UUID_PATTERN } from "./types.js";
+export type { ArrayCheck, ArrayMaxCheck, ArrayMinCheck, ArraySchema, BigIntSchema, BooleanSchema, BrandSchema, DateCheck, DateMaxCheck, DateMinCheck, DateSchema, DiscriminatedUnionCase, DiscriminatedUnionSchema, IntersectionSchema, LazySchema, LiteralSchema, LiteralValue, NeverSchema, NullableSchema, NumberCheck, NumberGtCheck, NumberGteCheck, NumberIntegerCheck, NumberLtCheck, NumberLteCheck, NumberMultipleOfCheck, NumberSchema, ObjectEntry, ObjectKeyLookup, ObjectSchema, OptionalSchema, InstanceOfSchema, MapSchema, PropertySchema, RecordSchema, RefineSchema, Schema, SetSchema, StringCheck, StringEmailCheck, StringIsoDateCheck, StringIsoDateTimeCheck, StringIpv4Check, StringIpv6Check, StringMaxCheck, StringMinCheck, StringRegexCheck, StringSchema, StringUlidCheck, StringUrlCheck, StringUuidCheck, SymbolSchema, TupleSchema, UndefinedableSchema, UnionSchema, UnknownSchema } from "./types.js";
+export { EMAIL_PATTERN, IPV4_PATTERN, IPV6_PATTERN, ISO_DATETIME_PATTERN, ISO_DATE_PATTERN, ULID_PATTERN, URL_PATTERN, UUID_PATTERN } from "./types.js";
 export { isLiteralValue } from "./literal.js";
 export { isSchemaValue } from "./validate.js";
 export { freezeSchema } from "./freeze.js";
 export { resolveLazySchema } from "./lazy.js";
+export { schemaCanAcceptUndefined } from "./undefined.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/schema/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,YAAY,EACV,WAAW,EACX,YAAY,EACZ,aAAa,EACb,WAAW,EACX,sBAAsB,EACtB,wBAAwB,EACxB,kBAAkB,EAClB,UAAU,EACV,aAAa,EACb,YAAY,EACZ,WAAW,EACX,cAAc,EACd,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,YAAY,EACZ,WAAW,EACX,eAAe,EACf,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,MAAM,EACN,WAAW,EACX,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,WAAW,EACX,mBAAmB,EACnB,WAAW,EACX,aAAa,EACd,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,YAAY,EACR,UAAU,EACV,aAAa,EACb,aAAa,EACb,WAAW,EACX,YAAY,EACZ,aAAa,EACb,WAAW,EACX,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,sBAAsB,EACtB,wBAAwB,EACxB,kBAAkB,EAClB,UAAU,EACV,aAAa,EACb,YAAY,EACZ,WAAW,EACX,cAAc,EACd,WAAW,EACX,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,aAAa,EACb,cAAc,EACd,qBAAqB,EACrB,YAAY,EACZ,WAAW,EACX,eAAe,EACf,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,SAAS,EACT,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,MAAM,EACN,SAAS,EACT,WAAW,EACX,gBAAgB,EAChB,kBAAkB,EAClB,sBAAsB,EACtB,eAAe,EACf,eAAe,EACf,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,YAAY,EACZ,eAAe,EACf,cAAc,EACd,eAAe,EACf,YAAY,EACZ,WAAW,EACX,mBAAmB,EACnB,WAAW,EACX,aAAa,EAChB,MAAM,YAAY,CAAC;AACpB,OAAO,EACH,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,oBAAoB,EACpB,gBAAgB,EAChB,YAAY,EACZ,WAAW,EACX,YAAY,EACf,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/schema/index.js

@@ -1,9 +1,12 @@
 /**
  * @file schema/index.ts
  * @brief Schema module aggregate.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
  */
-export { UUID_PATTERN } from "./types.js";
+export { EMAIL_PATTERN, IPV4_PATTERN, IPV6_PATTERN, ISO_DATETIME_PATTERN, ISO_DATE_PATTERN, ULID_PATTERN, URL_PATTERN, UUID_PATTERN } from "./types.js";
 export { isLiteralValue } from "./literal.js";
 export { isSchemaValue } from "./validate.js";
 export { freezeSchema } from "./freeze.js";
 export { resolveLazySchema } from "./lazy.js";
+export { schemaCanAcceptUndefined } from "./undefined.js";

package/dist/schema/lazy.d.ts

@@ -1,10 +1,14 @@
 /**
  * @file schema/lazy.ts
  * @brief Lazy schema resolution.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
  */
 import type { LazySchema, Schema } from "./types.js";
 /**
  * @brief resolve lazy schema.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
  */
 export declare function resolveLazySchema(schema: LazySchema, resolving: WeakSet<object>): Schema;
 //# sourceMappingURL=lazy.d.ts.map

package/dist/schema/lazy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../src/schema/lazy.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAErD;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,UAAU,EAClB,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,GACzB,MAAM,CAcR"}
+{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../src/schema/lazy.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAErD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC7B,MAAM,EAAE,UAAU,EAClB,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,GAC3B,MAAM,CAcR"}

package/dist/schema/lazy.js

@@ -1,12 +1,16 @@
 /**
  * @file schema/lazy.ts
  * @brief Lazy schema resolution.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
  */
 import { SchemaTag } from "../kind/index.js";
 import { freezeSchema } from "./freeze.js";
 import { isSchemaValue } from "./validate.js";
 /**
  * @brief resolve lazy schema.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
  */
 export function resolveLazySchema(schema, resolving) {
     if (resolving.has(schema)) {

package/dist/schema/literal.d.ts

@@ -1,10 +1,16 @@
 /**
  * @file schema/literal.ts
  * @brief Literal-value boundary checks.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
  */
 import type { LiteralValue } from "./types.js";
 /**
- * @brief is literal value.
+ * @brief Validate values that TypeSea can store as exact literals.
+ * @param value Candidate literal payload.
+ * @returns True for JavaScript primitive literal values plus null and undefined.
+ * @details Objects are excluded because literal matching uses `Object.is`.
+ * Keeping literals primitive preserves stable interpreter and codegen behavior.
  */
 export declare function isLiteralValue(value: unknown): value is LiteralValue;
 //# sourceMappingURL=literal.d.ts.map

package/dist/schema/literal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"literal.d.ts","sourceRoot":"","sources":["../../src/schema/literal.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAWpE"}
+{"version":3,"file":"literal.d.ts","sourceRoot":"","sources":["../../src/schema/literal.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAWpE"}

package/dist/schema/literal.js

@@ -1,9 +1,15 @@
 /**
  * @file schema/literal.ts
  * @brief Literal-value boundary checks.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
  */
 /**
- * @brief is literal value.
+ * @brief Validate values that TypeSea can store as exact literals.
+ * @param value Candidate literal payload.
+ * @returns True for JavaScript primitive literal values plus null and undefined.
+ * @details Objects are excluded because literal matching uses `Object.is`.
+ * Keeping literals primitive preserves stable interpreter and codegen behavior.
  */
 export function isLiteralValue(value) {
     const valueType = typeof value;