@bigmistqke/lexicon-to-valibot 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,221 @@
+import * as v from 'valibot';
+export { InferOutput } from 'valibot';
+export { LexUserType, LexiconDoc } from '@atproto/lexicon';
+
+interface QueryValidators {
+    parameters: v.GenericSchema;
+    output: v.GenericSchema;
+}
+interface ProcedureValidators {
+    parameters: v.GenericSchema;
+    input: v.GenericSchema;
+    output: v.GenericSchema;
+}
+interface SubscriptionValidators {
+    parameters: v.GenericSchema;
+    message: v.GenericSchema;
+}
+
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type TypedBlobRef = {
+    $type: "blob";
+    ref: {
+        $link: string;
+    };
+    mimeType: string;
+    size: number;
+};
+type UntypedBlobRef = {
+    cid: string;
+    mimeType: string;
+};
+type BlobRef = TypedBlobRef | UntypedBlobRef;
+type CidLink = {
+    $link: string;
+};
+type ExternalRefsMap = Record<string, unknown>;
+type InferLexType<T, Defs = {}, ExtRefs extends ExternalRefsMap = {}> = T extends {
+    type: "boolean";
+} ? T extends {
+    const: infer C extends boolean;
+} ? C : boolean : T extends {
+    type: "integer";
+} ? T extends {
+    const: infer C extends number;
+} ? C : T extends {
+    enum: infer E extends readonly number[];
+} ? E[number] : number : T extends {
+    type: "string";
+} ? T extends {
+    const: infer C extends string;
+} ? C : T extends {
+    enum: infer E extends readonly string[];
+} ? E[number] : string : T extends {
+    type: "unknown";
+} ? unknown : T extends {
+    type: "bytes";
+} ? Uint8Array : T extends {
+    type: "blob";
+} ? BlobRef : T extends {
+    type: "cid-link";
+} ? CidLink : T extends {
+    type: "token";
+} ? string : T extends {
+    type: "array";
+    items: infer Items;
+} ? InferLexType<Items, Defs, ExtRefs>[] : T extends {
+    type: "object";
+    properties?: infer Props;
+} ? InferLexObject<Props, T, Defs, ExtRefs> : T extends {
+    type: "ref";
+    ref: infer R extends string;
+} ? InferLexRef<R, Defs, ExtRefs> : T extends {
+    type: "union";
+    refs: infer Refs extends readonly string[];
+} ? InferLexUnion<Refs, Defs, ExtRefs> : T extends {
+    type: "record";
+    record: infer Rec;
+} ? InferLexType<Rec, Defs, ExtRefs> : unknown;
+type InferLexObject<Props, Schema, Defs, ExtRefs extends ExternalRefsMap = {}> = Props extends Record<string, unknown> ? Prettify<{
+    [K in keyof Props as K extends RequiredKeys<Schema> ? K extends NullableKeys<Schema> ? never : K : never]: InferLexType<Props[K], Defs, ExtRefs>;
+} & {
+    [K in keyof Props as K extends RequiredKeys<Schema> ? K extends NullableKeys<Schema> ? K : never : never]: InferLexType<Props[K], Defs, ExtRefs> | null;
+} & {
+    [K in keyof Props as K extends RequiredKeys<Schema> ? never : K extends NullableKeys<Schema> ? never : K]?: InferLexType<Props[K], Defs, ExtRefs>;
+} & {
+    [K in keyof Props as K extends RequiredKeys<Schema> ? never : K extends NullableKeys<Schema> ? K : never]?: InferLexType<Props[K], Defs, ExtRefs> | null;
+}> : {};
+type RequiredKeys<T> = T extends {
+    required: infer R extends readonly string[];
+} ? R[number] : never;
+type NullableKeys<T> = T extends {
+    nullable: infer N extends readonly string[];
+} ? N[number] : never;
+type InferLexRef<R extends string, Defs, ExtRefs extends ExternalRefsMap = {}> = R extends `#${infer DefName}` ? DefName extends keyof Defs ? InferLexType<Defs[DefName], Defs, ExtRefs> : unknown : R extends keyof ExtRefs ? ExtRefs[R] : `${R}#main` extends keyof ExtRefs ? ExtRefs[`${R}#main`] : unknown;
+type InferLexUnion<Refs extends readonly string[], Defs, ExtRefs extends ExternalRefsMap = {}> = Refs extends readonly [
+    infer First extends string,
+    ...infer Rest extends readonly string[]
+] ? InferLexRef<First, Defs, ExtRefs> | InferLexUnion<Rest, Defs, ExtRefs> : never;
+type InferLexParams<T, Defs, ExtRefs extends ExternalRefsMap = {}> = T extends {
+    type: "params";
+    properties?: infer Props;
+    required?: infer R extends readonly string[];
+} ? Props extends Record<string, unknown> ? Prettify<{
+    [K in keyof Props as K extends R[number] ? K : never]: InferLexType<Props[K], Defs, ExtRefs>;
+} & {
+    [K in keyof Props as K extends R[number] ? never : K]?: InferLexType<Props[K], Defs, ExtRefs>;
+}> : {} : {};
+type InferLexBody<T, Defs, ExtRefs extends ExternalRefsMap = {}> = T extends {
+    schema: infer S;
+} ? InferLexType<S, Defs, ExtRefs> : unknown;
+type InferQueryValidators<T, Defs, ExtRefs extends ExternalRefsMap = {}> = T extends {
+    type: "query";
+} ? {
+    parameters: v.GenericSchema<InferLexParams<T extends {
+        parameters: infer P;
+    } ? P : never, Defs, ExtRefs>>;
+    output: v.GenericSchema<InferLexBody<T extends {
+        output: infer O;
+    } ? O : never, Defs, ExtRefs>>;
+} : never;
+type InferProcedureValidators<T, Defs, ExtRefs extends ExternalRefsMap = {}> = T extends {
+    type: "procedure";
+} ? {
+    parameters: v.GenericSchema<InferLexParams<T extends {
+        parameters: infer P;
+    } ? P : never, Defs, ExtRefs>>;
+    input: v.GenericSchema<InferLexBody<T extends {
+        input: infer I;
+    } ? I : never, Defs, ExtRefs>>;
+    output: v.GenericSchema<InferLexBody<T extends {
+        output: infer O;
+    } ? O : never, Defs, ExtRefs>>;
+} : never;
+type InferSubscriptionValidators<T, Defs, ExtRefs extends ExternalRefsMap = {}> = T extends {
+    type: "subscription";
+} ? {
+    parameters: v.GenericSchema<InferLexParams<T extends {
+        parameters: infer P;
+    } ? P : never, Defs, ExtRefs>>;
+    message: v.GenericSchema<InferLexBody<T extends {
+        message: infer M;
+    } ? M : never, Defs, ExtRefs>>;
+} : never;
+type IsXrpcType<T> = T extends {
+    type: "query" | "procedure" | "subscription";
+} ? true : false;
+type InferSchemaValidator<T, Defs, ExtRefs extends ExternalRefsMap = {}> = v.GenericSchema<InferLexType<T, Defs, ExtRefs>>;
+type InferXrpcValidator<T, Defs, ExtRefs extends ExternalRefsMap = {}> = T extends {
+    type: "query";
+} ? InferQueryValidators<T, Defs, ExtRefs> : T extends {
+    type: "procedure";
+} ? InferProcedureValidators<T, Defs, ExtRefs> : T extends {
+    type: "subscription";
+} ? InferSubscriptionValidators<T, Defs, ExtRefs> : never;
+type InferLexiconValidators<T extends {
+    defs: Record<string, unknown>;
+}, ExtRefs extends ExternalRefsMap = {}> = {
+    [K in keyof T["defs"] as IsXrpcType<T["defs"][K]> extends true ? never : K]: InferSchemaValidator<T["defs"][K], T["defs"], ExtRefs>;
+};
+type InferXrpcValidators<T extends {
+    defs: Record<string, unknown>;
+}, ExtRefs extends ExternalRefsMap = {}> = {
+    [K in keyof T["defs"] as IsXrpcType<T["defs"][K]> extends true ? K : never]: InferXrpcValidator<T["defs"][K], T["defs"], ExtRefs>;
+};
+type InferLexiconOutput<T extends {
+    defs: Record<string, unknown>;
+}, K extends keyof T["defs"], ExtRefs extends ExternalRefsMap = {}> = InferLexType<T["defs"][K], T["defs"], ExtRefs>;
+
+declare const atprotoRefs: {
+    readonly "com.atproto.repo.strongRef": v.ObjectSchema<{
+        readonly uri: v.StringSchema<undefined>;
+        readonly cid: v.StringSchema<undefined>;
+    }, undefined>;
+    readonly "com.atproto.repo.strongRef#main": v.ObjectSchema<{
+        readonly uri: v.StringSchema<undefined>;
+        readonly cid: v.StringSchema<undefined>;
+    }, undefined>;
+    readonly "com.atproto.label.defs#selfLabel": v.ObjectSchema<{
+        readonly val: v.StringSchema<undefined>;
+    }, undefined>;
+    readonly "com.atproto.label.defs#selfLabels": v.ObjectSchema<{
+        readonly values: v.ArraySchema<v.ObjectSchema<{
+            readonly val: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+    }, undefined>;
+};
+type AtprotoRefs = typeof atprotoRefs;
+
+interface LexiconInput {
+    lexicon: 1;
+    id: string;
+    defs: Record<string, unknown>;
+    description?: string;
+    revision?: number;
+}
+interface LexiconToValibotOptions {
+    /** External ref schemas (e.g., com.atproto.repo.strongRef) */
+    externalRefs?: Record<string, v.GenericSchema>;
+}
+
+type InferSchemaOutputs<T extends Record<string, v.GenericSchema>> = {
+    [K in keyof T]: v.InferOutput<T[K]>;
+};
+/**
+ * Convert a lexicon to valibot schemas for records and objects.
+ * Skips XRPC types (query, procedure, subscription) - use xrpcToValibot for those.
+ */
+declare function lexiconToValibot<T extends LexiconInput, ExtRefs extends Record<string, v.GenericSchema> = {}>(lexicon: T, options?: {
+    externalRefs?: ExtRefs;
+}): InferLexiconValidators<T, InferSchemaOutputs<ExtRefs>>;
+/**
+ * Convert a lexicon to valibot validators for XRPC endpoints.
+ * Only handles query, procedure, and subscription types.
+ */
+declare function xrpcToValibot<T extends LexiconInput, ExtRefs extends Record<string, v.GenericSchema> = {}>(lexicon: T, options?: {
+    externalRefs?: ExtRefs;
+}): InferXrpcValidators<T, InferSchemaOutputs<ExtRefs>>;
+
+export { type AtprotoRefs, type InferLexType, type InferLexiconOutput, type InferLexiconValidators, type LexiconInput, type LexiconToValibotOptions, type ProcedureValidators, type QueryValidators, type SubscriptionValidators, atprotoRefs, lexiconToValibot, xrpcToValibot };

package/dist/index.js

@@ -0,0 +1,412 @@
+// src/index.ts
+import * as v6 from "valibot";
+
+// src/converters/atproto.ts
+import * as v from "valibot";
+var typedBlobRef = v.object({
+  $type: v.literal("blob"),
+  ref: v.object({ $link: v.string() }),
+  mimeType: v.string(),
+  size: v.number()
+});
+var untypedBlobRef = v.object({
+  cid: v.string(),
+  mimeType: v.string()
+});
+var blobRefSchema = v.union([typedBlobRef, untypedBlobRef]);
+function convertBlob(schema) {
+  return blobRefSchema;
+}
+var cidLinkSchema = v.object({
+  $link: v.string()
+});
+function convertCidLink(_schema) {
+  return cidLinkSchema;
+}
+function convertToken(schema) {
+  return v.string();
+}
+
+// src/converters/complex.ts
+import * as v2 from "valibot";
+function convertArray(schema, ctx, convertType2) {
+  const itemsSchema = convertType2(schema.items, ctx);
+  const checks = [];
+  if (schema.minLength !== void 0) {
+    checks.push(v2.minLength(schema.minLength));
+  }
+  if (schema.maxLength !== void 0) {
+    checks.push(v2.maxLength(schema.maxLength));
+  }
+  if (checks.length === 0) {
+    return v2.array(itemsSchema);
+  }
+  return v2.pipe(v2.array(itemsSchema), ...checks);
+}
+function convertObject(schema, ctx, convertType2) {
+  const properties = {};
+  const requiredSet = new Set(schema.required ?? []);
+  const nullableSet = new Set(schema.nullable ?? []);
+  if (schema.properties) {
+    for (const [key, prop] of Object.entries(schema.properties)) {
+      let propSchema = convertType2(prop, ctx);
+      if (nullableSet.has(key)) {
+        propSchema = v2.nullable(propSchema);
+      }
+      if (!requiredSet.has(key)) {
+        propSchema = v2.optional(propSchema);
+      }
+      properties[key] = propSchema;
+    }
+  }
+  return v2.object(properties);
+}
+function convertRef(schema, ctx) {
+  return v2.lazy(() => ctx.resolveRef(schema.ref));
+}
+function convertUnion(schema, ctx) {
+  if (schema.refs.length === 0) {
+    return v2.never();
+  }
+  if (schema.refs.length === 1) {
+    return v2.lazy(() => ctx.resolveRef(schema.refs[0]));
+  }
+  const [first, second, ...rest] = schema.refs.map(
+    (ref) => v2.lazy(() => ctx.resolveRef(ref))
+  );
+  return v2.union([first, second, ...rest]);
+}
+
+// src/converters/primitives.ts
+import * as v3 from "valibot";
+function convertBoolean(schema) {
+  if (schema.const !== void 0) {
+    return v3.literal(schema.const);
+  }
+  return v3.boolean();
+}
+function convertInteger(schema) {
+  const checks = [v3.integer()];
+  if (schema.minimum !== void 0) {
+    checks.push(v3.minValue(schema.minimum));
+  }
+  if (schema.maximum !== void 0) {
+    checks.push(v3.maxValue(schema.maximum));
+  }
+  if (schema.enum !== void 0 && schema.enum.length > 0) {
+    return v3.picklist(schema.enum);
+  }
+  if (schema.const !== void 0) {
+    return v3.literal(schema.const);
+  }
+  return v3.pipe(v3.number(), ...checks);
+}
+var graphemeSegmenter = new Intl.Segmenter("en", { granularity: "grapheme" });
+function countGraphemes(str) {
+  return [...graphemeSegmenter.segment(str)].length;
+}
+function convertString(schema) {
+  const checks = [];
+  if (schema.minLength !== void 0) {
+    checks.push(v3.minLength(schema.minLength));
+  }
+  if (schema.maxLength !== void 0) {
+    checks.push(v3.maxLength(schema.maxLength));
+  }
+  if (schema.minGraphemes !== void 0) {
+    const min = schema.minGraphemes;
+    checks.push(
+      v3.check(
+        (value) => countGraphemes(value) >= min,
+        `String must have at least ${min} grapheme(s)`
+      )
+    );
+  }
+  if (schema.maxGraphemes !== void 0) {
+    const max = schema.maxGraphemes;
+    checks.push(
+      v3.check(
+        (value) => countGraphemes(value) <= max,
+        `String must have at most ${max} grapheme(s)`
+      )
+    );
+  }
+  if (schema.enum !== void 0 && schema.enum.length > 0) {
+    return v3.picklist(schema.enum);
+  }
+  if (schema.const !== void 0) {
+    return v3.literal(schema.const);
+  }
+  if (schema.format !== void 0) {
+    switch (schema.format) {
+      case "datetime":
+        checks.push(v3.isoTimestamp());
+        break;
+      case "uri":
+        checks.push(v3.url());
+        break;
+      case "at-uri":
+        checks.push(v3.regex(/^at:\/\/[a-zA-Z0-9._:%-]+\/[a-zA-Z0-9.]+\/[a-zA-Z0-9._~:@!$&')(*+,;=-]+$/));
+        break;
+      case "did":
+        checks.push(v3.regex(/^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$/));
+        break;
+      case "handle":
+        checks.push(v3.regex(/^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/));
+        break;
+      case "nsid":
+        checks.push(v3.regex(/^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\.[a-zA-Z]([a-zA-Z]{0,61}[a-zA-Z])?)$/));
+        break;
+      case "cid":
+        checks.push(v3.regex(/^[a-zA-Z0-9+/=]+$/));
+        break;
+      case "tid":
+        checks.push(v3.regex(/^[234567abcdefghijklmnopqrstuvwxyz]{13}$/));
+        break;
+      case "record-key":
+        checks.push(v3.regex(/^[a-zA-Z0-9._:~-]+$/));
+        break;
+      case "language":
+        checks.push(v3.regex(/^[a-zA-Z]{2,3}(-[a-zA-Z0-9]+)*$/));
+        break;
+      case "at-identifier":
+        checks.push(v3.regex(/^(did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]|([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)$/));
+        break;
+    }
+  }
+  if (checks.length === 0) {
+    return v3.string();
+  }
+  return v3.pipe(v3.string(), ...checks);
+}
+function convertUnknown(_schema) {
+  return v3.unknown();
+}
+function convertBytes(schema) {
+  const baseSchema = v3.instance(Uint8Array);
+  if (schema.minLength === void 0 && schema.maxLength === void 0) {
+    return baseSchema;
+  }
+  return v3.pipe(
+    baseSchema,
+    v3.check((value) => {
+      if (schema.minLength !== void 0 && value.length < schema.minLength) {
+        return false;
+      }
+      if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
+        return false;
+      }
+      return true;
+    }, `Bytes length must be between ${schema.minLength ?? 0} and ${schema.maxLength ?? "\u221E"}`)
+  );
+}
+
+// src/converters/xrpc.ts
+import * as v4 from "valibot";
+function convertParams(params, ctx, convertType2) {
+  if (!params?.properties) {
+    return v4.object({});
+  }
+  const properties = {};
+  const requiredSet = new Set(params.required ?? []);
+  for (const [key, prop] of Object.entries(params.properties)) {
+    let propSchema = convertType2(prop, ctx);
+    if (!requiredSet.has(key)) {
+      propSchema = v4.optional(propSchema);
+    }
+    properties[key] = propSchema;
+  }
+  return v4.object(properties);
+}
+function convertBody(body, ctx, convertType2) {
+  if (!body?.schema) {
+    return v4.unknown();
+  }
+  return convertType2(body.schema, ctx);
+}
+function convertQuery(schema, ctx, convertType2) {
+  return {
+    parameters: convertParams(schema.parameters, ctx, convertType2),
+    output: convertBody(schema.output, ctx, convertType2)
+  };
+}
+function convertProcedure(schema, ctx, convertType2) {
+  return {
+    parameters: convertParams(schema.parameters, ctx, convertType2),
+    input: convertBody(schema.input, ctx, convertType2),
+    output: convertBody(schema.output, ctx, convertType2)
+  };
+}
+function convertSubscription(schema, ctx, convertType2) {
+  return {
+    parameters: convertParams(schema.parameters, ctx, convertType2),
+    message: convertBody(schema.message, ctx, convertType2)
+  };
+}
+
+// src/atproto-refs.ts
+import * as v5 from "valibot";
+var strongRef = v5.object({
+  uri: v5.string(),
+  cid: v5.string()
+});
+var selfLabel = v5.object({
+  val: v5.string()
+});
+var selfLabels = v5.object({
+  values: v5.array(selfLabel)
+});
+var atprotoRefs = {
+  "com.atproto.repo.strongRef": strongRef,
+  "com.atproto.repo.strongRef#main": strongRef,
+  "com.atproto.label.defs#selfLabel": selfLabel,
+  "com.atproto.label.defs#selfLabels": selfLabels
+};
+
+// src/index.ts
+function convertType(schema, ctx) {
+  if (typeof schema !== "object" || schema === null) {
+    throw new Error(`Invalid schema: expected object, got ${typeof schema}`);
+  }
+  const schemaObj = schema;
+  switch (schemaObj.type) {
+    // Primitives
+    case "boolean":
+      return convertBoolean(schema);
+    case "integer":
+      return convertInteger(schema);
+    case "string":
+      return convertString(schema);
+    case "unknown":
+      return convertUnknown(schema);
+    // IPLD types
+    case "bytes":
+      return convertBytes(schema);
+    case "cid-link":
+      return convertCidLink(schema);
+    // AT Protocol types
+    case "blob":
+      return convertBlob(schema);
+    case "token":
+      return convertToken(schema);
+    // Complex types
+    case "array":
+      return convertArray(schema, ctx, convertType);
+    case "object":
+      return convertObject(schema, ctx, convertType);
+    case "ref":
+      return convertRef(schema, ctx);
+    case "union":
+      return convertUnion(schema, ctx);
+    // Record type
+    case "record":
+      return convertObject(schema.record, ctx, convertType);
+    default:
+      throw new Error(`Unknown schema type: ${schemaObj.type}`);
+  }
+}
+function convertXrpcDef(schema, ctx) {
+  if (typeof schema !== "object" || schema === null) {
+    throw new Error(`Invalid schema: expected object, got ${typeof schema}`);
+  }
+  const schemaObj = schema;
+  switch (schemaObj.type) {
+    case "query":
+      return convertQuery(schema, ctx, convertType);
+    case "procedure":
+      return convertProcedure(schema, ctx, convertType);
+    case "subscription":
+      return convertSubscription(schema, ctx, convertType);
+    default:
+      throw new Error(`Not an XRPC type: ${schemaObj.type}`);
+  }
+}
+function isXrpcDef(schema) {
+  if (typeof schema !== "object" || schema === null) return false;
+  const type = schema.type;
+  return type === "query" || type === "procedure" || type === "subscription";
+}
+function createRefResolver(lexiconId, defs, cache, externalRefs = {}) {
+  return (ref) => {
+    let resolvedRef = ref;
+    if (ref.startsWith("#")) {
+      resolvedRef = `${lexiconId}${ref}`;
+    } else if (!ref.includes("#")) {
+      resolvedRef = `${ref}#main`;
+    }
+    if (cache.has(resolvedRef)) {
+      return cache.get(resolvedRef);
+    }
+    if (externalRefs[ref]) {
+      cache.set(resolvedRef, externalRefs[ref]);
+      return externalRefs[ref];
+    }
+    if (externalRefs[resolvedRef]) {
+      cache.set(resolvedRef, externalRefs[resolvedRef]);
+      return externalRefs[resolvedRef];
+    }
+    const [nsid, defName] = resolvedRef.includes("#") ? resolvedRef.split("#") : [resolvedRef, "main"];
+    if (nsid !== lexiconId) {
+      console.warn(`External ref not resolved: ${ref} - provide it in externalRefs option`);
+      return v6.unknown();
+    }
+    const def = defs[defName];
+    if (!def) {
+      throw new Error(`Ref not found: ${ref} (resolved to ${resolvedRef})`);
+    }
+    const ctx = {
+      lexiconId,
+      defs,
+      resolveRef: createRefResolver(lexiconId, defs, cache, externalRefs)
+    };
+    const schema = convertType(def, ctx);
+    cache.set(resolvedRef, schema);
+    return schema;
+  };
+}
+function lexiconToValibot(lexicon, options = {}) {
+  const cache = /* @__PURE__ */ new Map();
+  const resolveRef = createRefResolver(
+    lexicon.id,
+    lexicon.defs,
+    cache,
+    options.externalRefs ?? {}
+  );
+  const ctx = {
+    lexiconId: lexicon.id,
+    defs: lexicon.defs,
+    resolveRef
+  };
+  const result = {};
+  for (const [defName, def] of Object.entries(lexicon.defs)) {
+    if (isXrpcDef(def)) continue;
+    result[defName] = convertType(def, ctx);
+  }
+  return result;
+}
+function xrpcToValibot(lexicon, options = {}) {
+  const cache = /* @__PURE__ */ new Map();
+  const resolveRef = createRefResolver(
+    lexicon.id,
+    lexicon.defs,
+    cache,
+    options.externalRefs ?? {}
+  );
+  const ctx = {
+    lexiconId: lexicon.id,
+    defs: lexicon.defs,
+    resolveRef
+  };
+  const result = {};
+  for (const [defName, def] of Object.entries(lexicon.defs)) {
+    if (!isXrpcDef(def)) continue;
+    result[defName] = convertXrpcDef(def, ctx);
+  }
+  return result;
+}
+export {
+  atprotoRefs,
+  lexiconToValibot,
+  xrpcToValibot
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/converters/atproto.ts","../src/converters/complex.ts","../src/converters/primitives.ts","../src/converters/xrpc.ts","../src/atproto-refs.ts"],"sourcesContent":["import * as v from \"valibot\";\nimport { convertBlob, convertCidLink, convertToken } from \"./converters/atproto.js\";\nimport { convertArray, convertObject, convertRef, convertUnion } from \"./converters/complex.js\";\nimport {\n  convertBoolean,\n  convertBytes,\n  convertInteger,\n  convertString,\n  convertUnknown,\n} from \"./converters/primitives.js\";\nimport {\n  convertProcedure,\n  convertQuery,\n  convertSubscription,\n  type ProcedureValidators,\n  type QueryValidators,\n  type SubscriptionValidators,\n} from \"./converters/xrpc.js\";\nimport type {\n  ConverterContext,\n  LexArray,\n  LexBlob,\n  LexBoolean,\n  LexBytes,\n  LexCidLink,\n  LexInteger,\n  LexObject,\n  LexRecord,\n  LexRef,\n  LexRefUnion,\n  LexString,\n  LexToken,\n  LexUnknown,\n  LexUserType,\n  LexXrpcProcedure,\n  LexXrpcQuery,\n  LexXrpcSubscription\n} from \"./types.js\";\n\n// Flexible input type that accepts both LexiconDoc and const objects\nexport interface LexiconInput {\n  lexicon: 1;\n  id: string;\n  defs: Record<string, unknown>;\n  description?: string;\n  revision?: number;\n}\n\n// Options for lexiconToValibot\nexport interface LexiconToValibotOptions {\n  /** External ref schemas (e.g., com.atproto.repo.strongRef) */\n  externalRefs?: Record<string, v.GenericSchema>;\n}\n\nexport type { ProcedureValidators, QueryValidators, SubscriptionValidators };\n\ntype XrpcResult = QueryValidators | ProcedureValidators | SubscriptionValidators;\n\nfunction convertType(schema: unknown, ctx: ConverterContext): v.GenericSchema {\n  if (typeof schema !== \"object\" || schema === null) {\n    throw new Error(`Invalid schema: expected object, got ${typeof schema}`);\n  }\n\n  const schemaObj = schema as { type?: string };\n\n  switch (schemaObj.type) {\n    // Primitives\n    case \"boolean\":\n      return convertBoolean(schema as LexBoolean);\n    case \"integer\":\n      return convertInteger(schema as LexInteger);\n    case \"string\":\n      return convertString(schema as LexString);\n    case \"unknown\":\n      return convertUnknown(schema as LexUnknown);\n\n    // IPLD types\n    case \"bytes\":\n      return convertBytes(schema as LexBytes);\n    case \"cid-link\":\n      return convertCidLink(schema as LexCidLink);\n\n    // AT Protocol types\n    case \"blob\":\n      return convertBlob(schema as LexBlob);\n    case \"token\":\n      return convertToken(schema as LexToken);\n\n    // Complex types\n    case \"array\":\n      return convertArray(schema as LexArray, ctx, convertType);\n    case \"object\":\n      return convertObject(schema as LexObject, ctx, convertType);\n    case \"ref\":\n      return convertRef(schema as LexRef, ctx);\n    case \"union\":\n      return convertUnion(schema as LexRefUnion, ctx);\n\n    // Record type\n    case \"record\":\n      return convertObject((schema as LexRecord).record, ctx, convertType);\n\n    default:\n      throw new Error(`Unknown schema type: ${schemaObj.type}`);\n  }\n}\n\n// Convert XRPC def - returns validators object\nfunction convertXrpcDef(schema: unknown, ctx: ConverterContext): XrpcResult {\n  if (typeof schema !== \"object\" || schema === null) {\n    throw new Error(`Invalid schema: expected object, got ${typeof schema}`);\n  }\n\n  const schemaObj = schema as { type?: string };\n\n  switch (schemaObj.type) {\n    case \"query\":\n      return convertQuery(schema as LexXrpcQuery, ctx, convertType);\n    case \"procedure\":\n      return convertProcedure(schema as LexXrpcProcedure, ctx, convertType);\n    case \"subscription\":\n      return convertSubscription(schema as LexXrpcSubscription, ctx, convertType);\n    default:\n      throw new Error(`Not an XRPC type: ${schemaObj.type}`);\n  }\n}\n\n// Check if a def is an XRPC type\nfunction isXrpcDef(schema: unknown): boolean {\n  if (typeof schema !== \"object\" || schema === null) return false;\n  const type = (schema as { type?: string }).type;\n  return type === \"query\" || type === \"procedure\" || type === \"subscription\";\n}\n\nfunction createRefResolver(\n  lexiconId: string,\n  defs: Record<string, LexUserType>,\n  cache: Map<string, v.GenericSchema>,\n  externalRefs: Record<string, v.GenericSchema> = {}\n): (ref: string) => v.GenericSchema {\n  return (ref: string) => {\n    // Parse the ref - could be:\n    // - \"#defName\" (local ref)\n    // - \"com.example.lexicon#defName\" (external ref)\n    // - \"com.example.lexicon\" (main def of external lexicon)\n\n    let resolvedRef = ref;\n\n    if (ref.startsWith(\"#\")) {\n      // Local ref\n      resolvedRef = `${lexiconId}${ref}`;\n    } else if (!ref.includes(\"#\")) {\n      // External ref to main def\n      resolvedRef = `${ref}#main`;\n    }\n\n    // Check cache first\n    if (cache.has(resolvedRef)) {\n      return cache.get(resolvedRef)!;\n    }\n\n    // Check external refs (try both original and resolved)\n    if (externalRefs[ref]) {\n      cache.set(resolvedRef, externalRefs[ref]);\n      return externalRefs[ref];\n    }\n    if (externalRefs[resolvedRef]) {\n      cache.set(resolvedRef, externalRefs[resolvedRef]);\n      return externalRefs[resolvedRef];\n    }\n\n    // Parse the full ref\n    const [nsid, defName] = resolvedRef.includes(\"#\")\n      ? resolvedRef.split(\"#\")\n      : [resolvedRef, \"main\"];\n\n    // Only handle local refs\n    if (nsid !== lexiconId) {\n      // External ref not found in externalRefs\n      console.warn(`External ref not resolved: ${ref} - provide it in externalRefs option`);\n      return v.unknown();\n    }\n\n    const def = defs[defName];\n    if (!def) {\n      throw new Error(`Ref not found: ${ref} (resolved to ${resolvedRef})`);\n    }\n\n    // Create context for conversion\n    const ctx: ConverterContext = {\n      lexiconId,\n      defs,\n      resolveRef: createRefResolver(lexiconId, defs, cache, externalRefs),\n    };\n\n    // Convert and cache\n    const schema = convertType(def, ctx);\n    cache.set(resolvedRef, schema);\n    return schema;\n  };\n}\n\nimport type { InferLexiconValidators, InferXrpcValidators } from \"./infer.js\";\n\n// Helper type to convert schema map to output type map\ntype InferSchemaOutputs<T extends Record<string, v.GenericSchema>> = {\n  [K in keyof T]: v.InferOutput<T[K]>;\n};\n\n/**\n * Convert a lexicon to valibot schemas for records and objects.\n * Skips XRPC types (query, procedure, subscription) - use xrpcToValibot for those.\n */\nexport function lexiconToValibot<\n  T extends LexiconInput,\n  ExtRefs extends Record<string, v.GenericSchema> = {}\n>(\n  lexicon: T,\n  options: { externalRefs?: ExtRefs } = {}\n): InferLexiconValidators<T, InferSchemaOutputs<ExtRefs>> {\n  const cache = new Map<string, v.GenericSchema>();\n  const resolveRef = createRefResolver(\n    lexicon.id,\n    lexicon.defs as Record<string, LexUserType>,\n    cache,\n    options.externalRefs ?? {}\n  );\n\n  const ctx: ConverterContext = {\n    lexiconId: lexicon.id,\n    defs: lexicon.defs,\n    resolveRef,\n  };\n\n  const result: Record<string, v.GenericSchema> = {};\n\n  for (const [defName, def] of Object.entries(lexicon.defs)) {\n    // Skip XRPC types\n    if (isXrpcDef(def)) continue;\n    result[defName] = convertType(def, ctx);\n  }\n\n  return result as InferLexiconValidators<T, InferSchemaOutputs<ExtRefs>>;\n}\n\n/**\n * Convert a lexicon to valibot validators for XRPC endpoints.\n * Only handles query, procedure, and subscription types.\n */\nexport function xrpcToValibot<\n  T extends LexiconInput,\n  ExtRefs extends Record<string, v.GenericSchema> = {}\n>(\n  lexicon: T,\n  options: { externalRefs?: ExtRefs } = {}\n): InferXrpcValidators<T, InferSchemaOutputs<ExtRefs>> {\n  const cache = new Map<string, v.GenericSchema>();\n  const resolveRef = createRefResolver(\n    lexicon.id,\n    lexicon.defs as Record<string, LexUserType>,\n    cache,\n    options.externalRefs ?? {}\n  );\n\n  const ctx: ConverterContext = {\n    lexiconId: lexicon.id,\n    defs: lexicon.defs,\n    resolveRef,\n  };\n\n  const result: Record<string, XrpcResult> = {};\n\n  for (const [defName, def] of Object.entries(lexicon.defs)) {\n    // Only handle XRPC types\n    if (!isXrpcDef(def)) continue;\n    result[defName] = convertXrpcDef(def, ctx);\n  }\n\n  return result as InferXrpcValidators<T, InferSchemaOutputs<ExtRefs>>;\n}\n\n// Re-export valibot's InferOutput for convenience\nexport type { InferOutput } from \"valibot\";\n// Re-export built-in AT Protocol refs\nexport { atprotoRefs, type AtprotoRefs } from \"./atproto-refs.js\";\n\n// Re-export inference types\nexport type { InferLexiconOutput, InferLexiconValidators, InferLexType } from \"./infer.js\";\n// Re-export types\nexport type { LexiconDoc, LexUserType } from \"./types.js\";\n","import * as v from \"valibot\";\nimport type { LexBlob, LexCidLink, LexToken } from \"../types.js\";\n\n// Blob reference structure used by AT Protocol\n// Can be either typed (with $type: \"blob\") or untyped (legacy format)\nconst typedBlobRef = v.object({\n  $type: v.literal(\"blob\"),\n  ref: v.object({ $link: v.string() }),\n  mimeType: v.string(),\n  size: v.number(),\n});\n\nconst untypedBlobRef = v.object({\n  cid: v.string(),\n  mimeType: v.string(),\n});\n\nconst blobRefSchema = v.union([typedBlobRef, untypedBlobRef]);\n\nexport function convertBlob(schema: LexBlob): v.GenericSchema {\n  // For now, we validate the structure but don't enforce accept/maxSize at runtime\n  // Those would require access to the actual blob data\n  return blobRefSchema;\n}\n\n// CID link is represented as an object with $link property containing the CID string\nconst cidLinkSchema = v.object({\n  $link: v.string(),\n});\n\nexport function convertCidLink(_schema: LexCidLink): v.GenericSchema {\n  return cidLinkSchema;\n}\n\nexport function convertToken(schema: LexToken): v.GenericSchema {\n  // Token is essentially a string literal representing a constant identifier\n  // The value should be the full NSID#name reference\n  return v.string();\n}\n","import * as v from \"valibot\";\nimport type { LexArray, LexObject, LexRef, LexRefUnion, ConverterContext } from \"../types.js\";\n\nexport function convertArray(\n  schema: LexArray,\n  ctx: ConverterContext,\n  convertType: (type: unknown, ctx: ConverterContext) => v.GenericSchema\n): v.GenericSchema {\n  const itemsSchema = convertType(schema.items, ctx);\n\n  const checks: v.PipeItem<unknown[], unknown[], v.BaseIssue<unknown>>[] = [];\n\n  if (schema.minLength !== undefined) {\n    checks.push(v.minLength(schema.minLength));\n  }\n  if (schema.maxLength !== undefined) {\n    checks.push(v.maxLength(schema.maxLength));\n  }\n\n  if (checks.length === 0) {\n    return v.array(itemsSchema);\n  }\n\n  return v.pipe(v.array(itemsSchema), ...checks);\n}\n\nexport function convertObject(\n  schema: LexObject,\n  ctx: ConverterContext,\n  convertType: (type: unknown, ctx: ConverterContext) => v.GenericSchema\n): v.GenericSchema {\n  const properties: Record<string, v.GenericSchema> = {};\n  const requiredSet = new Set(schema.required ?? []);\n  const nullableSet = new Set(schema.nullable ?? []);\n\n  if (schema.properties) {\n    for (const [key, prop] of Object.entries(schema.properties)) {\n      let propSchema = convertType(prop, ctx);\n\n      // Handle nullable\n      if (nullableSet.has(key)) {\n        propSchema = v.nullable(propSchema);\n      }\n\n      // Handle optional (not in required list)\n      if (!requiredSet.has(key)) {\n        propSchema = v.optional(propSchema);\n      }\n\n      properties[key] = propSchema;\n    }\n  }\n\n  return v.object(properties);\n}\n\nexport function convertRef(schema: LexRef, ctx: ConverterContext): v.GenericSchema {\n  return v.lazy(() => ctx.resolveRef(schema.ref));\n}\n\nexport function convertUnion(\n  schema: LexRefUnion,\n  ctx: ConverterContext\n): v.GenericSchema {\n  if (schema.refs.length === 0) {\n    return v.never();\n  }\n\n  if (schema.refs.length === 1) {\n    return v.lazy(() => ctx.resolveRef(schema.refs[0]));\n  }\n\n  // Create a union of lazy refs - we know there are at least 2 refs from the check above\n  const [first, second, ...rest] = schema.refs.map((ref) =>\n    v.lazy(() => ctx.resolveRef(ref))\n  );\n\n  return v.union([first, second, ...rest]);\n}\n","import * as v from \"valibot\";\nimport type { LexBoolean, LexInteger, LexString, LexUnknown, LexBytes } from \"../types.js\";\n\nexport function convertBoolean(schema: LexBoolean): v.GenericSchema {\n  if (schema.const !== undefined) {\n    return v.literal(schema.const);\n  }\n  return v.boolean();\n}\n\nexport function convertInteger(schema: LexInteger): v.GenericSchema {\n  const checks: v.PipeItem<number, number, v.BaseIssue<unknown>>[] = [v.integer()];\n\n  if (schema.minimum !== undefined) {\n    checks.push(v.minValue(schema.minimum));\n  }\n  if (schema.maximum !== undefined) {\n    checks.push(v.maxValue(schema.maximum));\n  }\n\n  if (schema.enum !== undefined && schema.enum.length > 0) {\n    return v.picklist(schema.enum);\n  }\n\n  if (schema.const !== undefined) {\n    return v.literal(schema.const);\n  }\n\n  return v.pipe(v.number(), ...checks);\n}\n\nconst graphemeSegmenter = new Intl.Segmenter(\"en\", { granularity: \"grapheme\" });\n\nfunction countGraphemes(str: string): number {\n  return [...graphemeSegmenter.segment(str)].length;\n}\n\nexport function convertString(schema: LexString): v.GenericSchema {\n  const checks: v.PipeItem<string, string, v.BaseIssue<unknown>>[] = [];\n\n  if (schema.minLength !== undefined) {\n    checks.push(v.minLength(schema.minLength));\n  }\n  if (schema.maxLength !== undefined) {\n    checks.push(v.maxLength(schema.maxLength));\n  }\n\n  if (schema.minGraphemes !== undefined) {\n    const min = schema.minGraphemes;\n    checks.push(\n      v.check(\n        (value) => countGraphemes(value) >= min,\n        `String must have at least ${min} grapheme(s)`\n      )\n    );\n  }\n  if (schema.maxGraphemes !== undefined) {\n    const max = schema.maxGraphemes;\n    checks.push(\n      v.check(\n        (value) => countGraphemes(value) <= max,\n        `String must have at most ${max} grapheme(s)`\n      )\n    );\n  }\n\n  if (schema.enum !== undefined && schema.enum.length > 0) {\n    return v.picklist(schema.enum);\n  }\n\n  if (schema.const !== undefined) {\n    return v.literal(schema.const);\n  }\n\n  if (schema.format !== undefined) {\n    switch (schema.format) {\n      case \"datetime\":\n        checks.push(v.isoTimestamp());\n        break;\n      case \"uri\":\n        checks.push(v.url());\n        break;\n      case \"at-uri\":\n        checks.push(v.regex(/^at:\\/\\/[a-zA-Z0-9._:%-]+\\/[a-zA-Z0-9.]+\\/[a-zA-Z0-9._~:@!$&')(*+,;=-]+$/));\n        break;\n      case \"did\":\n        checks.push(v.regex(/^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$/));\n        break;\n      case \"handle\":\n        checks.push(v.regex(/^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/));\n        break;\n      case \"nsid\":\n        checks.push(v.regex(/^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\\.[a-zA-Z]([a-zA-Z]{0,61}[a-zA-Z])?)$/));\n        break;\n      case \"cid\":\n        checks.push(v.regex(/^[a-zA-Z0-9+/=]+$/));\n        break;\n      case \"tid\":\n        checks.push(v.regex(/^[234567abcdefghijklmnopqrstuvwxyz]{13}$/));\n        break;\n      case \"record-key\":\n        checks.push(v.regex(/^[a-zA-Z0-9._:~-]+$/));\n        break;\n      case \"language\":\n        checks.push(v.regex(/^[a-zA-Z]{2,3}(-[a-zA-Z0-9]+)*$/));\n        break;\n      case \"at-identifier\":\n        // at-identifier can be a handle or a DID\n        checks.push(v.regex(/^(did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]|([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)$/));\n        break;\n    }\n  }\n\n  if (checks.length === 0) {\n    return v.string();\n  }\n\n  return v.pipe(v.string(), ...checks);\n}\n\nexport function convertUnknown(_schema: LexUnknown): v.GenericSchema {\n  return v.unknown();\n}\n\nexport function convertBytes(schema: LexBytes): v.GenericSchema {\n  const baseSchema = v.instance(Uint8Array);\n\n  if (schema.minLength === undefined && schema.maxLength === undefined) {\n    return baseSchema;\n  }\n\n  return v.pipe(\n    baseSchema,\n    v.check((value) => {\n      if (schema.minLength !== undefined && value.length < schema.minLength) {\n        return false;\n      }\n      if (schema.maxLength !== undefined && value.length > schema.maxLength) {\n        return false;\n      }\n      return true;\n    }, `Bytes length must be between ${schema.minLength ?? 0} and ${schema.maxLength ?? \"∞\"}`)\n  );\n}\n","import * as v from \"valibot\";\nimport type { LexXrpcQuery, LexXrpcProcedure, LexXrpcSubscription, ConverterContext } from \"../types.js\";\n\nexport interface QueryValidators {\n  parameters: v.GenericSchema;\n  output: v.GenericSchema;\n}\n\nexport interface ProcedureValidators {\n  parameters: v.GenericSchema;\n  input: v.GenericSchema;\n  output: v.GenericSchema;\n}\n\nexport interface SubscriptionValidators {\n  parameters: v.GenericSchema;\n  message: v.GenericSchema;\n}\n\n// Convert params object to valibot schema\nfunction convertParams(\n  params: { type: \"params\"; required?: string[]; properties?: Record<string, unknown> } | undefined,\n  ctx: ConverterContext,\n  convertType: (type: unknown, ctx: ConverterContext) => v.GenericSchema\n): v.GenericSchema {\n  if (!params?.properties) {\n    return v.object({});\n  }\n\n  const properties: Record<string, v.GenericSchema> = {};\n  const requiredSet = new Set(params.required ?? []);\n\n  for (const [key, prop] of Object.entries(params.properties)) {\n    let propSchema = convertType(prop, ctx);\n\n    if (!requiredSet.has(key)) {\n      propSchema = v.optional(propSchema);\n    }\n\n    properties[key] = propSchema;\n  }\n\n  return v.object(properties);\n}\n\n// Convert body (input/output/message) to valibot schema\nfunction convertBody(\n  body: { schema?: unknown } | undefined,\n  ctx: ConverterContext,\n  convertType: (type: unknown, ctx: ConverterContext) => v.GenericSchema\n): v.GenericSchema {\n  if (!body?.schema) {\n    return v.unknown();\n  }\n  return convertType(body.schema, ctx);\n}\n\nexport function convertQuery(\n  schema: LexXrpcQuery,\n  ctx: ConverterContext,\n  convertType: (type: unknown, ctx: ConverterContext) => v.GenericSchema\n): QueryValidators {\n  return {\n    parameters: convertParams(schema.parameters, ctx, convertType),\n    output: convertBody(schema.output, ctx, convertType),\n  };\n}\n\nexport function convertProcedure(\n  schema: LexXrpcProcedure,\n  ctx: ConverterContext,\n  convertType: (type: unknown, ctx: ConverterContext) => v.GenericSchema\n): ProcedureValidators {\n  return {\n    parameters: convertParams(schema.parameters, ctx, convertType),\n    input: convertBody(schema.input, ctx, convertType),\n    output: convertBody(schema.output, ctx, convertType),\n  };\n}\n\nexport function convertSubscription(\n  schema: LexXrpcSubscription,\n  ctx: ConverterContext,\n  convertType: (type: unknown, ctx: ConverterContext) => v.GenericSchema\n): SubscriptionValidators {\n  return {\n    parameters: convertParams(schema.parameters, ctx, convertType),\n    message: convertBody(schema.message, ctx, convertType),\n  };\n}\n","// Built-in AT Protocol type validators\n// Users can spread these into externalRefs option\n\nimport * as v from \"valibot\";\n\n// com.atproto.repo.strongRef - reference to another record\nconst strongRef = v.object({\n  uri: v.string(),\n  cid: v.string(),\n});\n\n// com.atproto.label.selfLabel\nconst selfLabel = v.object({\n  val: v.string(),\n});\n\n// com.atproto.label.selfLabels\nconst selfLabels = v.object({\n  values: v.array(selfLabel),\n});\n\nexport const atprotoRefs = {\n  \"com.atproto.repo.strongRef\": strongRef,\n  \"com.atproto.repo.strongRef#main\": strongRef,\n  \"com.atproto.label.defs#selfLabel\": selfLabel,\n  \"com.atproto.label.defs#selfLabels\": selfLabels,\n} as const;\n\nexport type AtprotoRefs = typeof atprotoRefs;"],"mappings":"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","names":["v","v","convertType","v","v","convertType","v"]}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@bigmistqke/lexicon-to-valibot",
+  "version": "0.1.0",
+  "description": "Convert AT Protocol Lexicon schemas to Valibot validators",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "lexicon",
+    "valibot",
+    "atproto",
+    "bluesky",
+    "validation"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "valibot": ">=1.0.0"
+  },
+  "devDependencies": {
+    "@atproto/lexicon": "^0.4.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "valibot": "^1.0.0",
+    "vitest": "^2.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}