@standards/cli 0.0.0-stage → 1.0.0-alpha.382

package/dist/builder-shorthand-DPVmGTec.mjs

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+/*! © 2025-2026 AND YOU CREATE SAS (RCS Paris 940 190 614). Proprietary — see LICENSE (Standards SDK License 1.0). */
+import { i as rewriteSourceFiles, n as parseSourceFile, t as applyEdits } from "./source-files-D2Bdfvhx.mjs";
+import ts from "typescript";
+//#region src/codemod/builder-shorthand.ts
+const BUILDERS = /* @__PURE__ */ new Set([
+	"text",
+	"richtext",
+	"number",
+	"checkbox",
+	"date",
+	"phone",
+	"currency",
+	"status",
+	"select",
+	"multiselect",
+	"location",
+	"user",
+	"relation",
+	"formula",
+	"rollup",
+	"document",
+	"object",
+	"nativeObject"
+]);
+const WITH_ID = /* @__PURE__ */ new Set(["object", "nativeObject"]);
+const SOURCE = "defineSchemaSource";
+const STANDARDS_PACKAGE = /^@standards\/(schema|client)$/;
+const RELATIVE_MODULE = /^\.{1,2}\//;
+const COMMENT_IN_CONFIG = "comment in config, rewrite by hand";
+/** Import clauses whose module counts as Standards: the packages, plus relative paths on opt-in. */
+function standardsImports(file, options) {
+	const clauses = [];
+	for (const statement of file.statements) {
+		if (!(ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier))) continue;
+		const specifier = statement.moduleSpecifier.text;
+		if ((STANDARDS_PACKAGE.test(specifier) || options.relativeImports === true && RELATIVE_MODULE.test(specifier)) && statement.importClause) clauses.push(statement.importClause);
+	}
+	return clauses;
+}
+/** Local identifier → exported builder name, for named imports from Standards. */
+function importedBuilders(clauses) {
+	const found = /* @__PURE__ */ new Map();
+	for (const clause of clauses) {
+		const bindings = clause.namedBindings;
+		if (!(bindings && ts.isNamedImports(bindings))) continue;
+		for (const element of bindings.elements) {
+			const exported = element.propertyName?.text ?? element.name.text;
+			if (BUILDERS.has(exported) || exported === SOURCE) found.set(element.name.text, exported);
+		}
+	}
+	return found;
+}
+/** True when `[start, end)` of the file holds a comment, which a rewrite would drop. */
+function hasComment(file, start, end) {
+	const scanner = ts.createScanner(ts.ScriptTarget.Latest, false, file.languageVariant, file.text.slice(start, end));
+	for (let token = scanner.scan(); token !== ts.SyntaxKind.EndOfFileToken; token = scanner.scan()) if (token === ts.SyntaxKind.SingleLineCommentTrivia || token === ts.SyntaxKind.MultiLineCommentTrivia) return true;
+	return false;
+}
+function readConfig(literal, file, allowed) {
+	const values = /* @__PURE__ */ new Map();
+	for (const property of literal.properties) {
+		if (ts.isSpreadAssignment(property)) return "spread in config";
+		if (ts.isShorthandPropertyAssignment(property)) {
+			values.set(property.name.text, property.name.text);
+			continue;
+		}
+		if (!(ts.isPropertyAssignment(property) && ts.isIdentifier(property.name))) return "unsupported property in config";
+		const key = property.name.text;
+		if (!allowed.has(key)) return `unsupported key "${key}"`;
+		values.set(key, property.initializer.getText(file));
+	}
+	if (!(values.has("name") && values.has("label"))) return "missing name or label";
+	return values;
+}
+function rewriteBuilder(call, exported, file) {
+	const [config] = call.arguments;
+	if (call.arguments.length !== 1 || config === void 0) return { kind: "none" };
+	if (!ts.isObjectLiteralExpression(config)) return {
+		kind: "skip",
+		reason: "config is not an object literal"
+	};
+	const values = readConfig(config, file, new Set(WITH_ID.has(exported) ? [
+		"name",
+		"label",
+		"id"
+	] : ["name", "label"]));
+	if (typeof values === "string") return {
+		kind: "skip",
+		reason: values
+	};
+	if (hasComment(file, config.getStart(file), config.getEnd())) return {
+		kind: "skip",
+		reason: COMMENT_IN_CONFIG
+	};
+	const edits = [{
+		start: config.getStart(file),
+		end: config.getEnd(),
+		text: `${values.get("name")}, ${values.get("label")}`
+	}];
+	const id = values.get("id");
+	if (id !== void 0) edits.push({
+		start: call.getEnd(),
+		end: call.getEnd(),
+		text: `.id(${id})`
+	});
+	return {
+		kind: "edit",
+		edits
+	};
+}
+function rewriteSource(call, file) {
+	const [id, config] = call.arguments;
+	if (call.arguments.length !== 2 || id === void 0 || config === void 0) return { kind: "none" };
+	if (!ts.isObjectLiteralExpression(config)) return {
+		kind: "skip",
+		reason: "config is not an object literal"
+	};
+	const idText = id.getText(file);
+	const hasProperties = config.properties.length > 0;
+	const open = config.getStart(file) + 1;
+	const spaces = /^[ \t]*/.exec(file.text.slice(open))?.[0].length ?? 0;
+	const multiline = /^[ \t]*[\r\n]/.test(file.text.slice(open));
+	const head = hasProperties ? `{ id: ${idText},${multiline ? "" : " "}` : `{ id: ${idText} }`;
+	const end = hasProperties ? multiline ? open : open + spaces : config.getEnd();
+	if (hasComment(file, id.getStart(file), end)) return {
+		kind: "skip",
+		reason: COMMENT_IN_CONFIG
+	};
+	return {
+		kind: "edit",
+		edits: [{
+			start: id.getStart(file),
+			end,
+			text: head
+		}]
+	};
+}
+function overlaps(x, y) {
+	if (x.start === x.end && y.start === y.end) return x.start === y.start;
+	return x.start < y.end && y.start < x.end;
+}
+/** The widest call among those whose edits collide with another call's edits. */
+function findOverlapVictim(calls) {
+	let victim;
+	for (const [i, first] of calls.entries()) for (const second of calls.slice(i + 1)) {
+		if (!first.edits.some((x) => second.edits.some((y) => overlaps(x, y)))) continue;
+		const wider = first.node.getWidth() >= second.node.getWidth() ? first : second;
+		if (victim === void 0 || wider.node.getWidth() > victim.node.getWidth()) victim = wider;
+	}
+	return victim;
+}
+/** Local names of `import * as x` from Standards. */
+function importedNamespaces(clauses) {
+	const found = /* @__PURE__ */ new Set();
+	for (const clause of clauses) {
+		const bindings = clause.namedBindings;
+		if (bindings && ts.isNamespaceImport(bindings)) found.add(bindings.name.text);
+	}
+	return found;
+}
+/** True when a call to `exported` still has the pre-shorthand argument shape. */
+function isLegacyShape(call, exported) {
+	if (exported === SOURCE) {
+		const config = call.arguments[1];
+		return call.arguments.length === 2 && config !== void 0 && ts.isObjectLiteralExpression(config);
+	}
+	return BUILDERS.has(exported) && call.arguments.length === 1;
+}
+/** Every TS and JS module a schema can live in; declaration files carry no calls. */
+/** Rewrites `fn({ name, label })` builders of one file to `fn(name, label)`. */
+function rewriteBuilderShorthand(text, fileName, options = {}) {
+	const { file } = parseSourceFile(text, fileName);
+	const clauses = standardsImports(file, options);
+	const builders = importedBuilders(clauses);
+	const namespaces = importedNamespaces(clauses);
+	const calls = [];
+	const skipped = [];
+	function skip(node, callee, reason) {
+		const { line, character } = file.getLineAndCharacterOfPosition(node.getStart(file));
+		skipped.push({
+			file: fileName,
+			line: line + 1,
+			column: character + 1,
+			callee,
+			reason
+		});
+	}
+	function visit(node) {
+		if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+			const exported = builders.get(node.expression.text);
+			if (exported !== void 0) {
+				const outcome = exported === SOURCE ? rewriteSource(node, file) : rewriteBuilder(node, exported, file);
+				if (outcome.kind === "edit") calls.push({
+					node,
+					edits: outcome.edits
+				});
+				else if (outcome.kind === "skip") skip(node, node.expression.text, outcome.reason);
+			}
+		} else if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && namespaces.has(node.expression.expression.text) && isLegacyShape(node, node.expression.name.text)) skip(node, node.expression.getText(file), "namespace import, rewrite by hand");
+		ts.forEachChild(node, visit);
+	}
+	visit(file);
+	let kept = calls;
+	for (;;) {
+		const victim = findOverlapVictim(kept);
+		if (victim === void 0) break;
+		skip(victim.node, victim.node.expression.text, "overlapping rewrite");
+		kept = kept.filter((call) => call !== victim);
+	}
+	skipped.sort((x, y) => x.line - y.line || x.column - y.column);
+	const changed = kept.length;
+	return {
+		output: applyEdits(text, kept.flatMap((call) => call.edits)),
+		changed,
+		skipped
+	};
+}
+/** Walks `paths`, rewrites every TS file, writes back when `write` is set. */
+async function runBuilderShorthand(paths, options) {
+	const report = {
+		files: 0,
+		changed: 0,
+		skipped: []
+	};
+	const results = await rewriteSourceFiles(paths, options.write, (text, path) => rewriteBuilderShorthand(text, path, options));
+	for (const { result } of results) {
+		report.skipped.push(...result.skipped);
+		if (result.changed === 0) continue;
+		report.files += 1;
+		report.changed += result.changed;
+	}
+	return report;
+}
+//#endregion
+export { runBuilderShorthand };

package/dist/engine-imports-K-yySYo3.mjs

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+/*! © 2025-2026 AND YOU CREATE SAS (RCS Paris 940 190 614). Proprietary — see LICENSE (Standards SDK License 1.0). */
+import { i as rewriteSourceFiles, n as parseSourceFile, t as applyEdits } from "./source-files-D2Bdfvhx.mjs";
+import { join, resolve } from "node:path";
+import ts from "typescript";
+//#region src/codemod/engine-imports.ts
+const SCHEMA = "@standards/schema";
+const ENGINE = "@standards/engine";
+/** Subpath entries that moved whole: their specifier is renamed, nothing else. */
+const MOVED_SUBPATHS = /* @__PURE__ */ new Set(["capabilities", "webhooks"]);
+function isSchemaSpecifier(specifier) {
+	return specifier === SCHEMA || specifier.startsWith(`${SCHEMA}/`);
+}
+function schemaLiteralOf(node) {
+	const literal = node.moduleSpecifier;
+	return literal !== void 0 && ts.isStringLiteral(literal) && isSchemaSpecifier(literal.text) ? literal : void 0;
+}
+function namedElements(node) {
+	if (ts.isImportDeclaration(node)) {
+		const bindings = node.importClause?.namedBindings;
+		if (node.importClause?.name !== void 0) return void 0;
+		return bindings !== void 0 && ts.isNamedImports(bindings) ? bindings.elements : void 0;
+	}
+	return node.exportClause !== void 0 && ts.isNamedExports(node.exportClause) ? node.exportClause.elements : void 0;
+}
+function declaration(node, elements, specifier) {
+	return `${ts.isImportDeclaration(node) ? "import" : "export"}${(ts.isImportDeclaration(node) ? node.importClause?.isTypeOnly : node.isTypeOnly) ? " type" : ""} { ${elements.join(", ")} } from "${specifier}";`;
+}
+/**
+* Moves every name `@standards/schema` no longer exports, and `@standards/engine`
+* does, out of a schema import into an engine import beside it.
+*/
+function rewriteEngineImports(source, fileName, exports) {
+	const parsed = parseSourceFile(source, fileName);
+	if (parsed.error !== void 0) return {
+		output: source,
+		changed: 0,
+		unresolved: [],
+		error: parsed.error
+	};
+	const edits = [];
+	const unresolved = [];
+	let moved = 0;
+	for (const node of parsed.file.statements) {
+		if (!(ts.isImportDeclaration(node) || ts.isExportDeclaration(node))) continue;
+		const literal = schemaLiteralOf(node);
+		if (literal === void 0) continue;
+		const specifier = literal.text;
+		const subpath = specifier.slice(18);
+		if (MOVED_SUBPATHS.has(subpath)) {
+			const quote = literal.getText().charAt(0);
+			edits.push({
+				start: literal.getStart(),
+				end: literal.getEnd(),
+				text: `${quote}${ENGINE}/${subpath}${quote}`
+			});
+			moved += 1;
+			continue;
+		}
+		const elements = namedElements(node);
+		if (elements === void 0) {
+			if (ts.isExportDeclaration(node) || node.importClause !== void 0) unresolved.push(node.getText());
+			continue;
+		}
+		const stay = [];
+		const go = [];
+		for (const element of elements) {
+			const name = (element.propertyName ?? element.name).text;
+			if (exports.schema(specifier).has(name)) stay.push(element.getText());
+			else if (exports.engine.has(name)) go.push(element.getText());
+			else {
+				unresolved.push(name);
+				stay.push(element.getText());
+			}
+		}
+		if (go.length === 0) continue;
+		moved += go.length;
+		const text = stay.length === 0 ? declaration(node, go, ENGINE) : `${declaration(node, stay, specifier)}\n${declaration(node, go, ENGINE)}`;
+		edits.push({
+			start: node.getStart(),
+			end: node.getEnd(),
+			text
+		});
+	}
+	function visit(node) {
+		if (ts.isImportTypeNode(node) && ts.isLiteralTypeNode(node.argument) && ts.isStringLiteral(node.argument.literal) && isSchemaSpecifier(node.argument.literal.text) && node.qualifier !== void 0) {
+			const literal = node.argument.literal;
+			const first = ts.isIdentifier(node.qualifier) ? node.qualifier : node.qualifier.left;
+			const name = ts.isIdentifier(first) ? first.text : void 0;
+			if (name !== void 0 && !exports.schema(literal.text).has(name) && exports.engine.has(name)) {
+				const quote = literal.getText().charAt(0);
+				edits.push({
+					start: literal.getStart(),
+					end: literal.getEnd(),
+					text: `${quote}${ENGINE}${quote}`
+				});
+				moved += 1;
+			}
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(parsed.file);
+	return {
+		output: applyEdits(source, edits),
+		changed: moved,
+		unresolved
+	};
+}
+/** The names a package's installed type declarations export, resolved from `root`. */
+function exportedNames(packageName, root) {
+	const options = {
+		module: ts.ModuleKind.NodeNext,
+		moduleResolution: ts.ModuleResolutionKind.NodeNext,
+		skipLibCheck: true,
+		noEmit: true
+	};
+	const resolved = ts.resolveModuleName(packageName, join(root, "index.ts"), options, ts.sys).resolvedModule?.resolvedFileName;
+	if (resolved === void 0) return /* @__PURE__ */ new Set();
+	const program = ts.createProgram([resolved], options);
+	const file = program.getSourceFile(resolved);
+	const symbol = file && program.getTypeChecker().getSymbolAtLocation(file);
+	if (symbol === void 0) return /* @__PURE__ */ new Set();
+	return new Set(program.getTypeChecker().getExportsOfModule(symbol).map((exported) => exported.name));
+}
+/** Reads both packages as installed under `root`; fails when engine is not installed there. */
+function installedExports(root) {
+	const bySpecifier = /* @__PURE__ */ new Map();
+	function schema(specifier) {
+		let names = bySpecifier.get(specifier);
+		if (names === void 0) {
+			names = exportedNames(specifier, root);
+			bySpecifier.set(specifier, names);
+		}
+		return names;
+	}
+	if (schema(SCHEMA).size === 0) return `${SCHEMA} is not installed under ${root}.`;
+	const engine = exportedNames(ENGINE, root);
+	if (engine.size === 0) return `Add ${ENGINE} to your dependencies and install it, then re-run.`;
+	return {
+		schema,
+		engine
+	};
+}
+async function runEngineImports(paths, options) {
+	const exports = installedExports(resolve(options.root));
+	if (typeof exports === "string") return exports;
+	const report = {
+		files: 0,
+		moved: 0,
+		unresolved: [],
+		failures: []
+	};
+	const results = await rewriteSourceFiles(paths, options.write, (text, path) => rewriteEngineImports(text, path, exports));
+	for (const { path, result } of results) {
+		if (result.error !== void 0) {
+			report.failures.push({
+				file: path,
+				message: result.error
+			});
+			continue;
+		}
+		for (const name of result.unresolved) report.unresolved.push({
+			file: path,
+			name
+		});
+		if (result.changed === 0) continue;
+		report.files += 1;
+		report.moved += result.changed;
+	}
+	return report;
+}
+//#endregion
+export { runEngineImports };

package/dist/palette-D63ag-eX.mjs

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+/*! © 2025-2026 AND YOU CREATE SAS (RCS Paris 940 190 614). Proprietary — see LICENSE (Standards SDK License 1.0). */
+import { i as rewriteSourceFiles, n as parseSourceFile, t as applyEdits } from "./source-files-D2Bdfvhx.mjs";
+import ts from "typescript";
+import { PALETTE_HUES } from "@standards/constants";
+//#region src/codemod/palette.ts
+/** Previous Tailwind colour id → nearest Standards palette id (same table as the SQL migration). */
+const OLD_TO_NEW = {
+	gray: "stone",
+	slate: "stone",
+	red: "brick",
+	rose: "brick",
+	orange: "terra",
+	amber: "ochre",
+	yellow: "ochre",
+	lime: "moss",
+	green: "sage",
+	emerald: "sage",
+	teal: "lagoon",
+	cyan: "lagoon",
+	blue: "ink",
+	sky: "ink",
+	indigo: "iris",
+	violet: "iris",
+	purple: "iris",
+	pink: "peony",
+	fuchsia: "peony"
+};
+const NEUTRAL = "stone";
+/** Fallback order doubles as the tie-break: earlier wins. */
+const HUE_IDS = Object.keys(PALETTE_HUES);
+const PALETTE_IDS = /* @__PURE__ */ new Set([NEUTRAL, ...HUE_IDS]);
+function isStringLike(node) {
+	return node !== void 0 && (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node));
+}
+function hueDistance(x, y) {
+	const delta = Math.abs(x - y) % 360;
+	return Math.min(delta, 360 - delta);
+}
+/** Smallest circular hue distance wins; a tie goes to the earlier id of the palette. */
+function nearestFree(target, taken) {
+	const hue = PALETTE_HUES[target];
+	if (hue === void 0) return void 0;
+	let best;
+	let bestDistance = Number.POSITIVE_INFINITY;
+	for (const id of HUE_IDS) {
+		if (taken.has(id)) continue;
+		const distance = hueDistance(hue, PALETTE_HUES[id]);
+		if (distance < bestDistance) {
+			best = id;
+			bestDistance = distance;
+		}
+	}
+	return best;
+}
+function propertyName(property) {
+	if (!(ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property))) return void 0;
+	const { name } = property;
+	return ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : void 0;
+}
+/** The string literal holding the `color` of an object literal, if it has one. */
+function colorLiteral(object) {
+	if (!ts.isObjectLiteralExpression(object)) return void 0;
+	for (const property of object.properties) if (ts.isPropertyAssignment(property) && propertyName(property) === "color") return isStringLike(property.initializer) ? property.initializer : void 0;
+}
+/** Every string literal that carries a colour id: `color` values, `variant` attributes, `.color()` arguments. */
+function colourLiterals(file) {
+	const found = [];
+	function visit(node) {
+		if (ts.isPropertyAssignment(node) && propertyName(node) === "color") {
+			if (isStringLike(node.initializer)) found.push(node.initializer);
+		} else if (ts.isJsxAttribute(node) && node.name.getText(file) === "variant") {
+			const value = node.initializer;
+			if (value && ts.isStringLiteral(value)) found.push(value);
+			else if (value && ts.isJsxExpression(value) && isStringLike(value.expression)) found.push(value.expression);
+		} else if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "color" && isStringLike(node.arguments[0])) found.push(node.arguments[0]);
+		ts.forEachChild(node, visit);
+	}
+	visit(file);
+	return found;
+}
+/** Rewrites the colour ids of one source file to the Standards palette. */
+function rewritePalette(text, fileName) {
+	const { file, error } = parseSourceFile(text, fileName);
+	if (error !== void 0) return {
+		output: text,
+		changed: 0,
+		error
+	};
+	const replacements = /* @__PURE__ */ new Map();
+	for (const literal of colourLiterals(file)) {
+		const mapped = OLD_TO_NEW[literal.text];
+		if (mapped !== void 0) replacements.set(literal, mapped);
+	}
+	function resolveArray(array) {
+		const options = array.elements.map(colorLiteral).filter((literal) => literal !== void 0);
+		const taken = new Set(options.map((o) => o.text).filter((id) => PALETTE_IDS.has(id)));
+		for (const option of options) {
+			const mapped = replacements.get(option);
+			if (mapped === void 0) continue;
+			const id = taken.has(mapped) ? nearestFree(mapped, taken) ?? mapped : mapped;
+			replacements.set(option, id);
+			taken.add(id);
+		}
+	}
+	function visitArrays(node) {
+		if (ts.isArrayLiteralExpression(node)) resolveArray(node);
+		ts.forEachChild(node, visitArrays);
+	}
+	visitArrays(file);
+	const edits = [...replacements.entries()].filter(([literal, id]) => literal.text !== id).map(([literal, id]) => ({
+		start: literal.getStart(file) + 1,
+		end: literal.getEnd() - 1,
+		text: id
+	}));
+	return {
+		output: applyEdits(text, edits),
+		changed: edits.length
+	};
+}
+/** Walks `paths`, rewrites every TS or JS file, writes back when `write` is set. */
+async function runPalette(paths, options) {
+	const report = {
+		files: 0,
+		changed: 0,
+		rewritten: [],
+		failures: []
+	};
+	for (const { path, result } of await rewriteSourceFiles(paths, options.write, rewritePalette)) {
+		if (result.error !== void 0) {
+			report.failures.push({
+				file: path,
+				message: result.error
+			});
+			continue;
+		}
+		if (result.changed === 0) continue;
+		report.files += 1;
+		report.changed += result.changed;
+		report.rewritten.push({
+			file: path,
+			changed: result.changed
+		});
+	}
+	return report;
+}
+//#endregion
+export { runPalette };

package/dist/scopes-Bqw1v3wB.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+/*! © 2025-2026 AND YOU CREATE SAS (RCS Paris 940 190 614). Proprietary — see LICENSE (Standards SDK License 1.0). */
+import { r as rewriteFiles } from "./source-files-D2Bdfvhx.mjs";
+import { readFile, writeFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+//#region src/codemod/scopes.ts
+/**
+* Every package that left `@stndrds` for `@standards`: the restricted ones
+* (now on the licensed registry only) and the public ones (now on npmjs and
+* the licensed registry). A historical list: packages created later never had
+* an `@stndrds` name.
+*/
+const RENAMED_PACKAGES = [
+	"adapter-cache",
+	"adapter-kernel",
+	"adapter-meilisearch",
+	"adapter-nestjs",
+	"adapter-oidc-provider",
+	"adapter-postgres",
+	"adapter-posthog",
+	"adapter-redis",
+	"adapter-supabase",
+	"adapter-vercel-sandbox",
+	"auth",
+	"blocks",
+	"cli",
+	"client",
+	"constants",
+	"ds",
+	"engine",
+	"fonts",
+	"react",
+	"runtime",
+	"schema",
+	"ui"
+];
+const SCOPE_REGISTRY_LINE = `@standards:registry=https://registry.standards.run/`;
+/**
+* The key line belongs in the user-level `~/.npmrc`, never the project one:
+* pnpm does not expand environment variables in registry credentials read
+* from a project `.npmrc`, so `${STANDARDS_TOKEN}` there reaches the
+* registry as no key at all (401). Earlier runs of this codemod wrote it.
+*/
+const PROJECT_AUTH_LINE = /^\s*\/\/registry\.standards\.run\/:_authToken=\$\{[^}]+\}\s*$/;
+/** Public on npmjs too: a project using only these needs no licence and no registry line. */
+const PUBLIC_PACKAGES = /* @__PURE__ */ new Set([
+	"cli",
+	"client",
+	"constants",
+	"schema"
+]);
+const LICENSED_NAME = new RegExp(`@standards/(${RENAMED_PACKAGES.filter((name) => !PUBLIC_PACKAGES.has(name)).join("|")})(?![a-z0-9-])`);
+const OLD_NAME = new RegExp(`@stndrds/(${RENAMED_PACKAGES.join("|")})(?![a-z0-9-])`, "g");
+/** Code, styles, manifests, workspace config and agent guidance (AGENTS.md, CLAUDE.md). */
+const REWRITTEN_FILE = /\.(?:[cm]?tsx?|[cm]?jsx?|css|scss|sass|less|json|jsonc|ya?ml|mdx?)$/;
+/** Lockfiles are regenerated by the install that follows, never edited. */
+const LOCKFILES = /* @__PURE__ */ new Set([
+	"pnpm-lock.yaml",
+	"package-lock.json",
+	"yarn.lock",
+	"bun.lock"
+]);
+/** Renames every reference to one of our packages from `@stndrds/<name>` to `@standards/<name>`. */
+function rewriteScopes(source) {
+	let changed = 0;
+	const output = source.replace(OLD_NAME, (_match, name) => {
+		changed += 1;
+		return `@standards/${name}`;
+	});
+	return {
+		output,
+		changed,
+		licensed: LICENSED_NAME.test(output)
+	};
+}
+/**
+* Project `.npmrc` pointing `@standards` at the licensed registry: a different
+* `@standards:registry` is replaced in place, an env-variable key line for the
+* registry is removed (it never worked there), every other line is kept.
+*/
+function ensureScopesNpmrc(text) {
+	const lines = text.split("\n");
+	if (lines.at(-1) === "") lines.pop();
+	const output = lines.filter((line) => !PROJECT_AUTH_LINE.test(line)).map((line) => line.trim().startsWith("@standards:registry=") ? SCOPE_REGISTRY_LINE : line);
+	if (!output.includes(SCOPE_REGISTRY_LINE)) output.push(SCOPE_REGISTRY_LINE);
+	return `${output.join("\n")}\n`;
+}
+function isRewritten(path) {
+	return REWRITTEN_FILE.test(path) && !LOCKFILES.has(basename(path));
+}
+async function readOptional(path) {
+	try {
+		return await readFile(path, "utf8");
+	} catch {
+		return "";
+	}
+}
+async function runScopes(paths, options) {
+	const report = {
+		files: 0,
+		changed: 0,
+		licensed: false
+	};
+	const results = await rewriteFiles(paths, isRewritten, options.write, rewriteScopes);
+	for (const { result } of results) {
+		if (result.licensed) report.licensed = true;
+		if (result.changed === 0) continue;
+		report.files += 1;
+		report.changed += result.changed;
+	}
+	if (!report.licensed) return report;
+	const npmrcPath = join(options.root, ".npmrc");
+	const current = await readOptional(npmrcPath);
+	const next = ensureScopesNpmrc(current);
+	if (next !== current) {
+		report.npmrc = npmrcPath;
+		if (options.write) await writeFile(npmrcPath, next);
+	}
+	return report;
+}
+//#endregion
+export { runScopes };