@unbound-app/cli 0.9.0 → 1.1.0

package/dist/oxlint/plugin.mjs

@@ -0,0 +1,154 @@
+// src/oxlint/property-name.ts
+/**
+* @description Reads the static key of a member access, so `a.b` and `a['b']` both name `b`.
+* @param node The member expression.
+* @returns The key, or undefined when it is computed from a non-string expression.
+*/
+function propertyName(node) {
+	const { property } = node;
+	if (!node.computed && property.type === "Identifier") return property.name;
+	return property.type === "Literal" && typeof property.value === "string" ? property.value : void 0;
+}
+// src/oxlint/platform-check-only-in-platform-file.ts
+const PLATFORM_FILE = /(^|\/)platform\.[cm]?[jt]sx?$/;
+const PLATFORM_KEY_BY_OBJECT = /* @__PURE__ */ new Map([["Platform", "OS"], ["context", "platform"]]);
+const platformCheckOnlyInPlatformFile = {
+	meta: {
+		type: "suggestion",
+		messages: { check: "`{{read}}` checks the platform outside `platform.ts`. Select the platform handler once in `platform.ts` with `definePlatform` and keep platform code in `ios/` and `android/`." }
+	},
+	create(context) {
+		if (PLATFORM_FILE.test(context.filename)) return {};
+		return { MemberExpression(node) {
+			if (node.object.type !== "Identifier") return;
+			const key = PLATFORM_KEY_BY_OBJECT.get(node.object.name);
+			if (!key || propertyName(node) !== key) return;
+			context.report({
+				node,
+				messageId: "check",
+				data: { read: `${node.object.name}.${key}` }
+			});
+		} };
+	}
+};
+// src/oxlint/no-module-scope-lookup.ts
+const LOOKUPS_BY_NAMESPACE = /* @__PURE__ */ new Map([["metro", /* @__PURE__ */ new Set([
+	"find",
+	"findByProps",
+	"findByName",
+	"findByFilePath",
+	"findByPrototypes",
+	"findStore"
+])], ["flux", /* @__PURE__ */ new Set(["getStore"])]]);
+const SUBPATH_NAMESPACES = /* @__PURE__ */ new Map([["@unbound-app/api/metro", "metro"], ["@unbound-app/api/flux", "flux"]]);
+const FUNCTIONS = /* @__PURE__ */ new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+function isInFunction(call) {
+	for (let node = call.parent; node.type !== "Program"; node = node.parent) if (FUNCTIONS.has(node.type)) return true;
+	return false;
+}
+function isLookup(namespace, name) {
+	return Boolean(namespace && name && LOOKUPS_BY_NAMESPACE.get(namespace)?.has(name));
+}
+function identifierOrLastKey(node) {
+	if (node.type === "Identifier") return node.name;
+	return node.type === "MemberExpression" ? propertyName(node) : void 0;
+}
+function isLazy(call, lazyByDefault) {
+	const last = call.arguments.at(-1);
+	if (last?.type !== "ObjectExpression") return lazyByDefault;
+	const option = last.properties.find((property) => property.type === "Property" && !property.computed && property.key.type === "Identifier" && property.key.name === "lazy");
+	if (!option || option.type !== "Property") return lazyByDefault;
+	return option.value.type === "Literal" && option.value.value === true;
+}
+const noModuleScopeLookup = {
+	meta: {
+		type: "problem",
+		schema: [{
+			type: "object",
+			properties: { lazyByDefault: { type: "boolean" } },
+			additionalProperties: false
+		}],
+		messages: { eager: "`{{call}}` searches every Discord module while the addon loads. Pass `{ lazy: true }` or move the lookup into the function that uses it." }
+	},
+	create(context) {
+		const [options] = context.options;
+		const lazyByDefault = options?.lazyByDefault ?? false;
+		const importedLookups = /* @__PURE__ */ new Map();
+		return {
+			Program(program) {
+				for (const statement of program.body) {
+					if (statement.type !== "ImportDeclaration") continue;
+					const namespace = SUBPATH_NAMESPACES.get(statement.source.value);
+					for (const specifier of statement.specifiers) {
+						if (specifier.type !== "ImportSpecifier") continue;
+						const { imported: source } = specifier;
+						const name = source.type === "Identifier" ? source.name : source.value;
+						if (isLookup(namespace, name)) importedLookups.set(specifier.local.name, name);
+					}
+				}
+			},
+			CallExpression(node) {
+				const { callee } = node;
+				let call;
+				if (callee.type === "Identifier" && importedLookups.has(callee.name)) call = callee.name;
+				else if (callee.type === "MemberExpression") {
+					const namespace = identifierOrLastKey(callee.object);
+					const name = propertyName(callee);
+					if (isLookup(namespace, name)) call = `${namespace}.${name}`;
+				}
+				if (!call || isLazy(node, lazyByDefault) || isInFunction(node)) return;
+				context.report({
+					node,
+					messageId: "eager",
+					data: { call }
+				});
+			}
+		};
+	}
+};
+// src/oxlint/no-window-unbound.ts
+const GLOBAL_OBJECTS = /* @__PURE__ */ new Set(["window", "globalThis"]);
+const STRING_GLOBAL_PATH = /^(window|globalThis)\.unbound(\.|$)/;
+// src/oxlint/plugin.ts
+const addonRules = {
+	meta: { name: "unbound" },
+	rules: {
+		"platform-check-only-in-platform-file": platformCheckOnlyInPlatformFile,
+		"no-module-scope-lookup": noModuleScopeLookup,
+		"no-window-unbound": {
+			meta: {
+				type: "problem",
+				messages: { global: "`window.unbound` is the unscoped API: patches, timers and listeners made through it outlive the plugin. Import from `@unbound-app/api` or use the scoped `unbound` global (ADR-0002)." }
+			},
+			create(context) {
+				return {
+					MemberExpression(node) {
+						if (node.object.type !== "Identifier" || !GLOBAL_OBJECTS.has(node.object.name)) return;
+						if (propertyName(node) === "unbound") context.report({
+							node,
+							messageId: "global"
+						});
+					},
+					Literal(node) {
+						if (typeof node.value === "string" && STRING_GLOBAL_PATH.test(node.value)) context.report({
+							node,
+							messageId: "global"
+						});
+					},
+					TemplateLiteral(node) {
+						const [head] = node.quasis;
+						if (head && STRING_GLOBAL_PATH.test(head.value.cooked ?? head.value.raw)) context.report({
+							node,
+							messageId: "global"
+						});
+					}
+				};
+			}
+		}
+	}
+};
+export { addonRules as default };

package/dist/rollup/index.d.mts

@@ -0,0 +1,418 @@
+import { StaticDecode, Type } from "typebox";
+import { ESTree } from "rolldown/utils";
+import MagicString from "magic-string";
+import { EmittedAsset, Plugin, PluginContext, RollupOptions } from "rollup";
+/** One locale's messages, keyed by message key. */
+type LocaleTable = Record<string, string>;
+/** A translation as the build emits it: its minified JSON and that text's SHA-256. */
+type EmittedLocale = {
+  text: string;
+  digest: string;
+};
+/** A plugin's `i18n/` folder, validated against its en-US file. */
+type LocaleFolder = {
+  source: LocaleTable;
+  translations: Map<string, EmittedLocale>;
+  warnings: LocaleWarning[];
+};
+/** A translation problem the build keeps going past: the file, the key, and what is wrong. */
+type LocaleWarning = {
+  file: string;
+  path: string;
+  message: string;
+  fix?: string;
+};
+/** The bare specifier a plugin imports its own messages from; the build resolves it to a generated module. */
+export declare const LOCALE_MODULE = "@unbound-app/i18n";
+/**
+ * Where `ubd build` and `ubd dev` write the ambient typings of {@link LOCALE_MODULE}, relative to the plugin.
+ * It sits in `src/`, which every plugin tsconfig includes, so the editor finds it with no setup.
+ */
+export declare const LOCALE_TYPINGS = "src/unbound-i18n.d.ts";
+/**
+ * @description Reads and validates a plugin's `i18n/` folder: every file must be a JSON object of strings in
+ * valid ICU syntax, and en-US.json is required. Keys en-US lacks, and placeholders it disagrees on, are warnings.
+ * @param pluginRoot The plugin's directory.
+ * @returns The folder, or `undefined` when the plugin has none; throws naming the file that is invalid.
+ */
+export declare function readLocaleFolder(pluginRoot: string): LocaleFolder | undefined;
+/**
+ * @description Rewrites `src/unbound-i18n.d.ts` from the plugin's en-US file, leaving the file alone when it is current.
+ * @param pluginRoot The plugin's directory.
+ * @returns Whether the file changed; `false` when the plugin has no en-US file. Throws when en-US is invalid.
+ */
+export declare function writeLocaleTypings(pluginRoot: string): boolean;
+/**
+ * @description Resolves {@link LOCALE_MODULE} to one generated module for the plugin being built, and refuses
+ * an import of the `i18n/` folder or its files by path: a JSON file would put that language in the bundle.
+ * @param pluginRoot The plugin's directory.
+ * @returns The rollup plugin.
+ */
+export declare function localeModule(pluginRoot: string): Plugin;
+/**
+ * @description Validates the plugin's `i18n/` folder, writes the typings of {@link LOCALE_MODULE}, emits each
+ * locale but en-US beside the bundle as `i18n/<code>.json`, and lists their SHA-256 under `locales` in the dist manifest.
+ * @param pluginRoot The plugin's directory.
+ * @returns The rollup plugin.
+ */
+export declare function locales(pluginRoot: string): Plugin;
+type Severity = 'error' | 'warning';
+/** One problem a check found, at a place in one of the addon's files. */
+type Diagnostic = {
+  /** The file, relative to the addon's directory, with `/` separators. */
+  file: string;
+  /** 1-based; 0 when the problem belongs to the whole file. */
+  line: number;
+  /** 1-based; 0 when the problem belongs to the whole file. */
+  column: number;
+  /** Where in the file's data the problem sits, such as a settings key or a manifest field. */
+  path?: string;
+  severity: Severity;
+  message: string;
+  fix?: string;
+  /** The check that found it; the runner fills in the check's id when a check leaves it out. */
+  check?: string;
+};
+/** Where and how bad a diagnostic is, for building one without spelling out every field. */
+type DiagnosticInit = Omit<Diagnostic, 'line' | 'column'> & {
+  line?: number;
+  column?: number;
+};
+/**
+ * @description Builds a diagnostic, placing it on the whole file when it has no line.
+ * @param init The diagnostic's fields.
+ * @returns The diagnostic.
+ */
+export declare function diagnostic({ line, column, ...rest }: DiagnosticInit): Diagnostic;
+/**
+ * @description Formats a diagnostic as `file:L:C  <path>  <problem>.  Fix: <fix>.`, the line every
+ * check, `ubd build` and `ubd check` print.
+ * @param diagnostic The diagnostic.
+ * @param file The file as the reader should see it; defaults to the diagnostic's own.
+ * @returns The line.
+ */
+export declare function formatDiagnostic(diagnostic: Diagnostic, file?: string): string;
+/**
+ * @description Reports a diagnostic from a rollup plugin hook: an error stops the build, a warning
+ * does not. Rollup prints the formatted line, and `ubd check` reads the diagnostic back from the
+ * log's `meta`, so both show the same problem the same way.
+ * @param context The hook's `this`.
+ * @param found The diagnostic, with its file relative to the plugin's directory.
+ */
+export declare function reportDiagnostic(context: Pick<PluginContext, 'warn' | 'error'>, found: Diagnostic): void;
+/** The image types a plugin ships: the formats React Native's `Image` decodes. An SVG is a component, not an asset. */
+declare const ASSET_TYPES: readonly ['png', 'jpg', 'webp', 'gif'];
+/** One of {@link ASSET_TYPES}. */
+type AssetType = (typeof ASSET_TYPES)[number];
+/** The scales an image ships at, as its `@2x` and `@3x` suffixes name them. */
+type AssetScale = '1' | '2' | '3';
+/** One image: its asset name, type, and its file at each scale found beside it. */
+type AssetGroup = {
+  name: string;
+  type: AssetType;
+  files: Map<AssetScale, string>;
+};
+/** The images one build's modules imported, shared by the main build and its lazy modules' builds. */
+type AssetCollector = {
+  imported: Map<string, AssetGroup>;
+};
+/**
+ * @description Creates the record of imported images that {@link assetImports} fills and {@link assets} ships.
+ * @returns An empty collector.
+ */
+export declare function createAssetCollector(): AssetCollector;
+/**
+ * @description Reads an image file and its scale siblings (`star.png`, `star@2x.png`, `star@3x.png`) as one asset.
+ * The name is the path without extension or scale, relative to `assets/` inside it and to the plugin root outside it.
+ * @param pluginRoot The plugin's directory.
+ * @param path Any of the image's files.
+ * @returns The asset; throws when the file is not a supported image or its name is not path-safe.
+ */
+export declare function readAssetGroup(pluginRoot: string, path: string): AssetGroup;
+/**
+ * @description Reads every image in a plugin's `assets/` folder, one group per name.
+ * @param pluginRoot The plugin's directory.
+ * @returns The assets by name; throws naming a file that is not a supported image, or two images sharing a name.
+ */
+export declare function readAssetFolder(pluginRoot: string): Map<string, AssetGroup>;
+/**
+ * @description Resolves a relative or `~/` import of an image to a module whose default export is the image's
+ * registered asset id, and records the image so {@link assets} ships it. An unsupported image type fails the build.
+ * @param pluginRoot The plugin's directory.
+ * @param collector Where imported images are recorded.
+ * @returns The rollup plugin.
+ */
+export declare function assetImports(pluginRoot: string, collector: AssetCollector): Plugin;
+/**
+ * @description Ships a plugin's images: every imported one, and each image in `assets/` whose name the bundle
+ * spells out as a whole string, as `assets.getIdByName('<name>')` does. Each file is emitted once beside the bundle as
+ * `assets/<sha256>.<type>`, and `assets` in the dist manifest lists each image's size and files.
+ * @param pluginRoot The plugin's directory.
+ * @param collector The images the build's modules imported.
+ * @returns The rollup plugin.
+ */
+export declare function assets(pluginRoot: string, collector: AssetCollector): Plugin;
+type BytecodeOptions = {
+  versions: number[];
+  sourceName: string;
+};
+/**
+ * @description Wraps a plugin bundle the way the client evaluates its source, so the compiled program's completion value is the same factory.
+ * @param code The plugin's final bundle expression.
+ * @returns The wrapped source.
+ */
+export declare function bytecodeSource(code: string): string;
+/**
+ * @description Names the compiled bundle beside a source bundle, matching the loader's lookup.
+ * @param fileName The source bundle's file name, such as `index.js`.
+ * @param version The Hermes bytecode version.
+ * @returns The bytecode file name, such as `index.98.hbc`.
+ */
+export declare function bytecodeFileName(fileName: string, version: number): string;
+/**
+ * @description Counts how many of hermesc's newest versions to resolve so every wanted version is among them.
+ * @param latest hermesc's versions, newest first.
+ * @param wanted The bytecode versions to compile for.
+ * @returns The number of newest versions to resolve.
+ */
+export declare function hermescCount(latest: number[], wanted: number[]): number;
+/**
+ * @description Compiles each plugin bundle to Hermes bytecode for exactly the bytecode versions the client ships.
+ * @param options The bytecode versions to compile for, and the name the bytecode's source locations use.
+ * @returns The rollup plugin.
+ */
+export declare function hermesBytecode({ versions, sourceName }: BytecodeOptions): Plugin;
+declare const reportSectionSchema: Type.TUnion<[Type.TLiteral<"inlined">, Type.TLiteral<"shipped">, Type.TLiteral<"metro">]>;
+/** What one feature plugin adds to the build report. Entries with the same section and label merge into one line. */
+declare const reportEntrySchema: Type.TObject<{
+  section: Type.TUnion<[Type.TLiteral<"inlined">, Type.TLiteral<"shipped">, Type.TLiteral<"metro">]>;
+  label: Type.TString;
+  /** Show how many entries merged, as `(3 <unit>s)`, or `(3)` for `''`. */
+  unit: Type.TOptional<Type.TString>;
+  /** Bytes this entry adds; merged entries sum them. */
+  bytes: Type.TOptional<Type.TInteger>;
+  /** Counts this entry under a kind, such as `keyed` or `uncached`. */
+  tally: Type.TOptional<Type.TString>;
+  /** Where the entry comes from, such as `src/index.tsx:12`. */
+  location: Type.TOptional<Type.TString>;
+  /** Names this entry in the `ubd dev` summary, such as `uncached filter`. */
+  issue: Type.TOptional<Type.TString>;
+}>;
+declare const budgetNameSchema: Type.TUnion<[Type.TLiteral<"bundle">, Type.TLiteral<"assets">]>;
+/** What `ubd build` reports for one plugin, written by the preset's `build-report` plugin. */
+declare const buildReportSchema: Type.TObject<{
+  name: Type.TString;
+  version: Type.TString;
+  bundle: Type.TObject<{
+    file: Type.TString;
+    bytes: Type.TInteger;
+    gzip: Type.TInteger;
+    bytecode: Type.TArray<Type.TObject<{
+      version: Type.TInteger;
+      bytes: Type.TInteger;
+    }>>;
+  }>;
+  inlined: Type.TArray<Type.TObject<{
+    label: Type.TString;
+    /** When set, the line shows how many contributions it merged, as `(3 <unit>s)`, or `(3)` for `''`. */
+    unit: Type.TOptional<Type.TString>;
+    items: Type.TInteger;
+    bytes: Type.TInteger;
+    /** Contributions counted by kind, such as `{ keyed: 9, uncached: 1 }`. */
+    tallies: Type.TRecord<"^.*$", Type.TInteger>;
+    /** Where each located contribution came from, such as `src/index.tsx:12`. */
+    locations: Type.TArray<Type.TString>;
+    /** Contributions `ubd dev` names in its one-line summary, counted by noun, such as `uncached filter`. */
+    issues: Type.TRecord<"^.*$", Type.TInteger>;
+  }>>;
+  shipped: Type.TArray<Type.TObject<{
+    label: Type.TString;
+    /** When set, the line shows how many contributions it merged, as `(3 <unit>s)`, or `(3)` for `''`. */
+    unit: Type.TOptional<Type.TString>;
+    items: Type.TInteger;
+    bytes: Type.TInteger;
+    /** Contributions counted by kind, such as `{ keyed: 9, uncached: 1 }`. */
+    tallies: Type.TRecord<"^.*$", Type.TInteger>;
+    /** Where each located contribution came from, such as `src/index.tsx:12`. */
+    locations: Type.TArray<Type.TString>;
+    /** Contributions `ubd dev` names in its one-line summary, counted by noun, such as `uncached filter`. */
+    issues: Type.TRecord<"^.*$", Type.TInteger>;
+  }>>;
+  metro: Type.TArray<Type.TObject<{
+    label: Type.TString;
+    /** When set, the line shows how many contributions it merged, as `(3 <unit>s)`, or `(3)` for `''`. */
+    unit: Type.TOptional<Type.TString>;
+    items: Type.TInteger;
+    bytes: Type.TInteger;
+    /** Contributions counted by kind, such as `{ keyed: 9, uncached: 1 }`. */
+    tallies: Type.TRecord<"^.*$", Type.TInteger>;
+    /** Where each located contribution came from, such as `src/index.tsx:12`. */
+    locations: Type.TArray<Type.TString>;
+    /** Contributions `ubd dev` names in its one-line summary, counted by noun, such as `uncached filter`. */
+    issues: Type.TRecord<"^.*$", Type.TInteger>;
+  }>>;
+  /** The largest source modules by rendered size, before minification. */
+  modules: Type.TArray<Type.TObject<{
+    id: Type.TString;
+    bytes: Type.TInteger;
+  }>>;
+  /** Each budget's limit in bytes. */
+  budgets: Type.TObject<{
+    bundle: Type.TInteger;
+    assets: Type.TInteger;
+  }>;
+  warnings: Type.TArray<Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"budget">;
+    budget: Type.TUnion<[Type.TLiteral<"bundle">, Type.TLiteral<"assets">]>;
+    bytes: Type.TInteger;
+    limit: Type.TInteger;
+  }>, Type.TObject<{
+    kind: Type.TLiteral<"shim">;
+    library: Type.TString;
+    modules: Type.TArray<Type.TString>;
+  }>]>>;
+}>;
+type ReportSection = StaticDecode<typeof reportSectionSchema>;
+type ReportEntry = StaticDecode<typeof reportEntrySchema>;
+type BudgetName = StaticDecode<typeof budgetNameSchema>;
+type BuildReport = StaticDecode<typeof buildReportSchema>;
+/**
+ * @description Wraps a report entry as an asset to pass to `this.emitFile`, from any hook up to `generateBundle`.
+ * @param entry The line to add.
+ * @returns The asset carrying the entry.
+ * @example this.emitFile(reportLine({ section: 'inlined', label: 'svg', unit: '', bytes: xml.length }));
+ */
+export declare function reportLine(entry: ReportEntry): EmittedAsset;
+/** A size in bytes, or a string such as `50kb`, `1.5mb` or `800b`. Units are binary: 1 KB is 1024 bytes. */
+type ByteSize = number | `${number}${'b' | 'kb' | 'mb'}`;
+/**
+ * @description Reads a budget size such as `50kb` as bytes.
+ * @param size The size, in bytes or with a `b`, `kb` or `mb` unit.
+ * @returns The size in bytes.
+ */
+export declare function parseByteSize(size: ByteSize): number;
+type BudgetOptions = Partial<Record<BudgetName, ByteSize>>;
+type BuildReportOptions = {
+  pluginRoot: string;
+  budget?: BudgetOptions;
+  /** Where to write the report as JSON; `ubd` sets it through {@link BUILD_REPORT_ENV}. Nothing is written without it. */
+  reportFile?: string;
+};
+export declare const DEFAULT_BUDGET: {
+  bundle: "50kb";
+  assets: "500kb";
+};
+/**
+ * @description Collects the entries feature plugins add with `reportLine`, keeps them out of `dist`, and writes the build report after the bundle is written.
+ * @param options The plugin's directory, its budgets, and where to write the report.
+ * @returns The rollup plugin. Its `generateBundle` runs last, so it sees the bytecode and every emitted file.
+ */
+export declare function buildReport({ pluginRoot, budget, reportFile }: BuildReportOptions): Plugin;
+type Globals = (id: string) => string;
+/**
+ * @description Maps an import the client provides at runtime to the global a plugin bundle reads instead.
+ * @param id The import specifier, such as `@unbound-app/api/metro/components`.
+ * @returns The global expression, such as `unbound.metro.components`, or an empty string to bundle the import.
+ */
+export declare function unboundGlobals(id: string): string;
+/**
+ * @description Builds rollup's `external` option from a globals function.
+ * @param globals Maps an import to its runtime global.
+ * @returns A predicate that is true for every import the client provides at runtime.
+ */
+export declare function externalFor(globals: Globals): (id: string) => boolean;
+type PluginConfigOptions = {
+  lazyModules?: string[];
+  bytecode?: boolean;
+  budget?: BudgetOptions;
+};
+/**
+ * @description Builds a plugin's rollup config with the given runtime globals.
+ * @param pluginUrl The `import.meta.url` of the plugin's `rollup.config.mjs`.
+ * @param globals Maps each import the client provides at runtime to its global.
+ * @param options List `lazyModules` to run only on first use, set `bytecode: false` to skip Hermes bytecode, and `budget` to change the build report's size limits.
+ * @returns The rollup config.
+ */
+export declare function pluginConfig(pluginUrl: string, globals: Globals, options?: PluginConfigOptions): RollupOptions;
+/**
+ * @description The Unbound plugin preset: bundles `src/index`, reads `unbound`, `React` and the other shared libraries from the bare globals, and emits the manifest and the Hermes expression entrypoint.
+ * @param pluginUrl The `import.meta.url` of the plugin's `rollup.config.mjs`.
+ * @param options List `lazyModules` to run only on first use, set `bytecode: false` to skip Hermes bytecode, and `budget` to change the build report's size limits.
+ * @returns The rollup config.
+ */
+export declare function unbound(pluginUrl: string, options?: PluginConfigOptions): RollupOptions;
+/** A component or hook that reads the plugin's strings, and the line it starts on. */
+type LocaleReader = {
+  name: string;
+  start: number;
+};
+/** What {@link injectLocaleHooks} did to one module. */
+type LocaleHookResult = {
+  /** The source with `useMessages()` added, or `undefined` when nothing changed. */
+  output: MagicString | undefined;
+  injected: LocaleReader[];
+  /** Class components that read strings; they cannot call hooks. */
+  classReaders: LocaleReader[];
+};
+/**
+ * @description Adds `useMessages()` at the top of each component and hook that reads `messages` or `format` from
+ * {@link LOCALE_MODULE}, directly, in a nested callback or through a same-file helper, unless it already calls it.
+ * @param code The module's source.
+ * @param program The module's program, as `rolldown/utils` parses it.
+ * @returns The edited source, the components and hooks that got the call, and the class components that read strings.
+ */
+export declare function injectLocaleHooks(code: string, program: ESTree.Program): LocaleHookResult;
+/**
+ * @description Adds `useMessages()` to every plugin component and hook that reads its strings, so each re-renders on
+ * a locale change. Runs before swc, so React Refresh signatures include the added hook. Warns on class components
+ * that read strings, and logs each addition when `UNBOUND_VERBOSE=1`.
+ * @param pluginRoot The plugin's directory; only its own sources are transformed.
+ * @returns The rollup plugin.
+ */
+export declare function localeHooks(pluginRoot: string): Plugin;
+type LazyModuleBuild = {
+  plugins: () => Plugin[];
+  external: (id: string) => boolean;
+  globals: Globals;
+};
+/**
+ * @description Generates a module whose exports load the wrapped bundle the first time one is used.
+ * @param code The wrapped module, built as an IIFE assigned to `__unboundLazyModule`.
+ * @param exportNames The wrapped module's export names.
+ * @returns The generated module's source.
+ */
+export declare function lazyModuleSource(code: string, exportNames: string[]): string;
+/**
+ * @description Builds the listed modules apart and evaluates each only when the plugin first uses one of its exports.
+ * @param specifiers Import specifiers to defer, such as `highlight.js/lib/common`.
+ * @param build How to build each deferred module.
+ * @returns The rollup plugin.
+ */
+export declare function lazyModules(specifiers: string[], build: LazyModuleBuild): Plugin;
+/**
+ * @description Rewrites each chunk into the object expression the client evaluates: `__load()` runs the plugin's
+ * module once and returns its named exports, which the client reads as `start`, `stop` and `SettingsPanel`.
+ * @returns The rollup plugin.
+ */
+export declare function hermesExpressionEntrypoint(): Plugin;
+/**
+ * @description Resolves a module path the way a bundler would, trying source extensions and then index files.
+ * @param candidate An absolute path, with or without its extension.
+ * @returns The file it resolves to, or `null` when none exists.
+ */
+export declare function findFile(candidate: string): string | null;
+/**
+ * @description Resolves `~/` imports to a plugin's `src` directory, mirroring the `paths` in its tsconfig.
+ * @param sourceRoot Absolute path of the plugin's `src` directory.
+ * @returns The rollup plugin.
+ */
+export declare function sourceAlias(sourceRoot: string): Plugin;
+/**
+ * @description Gives every filter a plugin passes to a metro search a cache key derived from its source, so equal filters in any plugin share one persisted cache entry.
+ * A predicate equal to built-in filters becomes those built-ins; one that reads an outside variable fails the build.
+ * Runs on the bundled chunk, where an imported or aliased predicate resolves to its definition, before minify renames anything.
+ * @param pluginRoot The plugin's directory, which diagnostics name files relative to.
+ * @returns The rollup plugin.
+ */
+export declare function filterKeys(pluginRoot: string): Plugin;
+export type { BudgetOptions, BuildReport, ByteSize, Diagnostic, Globals, PluginConfigOptions, ReportEntry, ReportSection, Severity };