@outfitter/tooling 0.3.3 → 0.3.4

package/dist/cli/init.d.ts

@@ -0,0 +1,31 @@
+/**
+* CLI init command - Initialize tooling config in a project
+*/
+/** Package.json structure for framework detection */
+interface PackageJson {
+	dependencies?: Record<string, string>;
+	devDependencies?: Record<string, string>;
+}
+/** Options for building the ultracite command */
+interface UltraciteOptions {
+	frameworks?: string[];
+	quiet?: boolean;
+}
+/**
+* Detect frameworks from package.json dependencies
+* @param pkg - Package.json contents
+* @returns Array of CLI flags for detected frameworks
+*/
+declare function detectFrameworks(pkg: PackageJson): string[];
+/**
+* Build the ultracite init command with appropriate flags
+* @param options - Command options
+* @returns Array of command arguments
+*/
+declare function buildUltraciteCommand(options: UltraciteOptions): string[];
+/**
+* Run the init command
+* @param cwd - Working directory
+*/
+declare function runInit(cwd?: string): Promise<void>;
+export { runInit, detectFrameworks, buildUltraciteCommand };

package/dist/cli/init.js

@@ -0,0 +1,12 @@
+// @bun
+import {
+  buildUltraciteCommand,
+  detectFrameworks,
+  runInit
+} from "../shared/@outfitter/tooling-9ram55dd.js";
+import"../shared/@outfitter/tooling-jnrs9rqd.js";
+export {
+  runInit,
+  detectFrameworks,
+  buildUltraciteCommand
+};

package/dist/cli/pre-push.d.ts

@@ -0,0 +1,60 @@
+/**
+* Check if branch is a TDD RED phase branch
+*/
+declare function isRedPhaseBranch(branch: string): boolean;
+/**
+* Check if branch is a scaffold branch
+*/
+declare function isScaffoldBranch(branch: string): boolean;
+declare function isReleaseBranch(branch: string): boolean;
+declare function isTestOnlyPath(path: string): boolean;
+declare function areFilesTestOnly(paths: readonly string[]): boolean;
+interface PushChangedFiles {
+	readonly files: readonly string[];
+	readonly deterministic: boolean;
+	readonly source: "upstream" | "baseRef" | "undetermined";
+}
+declare function canBypassRedPhaseByChangedFiles(changedFiles: PushChangedFiles): boolean;
+/**
+* Check whether any changed files are package source files.
+*
+* Matches files under "packages/PKGNAME/src/" (any depth).
+*/
+declare function hasPackageSourceChanges(changedFiles: PushChangedFiles): boolean;
+type ScriptMap = Readonly<Record<string, string | undefined>>;
+type VerificationPlan = {
+	readonly ok: true;
+	readonly scripts: readonly string[];
+	readonly source: "verify:ci" | "fallback";
+} | {
+	readonly ok: false;
+	readonly error: string;
+};
+/**
+* Derive strict pre-push verification from package scripts.
+*
+* Priority:
+* 1) `verify:ci`
+* 2) fallback sequence: `typecheck`, `check|lint`, `build`, `test`
+*/
+declare function createVerificationPlan(scripts: ScriptMap): VerificationPlan;
+interface BunVersionCheckResult {
+	readonly matches: boolean;
+	readonly expected?: string;
+	readonly actual?: string;
+}
+/**
+* Check that the local Bun version matches the pinned version in ".bun-version".
+*
+* @param projectRoot - Directory containing ".bun-version" (defaults to cwd)
+* @returns Result indicating whether versions match
+*/
+declare function checkBunVersion(projectRoot?: string): BunVersionCheckResult;
+interface PrePushOptions {
+	force?: boolean;
+}
+/**
+* Main pre-push command
+*/
+declare function runPrePush(options?: PrePushOptions): Promise<void>;
+export { runPrePush, isTestOnlyPath, isScaffoldBranch, isReleaseBranch, isRedPhaseBranch, hasPackageSourceChanges, createVerificationPlan, checkBunVersion, canBypassRedPhaseByChangedFiles, areFilesTestOnly, VerificationPlan, PushChangedFiles, PrePushOptions, BunVersionCheckResult };

package/dist/cli/pre-push.js

@@ -0,0 +1,27 @@
+// @bun
+import {
+  areFilesTestOnly,
+  canBypassRedPhaseByChangedFiles,
+  checkBunVersion,
+  createVerificationPlan,
+  hasPackageSourceChanges,
+  isRedPhaseBranch,
+  isReleaseBranch,
+  isScaffoldBranch,
+  isTestOnlyPath,
+  runPrePush
+} from "../shared/@outfitter/tooling-d363b88r.js";
+import"../shared/@outfitter/tooling-875svjnz.js";
+import"../shared/@outfitter/tooling-jnrs9rqd.js";
+export {
+  runPrePush,
+  isTestOnlyPath,
+  isScaffoldBranch,
+  isReleaseBranch,
+  isRedPhaseBranch,
+  hasPackageSourceChanges,
+  createVerificationPlan,
+  checkBunVersion,
+  canBypassRedPhaseByChangedFiles,
+  areFilesTestOnly
+};

package/dist/cli/upgrade-bun.d.ts

@@ -0,0 +1,8 @@
+interface UpgradeBunOptions {
+	install?: boolean;
+}
+/**
+* Main upgrade-bun command
+*/
+declare function runUpgradeBun(targetVersion?: string, options?: UpgradeBunOptions): Promise<void>;
+export { runUpgradeBun, UpgradeBunOptions };

package/dist/cli/upgrade-bun.js

@@ -0,0 +1,9 @@
+// @bun
+import {
+  runUpgradeBun
+} from "../shared/@outfitter/tooling-pq47jv6t.js";
+import"../shared/@outfitter/tooling-mkynjra9.js";
+import"../shared/@outfitter/tooling-jnrs9rqd.js";
+export {
+  runUpgradeBun
+};

package/dist/index.d.ts

@@ -1,186 +1,6 @@
-import { ZodType } from "zod";
-/** Coverage classification for a single declaration. */
-type CoverageLevel = "documented" | "partial" | "undocumented";
-/** Result for a single exported declaration. */
-interface DeclarationCoverage {
-	readonly name: string;
-	readonly kind: string;
-	readonly level: CoverageLevel;
-	readonly file: string;
-	readonly line: number;
-}
-/** Coverage summary statistics. */
-interface CoverageSummary {
-	readonly documented: number;
-	readonly partial: number;
-	readonly undocumented: number;
-	readonly total: number;
-	readonly percentage: number;
-}
-/** Per-package TSDoc coverage stats. */
-interface PackageCoverage {
-	readonly name: string;
-	readonly path: string;
-	readonly declarations: readonly DeclarationCoverage[];
-	readonly documented: number;
-	readonly partial: number;
-	readonly undocumented: number;
-	readonly total: number;
-	readonly percentage: number;
-}
-/** Aggregated result across all packages. */
-interface TsDocCheckResult {
-	readonly ok: boolean;
-	readonly packages: readonly PackageCoverage[];
-	readonly summary: CoverageSummary;
-}
-/** Zod schema for {@link CoverageLevel}. */
-declare const coverageLevelSchema: ZodType<CoverageLevel>;
-/** Zod schema for {@link DeclarationCoverage}. */
-declare const declarationCoverageSchema: ZodType<DeclarationCoverage>;
-/** Zod schema for {@link PackageCoverage}. */
-declare const packageCoverageSchema: ZodType<PackageCoverage>;
-/** Zod schema for {@link TsDocCheckResult}. */
-declare const tsDocCheckResultSchema: ZodType<TsDocCheckResult>;
-/** Options for the check-tsdoc command. */
-interface CheckTsDocOptions {
-	readonly strict?: boolean | undefined;
-	readonly json?: boolean | undefined;
-	readonly minCoverage?: number | undefined;
-	readonly cwd?: string | undefined;
-	readonly paths?: readonly string[] | undefined;
-}
-/**
-* Analyze TSDoc coverage across workspace packages.
-*
-* Pure function that discovers packages, analyzes TSDoc coverage on exported
-* declarations, and returns the aggregated result. Does not print output or
-* call `process.exit()`.
-*
-* @param options - Analysis options (paths, strict mode, coverage threshold)
-* @returns Aggregated coverage result across all packages, or `null` if no packages found
-*/
-declare function analyzeCheckTsdoc(options?: CheckTsDocOptions): TsDocCheckResult | null;
-/**
-* Print a TSDoc coverage result in human-readable format.
-*
-* Renders a bar chart per package with summary statistics. Writes to stdout/stderr.
-*
-* @param result - The coverage result to print
-* @param options - Display options (strict mode, coverage threshold for warning)
-*/
-declare function printCheckTsdocHuman(result: TsDocCheckResult, options?: {
-	strict?: boolean | undefined;
-	minCoverage?: number | undefined;
-}): void;
-import { ZodType as ZodType2 } from "zod";
-/**
-* File entry in a block.
-*/
-interface FileEntry {
-	/** Destination path relative to project root */
-	path: string;
-	/** File contents (embedded in registry) */
-	content: string;
-	/** Whether to chmod +x after copying */
-	executable?: boolean | undefined;
-	/** Whether to process as a template (future) */
-	template?: boolean | undefined;
-}
-/**
-* Schema for a file entry in a block.
-* Represents a file that will be copied to the user's project.
-*/
-declare const FileEntrySchema: ZodType2<FileEntry>;
-/**
-* Block in the registry.
-*/
-interface Block {
-	/** Block name (matches the key in blocks record) */
-	name: string;
-	/** Human-readable description */
-	description: string;
-	/** Files included in this block */
-	files?: FileEntry[] | undefined;
-	/** npm dependencies to add to package.json */
-	dependencies?: Record<string, string> | undefined;
-	/** npm devDependencies to add to package.json */
-	devDependencies?: Record<string, string> | undefined;
-	/** Other blocks this block extends (for composite blocks) */
-	extends?: string[] | undefined;
-}
-/**
-* Schema for a block in the registry.
-* A block is a collection of related files that can be added together.
-*/
-declare const BlockSchema: ZodType2<Block>;
-/**
-* Complete registry structure.
-*/
-interface Registry {
-	/** Registry schema version */
-	version: string;
-	/** Map of block name to block definition */
-	blocks: Record<string, Block>;
-}
-/**
-* Schema for the complete registry.
-* Contains all available blocks with their files and metadata.
-*/
-declare const RegistrySchema: ZodType2<Registry>;
-/**
-* Block definition used in the build script.
-* Specifies how to collect source files into a block.
-*/
-interface BlockDefinition {
-	/** Human-readable description */
-	description: string;
-	/** Source file paths (relative to repo root) */
-	files?: string[];
-	/** Remap source paths to destination paths */
-	remap?: Record<string, string>;
-	/** npm dependencies */
-	dependencies?: Record<string, string>;
-	/** npm devDependencies */
-	devDependencies?: Record<string, string>;
-	/** Other blocks this block extends */
-	extends?: string[];
-}
-/**
-* Configuration for the registry build.
-*/
-interface RegistryBuildConfig {
-	/** Registry schema version */
-	version: string;
-	/** Block definitions */
-	blocks: Record<string, BlockDefinition>;
-}
-/**
-* Result of adding a block to a project.
-*/
-interface AddBlockResult {
-	/** Files that were created */
-	created: string[];
-	/** Files that were skipped (already exist) */
-	skipped: string[];
-	/** Files that were overwritten (with --force) */
-	overwritten: string[];
-	/** Dependencies added to package.json */
-	dependencies: Record<string, string>;
-	/** devDependencies added to package.json */
-	devDependencies: Record<string, string>;
-}
-/**
-* Options for the add command.
-*/
-interface AddBlockOptions {
-	/** Overwrite existing files */
-	force?: boolean;
-	/** Show what would be added without making changes */
-	dryRun?: boolean;
-	/** Working directory (defaults to cwd) */
-	cwd?: string;
-}
-/** Package version, read from package.json at load time. */
-declare const VERSION: string;
-export { tsDocCheckResultSchema, printCheckTsdocHuman, packageCoverageSchema, declarationCoverageSchema, coverageLevelSchema, analyzeCheckTsdoc, VERSION, TsDocCheckResult, RegistrySchema, RegistryBuildConfig, Registry, PackageCoverage, FileEntrySchema, FileEntry, DeclarationCoverage, CoverageLevel, CheckTsDocOptions, BlockSchema, BlockDefinition, Block, AddBlockResult, AddBlockOptions };
+import { CheckTsDocOptions, CoverageLevel, DeclarationCoverage, PackageCoverage, TsDocCheckResult, analyzeCheckTsdoc, coverageLevelSchema, declarationCoverageSchema, packageCoverageSchema, printCheckTsdocHuman, tsDocCheckResultSchema } from "./shared/@outfitter/tooling-njw4z34x.js";
+import { ParsedSemver, isTypesBunVersionCompatible, parseSemver } from "./shared/@outfitter/tooling-vjmhvpjq.js";
+import { VERSION } from "./shared/@outfitter/tooling-9vs606gq.js";
+import "./shared/@outfitter/tooling-xqwn46sx.js";
+import { AddBlockOptions, AddBlockResult, Block, BlockDefinition, BlockSchema, FileEntry, FileEntrySchema, Registry, RegistryBuildConfig, RegistrySchema } from "./shared/@outfitter/tooling-sjm8nebx.js";
+export { tsDocCheckResultSchema, printCheckTsdocHuman, parseSemver, packageCoverageSchema, isTypesBunVersionCompatible, declarationCoverageSchema, coverageLevelSchema, analyzeCheckTsdoc, VERSION, TsDocCheckResult, RegistrySchema, RegistryBuildConfig, Registry, ParsedSemver, PackageCoverage, FileEntrySchema, FileEntry, DeclarationCoverage, CoverageLevel, CheckTsDocOptions, BlockSchema, BlockDefinition, Block, AddBlockResult, AddBlockOptions };

package/dist/index.js

@@ -1,42 +1,4 @@
-import {
-  VERSION,
-  analyzeCheckTsdoc,
-  coverageLevelSchema,
-  declarationCoverageSchema,
-  packageCoverageSchema,
-  printCheckTsdocHuman,
-  tsDocCheckResultSchema
-} from "./shared/chunk-cmde0fwx.js";
-import"./shared/chunk-3s189drz.js";
-// src/registry/schema.ts
-import { z } from "zod";
-var FileEntrySchema = z.object({
-  path: z.string().min(1),
-  content: z.string(),
-  executable: z.boolean().optional(),
-  template: z.boolean().optional()
-});
-var BlockSchema = z.object({
-  name: z.string().min(1),
-  description: z.string().min(1),
-  files: z.array(FileEntrySchema).optional(),
-  dependencies: z.record(z.string(), z.string()).optional(),
-  devDependencies: z.record(z.string(), z.string()).optional(),
-  extends: z.array(z.string()).optional()
-});
-var RegistrySchema = z.object({
-  version: z.string(),
-  blocks: z.record(z.string(), BlockSchema)
-});
-export {
-  tsDocCheckResultSchema,
-  printCheckTsdocHuman,
-  packageCoverageSchema,
-  declarationCoverageSchema,
-  coverageLevelSchema,
-  analyzeCheckTsdoc,
-  VERSION,
-  RegistrySchema,
-  FileEntrySchema,
-  BlockSchema
-};
+export { analyzeCheckTsdoc, coverageLevelSchema, declarationCoverageSchema, packageCoverageSchema, printCheckTsdocHuman, tsDocCheckResultSchema } from "./cli/check-tsdoc.js";
+export { isTypesBunVersionCompatible, parseSemver } from "./bun-version-compat.js";
+export { BlockSchema, FileEntrySchema, RegistrySchema } from "./registry/index.js";
+export { VERSION } from "./version.js";

package/dist/registry/build.d.ts

@@ -0,0 +1,4 @@
+import { RegistryBuildConfig } from "../shared/@outfitter/tooling-sjm8nebx.js";
+/** Registry build configuration with dynamically resolved versions. */
+declare const REGISTRY_CONFIG: RegistryBuildConfig;
+export { REGISTRY_CONFIG };

package/dist/registry/build.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env bun
+// @bun
+import"../shared/@outfitter/tooling-jnrs9rqd.js";
+
+// packages/tooling/src/registry/build.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync,
+  readFileSync as readFileSync2,
+  statSync as statSync2,
+  writeFileSync
+} from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// packages/presets/dist/index.js
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { dirname, isAbsolute, join, relative, resolve } from "path";
+import { fileURLToPath } from "url";
+var DEPENDENCY_SECTIONS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function loadWorkspaceCatalog(packageDir) {
+  let dir = packageDir;
+  for (let i = 0;i < 10; i++) {
+    const rootPkgPath = join(dir, "package.json");
+    if (existsSync(rootPkgPath)) {
+      try {
+        const raw = JSON.parse(readFileSync(rootPkgPath, "utf-8"));
+        if (isRecord(raw) && isRecord(raw["catalog"])) {
+          const catalog = {};
+          for (const [name, version] of Object.entries(raw["catalog"])) {
+            if (typeof version === "string") {
+              catalog[name] = version;
+            }
+          }
+          return catalog;
+        }
+      } catch {}
+    }
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return {};
+}
+function getResolvedVersions() {
+  const packageDir = join(dirname(fileURLToPath(import.meta.url)), "..");
+  const packageJsonPath = join(packageDir, "package.json");
+  const raw = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  if (!isRecord(raw)) {
+    throw new Error("@outfitter/presets package.json must be a JSON object");
+  }
+  const all = {};
+  let hasCatalogRefs = false;
+  for (const section of DEPENDENCY_SECTIONS) {
+    const deps = raw[section];
+    if (!isRecord(deps))
+      continue;
+    for (const [name, version] of Object.entries(deps)) {
+      if (typeof version === "string") {
+        if (version === "catalog:") {
+          hasCatalogRefs = true;
+        } else {
+          all[name] = version;
+        }
+      }
+    }
+  }
+  if (hasCatalogRefs) {
+    const catalog = loadWorkspaceCatalog(packageDir);
+    const unresolved = [];
+    for (const section of DEPENDENCY_SECTIONS) {
+      const deps = raw[section];
+      if (!isRecord(deps))
+        continue;
+      for (const [name, version] of Object.entries(deps)) {
+        if (version === "catalog:") {
+          if (catalog[name]) {
+            all[name] = catalog[name];
+          } else {
+            unresolved.push(name);
+          }
+        }
+      }
+    }
+    if (unresolved.length > 0) {
+      throw new Error(`Unresolvable catalog: references (no catalog entry found): ${unresolved.join(", ")}`);
+    }
+  }
+  return { all };
+}
+
+// packages/tooling/src/registry/build.ts
+function log(message) {
+  process.stdout.write(`${message}
+`);
+}
+function findRepoRoot(startDir) {
+  let dir = startDir;
+  while (dir !== "/") {
+    const pkgPath = join2(dir, "package.json");
+    if (existsSync2(pkgPath)) {
+      const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+      if (pkg.workspaces) {
+        return dir;
+      }
+    }
+    dir = dirname2(dir);
+  }
+  throw new Error("Could not find repository root");
+}
+function isExecutable(filePath) {
+  try {
+    const stats = statSync2(filePath);
+    return (stats.mode & 64) !== 0;
+  } catch {
+    return false;
+  }
+}
+function readFileEntry(repoRoot, sourcePath, destPath) {
+  const fullPath = join2(repoRoot, sourcePath);
+  if (!existsSync2(fullPath)) {
+    throw new Error(`Source file not found: ${fullPath}`);
+  }
+  const content = readFileSync2(fullPath, "utf-8");
+  const executable = isExecutable(fullPath);
+  return {
+    path: destPath,
+    content,
+    ...executable && { executable: true }
+  };
+}
+function buildBlock(repoRoot, name, def) {
+  const block = {
+    name,
+    description: def.description
+  };
+  if (def.files && def.files.length > 0) {
+    block.files = def.files.map((sourcePath) => {
+      const destPath = def.remap?.[sourcePath] ?? sourcePath;
+      return readFileEntry(repoRoot, sourcePath, destPath);
+    });
+  }
+  if (def.dependencies && Object.keys(def.dependencies).length > 0) {
+    block.dependencies = def.dependencies;
+  }
+  if (def.devDependencies && Object.keys(def.devDependencies).length > 0) {
+    block.devDependencies = def.devDependencies;
+  }
+  if (def.extends && def.extends.length > 0) {
+    block.extends = def.extends;
+  }
+  return block;
+}
+function buildRegistry(config, repoRoot) {
+  const blocks = {};
+  for (const [name, def] of Object.entries(config.blocks)) {
+    blocks[name] = buildBlock(repoRoot, name, def);
+  }
+  return {
+    version: config.version,
+    blocks
+  };
+}
+function resolveVersion(versions, name) {
+  const version = versions[name];
+  if (!version) {
+    throw new Error(`Missing resolved version for "${name}" in @outfitter/presets`);
+  }
+  return version;
+}
+function getWorkspacePackageVersion(relativePackageJsonPath) {
+  const pkgPath = join2(dirname2(fileURLToPath2(import.meta.url)), relativePackageJsonPath);
+  const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+  if (typeof pkg.version !== "string") {
+    throw new Error(`Expected version in package.json at ${pkgPath}`);
+  }
+  return `^${pkg.version}`;
+}
+function getToolingVersion() {
+  return getWorkspacePackageVersion("../../package.json");
+}
+function getOxlintPluginVersion() {
+  return getWorkspacePackageVersion("../../../oxlint-plugin/package.json");
+}
+function createRegistryConfig() {
+  const { all: versions } = getResolvedVersions();
+  const toolingVersion = getToolingVersion();
+  const oxlintPluginVersion = getOxlintPluginVersion();
+  return {
+    version: "1.0.0",
+    blocks: {
+      claude: {
+        description: "Claude Code settings and hooks for automated formatting",
+        files: [
+          ".claude/settings.json",
+          ".claude/hooks/format-code-on-stop.sh"
+        ]
+      },
+      linter: {
+        description: "Linter and formatter configuration (oxlint/oxfmt) via Ultracite",
+        files: [
+          "packages/tooling/configs/.oxlintrc.json",
+          "packages/tooling/configs/.oxfmtrc.jsonc"
+        ],
+        remap: {
+          "packages/tooling/configs/.oxlintrc.json": ".oxlintrc.json",
+          "packages/tooling/configs/.oxfmtrc.jsonc": ".oxfmtrc.jsonc"
+        },
+        devDependencies: {
+          "@outfitter/oxlint-plugin": oxlintPluginVersion,
+          ultracite: resolveVersion(versions, "ultracite"),
+          oxlint: resolveVersion(versions, "oxlint"),
+          oxfmt: resolveVersion(versions, "oxfmt")
+        }
+      },
+      lefthook: {
+        description: "Git hooks via Lefthook for pre-commit and pre-push",
+        files: ["packages/tooling/lefthook.yml"],
+        remap: { "packages/tooling/lefthook.yml": ".lefthook.yml" },
+        devDependencies: {
+          "@outfitter/tooling": toolingVersion,
+          lefthook: resolveVersion(versions, "lefthook"),
+          ultracite: resolveVersion(versions, "ultracite")
+        }
+      },
+      markdownlint: {
+        description: "Markdown linting configuration via markdownlint-cli2",
+        files: ["packages/tooling/.markdownlint-cli2.jsonc"],
+        remap: {
+          "packages/tooling/.markdownlint-cli2.jsonc": ".markdownlint-cli2.jsonc"
+        }
+      },
+      bootstrap: {
+        description: "Project bootstrap script for installing tools and dependencies",
+        files: ["packages/tooling/templates/bootstrap.sh"],
+        remap: {
+          "packages/tooling/templates/bootstrap.sh": "scripts/bootstrap.sh"
+        }
+      },
+      scaffolding: {
+        description: "Full starter kit: Claude settings, oxlint/oxfmt, Lefthook, markdownlint, and bootstrap script",
+        extends: ["claude", "linter", "lefthook", "markdownlint", "bootstrap"]
+      }
+    }
+  };
+}
+var REGISTRY_CONFIG = createRegistryConfig();
+function main() {
+  const scriptDir = dirname2(new URL(import.meta.url).pathname);
+  const repoRoot = findRepoRoot(scriptDir);
+  const outputDir = join2(repoRoot, "packages/tooling/registry");
+  const outputPath = join2(outputDir, "registry.json");
+  log(`Building registry from: ${repoRoot}`);
+  if (!existsSync2(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+  const registry = buildRegistry(REGISTRY_CONFIG, repoRoot);
+  writeFileSync(outputPath, `${JSON.stringify(registry, null, "\t")}
+`);
+  const blockCount = Object.keys(registry.blocks).length;
+  const fileCount = Object.values(registry.blocks).flatMap((b) => b.files ?? []).length;
+  log(`\u2713 Generated ${outputPath}`);
+  log(`  ${blockCount} blocks, ${fileCount} files embedded`);
+}
+if (import.meta.main) {
+  main();
+}
+export {
+  REGISTRY_CONFIG
+};

package/dist/registry/index.d.ts

@@ -0,0 +1,3 @@
+import "../shared/@outfitter/tooling-xqwn46sx.js";
+import { AddBlockOptions, AddBlockResult, Block, BlockDefinition, BlockSchema, FileEntry, FileEntrySchema, Registry, RegistryBuildConfig, RegistrySchema } from "../shared/@outfitter/tooling-sjm8nebx.js";
+export { RegistrySchema, RegistryBuildConfig, Registry, FileEntrySchema, FileEntry, BlockSchema, BlockDefinition, Block, AddBlockResult, AddBlockOptions };

package/dist/registry/index.js

@@ -0,0 +1 @@
+export { BlockSchema, FileEntrySchema, RegistrySchema } from "./schema.js";

package/dist/registry/schema.d.ts

@@ -0,0 +1,2 @@
+import { AddBlockOptions, AddBlockResult, Block, BlockDefinition, BlockSchema, FileEntry, FileEntrySchema, Registry, RegistryBuildConfig, RegistrySchema } from "../shared/@outfitter/tooling-sjm8nebx.js";
+export { RegistrySchema, RegistryBuildConfig, Registry, FileEntrySchema, FileEntry, BlockSchema, BlockDefinition, Block, AddBlockResult, AddBlockOptions };