@weavecode/weave 0.0.0-stage → 0.1.1

package/node_modules/zod/src/v4/core/function.ts

@@ -0,0 +1,176 @@
+import { _array, _tuple, _unknown } from "./api.js";
+import type * as core from "./core.js";
+import { parse, parseAsync } from "./parse.js";
+import * as schemas from "./schemas.js";
+import { $ZodTuple } from "./schemas.js";
+import type * as util from "./util.js";
+
+//////////////////////////////////////////
+//////////////////////////////////////////
+//////////                      //////////
+//////////     $ZodFunction     //////////
+//////////                      //////////
+//////////////////////////////////////////
+//////////////////////////////////////////
+export interface $ZodFunctionDef<
+  In extends $ZodFunctionIn = $ZodFunctionIn,
+  Out extends $ZodFunctionOut = $ZodFunctionOut,
+> {
+  type: "function";
+  input: In;
+  output: Out;
+}
+
+export type $ZodFunctionArgs = schemas.$ZodType<unknown[], unknown[]>;
+export type $ZodFunctionIn = $ZodFunctionArgs;
+export type $ZodFunctionOut = schemas.$ZodType;
+
+export type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (
+  ...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>
+) => core.input<Returns>;
+
+export type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (
+  ...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>
+) => util.MaybeAsync<core.input<Returns>>;
+
+export type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (
+  ...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>
+) => core.output<Returns>;
+
+export type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (
+  ...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>
+) => util.MaybeAsync<core.output<Returns>>;
+
+export class $ZodFunction<
+  Args extends $ZodFunctionIn = $ZodFunctionIn,
+  Returns extends $ZodFunctionOut = $ZodFunctionOut,
+> {
+  def: $ZodFunctionDef<Args, Returns>;
+
+  /** @deprecated */
+  _def!: $ZodFunctionDef<Args, Returns>;
+  _input!: $InferInnerFunctionType<Args, Returns>;
+  _output!: $InferOuterFunctionType<Args, Returns>;
+
+  constructor(def: $ZodFunctionDef<Args, Returns>) {
+    this._def = def;
+    this.def = def;
+  }
+
+  implement<F extends $InferInnerFunctionType<Args, Returns>>(
+    func: F
+  ): // allow for return type inference
+  (
+    ...args: Parameters<this["_output"]>
+  ) => ReturnType<F> extends ReturnType<this["_output"]> ? ReturnType<F> : ReturnType<this["_output"]> {
+    if (typeof func !== "function") {
+      throw new Error("implement() must be called with a function");
+    }
+    const impl = ((...args: any[]) => {
+      const parsedArgs = this._def.input ? parse(this._def.input, args, undefined, { callee: impl }) : args;
+      if (!Array.isArray(parsedArgs)) {
+        throw new Error("Invalid arguments schema: not an array or tuple schema.");
+      }
+      const output = func(...(parsedArgs as any));
+      return this._def.output ? parse(this._def.output, output, undefined, { callee: impl }) : output;
+    }) as any;
+    return impl;
+  }
+
+  implementAsync<F extends $InferInnerFunctionTypeAsync<Args, Returns>>(
+    func: F
+  ): F extends $InferOuterFunctionTypeAsync<Args, Returns> ? F : $InferOuterFunctionTypeAsync<Args, Returns> {
+    if (typeof func !== "function") {
+      throw new Error("implement() must be called with a function");
+    }
+
+    const impl = (async (...args: any[]) => {
+      const parsedArgs = this._def.input ? await parseAsync(this._def.input, args, undefined, { callee: impl }) : args;
+      if (!Array.isArray(parsedArgs)) {
+        throw new Error("Invalid arguments schema: not an array or tuple schema.");
+      }
+      const output = await func(...(parsedArgs as any));
+      return this._def.output ? parseAsync(this._def.output, output, undefined, { callee: impl }) : output;
+    }) as any;
+    return impl;
+  }
+
+  input<const Items extends util.TupleItems, const Rest extends $ZodFunctionOut = $ZodFunctionOut>(
+    args: Items,
+    rest?: Rest
+  ): $ZodFunction<schemas.$ZodTuple<Items, Rest>, Returns>;
+  input<NewArgs extends $ZodFunctionIn>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
+  input(...args: any[]): $ZodFunction<any, Returns> {
+    const F: any = this.constructor;
+    if (Array.isArray(args[0])) {
+      return new F({
+        type: "function",
+        input: new $ZodTuple({
+          type: "tuple",
+          items: args[0],
+          rest: args[1],
+        }),
+        output: this._def.output,
+      });
+    }
+
+    return new F({
+      type: "function",
+      input: args[0],
+      output: this._def.output,
+    });
+  }
+
+  output<NewReturns extends schemas.$ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns> {
+    const F: any = this.constructor;
+    return new F({
+      type: "function",
+      input: this._def.input,
+      output,
+    });
+  }
+}
+
+export interface $ZodFunctionParams<I extends $ZodFunctionIn, O extends schemas.$ZodType> {
+  input?: I;
+  output?: O;
+}
+
+function _function(): $ZodFunction;
+function _function<const In extends Array<schemas.$ZodType> = Array<schemas.$ZodType>>(params: {
+  input: In;
+}): $ZodFunction<$ZodTuple<In, null>, $ZodFunctionOut>;
+function _function<
+  const In extends Array<schemas.$ZodType> = Array<schemas.$ZodType>,
+  const Out extends $ZodFunctionOut = $ZodFunctionOut,
+>(params: {
+  input: In;
+  output: Out;
+}): $ZodFunction<$ZodTuple<In, null>, Out>;
+function _function<const In extends $ZodFunctionIn = $ZodFunctionIn>(params: {
+  input: In;
+}): $ZodFunction<In, $ZodFunctionOut>;
+function _function<const Out extends $ZodFunctionOut = $ZodFunctionOut>(params: {
+  output: Out;
+}): $ZodFunction<$ZodFunctionIn, Out>;
+function _function<
+  In extends $ZodFunctionIn = $ZodFunctionIn,
+  Out extends schemas.$ZodType = schemas.$ZodType,
+>(params?: {
+  input: In;
+  output: Out;
+}): $ZodFunction<In, Out>;
+function _function(params?: {
+  output?: schemas.$ZodType;
+  input?: $ZodFunctionArgs | Array<schemas.$ZodType>;
+}): any {
+  return new $ZodFunction({
+    type: "function",
+    input: Array.isArray(params?.input)
+      ? _tuple(schemas.$ZodTuple, params?.input as any)
+      : (params?.input ?? _array(schemas.$ZodArray, _unknown(schemas.$ZodUnknown))),
+    output: params?.output ?? _unknown(schemas.$ZodUnknown),
+  });
+}
+
+export { _function as function };

package/node_modules/zod/src/v4/core/index.ts

@@ -0,0 +1,15 @@
+export * from "./core.js";
+export * from "./parse.js";
+export * from "./errors.js";
+export * from "./schemas.js";
+export * from "./checks.js";
+export * from "./versions.js";
+export * as util from "./util.js";
+export * as regexes from "./regexes.js";
+export * as locales from "../locales/index.js";
+export * from "./registries.js";
+export * from "./doc.js";
+export * from "./function.js";
+export * from "./api.js";
+export * from "./to-json-schema.js";
+export * as JSONSchema from "./json-schema.js";

package/node_modules/zod/src/v4/core/json-schema.ts

@@ -0,0 +1,143 @@
+export type Schema =
+  | ObjectSchema
+  | ArraySchema
+  | StringSchema
+  | NumberSchema
+  | IntegerSchema
+  | BooleanSchema
+  | NullSchema;
+
+// export type JsonType = "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
+
+// export interface JSONSchema {
+//   type?: string ;
+//   $id?: string ;
+//   id?: string ;
+//   $schema?: string ;
+//   $ref?: string ;
+//   $anchor?: string ;
+//   $defs?: { [key: string]: JSONSchema } ;
+//   definitions?: { [key: string]: JSONSchema } ;
+//   $comment?: string ;
+//   title?: string ;
+//   description?: string ;
+//   default?: unknown ;
+//   examples?: unknown[] ;
+//   readOnly?: boolean ;
+//   writeOnly?: boolean ;
+//   deprecated?: boolean ;
+//   allOf?: JSONSchema[] ;
+//   anyOf?: JSONSchema[] ;
+//   oneOf?: JSONSchema[] ;
+//   not?: JSONSchema ;
+//   if?: JSONSchema ;
+//   then?: JSONSchema ;
+//   else?: JSONSchema ;
+//   enum?: Array<string | number | boolean | null> ;
+//   const?: string | number | boolean | null ;
+//   [k: string]: unknown;
+
+//   /** A special key used as an intermediate representation of extends-style relationships. Omitted as a $ref with additional properties. */
+//   // _ref?: JSONSchema;
+//   _prefault?: unknown ;
+// }
+
+export type _JSONSchema = boolean | JSONSchema;
+export type JSONSchema = {
+  [k: string]: unknown;
+  $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#";
+  $id?: string;
+  $anchor?: string;
+  $ref?: string;
+  $dynamicRef?: string;
+  $dynamicAnchor?: string;
+  $vocabulary?: Record<string, boolean>;
+  $comment?: string;
+  $defs?: Record<string, JSONSchema>;
+  type?: "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
+  additionalItems?: _JSONSchema;
+  unevaluatedItems?: _JSONSchema;
+  prefixItems?: _JSONSchema[];
+  items?: _JSONSchema | _JSONSchema[];
+  contains?: _JSONSchema;
+  additionalProperties?: _JSONSchema;
+  unevaluatedProperties?: _JSONSchema;
+  properties?: Record<string, _JSONSchema>;
+  patternProperties?: Record<string, _JSONSchema>;
+  dependentSchemas?: Record<string, _JSONSchema>;
+  propertyNames?: _JSONSchema;
+  if?: _JSONSchema;
+  then?: _JSONSchema;
+  else?: _JSONSchema;
+  allOf?: JSONSchema[];
+  anyOf?: JSONSchema[];
+  oneOf?: JSONSchema[];
+  not?: _JSONSchema;
+  multipleOf?: number;
+  maximum?: number;
+  exclusiveMaximum?: number;
+  minimum?: number;
+  exclusiveMinimum?: number;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  maxContains?: number;
+  minContains?: number;
+  maxProperties?: number;
+  minProperties?: number;
+  required?: string[];
+  dependentRequired?: Record<string, string[]>;
+  enum?: Array<string | number | boolean | null>;
+  const?: string | number | boolean | null;
+
+  // metadata
+  id?: string;
+  title?: string;
+  description?: string;
+  default?: unknown;
+  deprecated?: boolean;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  examples?: unknown[];
+  format?: string;
+  contentMediaType?: string;
+  contentEncoding?: string;
+  contentSchema?: JSONSchema;
+
+  // internal
+  _prefault?: unknown;
+};
+
+// for backwards compatibility
+export type BaseSchema = JSONSchema;
+
+export interface ObjectSchema extends JSONSchema {
+  type: "object";
+}
+
+export interface ArraySchema extends JSONSchema {
+  type: "array";
+}
+
+export interface StringSchema extends JSONSchema {
+  type: "string";
+}
+
+export interface NumberSchema extends JSONSchema {
+  type: "number";
+}
+
+export interface IntegerSchema extends JSONSchema {
+  type: "integer";
+}
+
+export interface BooleanSchema extends JSONSchema {
+  type: "boolean";
+}
+
+export interface NullSchema extends JSONSchema {
+  type: "null";
+}

package/node_modules/zod/src/v4/core/parse.ts

@@ -0,0 +1,94 @@
+import * as core from "./core.js";
+import * as errors from "./errors.js";
+import type * as schemas from "./schemas.js";
+import * as util from "./util.js";
+
+export type $ZodErrorClass = { new (issues: errors.$ZodIssue[]): errors.$ZodError };
+
+///////////        METHODS       ///////////
+export type $Parse = <T extends schemas.$ZodType>(
+  schema: T,
+  value: unknown,
+  _ctx?: schemas.ParseContext<errors.$ZodIssue>,
+  _params?: { callee?: util.AnyFunc; Err?: $ZodErrorClass }
+) => core.output<T>;
+
+export const _parse: (_Err: $ZodErrorClass) => $Parse = (_Err) => (schema, value, _ctx, _params) => {
+  const ctx: schemas.ParseContextInternal = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
+  const result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise) {
+    throw new core.$ZodAsyncError();
+  }
+  if (result.issues.length) {
+    const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
+    util.captureStackTrace(e, _params?.callee);
+    throw e;
+  }
+  return result.value as core.output<typeof schema>;
+};
+
+export const parse: $Parse = /* @__PURE__*/ _parse(errors.$ZodRealError);
+
+export type $ParseAsync = <T extends schemas.$ZodType>(
+  schema: T,
+  value: unknown,
+  _ctx?: schemas.ParseContext<errors.$ZodIssue>,
+  _params?: { callee?: util.AnyFunc; Err?: $ZodErrorClass }
+) => Promise<core.output<T>>;
+
+export const _parseAsync: (_Err: $ZodErrorClass) => $ParseAsync = (_Err) => async (schema, value, _ctx, params) => {
+  const ctx: schemas.ParseContextInternal = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+  let result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise) result = await result;
+  if (result.issues.length) {
+    const e = new (params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
+    util.captureStackTrace(e, params?.callee);
+    throw e;
+  }
+  return result.value as core.output<typeof schema>;
+};
+
+export const parseAsync: $ParseAsync = /* @__PURE__*/ _parseAsync(errors.$ZodRealError);
+
+export type $SafeParse = <T extends schemas.$ZodType>(
+  schema: T,
+  value: unknown,
+  _ctx?: schemas.ParseContext<errors.$ZodIssue>
+) => util.SafeParseResult<core.output<T>>;
+
+export const _safeParse: (_Err: $ZodErrorClass) => $SafeParse = (_Err) => (schema, value, _ctx) => {
+  const ctx: schemas.ParseContextInternal = _ctx ? { ..._ctx, async: false } : { async: false };
+  const result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise) {
+    throw new core.$ZodAsyncError();
+  }
+
+  return result.issues.length
+    ? {
+        success: false,
+        error: new (_Err ?? errors.$ZodError)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),
+      }
+    : ({ success: true, data: result.value } as any);
+};
+export const safeParse: $SafeParse = /* @__PURE__*/ _safeParse(errors.$ZodRealError);
+
+export type $SafeParseAsync = <T extends schemas.$ZodType>(
+  schema: T,
+  value: unknown,
+  _ctx?: schemas.ParseContext<errors.$ZodIssue>
+) => Promise<util.SafeParseResult<core.output<T>>>;
+
+export const _safeParseAsync: (_Err: $ZodErrorClass) => $SafeParseAsync = (_Err) => async (schema, value, _ctx) => {
+  const ctx: schemas.ParseContextInternal = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+  let result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise) result = await result;
+
+  return result.issues.length
+    ? {
+        success: false,
+        error: new _Err(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),
+      }
+    : ({ success: true, data: result.value } as any);
+};
+
+export const safeParseAsync: $SafeParseAsync = /* @__PURE__*/ _safeParseAsync(errors.$ZodRealError);

package/node_modules/zod/src/v4/core/regexes.ts

@@ -0,0 +1,135 @@
+export const cuid: RegExp = /^[cC][^\s-]{8,}$/;
+export const cuid2: RegExp = /^[0-9a-z]+$/;
+export const ulid: RegExp = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
+export const xid: RegExp = /^[0-9a-vA-V]{20}$/;
+export const ksuid: RegExp = /^[A-Za-z0-9]{27}$/;
+export const nanoid: RegExp = /^[a-zA-Z0-9_-]{21}$/;
+
+/** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */
+export const duration: RegExp =
+  /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
+
+/** Implements ISO 8601-2 extensions like explicit +- prefixes, mixing weeks with other units, and fractional/negative components. */
+export const extendedDuration: RegExp =
+  /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
+
+/** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */
+export const guid: RegExp = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
+
+/** Returns a regex for validating an RFC 4122 UUID.
+ *
+ * @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */
+export const uuid = (version?: number | undefined): RegExp => {
+  if (!version)
+    return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000)$/;
+  return new RegExp(
+    `^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`
+  );
+};
+export const uuid4: RegExp = /*@__PURE__*/ uuid(4);
+export const uuid6: RegExp = /*@__PURE__*/ uuid(6);
+export const uuid7: RegExp = /*@__PURE__*/ uuid(7);
+
+/** Practical email validation */
+export const email: RegExp =
+  /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
+
+/** Equivalent to the HTML5 input[type=email] validation implemented by browsers. Source: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email */
+export const html5Email: RegExp =
+  /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+
+/** The classic emailregex.com regex for RFC 5322-compliant emails */
+export const rfc5322Email =
+  /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+
+/** A loose regex that allows Unicode characters, enforces length limits, and that's about it. */
+export const unicodeEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
+
+export const browserEmail: RegExp =
+  /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+// from https://thekevinscott.com/emojis-in-javascript/#writing-a-regular-expression
+
+export const _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
+export function emoji(): RegExp {
+  return new RegExp(_emoji, "u");
+}
+
+export const ipv4: RegExp =
+  /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
+export const ipv6: RegExp =
+  /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})$/;
+
+export const cidrv4: RegExp =
+  /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
+export const cidrv6: RegExp =
+  /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
+
+// https://stackoverflow.com/questions/7860392/determine-if-string-is-in-base64-using-javascript
+export const base64: RegExp = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
+export const base64url: RegExp = /^[A-Za-z0-9_-]*$/;
+
+// based on https://stackoverflow.com/questions/106179/regular-expression-to-match-dns-hostname-or-ip-address
+// export const hostname: RegExp =
+//   /^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)+([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$/;
+export const hostname: RegExp = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
+export const domain: RegExp = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
+
+// https://blog.stevenlevithan.com/archives/validate-phone-number#r4-3 (regex sans spaces)
+export const e164: RegExp = /^\+(?:[0-9]){6,14}[0-9]$/;
+
+// const dateSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
+const dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
+export const date: RegExp = /*@__PURE__*/ new RegExp(`^${dateSource}$`);
+
+function timeSource(args: { precision?: number | null | undefined }) {
+  const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
+  const regex =
+    typeof args.precision === "number"
+      ? args.precision === -1
+        ? `${hhmm}`
+        : args.precision === 0
+          ? `${hhmm}:[0-5]\\d`
+          : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}`
+      : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
+  return regex;
+}
+export function time(args: {
+  precision?: number | null;
+  // local?: boolean;
+}): RegExp {
+  return new RegExp(`^${timeSource(args)}$`);
+}
+
+// Adapted from https://stackoverflow.com/a/3143231
+export function datetime(args: {
+  precision?: number | null;
+  offset?: boolean;
+  local?: boolean;
+}): RegExp {
+  const time = timeSource({ precision: args.precision });
+  const opts = ["Z"];
+  if (args.local) opts.push("");
+  if (args.offset) opts.push(`([+-]\\d{2}:\\d{2})`);
+  const timeRegex = `${time}(?:${opts.join("|")})`;
+
+  return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
+}
+
+export const string = (params?: { minimum?: number | undefined; maximum?: number | undefined }): RegExp => {
+  const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
+  return new RegExp(`^${regex}$`);
+};
+
+export const bigint: RegExp = /^\d+n?$/;
+export const integer: RegExp = /^\d+$/;
+export const number: RegExp = /^-?\d+(?:\.\d+)?/i;
+export const boolean: RegExp = /true|false/i;
+const _null: RegExp = /null/i;
+export { _null as null };
+const _undefined: RegExp = /undefined/i;
+export { _undefined as undefined };
+
+// regex for string with no uppercase letters
+export const lowercase: RegExp = /^[^A-Z]*$/;
+// regex for string with no lowercase letters
+export const uppercase: RegExp = /^[^a-z]*$/;

package/node_modules/zod/src/v4/core/registries.ts

@@ -0,0 +1,96 @@
+import type * as core from "./core.js";
+import type { $ZodType } from "./schemas.js";
+
+export const $output: unique symbol = Symbol("ZodOutput");
+export type $output = typeof $output;
+export const $input: unique symbol = Symbol("ZodInput");
+export type $input = typeof $input;
+
+export type $replace<Meta, S extends $ZodType> = Meta extends $output
+  ? core.output<S>
+  : Meta extends $input
+    ? core.input<S>
+    : Meta extends (infer M)[]
+      ? $replace<M, S>[]
+      : Meta extends (...args: infer P) => infer R
+        ? (
+            ...args: {
+              [K in keyof P]: $replace<P[K], S>; // tuple
+            }
+          ) => $replace<R, S>
+        : // handle objects
+          Meta extends object
+          ? { [K in keyof Meta]: $replace<Meta[K], S> }
+          : Meta;
+
+type MetadataType = Record<string, unknown> | undefined;
+export class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {
+  _meta!: Meta;
+  _schema!: Schema;
+  _map: Map<Schema, $replace<Meta, Schema>> = new Map();
+  _idmap: Map<string, Schema> = new Map();
+
+  add<S extends Schema>(
+    schema: S,
+    ..._meta: undefined extends Meta ? [$replace<Meta, S>?] : [$replace<Meta, S>]
+  ): this {
+    const meta: any = _meta[0];
+    this._map.set(schema, meta!);
+    if (meta && typeof meta === "object" && "id" in meta) {
+      if (this._idmap.has(meta.id!)) {
+        throw new Error(`ID ${meta.id} already exists in the registry`);
+      }
+      this._idmap.set(meta.id!, schema);
+    }
+    return this as any;
+  }
+
+  clear(): this {
+    this._map = new Map();
+    this._idmap = new Map();
+    return this;
+  }
+
+  remove(schema: Schema): this {
+    const meta: any = this._map.get(schema);
+    if (meta && typeof meta === "object" && "id" in meta) {
+      this._idmap.delete(meta.id!);
+    }
+    this._map.delete(schema);
+    return this;
+  }
+
+  get<S extends Schema>(schema: S): $replace<Meta, S> | undefined {
+    // return this._map.get(schema) as any;
+
+    // inherit metadata
+    const p = schema._zod.parent as Schema;
+    if (p) {
+      const pm: any = { ...(this.get(p) ?? {}) };
+      delete pm.id; // do not inherit id
+      return { ...pm, ...this._map.get(schema) } as any;
+    }
+    return this._map.get(schema) as any;
+  }
+
+  has(schema: Schema): boolean {
+    return this._map.has(schema);
+  }
+}
+
+export interface JSONSchemaMeta {
+  id?: string | undefined;
+  title?: string | undefined;
+  description?: string | undefined;
+  deprecated?: boolean | undefined;
+  [k: string]: unknown;
+}
+
+export interface GlobalMeta extends JSONSchemaMeta {}
+
+// registries
+export function registry<T extends MetadataType = MetadataType, S extends $ZodType = $ZodType>(): $ZodRegistry<T, S> {
+  return new $ZodRegistry<T, S>();
+}
+
+export const globalRegistry: $ZodRegistry<GlobalMeta> = /*@__PURE__*/ registry<GlobalMeta>();