zintljs 0.1.0-alpha.7

package/dist/facets.d.mts

@@ -0,0 +1,56 @@
+import { t as FacetsInput } from "./types-DTRiQkFi.mjs";
+import { AssetTargetConfig, BaseFacet, BundlerFacet, CapabilityFlags, CatalogManager, CodegenFacet, CompiledExtractionState, CompilerCapabilities, CompilerCapabilities as CompilerCapabilities$1, CompilerContext, CompilerSystemView, ContentFacet, ExtractionContribution, ExtractionFacet, FacetConcern, HtmlProjectionPayload, IOManager, LocaleDetectionContext, MultiplexDetectionContext, MustacheRule, RuntimeFacet, SfcBlockRule, SfcRule, SsrFacet, SsrWrapParams, SuppressionRule, TagMapEntry, TargetDescriptor, TargetPlugin, ZintlFacet, ZintlFacet as ZintlFacet$1 } from "@zintljs/compiler";
+export * from "@zintljs/compiler/facets";
+//#region src/facets/resolve.d.ts
+/**
+ * Resolve a flat list of facet objects into the capabilities handed to the compiler.
+ */
+declare function resolveFacets(facets?: ZintlFacet$1[]): CompilerCapabilities$1;
+//#endregion
+//#region src/facets/detect.d.ts
+type Framework = "react" | "vue" | "svelte" | "nextjs";
+/** The framework assumed when detection finds nothing. */
+declare const FALLBACK_FRAMEWORK: Framework;
+interface DetectionInput {
+  /** Plugin names from the resolved bundler config. */
+  pluginNames?: string[];
+  /** Project root, scanned for a package.json. */
+  root?: string;
+}
+/**
+ * Detect frameworks from bundler plugin names and the project's package.json.
+ *
+ * Returns an empty array when nothing matched — callers decide whether to apply
+ * {@link FALLBACK_FRAMEWORK}, so the guess stays visible rather than buried.
+ */
+declare function detectFrameworks({ pluginNames, root }: DetectionInput): Framework[];
+/** Detect, falling back to {@link FALLBACK_FRAMEWORK} when nothing matched. */
+declare function detectFrameworksOrFallback(input: DetectionInput): Framework[];
+//#endregion
+//#region src/facets/assemble.d.ts
+interface AssembleInput {
+  /** Frameworks detected for this project. */
+  frameworks: Framework[];
+  /** Whether this build targets SSR. */
+  ssr?: boolean;
+  /** User-declared facets; defaults to `["auto"]`. */
+  facets?: FacetsInput[];
+  /** Asset facet configuration drawn from plugin options. */
+  assetsTarget?: (string | AssetTargetConfig)[];
+  virtualAssets?: boolean;
+}
+/**
+ * The facet set that `"auto"` expands to.
+ */
+declare function autoFacets(input: AssembleInput): ZintlFacet$1[];
+/**
+ * Flatten user facet input, expanding `"auto"`, thunks and nested arrays.
+ */
+declare function flattenFacets(inputs: FacetsInput[], auto: ZintlFacet$1[]): ZintlFacet$1[];
+/**
+ * The complete facet list for a project: user input (with `"auto"` expanded)
+ * plus the always-injected Vite bundler facet.
+ */
+declare function assembleFacets(input: AssembleInput): ZintlFacet$1[];
+//#endregion
+export { type BaseFacet, type BundlerFacet, type CapabilityFlags, type CatalogManager, type CodegenFacet, type CompiledExtractionState, type CompilerCapabilities, type CompilerContext, type CompilerSystemView, type ContentFacet, type ExtractionContribution, type ExtractionFacet, FALLBACK_FRAMEWORK, type FacetConcern, type Framework, type HtmlProjectionPayload, type IOManager, type LocaleDetectionContext, type MultiplexDetectionContext, type MustacheRule, type RuntimeFacet, type SfcBlockRule, type SfcRule, type SsrFacet, type SsrWrapParams, type SuppressionRule, type TagMapEntry, type TargetDescriptor, type TargetPlugin, type ZintlFacet, assembleFacets, autoFacets, detectFrameworks, detectFrameworksOrFallback, flattenFacets, resolveFacets };

package/dist/facets.mjs

@@ -0,0 +1,3 @@
+import { a as detectFrameworks, i as FALLBACK_FRAMEWORK, n as autoFacets, o as detectFrameworksOrFallback, r as flattenFacets, s as resolveFacets, t as assembleFacets } from "./assemble-DJKgHgSM.mjs";
+export * from "@zintljs/compiler/facets";
+export { FALLBACK_FRAMEWORK, assembleFacets, autoFacets, detectFrameworks, detectFrameworksOrFallback, flattenFacets, resolveFacets };

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+import { ZintlInstance, getLocale, getStoreVersion, setLocale, subscribe, t, zintl } from "./macro.mjs";
+export { ZintlInstance, getLocale, getStoreVersion, setLocale, subscribe, t, zintl };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { getLocale, getStoreVersion, setLocale, subscribe, t, zintl } from "./macro.mjs";
+export { getLocale, getStoreVersion, setLocale, subscribe, t, zintl };

package/dist/macro.d.mts

@@ -0,0 +1,148 @@
+//#region src/macro.d.ts
+/**
+ * @module zintl/macro
+ *
+ * The macro facade — everything you write in application code.
+ *
+ * These are compiler markers, not a runtime library. At build time the Zintl
+ * plugin rewrites each call and each import in this module to its real runtime
+ * equivalent, which is why the bodies you see here look like no-ops. They are:
+ * the bodies are the fallback for an untransformed environment (a plain `tsc`
+ * run, a unit test without the plugin), where the app must still work in the
+ * source locale rather than crash.
+ *
+ * The plugin itself lives at `zintl/vite`, not here.
+ */
+/**
+ * The i18n handle a resolved {@link zintl} anchor gives you.
+ *
+ * Rarely needed — most apps `await zintl(locale)` for the side effect and read
+ * the locale later with {@link getLocale}. It is there for the cases where you
+ * want to act on the boundary you just created.
+ */
+interface ZintlInstance {
+  /**
+   * The locale at the moment this anchor resolved.
+   *
+   * A snapshot, not a live value: a later `setLocale` does not change it. Use
+   * {@link getLocale} for the current locale.
+   */
+  readonly locale: string;
+  /** Log translation misses and catalog loads for this boundary. */
+  debug: boolean;
+  /** Switch the active locale, loading any catalogs it needs. */
+  setLocale(locale?: string | null): Promise<void>;
+  /** Run `listener` on every locale or catalog change. Returns an unsubscribe function. */
+  subscribe(listener: () => void): () => void;
+  /** Translate a key against this boundary. See {@link t}. */
+  t(key: string, params?: Record<string, any>): string;
+}
+/**
+ * Declare an internationalization boundary — the trust anchor.
+ *
+ * Awaiting `zintl()` sets the active locale and loads the catalogs for every
+ * string reachable from this file. Everything downstream of it is extracted and
+ * translated with no further annotation: no wrapper functions, no key maps.
+ *
+ * Every call is an **independent** anchor with its own catalog boundary and
+ * hydration lifecycle, whether it sits at module level or inside a function. A
+ * nested call opts out of any parent context rather than inheriting it, so
+ * loading stays deterministic.
+ *
+ * What you pass decides how much work happens at runtime:
+ *
+ * - `zintl("ar")` — a static literal. The compiler inlines that catalog into the
+ *   generated loader, so the boundary is ready with no network round-trip.
+ * - `zintl(userLang)` — an expression. Catalogs load lazily for whichever locale
+ *   is asked for.
+ * - `zintl()` — no argument. Reads `document.documentElement.lang`.
+ * - `zintl("*")` — every locale is a valid target. Together with `zintl()`, this
+ *   is what the plugin looks for when auto-detecting `multiplex` builds.
+ *
+ * @param locale - The locale to activate. Omit to read it from the document.
+ * @returns The boundary's i18n handle, once its catalogs have loaded.
+ *
+ * @example
+ * ```ts
+ * import { zintl } from "zintljs/macro";
+ *
+ * await zintl(new URLSearchParams(location.search).get("lang") ?? "en");
+ *
+ * // Extracted automatically — no wrapper needed.
+ * document.querySelector("#app")!.innerHTML = `<h1>Welcome back!</h1>`;
+ * ```
+ *
+ * @zintl-macro
+ */
+declare function zintl(_locale?: string): Promise<ZintlInstance>;
+/**
+ * Translate an explicit key.
+ *
+ * The escape hatch, not the main road: Zintl extracts string literals, template
+ * literals, JSX and HTML on its own, so reach for `t()` only when the string is
+ * not in the source — a key assembled at runtime, or one arriving from data.
+ *
+ * `params` fills the `{name}` placeholders in a message, and feeds the plural
+ * and select branches the compiler bakes from the catalog's ZCU form. Context
+ * variables bound with `@zintl-pass` arrive the same way, which is how a target
+ * language can vary on gender or count that the source string never mentions.
+ *
+ * @param key - The message key, as it appears in the catalog.
+ * @param _params - Values for the message's placeholders and grammatical branches.
+ * @returns The translation for the active locale, or `key` itself if there is none.
+ *
+ * @example
+ * ```ts
+ * t("cart.items", { count: cart.length })
+ * t(`status.${order.state}`)
+ * ```
+ *
+ * @zintl-macro
+ */
+declare function t(key: string, _params?: Record<string, any>): string;
+/**
+ * The locale currently active.
+ *
+ * The plugin rewrites this import to the real runtime binding, so it reflects
+ * the live store — including a locale set after the anchor resolved. Returns
+ * `""` when no boundary has been established yet.
+ */
+declare function getLocale(): string;
+/**
+ * Switch the active locale, loading whatever catalogs it needs.
+ *
+ * Resolves once the new locale is in effect. If the catalogs are already
+ * present — inlined for a static anchor, or loaded earlier — the switch applies
+ * synchronously and subscribers see it before the promise settles.
+ *
+ * Passing `null` or `undefined` is a no-op, so a value straight from a router or
+ * a query string needs no guard.
+ *
+ * @example
+ * ```ts
+ * document.querySelector("#lang")!.addEventListener("change", (e) => {
+ *   void setLocale((e.target as HTMLSelectElement).value);
+ * });
+ * ```
+ */
+declare function setLocale(_locale?: string | null): Promise<void>;
+/**
+ * Run `listener` whenever the locale or the loaded catalogs change.
+ *
+ * The building block for wiring Zintl into a UI framework by hand. Call the
+ * returned function to unsubscribe. Framework integrations built from the
+ * `"auto"` facets already do this for you — React components, for instance, are
+ * re-rendered through `useSyncExternalStore` without any subscription of yours.
+ *
+ * @returns An unsubscribe function.
+ */
+declare function subscribe(_listener: () => void): () => void;
+/**
+ * A counter that increments on every locale or catalog change.
+ *
+ * The snapshot half of a `useSyncExternalStore`-style pairing with
+ * {@link subscribe}: compare it to know whether anything translated has moved.
+ */
+declare function getStoreVersion(): number;
+//#endregion
+export { ZintlInstance, getLocale, getStoreVersion, setLocale, subscribe, t, zintl };

package/dist/macro.mjs

@@ -0,0 +1,130 @@
+//#region src/macro.ts
+/**
+* Declare an internationalization boundary — the trust anchor.
+*
+* Awaiting `zintl()` sets the active locale and loads the catalogs for every
+* string reachable from this file. Everything downstream of it is extracted and
+* translated with no further annotation: no wrapper functions, no key maps.
+*
+* Every call is an **independent** anchor with its own catalog boundary and
+* hydration lifecycle, whether it sits at module level or inside a function. A
+* nested call opts out of any parent context rather than inheriting it, so
+* loading stays deterministic.
+*
+* What you pass decides how much work happens at runtime:
+*
+* - `zintl("ar")` — a static literal. The compiler inlines that catalog into the
+*   generated loader, so the boundary is ready with no network round-trip.
+* - `zintl(userLang)` — an expression. Catalogs load lazily for whichever locale
+*   is asked for.
+* - `zintl()` — no argument. Reads `document.documentElement.lang`.
+* - `zintl("*")` — every locale is a valid target. Together with `zintl()`, this
+*   is what the plugin looks for when auto-detecting `multiplex` builds.
+*
+* @param locale - The locale to activate. Omit to read it from the document.
+* @returns The boundary's i18n handle, once its catalogs have loaded.
+*
+* @example
+* ```ts
+* import { zintl } from "zintljs/macro";
+*
+* await zintl(new URLSearchParams(location.search).get("lang") ?? "en");
+*
+* // Extracted automatically — no wrapper needed.
+* document.querySelector("#app")!.innerHTML = `<h1>Welcome back!</h1>`;
+* ```
+*
+* @zintl-macro
+*/
+async function zintl(_locale) {
+	return {
+		locale: "",
+		debug: false,
+		setLocale: () => Promise.resolve(),
+		subscribe: () => () => {},
+		t: (key) => key
+	};
+}
+/**
+* Translate an explicit key.
+*
+* The escape hatch, not the main road: Zintl extracts string literals, template
+* literals, JSX and HTML on its own, so reach for `t()` only when the string is
+* not in the source — a key assembled at runtime, or one arriving from data.
+*
+* `params` fills the `{name}` placeholders in a message, and feeds the plural
+* and select branches the compiler bakes from the catalog's ZCU form. Context
+* variables bound with `@zintl-pass` arrive the same way, which is how a target
+* language can vary on gender or count that the source string never mentions.
+*
+* @param key - The message key, as it appears in the catalog.
+* @param _params - Values for the message's placeholders and grammatical branches.
+* @returns The translation for the active locale, or `key` itself if there is none.
+*
+* @example
+* ```ts
+* t("cart.items", { count: cart.length })
+* t(`status.${order.state}`)
+* ```
+*
+* @zintl-macro
+*/
+function t(key, _params = {}) {
+	return key;
+}
+/**
+* The locale currently active.
+*
+* The plugin rewrites this import to the real runtime binding, so it reflects
+* the live store — including a locale set after the anchor resolved. Returns
+* `""` when no boundary has been established yet.
+*/
+function getLocale() {
+	if (typeof globalThis !== "undefined" && globalThis.__zintl_active) return globalThis.__zintl_active.locale;
+	return "";
+}
+/**
+* Switch the active locale, loading whatever catalogs it needs.
+*
+* Resolves once the new locale is in effect. If the catalogs are already
+* present — inlined for a static anchor, or loaded earlier — the switch applies
+* synchronously and subscribers see it before the promise settles.
+*
+* Passing `null` or `undefined` is a no-op, so a value straight from a router or
+* a query string needs no guard.
+*
+* @example
+* ```ts
+* document.querySelector("#lang")!.addEventListener("change", (e) => {
+*   void setLocale((e.target as HTMLSelectElement).value);
+* });
+* ```
+*/
+function setLocale(_locale) {
+	return Promise.resolve();
+}
+/**
+* Run `listener` whenever the locale or the loaded catalogs change.
+*
+* The building block for wiring Zintl into a UI framework by hand. Call the
+* returned function to unsubscribe. Framework integrations built from the
+* `"auto"` facets already do this for you — React components, for instance, are
+* re-rendered through `useSyncExternalStore` without any subscription of yours.
+*
+* @returns An unsubscribe function.
+*/
+function subscribe(_listener) {
+	return () => {};
+}
+/**
+* A counter that increments on every locale or catalog change.
+*
+* The snapshot half of a `useSyncExternalStore`-style pairing with
+* {@link subscribe}: compare it to know whether anything translated has moved.
+*/
+function getStoreVersion() {
+	if (typeof globalThis !== "undefined" && globalThis.__zintl_active) return globalThis.__zintl_active.version;
+	return 0;
+}
+//#endregion
+export { getLocale, getStoreVersion, setLocale, subscribe, t, zintl };

package/dist/types-DTRiQkFi.d.mts

@@ -0,0 +1,243 @@
+import { AssetTargetConfig, CatalogFormatContext, LogLevel, ZintlFacet } from "@zintljs/compiler";
+//#region src/types.d.ts
+/**
+ * What a user may write in `facets: [...]`.
+ *
+ * Accepts the `"auto"` sentinel (expanded by framework detection), bare facets,
+ * arrays, and thunks — all flattened during assembly before resolution.
+ *
+ * @example
+ * ```ts
+ * zintl({ facets: ["auto", myFacet()] })          // keep the defaults, add one
+ * zintl({ facets: [reactFacet(), ssrFacet()] })   // opt out of "auto" entirely
+ * zintl({ facets: [() => expensiveFacet()] })     // thunk, evaluated at assembly
+ * ```
+ */
+type FacetsInput = "auto" | ZintlFacet | ZintlFacet[] | (() => ZintlFacet | ZintlFacet[]) | FacetsInput[];
+/**
+ * Options for the Zintl Vite plugin.
+ *
+ * Every field is optional; the defaults are tuned for a typical app, and a
+ * working setup is usually just `locales`.
+ *
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import { defineConfig } from "vite";
+ * import zintl from "zintljs/vite";
+ *
+ * export default defineConfig({
+ *   plugins: [zintl({ locales: ["en", "ar", "fr"] })],
+ * });
+ * ```
+ */
+interface Options {
+  /**
+   * The locale your source code is written in.
+   *
+   * This locale is **diskless**. Zintl never writes a catalog for it: a file of
+   * `{ "Hello": "Hello" }` carries no information, so the compiler virtualizes
+   * it from the extraction manifest instead. You will not find it in
+   * {@link Options.outputDir | `outputDir`}, and that is not a bug.
+   *
+   * @default "en"
+   */
+  sourceLocale?: string;
+  /**
+   * Every locale the app ships, including {@link Options.sourceLocale | `sourceLocale`}.
+   *
+   * Each entry gets a catalog written under {@link Options.outputDir | `outputDir`}
+   * (except the source locale), and becomes a value you can pass to `zintl()`.
+   *
+   * @default ["en"]
+   * @example
+   * ```ts
+   * locales: ["en", "ar", "fr"]
+   * ```
+   */
+  locales?: string[];
+  /**
+   * Where translation catalogs are written, relative to the project root.
+   *
+   * These files are yours: commit them, edit them, hand them to translators.
+   * The compiler writes new keys in and reconciles renames, but never discards
+   * a translation you have written (see {@link Options.prune | `prune`}).
+   *
+   * @default "./zintl"
+   */
+  outputDir?: string;
+  /**
+   * How catalog files are named inside {@link Options.outputDir | `outputDir`}.
+   *
+   * A token string, or a function returning a path relative to `outputDir`.
+   * Supported tokens:
+   *
+   * - `[locale]` — the target locale, e.g. `ar`
+   * - `[path]` — the boundary's source path, e.g. `src/pages/Home.ts`
+   * - `[dir]` — its directory, e.g. `src/pages` (empty for the root)
+   * - `[name]` — its filename with extension, e.g. `Home.ts`
+   * - `[func]` — the enclosing function, for anchors nested inside one (empty otherwise)
+   * - `[bId]` — the full boundary id; `:` and `/` become `_`
+   * - `[hash]` — the boundary's stable short hash
+   *
+   * Grouping many boundaries into one file is supported: point several at the
+   * same name and they are merged.
+   *
+   * @default `<path>[.<func>].<locale>.json`, e.g. `src/pages/Home.ts.ar.json`
+   * @example
+   * ```ts
+   * catalogFormat: "[locale]/[dir]/[name].json"  // ar/src/pages/Home.ts.json
+   * catalogFormat: "[locale].json"               // one file per locale
+   * catalogFormat: ({ locale, name }) => `${locale}/${name}.json`
+   * ```
+   */
+  catalogFormat?: string | ((ctx: CatalogFormatContext) => string);
+  /**
+   * How similar an edited string must be to a remembered one before its
+   * translation is carried forward instead of being dropped.
+   *
+   * A ratio from `0` to `1`. Fixing a typo in a source string is the case this
+   * exists for: the translation moves to the new key and no translator is
+   * involved. Raising it toward `1` demands near-identical strings and loses
+   * more translations to small edits; lowering it risks a translation landing on
+   * an unrelated string.
+   *
+   * Escape hatch — the default is usually right, and a threshold cannot fix a
+   * string that was genuinely rewritten.
+   *
+   * @default 0.6
+   */
+  similarityThreshold?: number;
+  /**
+   * How much Zintl prints.
+   *
+   * The `ZINTL_LOG_LEVEL` environment variable overrides this when set. Under
+   * test (`NODE_ENV=test` or Vitest) the effective level is `"silent"` unless
+   * {@link Options.debug | `debug`} is on.
+   *
+   * @default Vite's own `logLevel`, falling back to `"info"`
+   */
+  logLevel?: LogLevel;
+  /**
+   * Where the compiler keeps its own bookkeeping — the extraction manifest,
+   * boundary graph and translation hive.
+   *
+   * Build artifacts, not source. They live outside your repo by default and you
+   * should not need to move them.
+   *
+   * Escape hatch — mainly useful for test harnesses and sandboxes.
+   *
+   * @default `<root>/node_modules/.zintl`
+   */
+  metadataDir?: string;
+  /**
+   * Verbose compiler tracing.
+   *
+   * `true` enables everything. A **string** is a scope filter, matched against
+   * the prefix of each debug channel, so you can watch one subsystem instead of
+   * the whole pipeline. The `DEBUG` environment variable (`DEBUG=zintl:*`,
+   * `DEBUG=*`, or `DEBUG=zintl:<prefix>`) turns the same tracing on.
+   *
+   * @default false
+   * @example
+   * ```ts
+   * debug: true          // everything
+   * debug: "boundary"    // only the boundary-graph channels
+   * ```
+   */
+  debug?: boolean | string;
+  /**
+   * Remove keys from catalogs once no source string produces them.
+   *
+   * On by default, so deleting a component takes its dead keys with it. Turn it
+   * off if catalogs are edited by a system that expects keys to survive their
+   * source — the cost is that catalogs only ever grow.
+   *
+   * Pruning runs after reconciliation, so a renamed or retyped string is carried
+   * forward rather than pruned and re-added.
+   *
+   * @default true
+   */
+  prune?: boolean;
+  /**
+   * Verify on-disk catalogs against the extraction manifest and repair drift.
+   *
+   * The check that catches a hand-edited catalog that no longer matches the
+   * code. It costs a pass over every catalog, which is why it is on for builds
+   * and off while serving.
+   *
+   * Escape hatch — set `false` to skip it in a slow CI build, `true` to catch
+   * drift during development.
+   *
+   * @default `true` for `vite build`, `false` for `vite dev`
+   */
+  verifyIntegrity?: boolean;
+  /**
+   * Build every locale as its own set of HTML entries, instead of one app that
+   * loads catalogs at runtime.
+   *
+   * Detected automatically: an anchor written `zintl()` or `zintl("*")` defers
+   * the locale to the document or the URL, which is exactly the multiplex shape,
+   * so the plugin scans your entries and decides.
+   *
+   * Escape hatch — set it explicitly only when the scan gets it wrong.
+   *
+   * @default auto-detected from your entry files
+   */
+  multiplex?: boolean;
+  /**
+   * Static content files to localize alongside your code, as extensions or
+   * glob configs.
+   *
+   * A bare extension expands to `**\/*.<ext>`. When a target's
+   * {@link AssetTargetConfig.strategy | `strategy`} is not given it is inferred
+   * from the extension: `.md`/`.mdx` merge frontmatter, `.txt` passes through as
+   * text, anything else is copied as binary.
+   *
+   * @default ["md", "txt"]
+   * @example
+   * ```ts
+   * assetsTarget: ["md", "txt", "mdx"]
+   * assetsTarget: [{ targetPattern: "content/**\/*.md", outputPattern: "[locale]/[dir]/[name][ext]" }]
+   * ```
+   */
+  assetsTarget?: (string | AssetTargetConfig)[];
+  /**
+   * Serve localized assets from virtual modules instead of writing them to disk.
+   *
+   * With the default (`false`), a localized copy of each matched asset is
+   * written next to your catalogs, so you can read and edit the translated
+   * Markdown directly. With `true` nothing is written: the localized content is
+   * kept in the translation hive and served through virtual modules, which keeps
+   * the working tree clean at the cost of not being able to edit the output as a
+   * file.
+   *
+   * @default false
+   */
+  virtualAssets?: boolean;
+  /**
+   * Which capabilities the compiler is built with — framework support, SSR,
+   * client locale sync, asset handling.
+   *
+   * `"auto"` covers almost every project. It detects your framework from the
+   * Vite plugins and `package.json`, then adds the baselines: vanilla DOM and
+   * HTML extraction, static assets, client-side locale sync for SPAs, and SSR
+   * wrapping for SSR builds. The Vite bundler facet is always appended and
+   * cannot be opted out of.
+   *
+   * Listing facets without `"auto"` opts out of all of that and gives you
+   * exactly what you name. Two facets that claim the same file extension, or
+   * that provide the same hook at the same priority, are a hard error rather
+   * than a silent winner.
+   *
+   * @default ["auto"]
+   * @example
+   * ```ts
+   * facets: ["auto", myMarkdownFacet()]   // defaults plus your own
+   * facets: [reactFacet(), ssrFacet()]    // exactly these, nothing implicit
+   * ```
+   */
+  facets?: FacetsInput[];
+}
+//#endregion
+export { Options as n, FacetsInput as t };

package/dist/vite.d.mts

@@ -0,0 +1,43 @@
+import { n as Options, t as FacetsInput } from "./types-DTRiQkFi.mjs";
+import { AssetMergeStrategy, AssetTargetConfig, CatalogFormatContext, LogLevel } from "@zintljs/compiler";
+//#region src/vite.d.ts
+/**
+ * The Zintl Vite plugin.
+ *
+ * Add it once, and Zintl takes over internationalization from there: it
+ * extracts the strings reachable from every `zintl()` anchor, writes a catalog
+ * per locale into {@link Options.outputDir | `outputDir`}, splits those catalogs
+ * along your bundler's own code-splitting boundaries, and rewrites the macros
+ * into a runtime with no message parser shipped to the client.
+ *
+ * Returns two Vite plugins — a `pre` pass that localizes HTML entries before
+ * anything else touches them, and the main `zintl` plugin. Pass the array
+ * straight to `plugins`; Vite flattens it.
+ *
+ * Catalogs are written for you but owned by you: edit them, commit them, hand
+ * them to translators. Renamed and lightly edited source strings carry their
+ * translations forward instead of resetting (see
+ * {@link Options.similarityThreshold | `similarityThreshold`}).
+ *
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import { defineConfig } from "vite";
+ * import zintl from "zintljs/vite";
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     zintl({
+ *       sourceLocale: "en",
+ *       locales: ["en", "ar", "fr"],
+ *       outputDir: "./src/locales",
+ *     }),
+ *   ],
+ * });
+ * ```
+ *
+ * @see {@link Options} for every option and its default.
+ */
+declare const vite: (options: Options) => import("vite").Plugin<any>[];
+//#endregion
+export { type AssetMergeStrategy, type AssetTargetConfig, type CatalogFormatContext, type FacetsInput, type LogLevel, type Options, type Options as ZintlOptions, vite as default, vite as "module.exports" };