@flare-ts/lib 0.1.0

package/dist/schema/json/serializer.js

@@ -0,0 +1,265 @@
+import { SCHEMA_BRAND, SCHEMA_DESCRIPTOR, SCHEMA_REQUIRED } from "../internal/token/symbols.js";
+function isSchemaToken(value) {
+  return SCHEMA_BRAND in value;
+}
+function isSchemaArrayToken(value) {
+  return isSchemaToken(value) && Array.isArray(value[SCHEMA_DESCRIPTOR]);
+}
+function isDescriptorValueRequired(value) {
+  if (isSchemaToken(value)) return value[SCHEMA_REQUIRED] !== false;
+  return value._required !== false;
+}
+function buildObjectArrayHelper(helperName, itemCode, closureArgs, closureVals, braceEmbedded = false) {
+  const itemAssign = braceEmbedded ? `p[i] = (${itemCode}) + '}';` : `p[i] = '{' + (${itemCode}) + '}';`;
+  return new Function(
+    ...closureArgs,
+    `return function ${helperName}(arr){
+      const p = new Array(arr.length);
+      for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
+        ${itemAssign}
+      }
+      return '['+p.join(',')+']';
+    }`
+  )(...closureVals);
+}
+function buildPrimitiveArrayHelper(helperName, itemExpr, closureArgs = [], closureVals = []) {
+  return new Function(
+    ...closureArgs,
+    `return function ${helperName}(arr){
+      const p = new Array(arr.length);
+      for (let i = 0; i < arr.length; i++) {
+        const v = arr[i];
+        p[i] = ${itemExpr};
+      }
+      return '['+p.join(',')+']';
+    }`
+  )(...closureVals);
+}
+const VALID_IDENTIFIER = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+const DIRTY_RE = /[\x00-\x1f"\\]/;
+function compileSerializer(token) {
+  const introspectable = token;
+  const descriptor = introspectable[SCHEMA_DESCRIPTOR];
+  if (Array.isArray(descriptor)) {
+    const first = descriptor[0];
+    if (first !== null && typeof first === "object" && "$record" in first) {
+      return jsonStringifyFallback;
+    }
+    const itemDescriptor = descriptor[0][SCHEMA_DESCRIPTOR];
+    const inner = buildSerializer(itemDescriptor);
+    return function serializeArray(doc) {
+      const arr = doc;
+      const parts = new Array(arr.length);
+      for (let i = 0; i < arr.length; i++) parts[i] = inner(arr[i]);
+      return "[" + parts.join(",") + "]";
+    };
+  }
+  if (isDiscriminatedDescriptor(descriptor)) {
+    return jsonStringifyFallback;
+  }
+  return buildSerializer(descriptor);
+}
+function jsonStringifyFallback(doc) {
+  return JSON.stringify(doc);
+}
+function serializeText(str) {
+  if (!DIRTY_RE.test(str)) return '"' + str + '"';
+  return JSON.stringify(str);
+}
+function serializeDate(value, format) {
+  if (!(value instanceof Date) || Number.isNaN(value.getTime())) return "null";
+  switch (format) {
+    case "DMY":
+    case "MDY":
+    case "YMD":
+      return '"' + value.toISOString().slice(0, 10) + '"';
+    case "TIMESTAMP":
+      return String(value.getTime());
+    default:
+      return '"' + value.toISOString() + '"';
+  }
+}
+function buildSerializer(descriptor) {
+  const closureArgs = ["esc", "date"];
+  const closureVals = [serializeText, serializeDate];
+  let generatedNameId = 0;
+  function nextGeneratedName(prefix, key) {
+    generatedNameId += 1;
+    return `${prefix}_${key}_${generatedNameId}`;
+  }
+  function emitFields(fields, acc, wrapBrace = false) {
+    const parts = [];
+    let firstReq = true;
+    for (const [key, field] of Object.entries(fields)) {
+      const required = isDescriptorValueRequired(field);
+      const isSafeString = !isSchemaToken(field) && (field._type === "string" || field._type === "uuid");
+      if (!VALID_IDENTIFIER.test(key)) {
+        throw new Error(`flareSchema: invalid field key "${key}" - must be a valid JS identifier`);
+      }
+      if (required) {
+        const sep = firstReq && wrapBrace ? '{"' : firstReq ? '"' : ',"';
+        const kPrefix = `'${sep}${key}":`;
+        if (isSafeString) {
+          parts.push(`${kPrefix}"' + ${acc}.${key} + '"'`);
+        } else {
+          parts.push(`${kPrefix}' + ${emitValue(key, field, acc)}`);
+        }
+        firstReq = false;
+      } else {
+        if (isSafeString) {
+          parts.push(`(${acc}.${key} != null ? ',"${key}":"' + ${acc}.${key} + '"' : '')`);
+        } else {
+          parts.push(`(${acc}.${key} != null ? ',"${key}":' + ${emitValue(key, field, acc)} : '')`);
+        }
+      }
+    }
+    return parts.join("+");
+  }
+  function emitValue(key, field, acc) {
+    if (isSchemaArrayToken(field)) {
+      const itemDescriptor = field[SCHEMA_DESCRIPTOR][0][SCHEMA_DESCRIPTOR];
+      const firstItemField = Object.values(itemDescriptor)[0];
+      const canEmbedBrace = firstItemField != null && isDescriptorValueRequired(firstItemField);
+      const itemCode = emitFields(itemDescriptor, "item", canEmbedBrace);
+      const helperName = nextGeneratedName("arrHelper", key);
+      const snapshot = { args: [...closureArgs], vals: [...closureVals] };
+      closureArgs.push(helperName);
+      closureVals.push(buildObjectArrayHelper(helperName, itemCode, snapshot.args, snapshot.vals, canEmbedBrace));
+      return `${helperName}(${acc}.${key})`;
+    }
+    if (isSchemaToken(field)) {
+      const desc = field[SCHEMA_DESCRIPTOR];
+      const firstNestedField = Object.values(desc)[0];
+      const canEmbed = firstNestedField != null && isDescriptorValueRequired(firstNestedField);
+      const inner = emitFields(desc, `${acc}.${key}`, canEmbed);
+      return canEmbed ? `(${inner} + '}')` : `('{' + ${inner} + '}')`;
+    }
+    switch (field._type) {
+      case "int":
+      case "float":
+        return `(+${acc}.${key})`;
+      case "bool":
+        return `(${acc}.${key} ? 'true' : 'false')`;
+      case "string":
+      case "uuid":
+        return `'"' + ${acc}.${key} + '"'`;
+      case "date":
+        return `date(${acc}.${key}, ${JSON.stringify(field._format)})`;
+      case "text":
+        return `(esc(${acc}.${key}))`;
+      case "enum": {
+        const lut = field.lut;
+        const lutName = nextGeneratedName("lut", key);
+        closureArgs.push(lutName);
+        closureVals.push(lut);
+        return `${lutName}[${acc}.${key}]`;
+      }
+    }
+    const jsonSchema = field.jsonSchema;
+    if ("type" in jsonSchema && jsonSchema.type === "array" && "items" in jsonSchema) {
+      const itemType = jsonSchema.items.type;
+      const itemPrimitive = field._item;
+      const helperName = nextGeneratedName("arrHelper", key);
+      if (itemPrimitive?._type === "date") {
+        const itemFormat = itemPrimitive._format;
+        const snapshot = { args: [...closureArgs], vals: [...closureVals] };
+        closureArgs.push(helperName);
+        closureVals.push(
+          buildPrimitiveArrayHelper(
+            helperName,
+            `date(v, ${JSON.stringify(itemFormat)})`,
+            snapshot.args,
+            snapshot.vals
+          )
+        );
+        return `${helperName}(${acc}.${key})`;
+      }
+      if (itemType === "string") {
+        closureArgs.push(helperName);
+        closureVals.push(
+          new Function(
+            `return function ${helperName}(arr){if(arr.length===0)return'[]';return'["'+arr.join('","')+'"]';}`
+          )()
+        );
+        return `${helperName}(${acc}.${key})`;
+      }
+      let itemExpr;
+      switch (itemType) {
+        case "integer":
+        case "number":
+          itemExpr = `(+v)`;
+          break;
+        case "boolean":
+          itemExpr = `(v ? 'true' : 'false')`;
+          break;
+        default:
+          itemExpr = `JSON.stringify(v)`;
+          break;
+      }
+      closureArgs.push(helperName);
+      closureVals.push(buildPrimitiveArrayHelper(helperName, itemExpr));
+      return `${helperName}(${acc}.${key})`;
+    }
+    return `JSON.stringify(${acc}.${key})`;
+  }
+  const body = emitFields(descriptor, "o");
+  return new Function(...closureArgs, `return function serialize(o){ return '{' + ${body} + '}'; }`)(
+    ...closureVals
+  );
+}
+const DISCRIMINANT_PRIMITIVE = {
+  _type: "string",
+  _required: true,
+  jsonSchema: { type: "string" }
+};
+function toJsonSchema(token) {
+  return descriptorToJsonSchema(token[SCHEMA_DESCRIPTOR]);
+}
+function isDiscriminatedDescriptor(value) {
+  return "discriminant" in value;
+}
+function schemaTokenToJsonSchema(token) {
+  return descriptorToJsonSchema(token[SCHEMA_DESCRIPTOR]);
+}
+function descriptorValueToJsonSchema(value) {
+  if (isSchemaToken(value)) return schemaTokenToJsonSchema(value);
+  return value.jsonSchema;
+}
+function descriptorToJsonSchema(descriptor) {
+  if (Array.isArray(descriptor)) {
+    const first = descriptor[0];
+    if (first !== null && typeof first === "object" && "$record" in first) {
+      const valueSchema = first.$record;
+      return {
+        type: "object",
+        additionalProperties: schemaTokenToJsonSchema(valueSchema)
+      };
+    }
+    return { type: "array", items: schemaTokenToJsonSchema(descriptor[0]) };
+  }
+  if (isDiscriminatedDescriptor(descriptor)) {
+    return {
+      anyOf: Object.entries(descriptor.branches).map(
+        ([, branchDescriptor]) => descriptorToJsonSchema({
+          [descriptor.discriminant]: DISCRIMINANT_PRIMITIVE,
+          ...branchDescriptor
+        })
+      )
+    };
+  }
+  const properties = {};
+  const required = [];
+  for (const key in descriptor) {
+    const field = descriptor[key];
+    properties[key] = descriptorValueToJsonSchema(field);
+    if (isDescriptorValueRequired(field)) required.push(key);
+  }
+  const jsonSchema = { type: "object", properties };
+  if (required.length > 0) jsonSchema.required = required;
+  return jsonSchema;
+}
+export {
+  compileSerializer,
+  toJsonSchema
+};

package/dist/schema/model.d.ts

@@ -0,0 +1,54 @@
+import { type BranchShape, type DescriptorValue, type DiscriminantValues, type SchemaToken } from "./schema.js";
+/**
+ * Schema token that also acts as an abstract base class for DTO authoring.
+ *
+ * Returned by {@link model}. Extend it to declare a named model class:
+ * ```ts
+ * class UserModel extends model({ id: uuid, name: string }) {}
+ * ```
+ *
+ * Instances are typed as `T`, so properties are accessible directly without
+ * any unwrapping. Only model tokens carry a construct signature; {@link SchemaToken}
+ * values from {@link schema} are intentionally not extendable.
+ */
+export type ModelTokenBuilder<T> = (abstract new (...args: never[]) => T) & SchemaToken<T>;
+/**
+ * Creates an extendable schema token for naming and authoring model classes.
+ *
+ * Three calling forms are supported:
+ *
+ * **From a descriptor** - define field shapes inline:
+ * ```ts
+ * class UserModel extends model({
+ *   id: uuid,
+ *   name: string,
+ * }) {}
+ * ```
+ *
+ * **From an existing schema** - promote a {@link schema} token to a model token:
+ * ```ts
+ * const UserSchema = schema({ id: uuid, name: string });
+ * class UserModel extends model(UserSchema) {}
+ * ```
+ *
+ * **Discriminated union** - branch on a string discriminant key:
+ * ```ts
+ * class PetModel extends model<Cat | Dog, "union">("kind", {
+ *   cat: { lives: int },
+ *   dog: { breed: string },
+ * }) {}
+ * ```
+ *
+ * The returned token also satisfies {@link SchemaToken}`<T>`, so it can be used
+ * as a nested field value inside other schema descriptors.
+ */
+export declare function model<T extends object>(schema: SchemaToken<T>): ModelTokenBuilder<T>;
+export declare function model<T extends object>(descriptor: {
+    [K in keyof T]: DescriptorValue<T[K]>;
+}): ModelTokenBuilder<T>;
+export declare function model<T extends object, _ extends "union", K extends keyof T & string = keyof T & string>(discriminant: K, branches: {
+    [V in DiscriminantValues<T, K>]: {
+        [F in keyof BranchShape<T, K, V>]: DescriptorValue<BranchShape<T, K, V>[F]>;
+    };
+}): ModelTokenBuilder<T>;
+//# sourceMappingURL=model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../src/schema/model.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EAIvB,KAAK,WAAW,EACjB,MAAM,aAAa,CAAC;AAGrB;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CAAC,QAAQ,MAAK,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;AAE1F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC;AACtF,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,UAAU,EAAE;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAG,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC;AACtH,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,OAAO,EAAE,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,GAAG,MAAM,CAAC,GAAG,MAAM,EACtG,YAAY,EAAE,CAAC,EACf,QAAQ,EAAE;KACP,CAAC,IAAI,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG;SAAG,CAAC,IAAI,MAAM,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,eAAe,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;KAAG;CAClH,GACA,iBAAiB,CAAC,CAAC,CAAC,CAAC"}

package/dist/schema/model.js

@@ -0,0 +1,41 @@
+import { SCHEMA_BRAND, SCHEMA_DESCRIPTOR, SCHEMA_REQUIRED } from "./internal/token/symbols.js";
+import { compileSerializer } from "./json/serializer.js";
+import {
+  schema
+} from "./schema.js";
+import { COMPILED_SERIALIZER } from "./symbol.js";
+function model(descriptorOrDiscriminant, branches) {
+  let token;
+  if (typeof descriptorOrDiscriminant === "object" && SCHEMA_BRAND in descriptorOrDiscriminant) {
+    token = descriptorOrDiscriminant;
+  } else {
+    token = schema(
+      descriptorOrDiscriminant,
+      branches
+    );
+  }
+  const tokenDescriptor = token[SCHEMA_DESCRIPTOR];
+  let cachedSerializer;
+  const ModelClass = class {
+    static [SCHEMA_BRAND] = true;
+    static [SCHEMA_REQUIRED] = true;
+    static [SCHEMA_DESCRIPTOR] = tokenDescriptor;
+    static get [COMPILED_SERIALIZER]() {
+      if (cachedSerializer === void 0) cachedSerializer = compileSerializer(token);
+      return cachedSerializer;
+    }
+    static safeParse(raw) {
+      return token.safeParse(raw);
+    }
+    static optional() {
+      return token.optional();
+    }
+  };
+  return asModelToken(ModelClass);
+}
+function asModelToken(token) {
+  return token;
+}
+export {
+  model
+};

package/dist/schema/primitives/array.d.ts

@@ -0,0 +1,14 @@
+import type { TypedPrimitive } from "./index.js";
+/**
+ * Creates a primitive that splits a comma-separated string and coerces each item
+ * using the provided `primitive`. An empty or missing input produces an empty array.
+ *
+ * @example
+ * ```ts
+ * const tags = array(string);      // TypedPrimitive<string[]>
+ * const ids  = array(int.min(1));  // TypedPrimitive<number[]>
+ * ```
+ */
+declare function array<T>(primitive: TypedPrimitive<T>): TypedPrimitive<T[]>;
+export { array };
+//# sourceMappingURL=array.d.ts.map

package/dist/schema/primitives/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../../src/schema/primitives/array.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;;;;;GASG;AACH,iBAAS,KAAK,CAAC,CAAC,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,EAAE,CAAC,CAiBnE;AAED,OAAO,EAAE,KAAK,EAAE,CAAC"}

package/dist/schema/primitives/array.js

@@ -0,0 +1,21 @@
+function array(primitive) {
+  const fn = (v) => {
+    if (v === void 0) throw new TypeError("array primitive received undefined");
+    if (v === "") return [];
+    if (Array.isArray(v)) {
+      return v.map((item) => primitive(item.trim()));
+    }
+    return v.split(",").map((item) => primitive(item.trim()));
+  };
+  fn._type = `array<${primitive._type}>`;
+  fn._required = primitive._required;
+  fn.jsonSchema = {
+    type: "array",
+    items: primitive.jsonSchema
+  };
+  fn._item = primitive;
+  return fn;
+}
+export {
+  array
+};

package/dist/schema/primitives/bool.d.ts

@@ -0,0 +1,7 @@
+import type { TypedPrimitive } from "./index.js";
+/**
+ * Boolean primitive. Accepts `"true"`, `"1"`, `"false"`, `"0"` (case-insensitive).
+ */
+declare const bool: TypedPrimitive<boolean>;
+export { bool };
+//# sourceMappingURL=bool.d.ts.map

package/dist/schema/primitives/bool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bool.d.ts","sourceRoot":"","sources":["../../../src/schema/primitives/bool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD;;GAEG;AACH,QAAA,MAAM,IAAI,EAAE,cAAc,CAAC,OAAO,CAQjC,CAAC;AAEF,OAAO,EAAE,IAAI,EAAE,CAAC"}

package/dist/schema/primitives/bool.js

@@ -0,0 +1,12 @@
+const bool = Object.assign(
+  (v) => {
+    const lower = v.toLowerCase();
+    if (lower === "true" || lower === "1") return true;
+    if (lower === "false" || lower === "0") return false;
+    throw new Error(`Expected boolean, got "${v}"`);
+  },
+  { _type: "bool", _required: true, jsonSchema: { type: "boolean" } }
+);
+export {
+  bool
+};

package/dist/schema/primitives/date.d.ts

@@ -0,0 +1,23 @@
+import type { TypedPrimitive } from "./index.js";
+/**
+ * Format key that controls how {@link date} and {@link parseDate} interpret an input string.
+ */
+type DateFormatKey = "DMY" | "MDY" | "YMD" | "ISO" | "TIMESTAMP";
+type DatePrimitive = TypedPrimitive<Date> & {
+    format(format: DateFormatKey): DatePrimitive;
+    readonly _format: string;
+};
+/**
+ * Date primitive. Parses a date string and returns a `Date` object.
+ * Defaults to ISO 8601. Chain `.format()` to select a different input format.
+ *
+ * @example
+ * ```ts
+ * date                       // ISO 8601 (default)
+ * date.format("DMY")         // DD/MM/YYYY
+ * date.format("TIMESTAMP")   // Unix seconds / ms / μs
+ * ```
+ */
+export declare const date: DatePrimitive;
+export {};
+//# sourceMappingURL=date.d.ts.map

package/dist/schema/primitives/date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../../src/schema/primitives/date.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD;;GAEG;AACH,KAAK,aAAa,GACd,KAAK,GACL,KAAK,GACL,KAAK,GACL,KAAK,GACL,WAAW,CAAC;AAEhB,KAAK,aAAa,GAAG,cAAc,CAAC,IAAI,CAAC,GAAG;IAC1C,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,aAAa,CAAC;IAC7C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;AAuHF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,IAAI,EAAE,aAAmC,CAAC"}

package/dist/schema/primitives/date.js

@@ -0,0 +1,92 @@
+function throwBadInput(format, raw) {
+  throw new Error(`Invalid ${format} date: "${raw}"`);
+}
+function utcMidnight(year, month, day) {
+  return new Date(Date.UTC(year, month, day, 0, 0, 0, 0));
+}
+function normalizeYear(yy) {
+  return yy < 100 ? 2e3 + yy : yy;
+}
+function parseISO(raw) {
+  const ISO_RE = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})?)?$/;
+  if (!ISO_RE.test(raw)) throwBadInput("ISO", raw);
+  const normalized = raw.includes("T") ? raw : raw + "T00:00:00Z";
+  const d = new Date(normalized);
+  if (isNaN(d.getTime())) throwBadInput("ISO", raw);
+  return d;
+}
+function parseDayMonthYear(raw, dayFirst) {
+  const SEP_RE = /^(\d{1,2})[\/\-.](\d{1,2})[\/\-.](\d{2,4})$/;
+  const COMPACT_RE = /^(\d{2})(\d{2})(\d{4})$/;
+  const m = SEP_RE.exec(raw) ?? COMPACT_RE.exec(raw);
+  const label = dayFirst ? "DMY" : "MDY";
+  if (!m) throwBadInput(label, raw);
+  const a = parseInt(m[1], 10);
+  const b = parseInt(m[2], 10);
+  const year = normalizeYear(parseInt(m[3], 10));
+  const [day, month] = dayFirst ? [a, b - 1] : [b, a - 1];
+  const d = utcMidnight(year, month, day);
+  if (d.getUTCFullYear() !== year || d.getUTCMonth() !== month || d.getUTCDate() !== day) {
+    throwBadInput(label, raw);
+  }
+  if (isNaN(d.getTime())) throwBadInput(label, raw);
+  return d;
+}
+function parseYMD(raw) {
+  const SEP_RE = /^(\d{4})[\/\-.](\d{1,2})[\/\-.](\d{1,2})$/;
+  const COMPACT_RE = /^(\d{4})(\d{2})(\d{2})$/;
+  const m = SEP_RE.exec(raw) ?? COMPACT_RE.exec(raw);
+  if (!m) throwBadInput("YMD", raw);
+  const year = parseInt(m[1], 10);
+  const month = parseInt(m[2], 10) - 1;
+  const day = parseInt(m[3], 10);
+  const d = utcMidnight(year, month, day);
+  if (isNaN(d.getTime())) throwBadInput("YMD", raw);
+  if (d.getUTCFullYear() !== year || d.getUTCMonth() !== month || d.getUTCDate() !== day) {
+    throwBadInput("YMD", raw);
+  }
+  return d;
+}
+function parseTimestamp(raw) {
+  const ts = raw.trim();
+  if (!/^\d{10}$|^\d{13}$|^\d{16}$/.test(ts)) throwBadInput("TIMESTAMP", raw);
+  const n = parseInt(ts, 10);
+  const ms = ts.length === 10 ? n * 1e3 : ts.length === 13 ? n : Math.floor(n / 1e3);
+  const d = new Date(ms);
+  if (isNaN(d.getTime())) throwBadInput("TIMESTAMP", raw);
+  return d;
+}
+const DATE_JSON_SCHEMA = {
+  ISO: { type: "string", format: "date-time" },
+  YMD: { type: "string", format: "date" },
+  DMY: { type: "string" },
+  MDY: { type: "string" },
+  TIMESTAMP: { type: "string" }
+};
+function parseDate(raw, format = "ISO") {
+  switch (format) {
+    case "ISO":
+      return parseISO(raw);
+    case "DMY":
+      return parseDayMonthYear(raw, true);
+    case "MDY":
+      return parseDayMonthYear(raw, false);
+    case "YMD":
+      return parseYMD(raw);
+    case "TIMESTAMP":
+      return parseTimestamp(raw);
+  }
+}
+function makeDatePrimitive(format = "ISO") {
+  const fn = (raw) => parseDate(raw, format);
+  fn._type = "date";
+  fn._required = true;
+  fn.jsonSchema = DATE_JSON_SCHEMA[format];
+  fn._format = format;
+  fn.format = (nextFormat) => makeDatePrimitive(nextFormat);
+  return fn;
+}
+const date = makeDatePrimitive();
+export {
+  date
+};

package/dist/schema/primitives/enum.d.ts

@@ -0,0 +1,19 @@
+import type { TypedPrimitive } from "./index.js";
+/**
+ * String enum primitive carrying a lookup table of pre-quoted JSON literals for each value.
+ */
+type EnumPrimitive<T extends readonly string[]> = TypedPrimitive<T[number]> & {
+    /** Lookup of value -> pre-quoted JSON literal, built once at creation for O(1) serializer lookups. */
+    lut: Record<string, string>;
+};
+/**
+ * Creates a primitive that accepts any string value present in the provided tuple.
+ *
+ * @example
+ * ```ts
+ * const role = enums(["admin", "user", "guest"]);
+ * ```
+ */
+declare function enums<const T extends readonly string[]>(values: T): EnumPrimitive<T>;
+export { enums };
+//# sourceMappingURL=enum.d.ts.map

package/dist/schema/primitives/enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum.d.ts","sourceRoot":"","sources":["../../../src/schema/primitives/enum.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD;;GAEG;AACH,KAAK,aAAa,CAAC,CAAC,SAAS,SAAS,MAAM,EAAE,IAAI,cAAc,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG;IAC5E,sGAAsG;IACtG,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7B,CAAC;AAEF;;;;;;;GAOG;AACH,iBAAS,KAAK,CAAC,KAAK,CAAC,CAAC,SAAS,SAAS,MAAM,EAAE,EAAE,MAAM,EAAE,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAe7E;AAED,OAAO,EAAE,KAAK,EAAE,CAAC"}

package/dist/schema/primitives/enum.js

@@ -0,0 +1,19 @@
+function enums(values) {
+  const fn = (v) => {
+    if (!values.includes(v)) {
+      throw new Error(`Expected one of [${values.join(", ")}], got "${v}"`);
+    }
+    return v;
+  };
+  fn._type = "enum";
+  fn._required = true;
+  fn.jsonSchema = {
+    type: "string",
+    enum: values
+  };
+  fn.lut = Object.fromEntries(values.map((v) => [v, `"${v}"`]));
+  return fn;
+}
+export {
+  enums
+};

package/dist/schema/primitives/float.d.ts

@@ -0,0 +1,23 @@
+import type { TypedPrimitive } from "./index.js";
+/**
+ * Float primitive with optional chainable range constraints.
+ * Each builder method returns a new independent primitive so the original is never mutated.
+ */
+type FloatPrimitive = TypedPrimitive<number> & {
+    /** Returns a new primitive that rejects values below `n`. */
+    min(n: number): FloatPrimitive;
+    /** Returns a new primitive that rejects values above `n`. */
+    max(n: number): FloatPrimitive;
+};
+/**
+ * Floating-point number primitive with optional chainable range constraints.
+ *
+ * @example
+ * ```ts
+ * float                 // any number
+ * float.min(0).max(1)   // probability range
+ * ```
+ */
+export declare const float: FloatPrimitive;
+export {};
+//# sourceMappingURL=float.d.ts.map

package/dist/schema/primitives/float.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"float.d.ts","sourceRoot":"","sources":["../../../src/schema/primitives/float.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD;;;GAGG;AACH,KAAK,cAAc,GAAG,cAAc,CAAC,MAAM,CAAC,GAAG;IAC7C,6DAA6D;IAC7D,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,cAAc,CAAC;IAC/B,6DAA6D;IAC7D,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,cAAc,CAAC;CAChC,CAAC;AAkCF;;;;;;;;GAQG;AACH,eAAO,MAAM,KAAK,EAAE,cAA4B,CAAC"}

package/dist/schema/primitives/float.js

@@ -0,0 +1,33 @@
+function makeFloat(config = {}) {
+  const fn = (v) => {
+    const raw = v.trim();
+    if (!/^[+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(raw)) {
+      throw new Error(`Expected float, got "${v}"`);
+    }
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed)) {
+      throw new Error(`Expected finite float, got "${v}"`);
+    }
+    if (config.min !== void 0 && parsed < config.min) {
+      throw new Error(`Value too small: minimum is ${config.min}, got ${parsed}`);
+    }
+    if (config.max !== void 0 && parsed > config.max) {
+      throw new Error(`Value too large: maximum is ${config.max}, got ${parsed}`);
+    }
+    return parsed;
+  };
+  fn._type = "float";
+  fn._required = true;
+  fn.jsonSchema = {
+    type: "number",
+    ...config.min !== void 0 ? { minimum: config.min } : {},
+    ...config.max !== void 0 ? { maximum: config.max } : {}
+  };
+  fn.min = (n) => makeFloat({ ...config, min: n });
+  fn.max = (n) => makeFloat({ ...config, max: n });
+  return fn;
+}
+const float = makeFloat();
+export {
+  float
+};