@zod-to-form/vite 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present Pradeep Mouli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,40 @@
+# @zod-to-form/vite
+
+Vite plugin for [zod-to-form](https://github.com/pradeepmouli/zod-to-form). Transforms `?z2f` imports into generated form components and (opt-in) rewrites `<ZodForm>` JSX call sites into generated components at build time — all with no separate codegen CLI step.
+
+> **Status**: In active development. See [`specs/007-vite-codegen-plugin/`](../../specs/007-vite-codegen-plugin/) for the full specification, plan, and implementation tasks.
+
+## Quickstart
+
+See the full walkthrough in [quickstart.md](../../specs/007-vite-codegen-plugin/quickstart.md).
+
+Minimal usage:
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import z2fVite from '@zod-to-form/vite';
+
+export default defineConfig({
+  plugins: [z2fVite(), react()]
+});
+```
+
+```tsx
+// src/App.tsx
+import SignupForm from './schemas/signup.ts?z2f';
+
+export default function App() {
+  return <SignupForm onSubmit={(data) => console.log(data)} />;
+}
+```
+
+## Modes
+
+- **Query-string mode** (default): imports carrying `?z2f` become generated form components.
+- **Generate mode** (opt-in via `generate: {}`): scans source for `<ZodForm schema={X}>` usages and replaces statically resolvable ones with generated components at build time. Unresolvable sites are left alone and fall through to the runtime path. Presence of the `generate` object — even empty — enables the mode; pass `generate: { include: [...], exclude: [...] }` to constrain which files are scanned. The name mirrors the CLI's `zod-to-form generate` command: same codegen, driven by static analysis instead of an explicit CLI step.
+
+## License
+
+MIT

package/dist/cache.d.ts

@@ -0,0 +1,39 @@
+/**
+ * CompilationCache — entity #3 from `data-model.md`.
+ *
+ * Stores the result of compiling each (schemaFile, variant, configHash)
+ * triple to a generated form module. Maintains a reverse index so HMR can
+ * invalidate every entry that depends on a given schema file in O(1).
+ *
+ * The cache is single-threaded: Vite runs plugin hooks sequentially on the
+ * main event loop, so no locking is needed.
+ */
+import type { CompilationEntry, GenerationTarget } from './types.js';
+export interface CacheStats {
+    /** Number of entries currently in the cache. */
+    size: number;
+    /** Number of cache hits since the cache was created. */
+    hits: number;
+    /** Number of cache misses since the cache was created. */
+    misses: number;
+}
+export interface CompilationCache {
+    /** Look up a cached compilation by target. Returns undefined on miss. */
+    get(target: GenerationTarget): CompilationEntry | undefined;
+    /** Store a compilation result. Updates the reverse index. */
+    set(target: GenerationTarget, entry: CompilationEntry): void;
+    /**
+     * Evict every entry whose `schemaFile` equals the given path.
+     * Returns the list of evicted cache keys for HMR fan-out.
+     */
+    invalidateByFile(schemaFile: string): string[];
+    /**
+     * Evict every cache entry. Used when the config file changes.
+     * Returns the list of evicted cache keys for HMR fan-out.
+     */
+    invalidateAll(): string[];
+    /** Snapshot of cache size and hit/miss counters. */
+    stats(): CacheStats;
+}
+export declare function createCompilationCache(): CompilationCache;
+//# sourceMappingURL=cache.d.ts.map

package/dist/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAErE,MAAM,WAAW,UAAU;IACzB,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,0DAA0D;IAC1D,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,yEAAyE;IACzE,GAAG,CAAC,MAAM,EAAE,gBAAgB,GAAG,gBAAgB,GAAG,SAAS,CAAC;IAE5D,6DAA6D;IAC7D,GAAG,CAAC,MAAM,EAAE,gBAAgB,EAAE,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAE7D;;;OAGG;IACH,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAE/C;;;OAGG;IACH,aAAa,IAAI,MAAM,EAAE,CAAC;IAE1B,oDAAoD;IACpD,KAAK,IAAI,UAAU,CAAC;CACrB;AAOD,wBAAgB,sBAAsB,IAAI,gBAAgB,CAwDzD"}

package/dist/cache.js

@@ -0,0 +1,56 @@
+/** Build a stable key from a target. */
+function keyFor(target) {
+    return `${target.schemaFile}::${target.variant}::${target.configHash}`;
+}
+export function createCompilationCache() {
+    const entries = new Map();
+    const byFile = new Map();
+    let hits = 0;
+    let misses = 0;
+    return {
+        get(target) {
+            const key = keyFor(target);
+            const entry = entries.get(key);
+            if (entry === undefined) {
+                misses += 1;
+                return undefined;
+            }
+            hits += 1;
+            return entry;
+        },
+        set(target, entry) {
+            const key = keyFor(target);
+            entries.set(key, entry);
+            let group = byFile.get(target.schemaFile);
+            if (group === undefined) {
+                group = new Set();
+                byFile.set(target.schemaFile, group);
+            }
+            group.add(key);
+        },
+        invalidateByFile(schemaFile) {
+            const group = byFile.get(schemaFile);
+            if (group === undefined || group.size === 0) {
+                return [];
+            }
+            const evicted = [];
+            for (const key of group) {
+                if (entries.delete(key)) {
+                    evicted.push(key);
+                }
+            }
+            byFile.delete(schemaFile);
+            return evicted;
+        },
+        invalidateAll() {
+            const evicted = Array.from(entries.keys());
+            entries.clear();
+            byFile.clear();
+            return evicted;
+        },
+        stats() {
+            return { size: entries.size, hits, misses };
+        }
+    };
+}
+//# sourceMappingURL=cache.js.map

package/dist/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AA4CA,wCAAwC;AACxC,SAAS,MAAM,CAAC,MAAwB;IACtC,OAAO,GAAG,MAAM,CAAC,UAAU,KAAK,MAAM,CAAC,OAAO,KAAK,MAAM,CAAC,UAAU,EAAE,CAAC;AACzE,CAAC;AAED,MAAM,UAAU,sBAAsB;IACpC,MAAM,OAAO,GAAG,IAAI,GAAG,EAA4B,CAAC;IACpD,MAAM,MAAM,GAAG,IAAI,GAAG,EAAuB,CAAC;IAC9C,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,IAAI,MAAM,GAAG,CAAC,CAAC;IAEf,OAAO;QACL,GAAG,CAAC,MAAM;YACR,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;YAC3B,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAC/B,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBACxB,MAAM,IAAI,CAAC,CAAC;gBACZ,OAAO,SAAS,CAAC;YACnB,CAAC;YACD,IAAI,IAAI,CAAC,CAAC;YACV,OAAO,KAAK,CAAC;QACf,CAAC;QAED,GAAG,CAAC,MAAM,EAAE,KAAK;YACf,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;YAC3B,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YAExB,IAAI,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;YAC1C,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBACxB,KAAK,GAAG,IAAI,GAAG,EAAU,CAAC;gBAC1B,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;YACvC,CAAC;YACD,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACjB,CAAC;QAED,gBAAgB,CAAC,UAAU;YACzB,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;YACrC,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;gBAC5C,OAAO,EAAE,CAAC;YACZ,CAAC;YACD,MAAM,OAAO,GAAa,EAAE,CAAC;YAC7B,KAAK,MAAM,GAAG,IAAI,KAAK,EAAE,CAAC;gBACxB,IAAI,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;oBACxB,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBACpB,CAAC;YACH,CAAC;YACD,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;YAC1B,OAAO,OAAO,CAAC;QACjB,CAAC;QAED,aAAa;YACX,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;YAC3C,OAAO,CAAC,KAAK,EAAE,CAAC;YAChB,MAAM,CAAC,KAAK,EAAE,CAAC;YACf,OAAO,OAAO,CAAC;QACjB,CAAC;QAED,KAAK;YACH,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAC9C,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/config/load.d.ts

@@ -0,0 +1,59 @@
+import type { CodegenConfig } from '@zod-to-form/core';
+import type { $ZodType } from 'zod/v4/core';
+import type { Z2FViteConfig } from '../types.js';
+/**
+ * Build the effective `CodegenConfig` for a given (config, variant) pair.
+ *
+ * The bare default variant (`''`) returns the config as-is (minus the
+ * `variants` field, which has no business in `generateFormComponent`'s
+ * input). A named variant looks up `config.variants[variant]` and merges
+ * it on top of the global fields. Unknown variants throw.
+ */
+/**
+ * The plugin-side effective config — same shape as `CodegenConfig` except
+ * `exportName` may still be empty (auto-detect). `compileTarget` promotes
+ * it to a real name via `selectExport` before handing off to codegen.
+ */
+export type EffectiveZ2FConfig = Omit<CodegenConfig, 'exportName'> & {
+    exportName?: string;
+};
+export declare function buildEffectiveConfig(config: Z2FViteConfig, variant: string): EffectiveZ2FConfig;
+/**
+ * Module namespace returned by Vite's `ssrLoadModule`. The shape is
+ * `Record<string, unknown>` — each named export is a property whose value
+ * is whatever the user wrote.
+ */
+export type ModuleNamespace = Record<string, unknown>;
+/**
+ * Pick the named export from a module namespace that should be compiled
+ * into a form. Resolution order:
+ *
+ * 1. If `expectedName` is provided, return that export (or throw if it
+ *    doesn't exist or isn't a Zod schema).
+ * 2. Otherwise, find every named export that looks like a Zod schema.
+ *    If exactly one matches, return it. If zero or more than one match,
+ *    throw with a clear diagnostic — the user must disambiguate via
+ *    `config.exportName` or `config.variants[name].exportName`.
+ *
+ * Default exports are NOT considered — the contract is "named export
+ * matching the convention". This avoids surprising the user when they
+ * have both a default-exported helper and a named schema.
+ */
+export declare function selectExport(namespace: ModuleNamespace, schemaFile: string, expectedName?: string): {
+    name: string;
+    schema: $ZodType;
+};
+/**
+ * Compute a stable cache key from a config-shaped value. Consumers (the
+ * `CompilationCache` keying logic in `plugin.ts`) should call this rather
+ * than canonicalizing themselves so the hashing strategy stays in one
+ * place. The parameter is widened beyond `CodegenConfig` because the
+ * plugin hashes its own `Z2FViteConfig` (which adds `variants`) — and
+ * `canonicalizeConfig` walks structurally, so either shape round-trips.
+ *
+ * Truncated to 16 hex chars (64 bits): collision-resistant enough for a
+ * per-project cache keyed by (schemaFile, variant) pairs and keeps the
+ * resulting virtual-module query strings short.
+ */
+export declare function configHash(config: CodegenConfig | Record<string, unknown>): string;
+//# sourceMappingURL=load.d.ts.map

package/dist/config/load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../src/config/load.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAIjD;;;;;;;GAOG;AACH;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,aAAa,EAAE,YAAY,CAAC,GAAG;IACnE,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,GAAG,kBAAkB,CA0B/F;AAID;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAoBtD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE,eAAe,EAC1B,UAAU,EAAE,MAAM,EAClB,YAAY,CAAC,EAAE,MAAM,GACpB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,QAAQ,CAAA;CAAE,CA8CpC;AAID;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAGlF"}

package/dist/config/load.js

@@ -0,0 +1,117 @@
+/**
+ * Config loading + variant merging.
+ *
+ * The Vite plugin uses Vite's own module loaders (`server.ssrLoadModule`
+ * in dev, `this.load` in build) to load `z2f.config.ts` — see research R2.
+ * This file's responsibility is the pure parts of that pipeline:
+ *
+ * - Build the effective config for a given variant by merging the variant
+ *   override on top of the global config
+ * - Validate that the loaded config has the shape of a `CodegenConfig`
+ * - `selectExport` — pick the right Zod schema from a module namespace,
+ *   throwing on ambiguity
+ * - `canonicalizeForCache` — produce the SHA-256 cache key for a target
+ */
+import { createHash } from 'node:crypto';
+import { canonicalizeConfig } from '@zod-to-form/core';
+import { Z2FViteError } from '../errors.js';
+export function buildEffectiveConfig(config, variant) {
+    // Strip the plugin-only `variants` field — generateFormComponent doesn't
+    // know about it and would copy it through.
+    const { variants, ...base } = config;
+    // Default variant + plugin-internal `__generate_<n>` variants always
+    // resolve to the base config. Generate-mode synthesizes one variant per
+    // `<ZodForm>` site to give each generated component its own cache
+    // entry, but they share the user's global config — there's no per-site
+    // override mechanism in v1.
+    if (variant === '' || /^__generate_\d+$/.test(variant)) {
+        return base;
+    }
+    if (variants === undefined || variants[variant] === undefined) {
+        const known = variants ? Object.keys(variants).join(', ') : '(none declared)';
+        throw new Z2FViteError('Z2F_VITE_UNKNOWN_VARIANT', `Variant '${variant}' is not declared in z2f.config.ts. Known variants: ${known}.`);
+    }
+    // Per-variant overrides win over global fields. Only top-level keys are
+    // merged — there's no deep merge of nested objects like componentConfig,
+    // because variants typically swap whole sub-objects rather than patch them.
+    return { ...base, ...variants[variant] };
+}
+/**
+ * Structural Zod-v4 check: the value is a non-null object whose `_zod`
+ * property is itself a non-null object. Zod v4 attaches its internal
+ * machinery under `_zod`, so this is the standard duck-type.
+ *
+ * The predicate narrows to `$ZodType` because `walkSchema` from core and
+ * all downstream codegen helpers consume that interface — tightening here
+ * eliminates `as $ZodType` casts at every call site.
+ *
+ * We deliberately avoid a runtime `import` of zod: the user's project owns
+ * the zod version, and the plugin mustn't couple to a specific copy.
+ */
+function isZodSchema(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const zodInternal = value._zod;
+    return typeof zodInternal === 'object' && zodInternal !== null;
+}
+/**
+ * Pick the named export from a module namespace that should be compiled
+ * into a form. Resolution order:
+ *
+ * 1. If `expectedName` is provided, return that export (or throw if it
+ *    doesn't exist or isn't a Zod schema).
+ * 2. Otherwise, find every named export that looks like a Zod schema.
+ *    If exactly one matches, return it. If zero or more than one match,
+ *    throw with a clear diagnostic — the user must disambiguate via
+ *    `config.exportName` or `config.variants[name].exportName`.
+ *
+ * Default exports are NOT considered — the contract is "named export
+ * matching the convention". This avoids surprising the user when they
+ * have both a default-exported helper and a named schema.
+ */
+export function selectExport(namespace, schemaFile, expectedName) {
+    if (expectedName !== undefined) {
+        const value = namespace[expectedName];
+        if (value === undefined) {
+            throw new Z2FViteError('Z2F_VITE_SCHEMA_NOT_FOUND', `Schema export '${expectedName}' not found in '${schemaFile}'. Available named exports: ${Object.keys(namespace).join(', ') || '(none)'}.`, { file: schemaFile });
+        }
+        if (!isZodSchema(value)) {
+            throw new Z2FViteError('Z2F_VITE_SCHEMA_NOT_ZOD', `Export '${expectedName}' from '${schemaFile}' is not a Zod v4 schema (no '_zod' property). Make sure the export is a Zod schema instance, not a constructor or plain object.`, { file: schemaFile });
+        }
+        return { name: expectedName, schema: value };
+    }
+    // Auto-detect mode: find every Zod-shaped named export.
+    const candidates = [];
+    for (const [name, value] of Object.entries(namespace)) {
+        if (name === 'default')
+            continue; // skip default exports per the contract above
+        if (isZodSchema(value)) {
+            candidates.push({ name, schema: value });
+        }
+    }
+    if (candidates.length === 0) {
+        throw new Z2FViteError('Z2F_VITE_SCHEMA_NOT_FOUND', `No Zod v4 schema exports found in '${schemaFile}'. Default exports are not considered — re-export as a named export (e.g. 'export const signupSchema = z.object({ ... });').`, { file: schemaFile });
+    }
+    if (candidates.length > 1) {
+        throw new Z2FViteError('Z2F_VITE_AMBIGUOUS_EXPORT', `Schema file '${schemaFile}' has multiple Zod schema exports (${candidates.map((c) => c.name).join(', ')}) and no 'exportName' is configured. Set 'exportName' in z2f.config.ts (or in a variant) to disambiguate.`, { file: schemaFile });
+    }
+    return candidates[0];
+}
+// ─── Cache key helper ────────────────────────────────────────────────
+/**
+ * Compute a stable cache key from a config-shaped value. Consumers (the
+ * `CompilationCache` keying logic in `plugin.ts`) should call this rather
+ * than canonicalizing themselves so the hashing strategy stays in one
+ * place. The parameter is widened beyond `CodegenConfig` because the
+ * plugin hashes its own `Z2FViteConfig` (which adds `variants`) — and
+ * `canonicalizeConfig` walks structurally, so either shape round-trips.
+ *
+ * Truncated to 16 hex chars (64 bits): collision-resistant enough for a
+ * per-project cache keyed by (schemaFile, variant) pairs and keeps the
+ * resulting virtual-module query strings short.
+ */
+export function configHash(config) {
+    const canonical = canonicalizeConfig(config);
+    return createHash('sha256').update(canonical).digest('hex').slice(0, 16);
+}
+//# sourceMappingURL=load.js.map

package/dist/config/load.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.js","sourceRoot":"","sources":["../../src/config/load.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAGvD,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAsB5C,MAAM,UAAU,oBAAoB,CAAC,MAAqB,EAAE,OAAe;IACzE,yEAAyE;IACzE,2CAA2C;IAC3C,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,GAAG,MAAM,CAAC;IAErC,qEAAqE;IACrE,wEAAwE;IACxE,kEAAkE;IAClE,uEAAuE;IACvE,4BAA4B;IAC5B,IAAI,OAAO,KAAK,EAAE,IAAI,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QACvD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,QAAQ,KAAK,SAAS,IAAI,QAAQ,CAAC,OAAO,CAAC,KAAK,SAAS,EAAE,CAAC;QAC9D,MAAM,KAAK,GAAG,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC;QAC9E,MAAM,IAAI,YAAY,CACpB,0BAA0B,EAC1B,YAAY,OAAO,uDAAuD,KAAK,GAAG,CACnF,CAAC;IACJ,CAAC;IAED,wEAAwE;IACxE,yEAAyE;IACzE,4EAA4E;IAC5E,OAAO,EAAE,GAAG,IAAI,EAAE,GAAG,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;AAC3C,CAAC;AAWD;;;;;;;;;;;GAWG;AACH,SAAS,WAAW,CAAC,KAAc;IACjC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC9D,MAAM,WAAW,GAAI,KAA4B,CAAC,IAAI,CAAC;IACvD,OAAO,OAAO,WAAW,KAAK,QAAQ,IAAI,WAAW,KAAK,IAAI,CAAC;AACjE,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,YAAY,CAC1B,SAA0B,EAC1B,UAAkB,EAClB,YAAqB;IAErB,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;QAC/B,MAAM,KAAK,GAAG,SAAS,CAAC,YAAY,CAAC,CAAC;QACtC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,IAAI,YAAY,CACpB,2BAA2B,EAC3B,kBAAkB,YAAY,mBAAmB,UAAU,+BAA+B,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,QAAQ,GAAG,EAC1I,EAAE,IAAI,EAAE,UAAU,EAAE,CACrB,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,YAAY,CACpB,yBAAyB,EACzB,WAAW,YAAY,WAAW,UAAU,kIAAkI,EAC9K,EAAE,IAAI,EAAE,UAAU,EAAE,CACrB,CAAC;QACJ,CAAC;QACD,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAC/C,CAAC;IAED,wDAAwD;IACxD,MAAM,UAAU,GAA8C,EAAE,CAAC;IACjE,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;QACtD,IAAI,IAAI,KAAK,SAAS;YAAE,SAAS,CAAC,8CAA8C;QAChF,IAAI,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;YACvB,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC;IAED,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,YAAY,CACpB,2BAA2B,EAC3B,sCAAsC,UAAU,8HAA8H,EAC9K,EAAE,IAAI,EAAE,UAAU,EAAE,CACrB,CAAC;IACJ,CAAC;IAED,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,YAAY,CACpB,2BAA2B,EAC3B,gBAAgB,UAAU,sCAAsC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,2GAA2G,EACnN,EAAE,IAAI,EAAE,UAAU,EAAE,CACrB,CAAC;IACJ,CAAC;IAED,OAAO,UAAU,CAAC,CAAC,CAAE,CAAC;AACxB,CAAC;AAED,wEAAwE;AAExE;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,UAAU,CAAC,MAA+C;IACxE,MAAM,SAAS,GAAG,kBAAkB,CAAC,MAAuB,CAAC,CAAC;IAC9D,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAC3E,CAAC"}

package/dist/errors.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Plugin error classes.
+ *
+ * Every plugin error carries a stable `code` string and an optional `location`
+ * (file path + line/column). Codes are part of the public contract — see
+ * `specs/007-vite-codegen-plugin/contracts/plugin-options.md`.
+ *
+ * Errors are recoverable during `vite dev` (the plugin catches and reports
+ * them via the dev server's error collector without crashing). On `vite build`
+ * they propagate normally and abort the build.
+ */
+export type Z2FViteErrorCode = 'Z2F_VITE_CONFIG_NOT_FOUND' | 'Z2F_VITE_CONFIG_INVALID' | 'Z2F_VITE_SCHEMA_NOT_FOUND' | 'Z2F_VITE_SCHEMA_OUTSIDE_ROOT' | 'Z2F_VITE_SCHEMA_NOT_ZOD' | 'Z2F_VITE_AMBIGUOUS_EXPORT' | 'Z2F_VITE_UNKNOWN_VARIANT' | 'Z2F_VITE_QUERY_COMPOSITION_UNSUPPORTED' | 'Z2F_VITE_INVALID_VARIANT_NAME' | 'Z2F_VITE_CODEGEN_FAILURE' | 'Z2F_VITE_GENERATE_PARSE_ERROR' | 'Z2F_VITE_WOULD_CLOBBER_FILE' | 'Z2F_VITE_INVALID_OPTIONS' | 'Z2F_VITE_NOT_IMPLEMENTED' | 'Z2F_VITE_RESOLVER_STRIP_FAILED';
+export interface Z2FViteErrorLocation {
+    file?: string;
+    line?: number;
+    column?: number;
+}
+/**
+ * Structured error thrown by the `@zod-to-form/vite` plugin.
+ *
+ * Every error carries a stable `code` (see `Z2FViteErrorCode`) and an optional
+ * file location. During `vite dev` the plugin catches these and reports them via
+ * the dev-server error overlay. During `vite build` they propagate and abort the
+ * build with the code as a breadcrumb.
+ *
+ * @useWhen
+ * - Catching plugin errors in integration tests: `expect(fn).toThrow(/Z2F_VITE_/))`
+ * - Wrapping plugin calls in error handlers that need to branch on specific error codes
+ *
+ * @avoidWhen
+ * - General application error handling — this class is specific to plugin-level failures
+ *
+ * @pitfalls
+ * - NEVER compare `error.message` to detect error type — the message format may change.
+ *   Use `error.code` (e.g. `error.code === 'Z2F_VITE_SCHEMA_NOT_FOUND'`) for stable matching
+ *
+ * @category Errors
+ */
+export declare class Z2FViteError extends Error {
+    readonly code: Z2FViteErrorCode;
+    readonly location?: Z2FViteErrorLocation;
+    constructor(code: Z2FViteErrorCode, message: string, location?: Z2FViteErrorLocation);
+}
+/**
+ * Format an error for inclusion in a Vite error overlay or terminal output.
+ * The error's `message` already includes the code prefix; this function
+ * appends the location line when available.
+ */
+export declare function formatZ2FViteError(error: Z2FViteError): string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,MAAM,gBAAgB,GACxB,2BAA2B,GAC3B,yBAAyB,GACzB,2BAA2B,GAC3B,8BAA8B,GAC9B,yBAAyB,GACzB,2BAA2B,GAC3B,0BAA0B,GAC1B,wCAAwC,GACxC,+BAA+B,GAC/B,0BAA0B,GAC1B,+BAA+B,GAC/B,6BAA6B,GAC7B,0BAA0B,GAC1B,0BAA0B,GAC1B,gCAAgC,CAAC;AAErC,MAAM,WAAW,oBAAoB;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,YAAa,SAAQ,KAAK;IACrC,SAAgB,IAAI,EAAE,gBAAgB,CAAC;IACvC,SAAgB,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAEhD,YAAY,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,oBAAoB,EAUnF;CACF;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAQ9D"}

package/dist/errors.js

@@ -0,0 +1,62 @@
+/**
+ * Plugin error classes.
+ *
+ * Every plugin error carries a stable `code` string and an optional `location`
+ * (file path + line/column). Codes are part of the public contract — see
+ * `specs/007-vite-codegen-plugin/contracts/plugin-options.md`.
+ *
+ * Errors are recoverable during `vite dev` (the plugin catches and reports
+ * them via the dev server's error collector without crashing). On `vite build`
+ * they propagate normally and abort the build.
+ */
+/**
+ * Structured error thrown by the `@zod-to-form/vite` plugin.
+ *
+ * Every error carries a stable `code` (see `Z2FViteErrorCode`) and an optional
+ * file location. During `vite dev` the plugin catches these and reports them via
+ * the dev-server error overlay. During `vite build` they propagate and abort the
+ * build with the code as a breadcrumb.
+ *
+ * @useWhen
+ * - Catching plugin errors in integration tests: `expect(fn).toThrow(/Z2F_VITE_/))`
+ * - Wrapping plugin calls in error handlers that need to branch on specific error codes
+ *
+ * @avoidWhen
+ * - General application error handling — this class is specific to plugin-level failures
+ *
+ * @pitfalls
+ * - NEVER compare `error.message` to detect error type — the message format may change.
+ *   Use `error.code` (e.g. `error.code === 'Z2F_VITE_SCHEMA_NOT_FOUND'`) for stable matching
+ *
+ * @category Errors
+ */
+export class Z2FViteError extends Error {
+    code;
+    location;
+    constructor(code, message, location) {
+        // Prefix the message with the code so error.message, error.toString(),
+        // and Vitest's `expect.toThrow(/CODE/)` matchers all surface the code
+        // without callers having to inspect `error.code` separately.
+        super(`[${code}] ${message}`);
+        this.name = 'Z2FViteError';
+        this.code = code;
+        if (location !== undefined) {
+            this.location = location;
+        }
+    }
+}
+/**
+ * Format an error for inclusion in a Vite error overlay or terminal output.
+ * The error's `message` already includes the code prefix; this function
+ * appends the location line when available.
+ */
+export function formatZ2FViteError(error) {
+    const parts = [error.message];
+    if (error.location?.file) {
+        const line = error.location.line ?? 0;
+        const column = error.location.column ?? 0;
+        parts.push(`  at ${error.location.file}:${line}:${column}`);
+    }
+    return parts.join('\n');
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAyBH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,OAAO,YAAa,SAAQ,KAAK;IACrB,IAAI,CAAmB;IACvB,QAAQ,CAAwB;IAEhD,YAAY,IAAsB,EAAE,OAAe,EAAE,QAA+B;QAClF,uEAAuE;QACvE,sEAAsE;QACtE,6DAA6D;QAC7D,KAAK,CAAC,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC,CAAC;QAC9B,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC;QAC3B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QAC3B,CAAC;IACH,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAmB;IACpD,MAAM,KAAK,GAAa,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACxC,IAAI,KAAK,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC;QACzB,MAAM,IAAI,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,CAAC;QACtC,MAAM,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAC,MAAM,IAAI,CAAC,CAAC;QAC1C,KAAK,CAAC,IAAI,CAAC,QAAQ,KAAK,CAAC,QAAQ,CAAC,IAAI,IAAI,IAAI,IAAI,MAAM,EAAE,CAAC,CAAC;IAC9D,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC"}

package/dist/generate-mode/babel-traverse.d.ts

@@ -0,0 +1,5 @@
+import type { TraverseOptions } from '@babel/traverse';
+type TraverseFn = <S = unknown>(ast: unknown, opts: TraverseOptions<S>) => void;
+export declare const traverse: TraverseFn;
+export {};
+//# sourceMappingURL=babel-traverse.d.ts.map

package/dist/generate-mode/babel-traverse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"babel-traverse.d.ts","sourceRoot":"","sources":["../../src/generate-mode/babel-traverse.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,KAAK,UAAU,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;AAIhF,eAAO,MAAM,QAAQ,EAAE,UACgD,CAAC"}

package/dist/generate-mode/babel-traverse.js

@@ -0,0 +1,16 @@
+/**
+ * `@babel/traverse` ESM/CJS interop shim.
+ *
+ * The package's published types model the entry point as a namespace,
+ * but at runtime it's either the function itself (modern bundlers) or
+ * a `{ default: fn }` object (CJS interop). Importing as a namespace
+ * and then unwrapping at runtime is the only shape that works under
+ * tsgo, vitest, AND esbuild's bundler at the same time.
+ *
+ * This file owns the cast so neither `scan-jsx.ts` nor `resolve-schema.ts`
+ * has to repeat the same five-line dance.
+ */
+import * as traverseModule from '@babel/traverse';
+const traverseAny = traverseModule;
+export const traverse = typeof traverseAny === 'function' ? traverseAny : traverseAny.default;
+//# sourceMappingURL=babel-traverse.js.map

package/dist/generate-mode/babel-traverse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"babel-traverse.js","sourceRoot":"","sources":["../../src/generate-mode/babel-traverse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,cAAc,MAAM,iBAAiB,CAAC;AAKlD,MAAM,WAAW,GAAG,cAAiE,CAAC;AAEtF,MAAM,CAAC,MAAM,QAAQ,GACnB,OAAO,WAAW,KAAK,UAAU,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,OAAO,CAAC"}

package/dist/generate-mode/generate-source.d.ts

@@ -0,0 +1,51 @@
+import MagicString from 'magic-string';
+import type { ResolvedSite } from './resolve-schema.js';
+export interface GenerateSourceInput {
+    source: string;
+    resolved: ResolvedSite[];
+    /**
+     * Optional diagnostic callback. Called with an error message (never
+     * an Error object) when an internal invariant is violated — e.g., the
+     * insertion-point scanner's Babel re-parse fails even though scanJsx
+     * already parsed the same source successfully. Wired to the plugin's
+     * logger at the call site so these land in the buildEnd summary
+     * instead of being lost.
+     */
+    onWarn?: (message: string) => void;
+}
+export interface GenerateSourceOutput {
+    /** The transformed source (or the original, if there was nothing to do). */
+    code: string;
+    /** Hi-res sourcemap from magic-string, suitable for Vite. */
+    map: ReturnType<MagicString['generateMap']>;
+    /** Number of sites actually rewritten (== `resolved.length`). */
+    rewritten: number;
+}
+export declare function generateSource(input: GenerateSourceInput): GenerateSourceOutput;
+/**
+ * Find the byte offset at which to insert generated imports. The target
+ * is "immediately after the last thing that must come first": the file's
+ * shebang, its leading string directives (`'use client'`, `'use strict'`),
+ * and any existing top-level `import` statements. If none of those exist,
+ * the result is byte 0 (the file starts with user code and the generated
+ * imports go at the very top).
+ *
+ * Uses Babel's parser — the same dependency scan-jsx and resolve-schema
+ * already rely on — so directive detection, multi-line imports,
+ * TypeScript-specific forms (`import type`), side-effect-only imports,
+ * BOM handling, and escape sequences inside string literals are all
+ * handled by the production-grade parser instead of a hand-rolled
+ * textual walker.
+ *
+ * On parse failure (e.g. the user is mid-save with broken syntax) we
+ * warn via `onWarn` and return 0. This is defense-in-depth: `scanJsx`'s
+ * upstream parse normally filters broken sources before this code runs,
+ * but a future Babel plugin-flag drift between the two parsers could
+ * make them disagree, and silent corruption is worse than a warn line.
+ *
+ * `onWarn` MUST NOT throw — exceptions in the callback would kill the
+ * transform and turn a recoverable warning into a hard build failure.
+ * Any throw is caught and ignored below.
+ */
+export declare function findImportInsertionPoint(source: string, onWarn?: (message: string) => void): number;
+//# sourceMappingURL=generate-source.d.ts.map

package/dist/generate-mode/generate-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-source.d.ts","sourceRoot":"","sources":["../../src/generate-mode/generate-source.ts"],"names":[],"mappings":"AAoBA,OAAO,WAAW,MAAM,cAAc,CAAC;AAEvC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC;AAED,MAAM,WAAW,oBAAoB;IACnC,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC;IACb,6DAA6D;IAC7D,GAAG,EAAE,UAAU,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC;IAC5C,iEAAiE;IACjE,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,mBAAmB,GAAG,oBAAoB,CAyE/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GACjC,MAAM,CAqER"}