@auspex-ai/react 0.0.0-stage → 1.4.1

package/dist/vite.mjs

@@ -0,0 +1,1843 @@
+import path from "node:path";
+import { createHmac, randomBytes } from "node:crypto";
+import { promises } from "node:fs";
+import { parse } from "@babel/parser";
+import { MagicString } from "magic-string";
+//#region ../build-names/src/element-ref.ts
+const ALPHABET = "abcdefghijklmnopqrstuvwxyz234567";
+const REF_LENGTH = 12;
+/** RFC 4648 の base32 を小文字・パディング無しにしたもの */
+function base32(bytes) {
+	let out = "";
+	let bits = 0;
+	let acc = 0;
+	for (const b of bytes) {
+		acc = acc << 8 | b;
+		bits += 8;
+		while (bits >= 5) {
+			out += ALPHABET[acc >>> bits - 5 & 31];
+			bits -= 5;
+		}
+		acc &= (1 << bits) - 1;
+	}
+	if (bits > 0) out += ALPHABET[acc << 5 - bits & 31];
+	return out;
+}
+/** 名前の参照(`^[a-z2-7]{12}$`)。ビルド鍵は UTF-8 のバイト列として HMAC の鍵にする */
+function nameRef(key, name, kind) {
+	return base32(createHmac("sha256", Buffer.from(key, "utf8")).update(`${kind}:${name}`).digest()).slice(0, REF_LENGTH);
+}
+//#endregion
+//#region ../build-names/src/host.ts
+function isValidHost(host) {
+	let u;
+	try {
+		u = new URL(host);
+	} catch {
+		return false;
+	}
+	if (u.username || u.password) return false;
+	if (u.protocol === "https:") return true;
+	return u.protocol === "http:" && (u.hostname === "localhost" || u.hostname === "127.0.0.1");
+}
+/** セルフホスト版で /api/names を受ける internal の面の URL。あれば通常の host より優先する(ビルド時だけ読む) */
+const INTERNAL_HOST_ENV = "AUSPEX_INTERNAL_HOST";
+/**
+* 名前の登録の送り先。環境変数 AUSPEX_INTERNAL_HOST が空でなければそれ(不正な値でも通常の host に
+* 落とさない。落とすと 404 になる面へビルド鍵を送るため、呼び出し側の isValidHost で弾く)。無ければ通常の host
+*/
+function registrationHost(host, internal = process.env[INTERNAL_HOST_ENV]) {
+	return internal?.trim() ? internal.trim() : host;
+}
+//#endregion
+//#region ../build-names/src/iap-token.ts
+const IAP_SERVICE_ACCOUNT_ENV = "AUSPEX_IAP_SERVICE_ACCOUNT";
+const TOKEN_LIFETIME_SECONDS = 3600;
+/** IAP が検証する aud。host の origin 全体(`<origin>/*`) */
+function iapAudience(host) {
+	return `${new URL(host).origin}/*`;
+}
+function iapPayload(serviceAccount, host, nowMs = Date.now()) {
+	const iat = Math.floor(nowMs / 1e3);
+	return JSON.stringify({
+		iss: serviceAccount,
+		sub: serviceAccount,
+		aud: iapAudience(host),
+		iat,
+		exp: iat + TOKEN_LIFETIME_SECONDS
+	});
+}
+/** 既定の署名: google-auth-library(任意の依存)で ADC を読み、IAM Credentials の signJwt を呼ぶ */
+const signJwtWithAdc = async (serviceAccount, payload) => {
+	let lib;
+	try {
+		lib = await import("google-auth-library");
+	} catch {
+		throw new Error(`${IAP_SERVICE_ACCOUNT_ENV} が設定されているが google-auth-library が入っていない。ビルドの環境に google-auth-library を入れる(例: pnpm add -D google-auth-library)`);
+	}
+	const res = await new lib.GoogleAuth({ scopes: ["https://www.googleapis.com/auth/cloud-platform"] }).request({
+		url: `https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/${encodeURIComponent(serviceAccount)}:signJwt`,
+		method: "POST",
+		data: { payload },
+		timeout: 2e4
+	});
+	if (!res.data.signedJwt) throw new Error("signJwt の応答に signedJwt が無い");
+	return res.data.signedJwt;
+};
+/** `Proxy-Authorization` の値(`Bearer <JWT>`)。失敗は投げる(呼び出し側が警告にする) */
+async function iapProxyAuthorization(host, serviceAccount, sign = signJwtWithAdc) {
+	return `Bearer ${await sign(serviceAccount, iapPayload(serviceAccount, host))}`;
+}
+//#endregion
+//#region ../build-names/src/log.ts
+const WARNED = Symbol.for("auspex.warned");
+const PREFIX = "[auspex]";
+const consoleLogger = {
+	info: (m) => console.log(`${PREFIX} ${m}`),
+	warn: (m) => console.warn(`${PREFIX} ${m}`)
+};
+/** `id` の警告を、このプロセスでまだ出していなければ出す(出したら true) */
+function warnOnce(id, message, logger = consoleLogger) {
+	const g = globalThis;
+	const seen = g[WARNED] ?? /* @__PURE__ */ new Set();
+	g[WARNED] = seen;
+	if (seen.has(id)) return false;
+	seen.add(id);
+	logger.warn(message);
+	return true;
+}
+//#endregion
+//#region ../build-names/src/icon-name/transform.ts
+/** 書く属性。@auspex-ai/core の ICON_REF_ATTR(読む側)と同じ値(test/ で一致を確かめる) */
+const ICON_REF_ATTR = "data-auspex-icon-ref";
+/** #12 の旧属性(平文の名前)。今は書かず、手書きのものを消すだけ */
+const LEGACY_ICON_ATTR = "data-auspex-icon";
+const ATTR = ICON_REF_ATTR;
+/** 自分の名前を使わない汎用名(名前は呼び出し側の props か、外から渡された値で決まる) */
+const GENERIC = /^(Icon|Icons|IconBase|BaseIcon|Svg|SvgIcon|IconWrapper|Glyph|StyledSvg)$/;
+/** アイコンらしい名前(呼び出し側の名前 props を拾う対象、根に返すと自分の名前を渡す対象) */
+const ICONISH = /Icon|Svg|Glyph/;
+/** 名前を表す props。type は汎用名の要素だけ(<Button type="submit"> 等を拾わないため) */
+const NAME_PROPS = [
+	"name",
+	"icon",
+	"iconName",
+	"glyph"
+];
+const NAME_PROPS_GENERIC = [...NAME_PROPS, "type"];
+const SKIP_KEYS$2 = /* @__PURE__ */ new Set([
+	"loc",
+	"start",
+	"end",
+	"extra",
+	"range",
+	"leadingComments",
+	"trailingComments",
+	"innerComments"
+]);
+/** AST を深さ優先でたどる。stopAtFunctions なら入れ子の関数の中には入らない */
+function walk(node, visit, stopAtFunctions = false, root = true) {
+	visit(node);
+	if (stopAtFunctions && !root && /Function|ClassMethod/.test(node.type)) return;
+	for (const key of Object.keys(node)) {
+		if (SKIP_KEYS$2.has(key)) continue;
+		const v = node[key];
+		if (Array.isArray(v)) {
+			for (const c of v) if (c && typeof c.type === "string") walk(c, visit, stopAtFunctions, false);
+		} else if (v && typeof v.type === "string") walk(v, visit, stopAtFunctions, false);
+	}
+}
+function calleeName(c) {
+	if (c.type === "Identifier") return c.name;
+	if (c.type === "MemberExpression" && c.property.type === "Identifier") return c.property.name;
+	return "";
+}
+/** forwardRef(...) / memo(...) / 型注釈の包みを剥がして関数を取り出す */
+function unwrapFn(e) {
+	let n = e;
+	while (n && (n.type === "TSAsExpression" || n.type === "TSSatisfiesExpression" || n.type === "ParenthesizedExpression")) n = n.expression;
+	if (!n) return null;
+	if (n.type === "ArrowFunctionExpression" || n.type === "FunctionExpression") return n;
+	if (n.type === "CallExpression" && ["forwardRef", "memo"].includes(calleeName(n.callee))) {
+		const [arg] = n.arguments;
+		return arg && arg.type !== "SpreadElement" && arg.type !== "ArgumentPlaceholder" ? unwrapFn(arg) : null;
+	}
+	return null;
+}
+function tagName$1(o) {
+	if (o.name.type === "JSXIdentifier") return o.name.name;
+	if (o.name.type === "JSXMemberExpression") return o.name.property.name;
+	return "";
+}
+/** ビルド時に値が決まる文字列: リテラル / 式を含まないテンプレートリテラル / 両辺がそうである条件式 */
+function isStaticString(e) {
+	if (!e) return false;
+	switch (e.type) {
+		case "StringLiteral": return true;
+		case "TemplateLiteral": return e.expressions.length === 0;
+		case "ConditionalExpression": return isStaticString(e.consequent) && isStaticString(e.alternate);
+		case "ParenthesizedExpression": return isStaticString(e.expression);
+		default: return false;
+	}
+}
+/** アイコンらしい要素で、名前を表す props が静的な文字列ならその式を返す */
+function staticNameProp(o) {
+	const tag = tagName$1(o);
+	if (!/^[A-Z]/.test(tag) || !ICONISH.test(tag)) return null;
+	const props = GENERIC.test(tag) ? NAME_PROPS_GENERIC : NAME_PROPS;
+	for (const a of o.attributes) {
+		if (a.type !== "JSXAttribute" || a.name.type !== "JSXIdentifier" || !props.includes(a.name.name) || !a.value) continue;
+		const v = a.value.type === "JSXExpressionContainer" ? a.value.expression : a.value;
+		if (isStaticString(v)) return v;
+	}
+	return null;
+}
+/** 名前を表す props を受け取るコンポーネントは汎用とみなす */
+function takesNameProp(fn) {
+	const [p0] = fn.params;
+	return p0?.type === "ObjectPattern" && p0.properties.some((p) => p.type === "ObjectProperty" && p.key.type === "Identifier" && NAME_PROPS_GENERIC.includes(p.key.name));
+}
+function collectComponents(program, file) {
+	const comps = [];
+	const base = path.basename(file).replace(/\.[^.]+$/, "");
+	walk(program, (n) => {
+		if (n.type === "FunctionDeclaration" && n.id) comps.push({
+			fn: n,
+			name: n.id.name,
+			isClass: false
+		});
+		else if (n.type === "VariableDeclarator" && n.id.type === "Identifier") {
+			const fn = unwrapFn(n.init);
+			if (fn) comps.push({
+				fn,
+				name: n.id.name,
+				isClass: false
+			});
+		} else if (n.type === "ObjectProperty" && !n.computed) {
+			const fn = unwrapFn(n.value);
+			const key = n.key.type === "Identifier" ? n.key.name : n.key.type === "StringLiteral" ? n.key.value : null;
+			if (fn && key) comps.push({
+				fn,
+				name: key,
+				isClass: false
+			});
+		} else if (n.type === "ExportDefaultDeclaration") {
+			const d = n.declaration;
+			const fn = d.type === "FunctionDeclaration" ? d.id ? null : d : unwrapFn(d);
+			if (fn) comps.push({
+				fn,
+				name: base,
+				isClass: false
+			});
+		} else if (n.type === "ClassDeclaration" && n.id) {
+			const render = n.body.body.find((m) => m.type === "ClassMethod" && m.key.type === "Identifier" && m.key.name === "render");
+			if (render) comps.push({
+				fn: render,
+				name: n.id.name,
+				isClass: true
+			});
+		}
+	});
+	return comps;
+}
+/** コンポーネントが返す根の要素(return / 式本体 / 条件式の両辺 / && の右辺 / フラグメントの最初の要素) */
+function rootsOf(fn) {
+	const roots = [];
+	const add = (e) => {
+		let n = e;
+		while (n && (n.type === "ParenthesizedExpression" || n.type === "TSAsExpression")) n = n.expression;
+		if (!n) return;
+		if (n.type === "JSXElement") roots.push({ jsx: n.openingElement });
+		else if (n.type === "ConditionalExpression") {
+			add(n.consequent);
+			add(n.alternate);
+		} else if (n.type === "LogicalExpression") add(n.right);
+		else if (n.type === "JSXFragment") {
+			const first = n.children.find((c) => c.type === "JSXElement");
+			if (first) roots.push({ jsx: first.openingElement });
+		} else if (n.type === "CallExpression" && [
+			"createElement",
+			"jsx",
+			"jsxs",
+			"_jsx",
+			"_jsxs"
+		].includes(calleeName(n.callee)) && n.arguments[0]?.type === "StringLiteral" && n.arguments[0].value === "svg") roots.push({ call: n });
+	};
+	if (fn.body.type !== "BlockStatement") add(fn.body);
+	else walk(fn.body, (n) => n.type === "ReturnStatement" && add(n.argument), true);
+	return roots;
+}
+const startOf$1 = (n) => n.start ?? 0;
+const endOf$1 = (n) => n.end ?? 0;
+/** JS/TS のソースを解析する(解析できなければ null。ビルドはバンドラ側のエラーに任せる) */
+function parseSource(source, file) {
+	const ext = path.extname(file);
+	try {
+		return parse(source, {
+			sourceType: "module",
+			plugins: ext === ".ts" ? ["typescript"] : ext === ".tsx" ? ["typescript", "jsx"] : ["jsx"]
+		}).program;
+	} catch {
+		return null;
+	}
+}
+/** アイコンに関係しうるファイルか(解析する前の絞り込み) */
+function mayHaveIcons(source) {
+	return /svg|Icon|Glyph/.test(source);
+}
+/**
+* アイコン名の参照の書き込みを `s` に積む(要素名の変換と同じ MagicString に積めるよう分けている。手書きの属性の削除は
+* 先に stripHandWritten で積む)。参照を書いた名前を返す
+*/
+function applyIconNames(program, source, file, s, refOf) {
+	const touched = /* @__PURE__ */ new Set();
+	const written = /* @__PURE__ */ new Set();
+	const refLiteral = (name) => {
+		written.add(name);
+		return JSON.stringify(refOf(name));
+	};
+	/** 静的な文字列の式を、各リテラルを参照に置き換えた式にする(名前は written に残る) */
+	const refExpr = (e) => {
+		switch (e.type) {
+			case "StringLiteral": return refLiteral(e.value);
+			case "TemplateLiteral": return refLiteral(e.quasis[0]?.value.cooked ?? "");
+			case "ConditionalExpression": return `${source.slice(startOf$1(e.test), endOf$1(e.test))} ? ${refExpr(e.consequent)} : ${refExpr(e.alternate)}`;
+			case "ParenthesizedExpression": return `(${refExpr(e.expression)})`;
+			default: return "undefined";
+		}
+	};
+	for (const { fn, name, isClass } of collectComponents(program, file)) {
+		const roots = rootsOf(fn);
+		const svgRoots = roots.flatMap((r) => "jsx" in r && tagName$1(r.jsx) === "svg" ? [r.jsx] : []);
+		const callRoots = roots.flatMap((r) => "call" in r ? [r.call] : []);
+		const iconishRoots = roots.flatMap((r) => "jsx" in r && /^[A-Z]/.test(tagName$1(r.jsx)) && ICONISH.test(tagName$1(r.jsx)) ? [r.jsx] : []);
+		if (!svgRoots.length && !callRoots.length && !iconishRoots.length) continue;
+		const generic = GENERIC.test(name) || !isClass && takesNameProp(fn);
+		let passed = null;
+		const [p0] = fn.params;
+		if (isClass) passed = `this.props?.[${JSON.stringify(ATTR)}]`;
+		else if (p0?.type === "ObjectPattern") {
+			s.appendRight(startOf$1(p0) + 1, ` ${JSON.stringify(ATTR)}: __auspexIcon,`);
+			passed = "__auspexIcon";
+		} else if (p0?.type === "Identifier") passed = `${p0.name}?.[${JSON.stringify(ATTR)}]`;
+		let cached;
+		const iconValue = () => {
+			if (cached === void 0) {
+				const own = generic ? "undefined" : refLiteral(name);
+				cached = passed ? `${passed} ?? ${own}` : own;
+			}
+			return cached;
+		};
+		for (const o of svgRoots) {
+			if (touched.has(o)) continue;
+			s.appendLeft(endOf$1(o.name), ` ${ATTR}={${iconValue()}}`);
+			touched.add(o);
+		}
+		for (const call of callRoots) {
+			const props = call.arguments[1];
+			const entry = `${JSON.stringify(ATTR)}: ${iconValue()}`;
+			if (!props) {
+				const tagArg = call.arguments[0];
+				if (tagArg) s.appendLeft(endOf$1(tagArg), `, { ${entry} }`);
+			} else if (props.type === "NullLiteral") s.overwrite(startOf$1(props), endOf$1(props), `{ ${entry} }`);
+			else if (props.type === "ObjectExpression") s.appendRight(startOf$1(props) + 1, ` ${entry},`);
+			else {
+				s.prependLeft(startOf$1(props), "{ ...");
+				s.appendRight(endOf$1(props), `, ${entry} }`);
+			}
+		}
+		for (const o of iconishRoots) {
+			if (touched.has(o) || staticNameProp(o)) continue;
+			if (generic && !passed) continue;
+			s.appendLeft(endOf$1(o.name), ` ${ATTR}={${generic ? passed : iconValue()}}`);
+			touched.add(o);
+		}
+	}
+	walk(program, (n) => {
+		if (n.type !== "JSXOpeningElement" || touched.has(n)) return;
+		const v = staticNameProp(n);
+		if (!v) return;
+		s.appendLeft(endOf$1(n.name), ` ${ATTR}={${refExpr(v)}}`);
+		touched.add(n);
+	});
+	return [...written];
+}
+const MAX_BUILD_ID = 128;
+const MAX_RETRIES = 3;
+/** ディレクトリのプロジェクトからの相対パス(ローダーが this.rootContext に対して解決する)。POSIX の区切りで書く */
+const fragmentsSubdir = (keyId) => `cache/auspex/names/${keyId}`;
+const KIND_ORDER = {
+	element: 0,
+	icon: 1,
+	label: 2
+};
+const defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+* 断片を読んで要素名・アイコン名の集合(それぞれ辞書順)にする。壊れた断片は警告して飛ばす。
+* `icons` の無い段階 1 の断片も読める
+*/
+async function readFragments(dir, logger) {
+	let files;
+	try {
+		files = (await promises.readdir(dir)).filter((f) => f.endsWith(".json"));
+	} catch {
+		return {
+			names: [],
+			icons: [],
+			labels: []
+		};
+	}
+	const names = /* @__PURE__ */ new Set();
+	const icons = /* @__PURE__ */ new Set();
+	const labels = /* @__PURE__ */ new Set();
+	for (const f of files) try {
+		const parsed = JSON.parse(await promises.readFile(path.join(dir, f), "utf8"));
+		if (!Array.isArray(parsed.names)) throw new Error("names が配列ではない");
+		if (parsed.icons !== void 0 && !Array.isArray(parsed.icons)) throw new Error("icons が配列ではない");
+		if (parsed.labels !== void 0 && !Array.isArray(parsed.labels)) throw new Error("labels が配列ではない");
+		for (const n of parsed.names) if (typeof n === "string") names.add(n);
+		for (const n of parsed.icons ?? []) if (typeof n === "string") icons.add(n);
+		for (const n of parsed.labels ?? []) if (typeof n === "string") labels.add(n);
+	} catch (e) {
+		logger.warn(`壊れた断片を飛ばした: ${path.join(dir, f)}(${e.message})`);
+	}
+	return {
+		names: [...names].sort(),
+		icons: [...icons].sort(),
+		labels: [...labels].sort()
+	};
+}
+/** build_id: `<distDir>/BUILD_ID`(か --build-id)。無い・128 文字超は自前の id(1 回の実行で 1 度だけ作る) */
+async function resolveBuildId(distDirAbs, override, logger, readFile = true) {
+	let raw = override;
+	if (raw === void 0 && readFile) try {
+		raw = (await promises.readFile(path.join(distDirAbs, "BUILD_ID"), "utf8")).trim();
+	} catch {}
+	if (raw && raw.length <= MAX_BUILD_ID) return raw;
+	const own = `local-${Date.now()}-${randomBytes(4).toString("hex")}`;
+	logger.info(raw ? `build_id が長すぎる(${raw.length} 文字。上限 ${MAX_BUILD_ID})ので、自前の id を使う: ${own}` : `build_id(${path.join(distDirAbs, "BUILD_ID")})が無いので、自前の id を使う: ${own}`);
+	return own;
+}
+async function post(o, buildId, names, icons, labels) {
+	const url = `${o.host.replace(/\/+$/, "")}/api/names`;
+	let reason = "";
+	for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+		if (attempt > 0) await o.sleep(500 * 2 ** (attempt - 1));
+		try {
+			const res = await o.fetch(url, {
+				method: "POST",
+				headers: {
+					"content-type": "application/json",
+					authorization: `Bearer ${o.key}`,
+					...o.proxyAuthorization ? { "proxy-authorization": o.proxyAuthorization } : {}
+				},
+				body: JSON.stringify({
+					build_id: buildId,
+					names,
+					...icons.length > 0 ? { icons } : {},
+					...labels.length > 0 ? { labels } : {}
+				}),
+				signal: AbortSignal.timeout(2e4),
+				redirect: "error"
+			});
+			if (res.status === 401) return { kind: "unauthorized" };
+			if (res.status >= 500) {
+				reason = `HTTP ${res.status}`;
+				continue;
+			}
+			if (res.status !== 200) return {
+				kind: "rejected",
+				status: res.status
+			};
+			const body = await res.json();
+			if (!Array.isArray(body.results)) return {
+				kind: "rejected",
+				status: res.status
+			};
+			return {
+				kind: "ok",
+				results: body.results
+			};
+		} catch (e) {
+			reason = e.message;
+		}
+	}
+	return {
+		kind: "failed",
+		reason
+	};
+}
+/**
+* 断片の名前を登録する。例外は投げない(ネットワーク・5xx・401・400・413 のどれでもビルドを落とさず警告する)
+*/
+async function registerNames(options) {
+	const logger = options.logger ?? consoleLogger;
+	const summary = {
+		buildId: null,
+		names: 0,
+		icons: 0,
+		labels: 0,
+		registered: 0,
+		already: 0,
+		dropped: [],
+		collisions: [],
+		unregistered: []
+	};
+	try {
+		let names;
+		let icons;
+		let labels;
+		let buildId;
+		if ("names" in options) {
+			names = [...new Set(options.names)].sort();
+			icons = [...new Set(options.icons)].sort();
+			summary.names = names.length;
+			labels = [...new Set(options.labels ?? [])].sort();
+			summary.icons = icons.length;
+			summary.labels = labels.length;
+			if (names.length + icons.length + labels.length === 0) logger.info("登録する名前が無い");
+			buildId = await resolveBuildId("", options.buildId, logger, false);
+		} else {
+			const distDirAbs = path.resolve(options.projectDir ?? process.cwd(), options.distDir);
+			const dir = path.join(distDirAbs, fragmentsSubdir(options.keyId));
+			({names, icons, labels} = await readFragments(dir, logger));
+			summary.names = names.length;
+			summary.icons = icons.length;
+			summary.labels = labels.length;
+			if (names.length + icons.length + labels.length === 0) logger.info(`登録する名前が無い(断片: ${dir})`);
+			buildId = await resolveBuildId(distDirAbs, options.buildId, logger, options.readBuildIdFile ?? true);
+		}
+		summary.buildId = buildId;
+		const iapServiceAccount = options.iapServiceAccount ?? process.env["AUSPEX_IAP_SERVICE_ACCOUNT"];
+		const proxyAuthorization = iapServiceAccount ? await iapProxyAuthorization(options.host, iapServiceAccount, options.iapSigner).catch((e) => {
+			throw new Error(`IAP 用のトークンを作れなかった: ${e.message}`);
+		}) : void 0;
+		const o = {
+			key: options.key,
+			host: options.host,
+			proxyAuthorization,
+			fetch: options.fetch ?? fetch,
+			sleep: options.sleep ?? defaultSleep
+		};
+		const items = (ns, is, ls) => [
+			...ns.map((name) => ({
+				kind: "element",
+				name
+			})),
+			...is.map((name) => ({
+				kind: "icon",
+				name
+			})),
+			...ls.map((name) => ({
+				kind: "label",
+				name
+			}))
+		];
+		const chunks = (list) => {
+			const out = [];
+			for (let i = 0; i < list.length; i += 100) out.push(list.slice(i, i + 100));
+			return out;
+		};
+		const retry = [];
+		const unregistered = /* @__PURE__ */ new Map();
+		const markUnregistered = (item, reason) => {
+			unregistered.set(`${item.kind}\0${item.name}`, {
+				item,
+				reason
+			});
+		};
+		const label = (kind) => kind === "icon" ? "アイコン名" : kind === "label" ? "ラベル" : "名前";
+		const send = async (list, second) => {
+			const all = list.length === 0 ? [[]] : chunks(list);
+			for (const [ci, chunk] of all.entries()) {
+				const out = await post(o, buildId, chunk.filter((i) => i.kind === "element").map((i) => i.name), chunk.filter((i) => i.kind === "icon").map((i) => i.name), chunk.filter((i) => i.kind === "label").map((i) => i.name));
+				if (out.kind === "unauthorized") {
+					logger.warn("ビルド鍵が受け付けられなかった(401)。鍵が違うか、再発行された可能性がある。登録せずに続ける(名前なしのクリックとして入る)");
+					for (const n of all.slice(ci).flat()) markUnregistered(n, "401");
+					return "stop";
+				}
+				if (out.kind === "rejected") {
+					logger.warn(`登録が拒否された(HTTP ${out.status}、${chunk.length} 件のチャンク)。再送しない`);
+					for (const n of chunk) markUnregistered(n, `HTTP ${out.status}`);
+					continue;
+				}
+				if (out.kind === "failed") {
+					logger.warn(`登録を送れなかった(${MAX_RETRIES} 回送り直した。${out.reason})。ビルドは続ける。次のビルドで再登録される`);
+					for (const n of chunk) markUnregistered(n, out.reason);
+					continue;
+				}
+				for (const r of out.results) {
+					const kind = r.kind === "icon" ? "icon" : r.kind === "label" ? "label" : "element";
+					if (r.status === "registered") summary.registered++;
+					else if (r.status === "already") summary.already++;
+					else if (r.status === "collision") {
+						summary.collisions.push({
+							kind,
+							name: r.name,
+							winner: r.winner
+						});
+						logger.warn(`${label(kind)} "${r.name}" は登録済みの "${r.winner}" と同じ参照になった。"${r.name}" の${kind === "icon" ? "アイコン" : kind === "label" ? "ラベル" : "要素"}は "${r.winner}" の名前で記録される`);
+					} else if (r.status === "retry") {
+						if (second) markUnregistered({
+							kind,
+							name: r.name
+						}, "retry");
+						else retry.push({
+							kind,
+							name: r.name
+						});
+					} else {
+						summary.dropped.push({
+							kind,
+							name: r.name,
+							status: r.status
+						});
+						logger.warn(`${label(kind)} "${r.name}" は登録されなかった(${r.status})`);
+					}
+				}
+			}
+			return "go";
+		};
+		if (await send(items(names, icons, labels), false) === "go" && retry.length > 0) await send(retry.sort((a, b) => KIND_ORDER[a.kind] - KIND_ORDER[b.kind] || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0)), true);
+		for (const { item, reason } of unregistered.values()) {
+			summary.unregistered.push(item);
+			if (reason !== "401") logger.warn(`${label(item.kind)} "${item.name}" は未登録(${reason})。次のビルドで再登録される`);
+		}
+		logger.info(`名前の登録: 要素名 ${summary.names} 件・アイコン名 ${summary.icons} 件・ラベル ${summary.labels} 件中 新規 ${summary.registered}・登録済み ${summary.already}・捨てた ${summary.dropped.length}・衝突 ${summary.collisions.length}・未登録 ${summary.unregistered.length}(build_id ${buildId})`);
+	} catch (e) {
+		logger.warn(`名前の登録に失敗した(ビルドは続ける): ${e.message}`);
+	}
+	return summary;
+}
+//#endregion
+//#region ../build-names/src/element-name/label.ts
+/** 式の置き換え */
+const HOLE = "[*]";
+/** 子の中のテキストを文書順に集める(入れ子の要素の子を含む)。式は HOLE にする */
+function collect(children, out) {
+	for (const c of children) switch (c.type) {
+		case "JSXText":
+			out.push(c.value);
+			break;
+		case "JSXElement":
+		case "JSXFragment":
+			collect(c.children ?? [], out);
+			break;
+		case "JSXExpressionContainer":
+			out.push(fromExpression(c.expression));
+			break;
+		case "JSXSpreadChild": out.push(HOLE);
+	}
+}
+/** 式 1 つ分のテキスト。文字列リテラルと式の無いテンプレートリテラルだけが静的な文言 */
+function fromExpression(e) {
+	if (!e || e.type === "JSXEmptyExpression") return "";
+	if (e.type === "StringLiteral") return e.value;
+	if (e.type === "TemplateLiteral") {
+		let s = "";
+		for (const [i, q] of e.quasis.entries()) {
+			s += q.value.cooked ?? q.value.raw;
+			if (i < e.expressions.length) s += HOLE;
+		}
+		return s;
+	}
+	return HOLE;
+}
+function normalize(raw) {
+	return raw.replace(/\s+/g, " ").trim().replace(/\[\*\](?: ?\[\*\])+/g, HOLE).normalize("NFC");
+}
+/** [*]・空白・句読点を除いて何も残らないか */
+function isEmptyText(s) {
+	return s.split(HOLE).join("").replace(/[\s\p{P}]/gu, "") === "";
+}
+/** 静的な文字列リテラルの属性値(式は取らない) */
+function staticAttr(o, name) {
+	for (const a of o.attributes) {
+		if (a.type !== "JSXAttribute" || a.name.type !== "JSXIdentifier" || a.name.name !== name) continue;
+		return a.value?.type === "StringLiteral" ? a.value.value : null;
+	}
+	return null;
+}
+/** クリックされうる JSX 要素のラベル。取れない・使えない(実行時の値だけ・句読点だけ・長すぎる)ときは null */
+function labelOf(el) {
+	const parts = [];
+	collect(el.children ?? [], parts);
+	let text = normalize(parts.join(""));
+	if (isEmptyText(text)) {
+		text = "";
+		for (const attr of ["aria-label", "title"]) {
+			const v = staticAttr(el.openingElement, attr);
+			if (v === null) continue;
+			const n = normalize(v);
+			if (!isEmptyText(n)) {
+				text = n;
+				break;
+			}
+		}
+	}
+	if (text === "" || [...text].length > 80) return null;
+	return text;
+}
+//#endregion
+//#region ../build-names/src/element-name/extract.ts
+const SKIP_KEYS$1 = /* @__PURE__ */ new Set([
+	"loc",
+	"start",
+	"end",
+	"extra",
+	"range",
+	"leadingComments",
+	"trailingComments",
+	"innerComments"
+]);
+function children(n) {
+	const out = [];
+	for (const k of Object.keys(n)) {
+		if (SKIP_KEYS$1.has(k)) continue;
+		const v = n[k];
+		if (Array.isArray(v)) {
+			for (const c of v) if (c && typeof c.type === "string") out.push(c);
+		} else if (v && typeof v.type === "string") out.push(v);
+	}
+	return out;
+}
+const GENERIC_HANDLER = /^((on|handle)(Click|Press|Tap|Change|Select|Submit|PointerDown|MouseDown|TouchStart|KeyDown|DoubleClick|Action)?|callback|cb|fn|handler|action|formAction|onClickHandler|clickHandler)$/;
+const GENERIC_COMPONENT = /^(App|Common|Shared|My|Main|Primary|Secondary|Submit)?(Button|IconButton|Link|NavLink|Anchor|Clickable|Pressable|Item|MenuItem|ListItem|Root|Trigger|Wrapper|Card|Tab|Option|Chip|App|Component|Default|Page|Layout|Home)$|^(Base|Styled|Custom|Ui|UI|Primitive)[A-Z]\w*$|(Page|Layout|Template)$/;
+const GENERIC_MEMBER_PROP = /* @__PURE__ */ new Set([
+	"mutate",
+	"mutateAsync",
+	"trigger",
+	"execute",
+	"run",
+	"call",
+	"open",
+	"close",
+	"toggle",
+	"show",
+	"hide",
+	"reset",
+	"refetch",
+	"submit",
+	"onOpen",
+	"onClose",
+	"onToggle"
+]);
+/** 呼んでも要素の意味にならない呼び出し */
+const NOISE_CALLS = /* @__PURE__ */ new Set([
+	"preventDefault",
+	"stopPropagation",
+	"stopImmediatePropagation",
+	"log",
+	"warn",
+	"error",
+	"info",
+	"debug",
+	"alert",
+	"confirm",
+	"prompt",
+	"setTimeout",
+	"clearTimeout",
+	"requestAnimationFrame",
+	"startTransition",
+	"then",
+	"catch",
+	"finally",
+	"resolve",
+	"all",
+	"focus",
+	"blur",
+	"scrollIntoView",
+	"success",
+	"loading",
+	"dismiss",
+	"toast",
+	"Number",
+	"String",
+	"Boolean",
+	"parseInt",
+	"structuredClone"
+]);
+/** メンバー呼び出しのときだけ雑音(配列・文字列・ストレージのメソッド) */
+const NOISE_MEMBER = /* @__PURE__ */ new Set([
+	"stringify",
+	"parse",
+	"push",
+	"filter",
+	"map",
+	"includes",
+	"find",
+	"slice",
+	"trim",
+	"join",
+	"replace",
+	"getItem",
+	"setItem",
+	"removeItem",
+	"getTime",
+	"now",
+	"max",
+	"min",
+	"floor",
+	"round",
+	"random",
+	"toString",
+	"toISOString",
+	"current",
+	"forEach",
+	"concat",
+	"split",
+	"set",
+	"get",
+	"delete",
+	"has",
+	"add"
+]);
+const NOISE_OBJECTS = /* @__PURE__ */ new Set([
+	"e",
+	"ev",
+	"evt",
+	"event",
+	"console",
+	"toast",
+	"Math",
+	"Date",
+	"JSON",
+	"Object",
+	"Array",
+	"localStorage",
+	"sessionStorage"
+]);
+/** 既存の計測呼び出し(第 1 引数などのイベント名を名前にする) */
+const TRACK_CALLEES = /* @__PURE__ */ new Set([
+	"track",
+	"trackEvent",
+	"sendGAEvent",
+	"sendGTMEvent",
+	"logEvent",
+	"gtag",
+	"capture",
+	"logAnalyticsEvent",
+	"analyticsTrack"
+]);
+const TRACK_OBJECTS = /* @__PURE__ */ new Set([
+	"posthog",
+	"mixpanel",
+	"amplitude",
+	"analytics",
+	"ga"
+]);
+const CLICKISH_COMPONENT = /Button|Link|Tab|MenuItem|Trigger|Checkbox|Radio|Switch|Toggle|SelectItem|Option|Chip|Action$/;
+const HANDLER_PROPS = [
+	"onClick",
+	"onPress",
+	"onPointerDown",
+	"onMouseDown",
+	"onTouchStart",
+	"onDoubleClick",
+	"onKeyDown",
+	"onChange",
+	"onCheckedChange",
+	"onValueChange",
+	"onSelect",
+	"onToggle"
+];
+const GROUP_HANDLER_PROPS = [
+	"onValueChange",
+	"onChange",
+	"onCheckedChange"
+];
+const VALUE_ELEMENTS = /^(input|option|SelectItem|TabsTrigger|RadioGroupItem|ToggleGroupItem|DropdownMenuRadioItem|Radio|Tab)$/;
+const NATIVE_CLICKABLE = /* @__PURE__ */ new Set([
+	"button",
+	"a",
+	"input",
+	"select",
+	"label",
+	"summary",
+	"area",
+	"option"
+]);
+const CLICK_ROLES = /* @__PURE__ */ new Set([
+	"button",
+	"link",
+	"tab",
+	"menuitem",
+	"option",
+	"switch",
+	"checkbox",
+	"radio",
+	"menuitemradio",
+	"menuitemcheckbox"
+]);
+/** 配列の名前として意味を持たない変数名 */
+const GENERIC_ARRAY = /^(items|list|data|rows|options|entries|children|props)$/;
+/**
+* 候補の名前として使える形か(受信口の形の規則 `isElementName` と同じ)。ここでは候補を選ぶためだけに使い、
+* 書き込んだ値の検査は受信口に一本化する(Design Doc #43 の 3 節)
+*/
+const ID = /^[A-Za-z0-9_.:/[\]*#|-]{1,64}$/;
+function usable(n) {
+	return !!n && ID.test(n) && !/\d{3,}/.test(n.replace(/\[\*\]/g, ""));
+}
+const WRAPPERS = /* @__PURE__ */ new Set([
+	"TSAsExpression",
+	"TSSatisfiesExpression",
+	"TSNonNullExpression",
+	"ParenthesizedExpression",
+	"JSXExpressionContainer",
+	"AwaitExpression",
+	"TSTypeAssertion"
+]);
+function unwrap(e) {
+	let n = e;
+	while (n && WRAPPERS.has(n.type)) n = n.type === "AwaitExpression" ? n.argument : n.expression;
+	return n;
+}
+function staticString(e) {
+	const n = unwrap(e);
+	if (!n) return null;
+	if (n.type === "StringLiteral") return n.value;
+	if (n.type === "TemplateLiteral" && n.expressions.length === 0) return n.quasis[0].value.cooked ?? null;
+	return null;
+}
+/** 引数の静的な値: 文字列・数値・真偽・null と、x ± 数値 の ±N */
+function literalArg(e) {
+	const str = staticString(e);
+	if (str !== null) return str;
+	const n = unwrap(e);
+	if (!n) return null;
+	if (n.type === "NumericLiteral") return String(n.value);
+	if (n.type === "UnaryExpression" && n.operator === "-" && n.argument.type === "NumericLiteral") return `-${n.argument.value}`;
+	if (n.type === "BooleanLiteral") return String(n.value);
+	if (n.type === "NullLiteral") return "null";
+	if (n.type === "BinaryExpression" && (n.operator === "+" || n.operator === "-") && n.right.type === "NumericLiteral") return `${n.operator}${n.right.value}`;
+	return null;
+}
+function keyName(p) {
+	if (p.computed) return null;
+	if (p.key.type === "Identifier") return p.key.name;
+	if (p.key.type === "StringLiteral") return p.key.value;
+	return null;
+}
+/** パスとして: 式の部分は [*]。静的な部分が無ければ null */
+function pathTemplate(e) {
+	const n = unwrap(e);
+	if (!n) return null;
+	const s = staticString(n);
+	if (s !== null) return s;
+	if (n.type === "TemplateLiteral") {
+		let out = "";
+		n.quasis.forEach((q, i) => {
+			out += q.value.cooked;
+			if (i < n.expressions.length) out += "[*]";
+		});
+		return out;
+	}
+	if (n.type === "BinaryExpression" && n.operator === "+") {
+		const l = pathTemplate(n.left);
+		if (l === null) return null;
+		return l + (pathTemplate(n.right) ?? "[*]");
+	}
+	if (n.type === "ObjectExpression") {
+		const p = n.properties.find((p) => p.type === "ObjectProperty" && keyName(p) === "pathname");
+		return p ? pathTemplate(p.value) : null;
+	}
+	return null;
+}
+/** パスを名前にする: クエリ・ハッシュを落とし、外部 URL はホストだけ、mailto・tel は種類だけ */
+function normalizePath(p) {
+	if (p === null) return null;
+	const s = p.trim();
+	if (/^mailto:/i.test(s)) return "mailto";
+	if (/^tel:/i.test(s)) return "tel";
+	if (/^https?:\/\//i.test(s)) {
+		const host = s.replace(/^https?:\/\//i, "").split(/[/?#]/)[0] ?? "";
+		return host.includes("[*]") || !host ? null : `ext:${host}`;
+	}
+	if (s.startsWith("#")) return s.length > 1 ? s : null;
+	if (!s.startsWith("/")) return null;
+	return (s.split(/[?#]/)[0] ?? "").replace(/\[\*\][^/]*/g, "[*]").replace(/\/+$/, "") || "/";
+}
+function calleeParts(c) {
+	const n = unwrap(c);
+	if (n.type === "Identifier") return {
+		obj: null,
+		prop: n.name
+	};
+	if (n.type === "MemberExpression" || n.type === "OptionalMemberExpression") {
+		const prop = !n.computed && n.property.type === "Identifier" ? n.property.name : null;
+		const o = unwrap(n.object);
+		return {
+			obj: o.type === "Identifier" ? o.name : o.type === "MemberExpression" && !o.computed && o.property.type === "Identifier" ? o.property.name : o.type === "ThisExpression" ? "this" : null,
+			prop
+		};
+	}
+	return {
+		obj: null,
+		prop: null
+	};
+}
+const PRIORITY = [
+	"track",
+	"call",
+	"setterArg",
+	"api",
+	"nav",
+	"mcall",
+	"setter"
+];
+/** 後始末(pause・stopSpeaking)が先に来て本体が後に来る書き方が多いので、同じ種類の中では最後のものを採る */
+const LAST = /* @__PURE__ */ new Set([
+	"call",
+	"setterArg",
+	"mcall"
+]);
+var Ctx = class {
+	parent = /* @__PURE__ */ new WeakMap();
+	constructor(program) {
+		const visit = (n) => {
+			for (const c of children(n)) {
+				this.parent.set(c, n);
+				visit(c);
+			}
+		};
+		visit(program);
+	}
+	ancestors(n) {
+		const out = [];
+		for (let p = this.parent.get(n); p; p = this.parent.get(p)) out.push(p);
+		return out;
+	}
+	/** 識別子の束縛(同じファイル内: 変数宣言・関数宣言・分割代入・引数)を内側のスコープから探す */
+	binding(name, from) {
+		for (const a of [from, ...this.ancestors(from)]) {
+			if (/Function/.test(a.type)) for (const p of a.params) {
+				if (p.type === "Identifier" && p.name === name) return {
+					init: null,
+					kind: "param"
+				};
+				if (p.type === "ObjectPattern") {
+					for (const pr of p.properties) if (pr.type === "ObjectProperty" && unwrap(pr.value)?.type === "Identifier" && pr.value.name === name) return {
+						init: null,
+						kind: "param"
+					};
+				}
+			}
+			const body = a.type === "BlockStatement" || a.type === "Program" ? a.body : null;
+			if (!body) continue;
+			for (const st of body) {
+				const decl = st.type === "ExportNamedDeclaration" || st.type === "ExportDefaultDeclaration" ? st.declaration : st;
+				if (decl?.type === "VariableDeclaration") for (const d of decl.declarations) {
+					if (d.id.type === "Identifier" && d.id.name === name) return {
+						init: d.init,
+						kind: "var"
+					};
+					if (d.id.type === "ObjectPattern") {
+						for (const pr of d.id.properties) if (pr.type === "ObjectProperty" && pr.value.type === "Identifier" && pr.value.name === name) return {
+							init: d.init,
+							kind: "destructure"
+						};
+					}
+					if (d.id.type === "ArrayPattern" && d.id.elements.some((el) => el?.type === "Identifier" && el.name === name)) return {
+						init: d.init,
+						kind: "destructure",
+						pattern: d.id
+					};
+				}
+				if (decl?.type === "FunctionDeclaration" && decl.id?.name === name) return {
+					init: decl,
+					kind: "fn"
+				};
+			}
+		}
+		return null;
+	}
+};
+function trackName(call) {
+	const { obj, prop } = calleeParts(call.callee);
+	const args = call.arguments;
+	const fromObj = (a) => {
+		const o = unwrap(a);
+		if (o?.type !== "ObjectExpression") return null;
+		const p = o.properties.find((p) => p.type === "ObjectProperty" && [
+			"event",
+			"name",
+			"action"
+		].includes(keyName(p) ?? ""));
+		return p ? staticString(p.value) : null;
+	};
+	if (obj === "dataLayer" && prop === "push") return fromObj(args[0]);
+	if (!(prop && (TRACK_CALLEES.has(prop) || obj && TRACK_OBJECTS.has(obj) && [
+		"track",
+		"capture",
+		"logEvent"
+	].includes(prop)))) return null;
+	if (prop === "gtag" || prop === "sendGAEvent" && staticString(args[0]) === "event") return staticString(args[1]);
+	if (prop === "logEvent" && args[0] && staticString(args[0]) === null) return staticString(args[1]);
+	return staticString(args[0]) ?? fromObj(args[0]);
+}
+/** 画面遷移: 遷移先のパス(名前にならなければ null)。遷移でなければ undefined */
+function navPath(call) {
+	const { obj, prop } = calleeParts(call.callee);
+	const a0 = call.arguments[0];
+	if (obj && /router|navigation|nav/i.test(obj) && (prop === "push" || prop === "replace") || prop === "redirect" || prop === "navigate" || prop === "permanentRedirect" || obj === "location" && (prop === "assign" || prop === "replace") || obj === "window" && prop === "open") return normalizePath(pathTemplate(a0));
+	if (obj && /router|history/i.test(obj) && prop === "back" || prop === "back") return "back";
+	if (obj && /router/i.test(obj) && prop === "refresh") return "refresh";
+}
+/** API の呼び出し: API のパス(名前にならなければ null)。API でなければ undefined */
+function apiPath(call) {
+	const { obj, prop } = calleeParts(call.callee);
+	if (prop === "fetch" || prop === "axios" || obj && /^(axios|api|client|http|ky|\$fetch)$/.test(obj) && /^(get|post|put|patch|delete|request)$/.test(prop ?? "")) {
+		const p = normalizePath(pathTemplate(call.arguments[0]));
+		return p?.startsWith("/") ? p : null;
+	}
+}
+function analyzeCall(call, ctx, out) {
+	const tracked = trackName(call);
+	if (tracked) {
+		out.push({
+			kind: "track",
+			name: tracked
+		});
+		return;
+	}
+	const nav = navPath(call);
+	if (nav !== void 0) {
+		if (nav) out.push({
+			kind: "nav",
+			name: nav
+		});
+		return;
+	}
+	const api = apiPath(call);
+	if (api !== void 0) {
+		if (api) out.push({
+			kind: "api",
+			name: api
+		});
+		return;
+	}
+	const { obj, prop } = calleeParts(call.callee);
+	if (prop && [
+		"startTransition",
+		"setTimeout",
+		"requestAnimationFrame",
+		"then",
+		"finally",
+		"catch"
+	].includes(prop)) {
+		const cu = unwrap(call.callee);
+		if (cu.type === "MemberExpression") walkExpr(cu.object, ctx, out);
+		for (const a of call.arguments) if (/Function/.test(a.type)) walkFn(a, ctx, out);
+		return;
+	}
+	if (prop === "dispatch") {
+		const a = unwrap(call.arguments[0]);
+		if (a?.type === "CallExpression") {
+			const c = calleeParts(a.callee).prop;
+			if (c) out.push({
+				kind: "call",
+				name: c
+			});
+		} else if (a?.type === "ObjectExpression") {
+			const p = a.properties.find((p) => keyName(p) === "type");
+			const s = p && staticString(p.value);
+			if (s) out.push({
+				kind: "call",
+				name: s
+			});
+		}
+		return;
+	}
+	if (!prop || NOISE_CALLS.has(prop) || obj && NOISE_MEMBER.has(prop)) {
+		for (const a of call.arguments) walkExpr(a, ctx, out);
+		return;
+	}
+	if (obj && NOISE_OBJECTS.has(obj)) return;
+	if (/^set[A-Z]/.test(prop)) {
+		const arg = literalArg(call.arguments[0]);
+		const promote = arg !== null && arg !== "false" && arg !== "null";
+		out.push(arg && usable(`${prop}:${arg}`) ? {
+			kind: promote ? "setterArg" : "setter",
+			name: `${prop}:${arg}`
+		} : {
+			kind: "setter",
+			name: prop
+		});
+		return;
+	}
+	if (GENERIC_MEMBER_PROP.has(prop) && !obj) {
+		const init = unwrap(ctx.binding(prop, call)?.init);
+		const key = init?.type === "CallExpression" ? normalizePath(pathTemplate(init.arguments[0])) : null;
+		if (key?.startsWith("/")) out.push({
+			kind: "api",
+			name: key
+		});
+		return;
+	}
+	if (GENERIC_MEMBER_PROP.has(prop)) {
+		if (obj && ![
+			"props",
+			"this",
+			"state",
+			"store",
+			"ref",
+			"current"
+		].includes(obj)) out.push({
+			kind: "call",
+			name: obj
+		});
+		else if (prop.startsWith("on") && !GENERIC_HANDLER.test(prop)) out.push({
+			kind: "call",
+			name: prop
+		});
+		return;
+	}
+	if (obj === "clipboard" || obj === "navigator") {
+		out.push({
+			kind: "call",
+			name: `clipboard.${prop}`
+		});
+		return;
+	}
+	if (obj === "window" && [
+		"print",
+		"scrollTo",
+		"close"
+	].includes(prop)) {
+		out.push({
+			kind: "call",
+			name: prop
+		});
+		return;
+	}
+	if (GENERIC_HANDLER.test(prop)) return;
+	const arg = literalArg(call.arguments[0]);
+	out.push({
+		kind: obj ? "mcall" : "call",
+		name: arg && usable(`${prop}:${arg}`) ? `${prop}:${arg}` : prop
+	});
+}
+function walkExpr(e, ctx, out) {
+	const n = unwrap(e);
+	if (!n) return;
+	switch (n.type) {
+		case "CallExpression":
+		case "OptionalCallExpression":
+			analyzeCall(n, ctx, out);
+			return;
+		case "LogicalExpression":
+			walkExpr(n.left, ctx, out);
+			walkExpr(n.right, ctx, out);
+			return;
+		case "ConditionalExpression":
+			walkExpr(n.consequent, ctx, out);
+			walkExpr(n.alternate, ctx, out);
+			return;
+		case "SequenceExpression":
+			for (const x of n.expressions) walkExpr(x, ctx, out);
+			return;
+		case "UnaryExpression":
+			walkExpr(n.argument, ctx, out);
+			return;
+		case "AssignmentExpression": {
+			const { obj, prop } = calleeParts(unwrap(n.left));
+			if (prop === "href" && /location/.test(obj ?? "")) {
+				const p = normalizePath(pathTemplate(n.right));
+				if (p) out.push({
+					kind: "nav",
+					name: p
+				});
+			} else walkExpr(n.right, ctx, out);
+			return;
+		}
+	}
+}
+function walkStmts(stmts, ctx, out) {
+	for (const st of stmts) switch (st.type) {
+		case "ExpressionStatement":
+			walkExpr(st.expression, ctx, out);
+			break;
+		case "ReturnStatement":
+			walkExpr(st.argument, ctx, out);
+			break;
+		case "IfStatement":
+			walkExpr(st.test, ctx, out);
+			walkStmts([st.consequent], ctx, out);
+			if (st.alternate) walkStmts([st.alternate], ctx, out);
+			break;
+		case "BlockStatement":
+			walkStmts(st.body, ctx, out);
+			break;
+		case "TryStatement":
+			walkStmts(st.block.body, ctx, out);
+			break;
+		case "VariableDeclaration": for (const d of st.declarations) walkExpr(d.init, ctx, out);
+	}
+}
+function walkFn(fn, ctx, out) {
+	if (fn.body.type === "BlockStatement") walkStmts(fn.body.body, ctx, out);
+	else walkExpr(fn.body, ctx, out);
+}
+function pick(cands) {
+	for (const k of PRIORITY) {
+		const xs = cands.filter((x) => x.kind === k && usable(x.name));
+		const found = LAST.has(k) ? xs[xs.length - 1] : xs[0];
+		if (found) return found;
+	}
+	return null;
+}
+function fromBody(fn, ctx) {
+	const out = [];
+	walkFn(fn, ctx, out);
+	const c = pick(out);
+	return c ? {
+		name: c.name,
+		source: c.kind
+	} : null;
+}
+/** ハンドラの式 → 名前 */
+function handlerName(expr, ctx, depth = 0) {
+	const n = unwrap(expr);
+	if (!n || depth > 3) return null;
+	if (n.type === "Identifier") {
+		const b = ctx.binding(n.name, n);
+		const init = unwrap(b?.init);
+		if (b?.kind === "destructure" && b.pattern && init?.type === "CallExpression" && /^(useActionState|useFormState)$/.test(calleeParts(init.callee).prop ?? "")) {
+			const a0 = init.arguments[0];
+			return a0?.type === "Identifier" ? {
+				name: a0.name,
+				source: "action"
+			} : null;
+		}
+		if (!GENERIC_HANDLER.test(n.name)) return {
+			name: n.name,
+			source: "handler"
+		};
+		if (init && /Function/.test(init.type)) return fromBody(init, ctx);
+		if (init?.type === "CallExpression" && /^(useCallback|useMemo)$/.test(calleeParts(init.callee).prop ?? "") && /Function/.test(init.arguments[0]?.type)) return fromBody(init.arguments[0], ctx);
+		return null;
+	}
+	if (n.type === "MemberExpression" || n.type === "OptionalMemberExpression") {
+		const { obj, prop } = calleeParts(n);
+		if (!prop) return null;
+		if (GENERIC_MEMBER_PROP.has(prop)) return obj && ![
+			"props",
+			"this",
+			"state"
+		].includes(obj) ? {
+			name: obj,
+			source: "handler"
+		} : null;
+		if (/^set[A-Z]/.test(prop)) return {
+			name: prop,
+			source: "setter"
+		};
+		return GENERIC_HANDLER.test(prop) ? null : {
+			name: prop,
+			source: "handler"
+		};
+	}
+	if (/Function/.test(n.type)) return fromBody(n, ctx);
+	if (n.type === "CallExpression") {
+		const { obj, prop } = calleeParts(n.callee);
+		if (prop === "bind" && obj) return GENERIC_HANDLER.test(obj) ? null : {
+			name: obj,
+			source: "action"
+		};
+		if (prop && /^(useCallback|useMemo)$/.test(prop)) return handlerName(n.arguments[0], ctx, depth + 1);
+		const arg = staticString(n.arguments[0]);
+		if (prop && arg && usable(`${prop}:${arg}`)) return {
+			name: `${prop}:${arg}`,
+			source: "handler"
+		};
+		if (prop && !GENERIC_HANDLER.test(prop)) return (n.arguments[0] ? handlerName(n.arguments[0], ctx, depth + 1) : null) ?? {
+			name: prop,
+			source: "handler"
+		};
+		return n.arguments[0] ? handlerName(n.arguments[0], ctx, depth + 1) : null;
+	}
+	return null;
+}
+function tagName(o) {
+	const nm = o.name;
+	if (nm.type === "JSXIdentifier") return nm.name;
+	if (nm.type === "JSXMemberExpression") {
+		const parts = [];
+		let x = nm;
+		while (x.type === "JSXMemberExpression") {
+			parts.unshift(x.property.name);
+			x = x.object;
+		}
+		parts.unshift(x.name);
+		return parts.join(".");
+	}
+	return "";
+}
+function jsxAttr(o, name) {
+	return o.attributes.find((a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === name);
+}
+function attrExpr(o, name) {
+	const a = jsxAttr(o, name);
+	return a ? a.value ?? {
+		type: "BooleanLiteral",
+		value: true
+	} : null;
+}
+function attrStatic(o, name) {
+	const e = attrExpr(o, name);
+	return e ? staticString(e) : null;
+}
+/** クリックされうる要素: ネイティブの要素、クリックの role、クリックのハンドラ、クリックらしいコンポーネント */
+function isClickable(o) {
+	const tag = tagName(o);
+	const last = tag.split(".").pop() ?? "";
+	const has = (p) => !!jsxAttr(o, p);
+	const role = attrStatic(o, "role");
+	if (NATIVE_CLICKABLE.has(tag)) return true;
+	if (role && CLICK_ROLES.has(role)) return true;
+	if (HANDLER_PROPS.some((p) => p !== "onChange" && has(p))) return true;
+	if (/^[A-Z]/.test(last)) {
+		if (has("href") || has("onChange") || has("formAction") || has("value") && VALUE_ELEMENTS.test(last)) return true;
+		if (CLICKISH_COMPONENT.test(last)) return true;
+	}
+	return false;
+}
+/** 要素を含むコンポーネント(名前が大文字で始まる関数・クラス) */
+function enclosingComponent(ctx, n) {
+	for (const a of ctx.ancestors(n)) {
+		if (a.type === "FunctionDeclaration" && a.id && /^[A-Z]/.test(a.id.name)) return {
+			name: a.id.name,
+			fn: a
+		};
+		if (/Function/.test(a.type)) {
+			let p = ctx.parent.get(a);
+			while (p && p.type === "CallExpression" && /^(forwardRef|memo)$/.test(calleeParts(p.callee).prop ?? "")) p = ctx.parent.get(p);
+			if (p?.type === "VariableDeclarator" && p.id.type === "Identifier" && /^[A-Z]/.test(p.id.name)) return {
+				name: p.id.name,
+				fn: a
+			};
+		}
+		if (a.type === "ClassDeclaration" && a.id) return {
+			name: a.id.name,
+			fn: a
+		};
+	}
+	return null;
+}
+/** 要素がコンポーネントの根か(return の直下 / 式本体。条件式・&& の枝を含む) */
+function isRootOf(ctx, el, fn) {
+	let p = ctx.parent.get(el);
+	while (p && [
+		"ParenthesizedExpression",
+		"ConditionalExpression",
+		"LogicalExpression"
+	].includes(p.type)) p = ctx.parent.get(p);
+	if (p === fn) return true;
+	if (p?.type === "ReturnStatement") {
+		for (const a of ctx.ancestors(p)) if (/Function|ClassMethod/.test(a.type)) return a === fn || fn.type === "ClassDeclaration" && ctx.ancestors(a).includes(fn);
+	}
+	return false;
+}
+function enclosingJsx(ctx, el, pred) {
+	for (const a of ctx.ancestors(el)) if (a.type === "JSXElement" && pred(a.openingElement)) return a.openingElement;
+	return null;
+}
+/** items.map(...) の中の要素なら配列の変数名 */
+function enclosingMapArray(ctx, el) {
+	for (const a of ctx.ancestors(el)) {
+		if (a.type === "CallExpression" && calleeParts(a.callee).prop === "map") {
+			const o = unwrap(unwrap(a.callee).object);
+			if (o?.type === "Identifier") return o.name;
+			if (o?.type === "MemberExpression" && !o.computed) return o.property.name;
+			return null;
+		}
+		if (a.type === "FunctionDeclaration") return null;
+	}
+	return null;
+}
+function nameOf(ctx, el) {
+	const o = el.openingElement;
+	const tag = tagName(o);
+	const last = tag.split(".").pop() ?? "";
+	const ok = (name, source) => usable(name) ? {
+		name,
+		source
+	} : null;
+	const value = VALUE_ELEMENTS.test(last) ? attrStatic(o, "value") : null;
+	const withValue = (r) => value && usable(`${r.name}:${value}`) && !r.name.includes(":") ? {
+		name: `${r.name}:${value}`,
+		source: `${r.source}+value`
+	} : r;
+	for (const p of HANDLER_PROPS) {
+		const e = attrExpr(o, p);
+		if (!e) continue;
+		const r = handlerName(e, ctx);
+		if (r && usable(r.name)) return withValue(r);
+	}
+	const fa = attrExpr(o, "formAction");
+	if (fa) {
+		const r = handlerName(fa, ctx);
+		if (r && usable(r.name)) return {
+			name: r.name,
+			source: "action"
+		};
+	}
+	for (const p of [
+		"id",
+		"data-gtm-click",
+		"data-gtm",
+		"data-gtm-id",
+		"name"
+	]) {
+		if (p === "name" && tag !== "input" && tag !== "select" && tag !== "button") continue;
+		const r = ok(attrStatic(o, p), p === "name" ? "name-attr" : "id");
+		if (r) return r;
+	}
+	for (const p of ["href", "to"]) {
+		const e = attrExpr(o, p);
+		if (e) {
+			const r = ok(normalizePath(pathTemplate(e)), "path");
+			if (r) return r;
+		}
+	}
+	if (value) {
+		const group = enclosingJsx(ctx, el, (g) => GROUP_HANDLER_PROPS.some((p) => jsxAttr(g, p)));
+		if (group) for (const p of GROUP_HANDLER_PROPS) {
+			const e = attrExpr(group, p);
+			if (!e) continue;
+			const r = handlerName(e, ctx);
+			if (r && usable(r.name)) return withValue(r);
+		}
+		if (usable(value)) return {
+			name: value,
+			source: "value"
+		};
+	}
+	const type = attrStatic(o, "type");
+	if (tag === "button" && (type === null || type === "submit") || tag === "input" && type === "submit" || /Submit/.test(last)) {
+		const form = enclosingJsx(ctx, el, (f) => tagName(f) === "form" || /Form$/.test(tagName(f)));
+		if (form) for (const p of ["action", "onSubmit"]) {
+			const e = attrExpr(form, p);
+			if (!e) continue;
+			const r = handlerName(e, ctx);
+			if (r && usable(r.name)) return {
+				name: r.name,
+				source: "form"
+			};
+		}
+	}
+	const arr = enclosingMapArray(ctx, el);
+	if (arr && !GENERIC_ARRAY.test(arr)) {
+		const r = ok(arr, "map-array");
+		if (r) return r;
+	}
+	if (/^[A-Z]/.test(last) && !tag.includes(".") && !GENERIC_COMPONENT.test(last) && !/^(Select|Tabs|TabsList|Dialog|Menu)/.test(last)) {
+		const r = ok(last, "component");
+		if (r) return r;
+	}
+	const enc = enclosingComponent(ctx, el);
+	if (enc && !GENERIC_COMPONENT.test(enc.name)) {
+		const r = ok(enc.name, isRootOf(ctx, el, enc.fn) ? "own-component" : "context");
+		if (r) return r;
+	}
+	if (arr) {
+		const r = ok(arr, "map-array");
+		if (r) return r;
+	}
+	return {
+		name: null,
+		source: "none"
+	};
+}
+/** プログラム中の JSX 要素ごとに名前を決める(既定ではクリックされうる要素だけを返す) */
+function extractFromProgram(program, options = {}) {
+	const ctx = new Ctx(program);
+	const out = [];
+	const visit = (n) => {
+		if (n.type === "JSXElement") {
+			const o = n.openingElement;
+			const clickable = isClickable(o);
+			if (clickable || options.all) {
+				const { name, source } = nameOf(ctx, n);
+				let receiver = null;
+				const enc = enclosingComponent(ctx, n);
+				if (enc && /^[a-z]/.test(tagName(o)) && isRootOf(ctx, n, enc.fn)) {
+					const p0 = enc.fn.params?.[0];
+					receiver = p0?.type === "ObjectPattern" ? {
+						kind: "pattern",
+						pattern: p0
+					} : p0?.type === "Identifier" ? {
+						kind: "ident",
+						name: p0.name
+					} : { kind: "none" };
+				}
+				out.push({
+					element: n,
+					tag: tagName(o),
+					name,
+					source,
+					label: labelOf(n),
+					clickable,
+					receiver
+				});
+			}
+		}
+		for (const c of children(n)) visit(c);
+	};
+	visit(program);
+	return out;
+}
+//#endregion
+//#region ../build-names/src/element-name/transform.ts
+/** 書く属性。@auspex-ai/core の ELEMENT_REF_ATTR(読む側)と同じ値(test/element-names.test.ts で一致を確かめる) */
+const REF_ATTR = "data-auspex-ref";
+/** ラベル(NAL-124)の参照。@auspex-ai/core の LABEL_REF_ATTR(読む側)と同じ値(test/element-names.test.ts で一致を確かめる) */
+const LABEL_REF_ATTR = "data-auspex-label-ref";
+/** 手書きは常に消す。アイコンの属性(#50 段階 2)も同じ理由 */
+const HAND_WRITTEN = /* @__PURE__ */ new Set([
+	REF_ATTR,
+	LABEL_REF_ATTR,
+	"data-auspex-name",
+	ICON_REF_ATTR,
+	LEGACY_ICON_ATTR
+]);
+/** 定義側で受け取った参照を入れる変数(この名前がソースにあれば変換済みとみなす) */
+const RECEIVED = "__auspexRef";
+/** 同じく、ラベルの参照を入れる変数 */
+const RECEIVED_LABEL = "__auspexLabelRef";
+const startOf = (n) => n.start ?? 0;
+const endOf = (n) => n.end ?? 0;
+/** JSX を含みうるファイルか(解析する前の絞り込み) */
+function mayHaveElements(source, file) {
+	return !file.endsWith(".ts") && /<[A-Za-z]/.test(source) && !source.includes(RECEIVED);
+}
+/** 手書きの属性を消す対象になりうるソースか(mayHaveElements とは別の判定。.ts など JSX を含まないファイルも) */
+function mayHaveHandWritten(source) {
+	return source.includes("data-auspex-ref") || source.includes("data-auspex-label-ref") || source.includes("data-auspex-name") || source.includes("data-auspex-icon");
+}
+function passedValue(receiver, attr, received) {
+	if (receiver.kind === "pattern") return received;
+	if (receiver.kind === "ident") return `${receiver.name}?.[${JSON.stringify(attr)}]`;
+	return null;
+}
+const SKIP_KEYS = /* @__PURE__ */ new Set([
+	"loc",
+	"start",
+	"end",
+	"extra",
+	"range",
+	"leadingComments",
+	"trailingComments",
+	"innerComments"
+]);
+/** オブジェクトリテラルのプロパティのキーが、リテラルで書かれた手書きの属性名か */
+function isHandWrittenKey(p) {
+	if (p.type === "SpreadElement") return false;
+	const k = p.key;
+	if (k.type === "StringLiteral") return HAND_WRITTEN.has(k.value);
+	return !p.computed && k.type === "Identifier" && HAND_WRITTEN.has(k.name);
+}
+/** JSX の属性と、オブジェクトリテラルのリテラルのキー(スプレッド・createElement・jsx() の props を含む)から手書きの属性を消す */
+function removeHandWritten(node, s) {
+	if (node.type === "JSXOpeningElement") {
+		for (const a of node.attributes) if (a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && HAND_WRITTEN.has(a.name.name)) s.remove(startOf(a), endOf(a));
+	}
+	if (node.type === "ObjectExpression") {
+		const props = node.properties;
+		for (let i = 0; i < props.length; i++) {
+			const p = props[i];
+			if (!p || !isHandWrittenKey(p)) continue;
+			let j = i;
+			while (j + 1 < props.length && props[j + 1] && isHandWrittenKey(props[j + 1])) j++;
+			const first = props[i];
+			const last = props[j];
+			const next = props[j + 1];
+			const prev = props[i - 1];
+			if (next) s.remove(startOf(first), startOf(next));
+			else if (prev) s.remove(endOf(prev), endOf(last));
+			else s.remove(startOf(first), endOf(last));
+			i = j;
+		}
+	}
+	for (const key of Object.keys(node)) {
+		if (SKIP_KEYS.has(key)) continue;
+		const v = node[key];
+		for (const c of Array.isArray(v) ? v : [v]) if (c && typeof c.type === "string") removeHandWritten(c, s);
+	}
+}
+/** 手書きの属性の削除だけを `s` に積む(strip のみのモード。JSX を含まないファイルも) */
+function stripHandWritten(program, s) {
+	removeHandWritten(program, s);
+}
+/**
+* 要素の参照の書き込みを `s` に積む(手書きの属性の削除は stripHandWritten で別に行う)。書いた名前とラベルを返す。
+* `refOf` は名前(kind = 'element')・ラベル(kind = 'label')から参照を計算する(鍵はここに渡らない)。
+* ラベルの参照(data-auspex-label-ref)も要素の参照と同じ仕組みで書く
+*/
+function applyElementNames(program, s, refOf) {
+	const written = /* @__PURE__ */ new Set();
+	const writtenLabels = /* @__PURE__ */ new Set();
+	const patched = /* @__PURE__ */ new Set();
+	for (const { element, tag, name, label, receiver } of extractFromProgram(program)) {
+		const dom = /^[a-z]/.test(tag);
+		const attrs = [];
+		const write = (attr, received, own) => {
+			const passed = receiver ? passedValue(receiver, attr, received) : null;
+			const fallback = own ?? (dom ? "\"\"" : null);
+			const value = passed && fallback ? `${passed} ?? ${fallback}` : passed ?? fallback;
+			return value === null ? null : { value };
+		};
+		const refValue = write(REF_ATTR, RECEIVED, name === null ? null : JSON.stringify(refOf(name, "element")));
+		const labelValue = write(LABEL_REF_ATTR, RECEIVED_LABEL, label === null ? null : JSON.stringify(refOf(label, "label")));
+		if (refValue === null && labelValue === null) continue;
+		if (refValue && name !== null) written.add(name);
+		if (labelValue && label !== null) writtenLabels.add(label);
+		if (receiver?.kind === "pattern" && !patched.has(receiver.pattern)) {
+			s.appendRight(startOf(receiver.pattern) + 1, ` ${JSON.stringify(REF_ATTR)}: ${RECEIVED}, ${JSON.stringify(LABEL_REF_ATTR)}: ${RECEIVED_LABEL},`);
+			patched.add(receiver.pattern);
+		}
+		if (refValue) attrs.push(` ${REF_ATTR}={${refValue.value}}`);
+		if (labelValue) attrs.push(` ${LABEL_REF_ATTR}={${labelValue.value}}`);
+		s.appendLeft(endOf(element.openingElement.name), attrs.join(""));
+	}
+	return {
+		names: [...written],
+		labels: [...writtenLabels]
+	};
+}
+//#endregion
+//#region ../build-names/src/transform.ts
+/** 変換が不要なら null */
+function transformNames(source, file, options = {}) {
+	const refOf = options.elementNames === "strip" ? void 0 : options.refOf;
+	const icons = refOf !== void 0 && options.iconNames !== false && mayHaveIcons(source);
+	const elements = refOf !== void 0 && options.elementAttrs !== false && mayHaveElements(source, file);
+	const strip = mayHaveHandWritten(source);
+	if (!icons && !elements && !strip) return null;
+	const program = parseSource(source, file);
+	if (!program) return null;
+	const s = new MagicString(source);
+	if (strip) stripHandWritten(program, s);
+	const { names, labels } = elements && refOf ? applyElementNames(program, s, (name, kind) => refOf(name, kind)) : {
+		names: [],
+		labels: []
+	};
+	const iconNames = icons && refOf ? applyIconNames(program, source, file, s, (name) => refOf(name, "icon")) : [];
+	if (!s.hasChanged()) return null;
+	return {
+		code: s.toString(),
+		map: s.generateMap({
+			hires: true,
+			source: file,
+			includeContent: true
+		}),
+		names,
+		icons: iconNames,
+		labels
+	};
+}
+//#endregion
+//#region src/vite.ts
+const BUILD_ID_ENV = "VITE_AUSPEX_BUILD_ID";
+const BUILD_ID_DEFINE = `import.meta.env.${BUILD_ID_ENV}`;
+const SOURCE = /\.(?:[jt]sx?|m[jt]s)$/;
+const NODE_MODULES = /[\\/]node_modules[\\/]/;
+const silent = {
+	info: () => {},
+	warn: () => {}
+};
+const nonEmpty = (v) => v ? v : void 0;
+function auspex(options = {}) {
+	const names = /* @__PURE__ */ new Set();
+	const icons = /* @__PURE__ */ new Set();
+	const labels = /* @__PURE__ */ new Set();
+	let env = {};
+	let buildId;
+	let isBuild = false;
+	let ssr = false;
+	let failed = false;
+	let registered = false;
+	let refs = null;
+	let host;
+	let buildKey;
+	const hostOf = () => registrationHost(options.host ?? nonEmpty(process.env.VITE_AUSPEX_HOST) ?? nonEmpty(env.VITE_AUSPEX_HOST));
+	return {
+		name: "auspex",
+		enforce: "pre",
+		async config(userConfig, { mode }) {
+			if (buildId === void 0) {
+				const root = path.resolve(userConfig.root ?? process.cwd());
+				const envDir = userConfig.envDir;
+				if (envDir !== false) {
+					const { loadEnv } = await import("vite");
+					env = loadEnv(mode, envDir === void 0 ? root : path.resolve(root, envDir), "VITE_");
+				}
+				const given = nonEmpty(process.env["VITE_AUSPEX_BUILD_ID"]) ?? nonEmpty(env["VITE_AUSPEX_BUILD_ID"]);
+				buildId = await resolveBuildId("", given, given ? consoleLogger : silent, false);
+			}
+			return { define: { [BUILD_ID_DEFINE]: JSON.stringify(buildId) } };
+		},
+		configResolved(config) {
+			isBuild = config.command === "build";
+			ssr = Boolean(config.build.ssr);
+			const key = nonEmpty(process.env.AUSPEX_BUILD_KEY);
+			buildKey = key;
+			host = hostOf();
+			refs = null;
+			if (!isBuild) return;
+			if (options.elementNames === false && options.iconNames === false) return;
+			if (!key) warnOnce("vite:no-key", "[auspex] 要素名が付かない: ビルド鍵(環境変数 AUSPEX_BUILD_KEY)が無い。アプリの設定のページで発行して CI の秘密に置く(VITE_ は付けない)");
+			else if (!host || !isValidHost(host)) warnOnce("vite:no-host", "[auspex] 要素名が付かない: 登録の受け口 host が無い、または https ではない。auspex({ host }) か環境変数 VITE_AUSPEX_HOST に受信口の https の URL を指定する(セルフホストで /api/names を internal の面に置くなら AUSPEX_INTERNAL_HOST)");
+			else refs = (name, kind) => nameRef(key, name, kind);
+			if (!process.env["VITE_AUSPEX_BUILD_ID"] && !env["VITE_AUSPEX_BUILD_ID"]) warnOnce("vite:local-build-id", `[auspex] ${BUILD_ID_ENV} が未設定なので、自前のビルド ID(${buildId})を使う`);
+		},
+		buildStart() {
+			names.clear();
+			icons.clear();
+			labels.clear();
+			failed = false;
+			registered = false;
+		},
+		buildEnd(error) {
+			if (error) failed = true;
+		},
+		transform(code, id) {
+			if (id.startsWith("\0")) return null;
+			const file = id.split("?")[0] ?? id;
+			if (NODE_MODULES.test(file) || !SOURCE.test(file)) return null;
+			const nameOptions = { elementNames: "strip" };
+			if (options.iconNames !== void 0) nameOptions.iconNames = options.iconNames;
+			if (options.elementNames === false) nameOptions.elementAttrs = false;
+			if (refs) {
+				nameOptions.elementNames = "refs";
+				nameOptions.refOf = refs;
+			}
+			const out = transformNames(code, file, nameOptions);
+			if (!out) return null;
+			for (const n of out.names) names.add(n);
+			for (const n of out.icons) icons.add(n);
+			for (const n of out.labels) labels.add(n);
+			return {
+				code: out.code,
+				map: out.map
+			};
+		},
+		async closeBundle() {
+			if (!isBuild || ssr || failed || registered || !refs || !buildKey || !host || buildId === void 0) return;
+			registered = true;
+			try {
+				await registerNames({
+					key: buildKey,
+					host,
+					names: [...names],
+					icons: [...icons],
+					labels: [...labels],
+					buildId
+				});
+			} catch {}
+		}
+	};
+}
+//#endregion
+export { BUILD_ID_ENV, auspex };