@omnifyjp/ts 7.0.1 → 7.0.3

package/dist/php/faker-mapper.js

@@ -18,8 +18,8 @@ export function toFaker(propName, property, schemas = {}) {
         case 'Int':
         case 'BigInt': return intFaker(snakeName, property);
         case 'TinyInt': return `'${snakeName}' => fake()->numberBetween(0, 127),`;
-        case 'Float':
-        case 'Decimal': return `'${snakeName}' => fake()->randomFloat(2, 1, 10000),`;
+        case 'Float': return `'${snakeName}' => fake()->randomFloat(2, 1, 10000),`;
+        case 'Decimal': return decimalFaker(snakeName, property);
         case 'Boolean': return `'${snakeName}' => fake()->boolean(),`;
         case 'Text': return `'${snakeName}' => fake()->paragraphs(3, true),`;
         case 'MediumText': return `'${snakeName}' => fake()->paragraphs(3, true),`;
@@ -82,43 +82,81 @@ export function associationFaker(propName, property, modelNamespace, currentSche
     return { fake, import: importLine };
 }
 function stringFaker(propName, snakeName, property) {
+    const expr = stringFakerExpr(propName, snakeName, property);
+    const length = property['length'];
+    // Clamp to the column's actual length regardless of which branch above
+    // picked the generator: a wrong/over-eager name heuristic (or a caller
+    // constraining `length` below what the heuristic normally produces) must
+    // stay inside the column instead of overflowing it — an SQL 1406 on
+    // MySQL/MariaDB weeks after the schema shipped (sqlite enforces no such
+    // limit, so this was invisible locally). Applied uniformly to every
+    // generator here rather than cherry-picked per branch (#264).
+    const value = length != null ? `mb_substr(${expr}, 0, ${length})` : expr;
+    return `'${snakeName}' => ${value},`;
+}
+function stringFakerExpr(propName, snakeName, property) {
     const lower = propName.toLowerCase();
+    // Name-heuristic tokens, split on the already-normalized snake_case column
+    // name so a single word boundary decides a match — `shipAddress` must not
+    // trip the bare `ip` check meant for `ipAddress` (#264: more-specific
+    // patterns must win, deterministically, not by accidental substring order).
+    const tokens = snakeName.split('_');
     if (propName === 'slug')
-        return `'${snakeName}' => fake()->unique()->slug(2),`;
+        return `fake()->unique()->slug(2)`;
     if (propName === 'uuid' || propName === 'uid')
-        return `'${snakeName}' => (string) \\Illuminate\\Support\\Str::uuid(),`;
+        return `(string) \\Illuminate\\Support\\Str::uuid()`;
+    if (tokens.includes('ip'))
+        return `fake()->ipv4()`;
     if (lower.includes('email'))
-        return `'${snakeName}' => fake()->unique()->safeEmail(),`;
+        return `fake()->unique()->safeEmail()`;
     if (lower.includes('phone'))
-        return `'${snakeName}' => fake()->phoneNumber(),`;
+        return `fake()->phoneNumber()`;
     if (lower.includes('image') || lower.includes('photo') || lower.includes('avatar'))
-        return `'${snakeName}' => fake()->imageUrl(),`;
+        return `fake()->imageUrl()`;
     if (lower.includes('url') || lower.includes('website'))
-        return `'${snakeName}' => fake()->url(),`;
+        return `fake()->url()`;
     if (lower.includes('path') || lower.includes('file'))
-        return `'${snakeName}' => 'uploads/'.fake()->uuid().'.jpg',`;
+        return `'uploads/'.fake()->uuid().'.jpg'`;
     if (propName === 'name' || propName === 'title')
-        return `'${snakeName}' => fake()->sentence(3),`;
+        return `fake()->sentence(3)`;
     if (lower.includes('name'))
-        return `'${snakeName}' => fake()->name(),`;
+        return `fake()->name()`;
     if (lower.includes('address'))
-        return `'${snakeName}' => fake()->address(),`;
+        return `fake()->address()`;
     if (lower.includes('city'))
-        return `'${snakeName}' => fake()->city(),`;
+        return `fake()->city()`;
     if (lower.includes('country'))
-        return `'${snakeName}' => fake()->country(),`;
+        return `fake()->country()`;
     if (lower.includes('zip') || lower.includes('postal'))
-        return `'${snakeName}' => fake()->postcode(),`;
+        return `fake()->postcode()`;
     if (lower.includes('color'))
-        return `'${snakeName}' => fake()->hexColor(),`;
+        return `fake()->hexColor()`;
     if (lower.includes('token') || lower.includes('secret') || lower.includes('key'))
-        return `'${snakeName}' => \\Illuminate\\Support\\Str::random(32),`;
+        return `\\Illuminate\\Support\\Str::random(32)`;
     if (lower.includes('code'))
-        return `'${snakeName}' => fake()->unique()->regexify('[A-Z0-9]{8}'),`;
+        return `fake()->unique()->regexify('[A-Z0-9]{8}')`;
     const length = property['length'];
     if (length != null && length <= 50)
-        return `'${snakeName}' => fake()->words(3, true),`;
-    return `'${snakeName}' => fake()->sentence(),`;
+        return `fake()->words(3, true)`;
+    return `fake()->sentence()`;
+}
+/** Largest value a `Decimal(precision, scale)` column accepts (all-9s at that precision/scale). */
+function decimalMax(precision, scale) {
+    const digits = '9'.repeat(Math.max(precision, 1));
+    if (scale <= 0)
+        return digits;
+    const intPart = digits.slice(0, digits.length - scale) || '0';
+    const fracPart = digits.slice(digits.length - scale);
+    return `${intPart}.${fracPart}`;
+}
+function decimalFaker(snakeName, property) {
+    // Laravel's default Decimal migration is `decimal(8, 2)` (blueprint.go),
+    // matched here so an unspecified precision/scale keeps generating the same
+    // range as before.
+    const precision = property['precision'] ?? 8;
+    const scale = property['scale'] ?? 2;
+    const max = decimalMax(precision, scale);
+    return `'${snakeName}' => fake()->randomFloat(${scale}, 0, ${max}),`;
 }
 function intFaker(snakeName, property) {
     const isUnique = property['unique'] ?? false;

package/dist/php/orphan-cleanup.js

@@ -19,7 +19,8 @@
  * warning is printed so the user can decide whether to clean up by hand.
  */
 import { existsSync, readFileSync, readdirSync, statSync, unlinkSync } from 'node:fs';
-import { join, resolve, basename } from 'node:path';
+import { join, relative, resolve, basename } from 'node:path';
+import { resolveModularBaseNamespace } from './types.js';
 /** Matches the header emitted by `generateEditableService` in service-generator.ts */
 export const OMNIFY_EDITABLE_SERVICE_MARKER = 'SAFE TO EDIT - This file is never overwritten by Omnify.';
 const EXTENDS_SERVICE_BASE_RE = /extends\s+[\w\\]+ServiceBase\b/;
@@ -60,34 +61,83 @@ function collectModularLayerDirs(configDir, config, category) {
     for (const entry of readdirSync(modulesAbs)) {
         const layerDir = join(modulesAbs, entry, category);
         if (existsSync(layerDir) && statSync(layerDir).isDirectory()) {
-            dirs.push(layerDir);
+            dirs.push({
+                dir: layerDir,
+                namespace: resolveModularBaseNamespace(config, entry, category, ''),
+            });
         }
     }
     return dirs;
 }
+/**
+ * FQCN a base file claims from its LOCATION: the layer root's namespace,
+ * one segment per group subdirectory, then the class name from the file
+ * name (`Base/Crm/FooRequestBase.php` under `App\...\Base` →
+ * `App\...\Base\Crm\FooRequestBase`). Derived relative to the layer
+ * root, never from the bare basename — a grouped file's group segment
+ * is part of its identity, and it is also what hand-written `use`
+ * imports name (#263).
+ */
+function fqcnFromLayerRelativePath(rootNamespace, relPath) {
+    const segments = relPath.split(/[\\/]/).filter((s) => s.length > 0);
+    const fileName = segments.pop();
+    if (!fileName)
+        return rootNamespace;
+    return [rootNamespace, ...segments, fileName.replace(/\.php$/i, '')]
+        .filter((s) => s.length > 0)
+        .join('\\');
+}
+/**
+ * Recursively visit every file under `root`. Directories are entered
+ * but never removed — the surrounding cleanup (pruneOrphanServiceFiles,
+ * walkPhpFiles) deletes files only and leaves emptied folders behind,
+ * and this prune matches that behaviour.
+ */
+function walkLayerFiles(root, visit) {
+    if (!existsSync(root))
+        return;
+    let entries;
+    try {
+        entries = readdirSync(root);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const full = join(root, entry);
+        let info;
+        try {
+            info = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (info.isDirectory()) {
+            walkLayerFiles(full, visit);
+        }
+        else {
+            visit(full);
+        }
+    }
+}
 function pruneDisabledLayerBasesInRoots(spec, roots, expectedAbs, referenced) {
     let pruned = 0;
     let kept = 0;
+    // Grouped schemas nest their bases one directory per group
+    // (`app/Omnify/Requests/OmnifyBase/Crm/FooRequestBase.php`), so the
+    // walk must recurse — a one-level `readdirSync` leaves every grouped
+    // stale base on disk (#263).
     for (const root of roots) {
-        if (!existsSync(root))
-            continue;
-        for (const entry of readdirSync(root)) {
-            if (!spec.matchesBaseFile(entry))
-                continue;
-            const fullPath = join(root, entry);
+        walkLayerFiles(root.dir, (fullPath) => {
+            const name = basename(fullPath);
+            if (!spec.matchesBaseFile(name))
+                return;
             if (expectedAbs.has(fullPath))
-                continue;
-            let content = '';
-            try {
-                content = readFileSync(fullPath, 'utf-8');
-            }
-            catch {
-                continue;
-            }
-            const fqcn = declaredClassName(content);
-            if (fqcn && referenced.has(fqcn)) {
+                return;
+            const fqcn = fqcnFromLayerRelativePath(root.namespace, relative(root.dir, fullPath));
+            if (referenced.has(fqcn)) {
                 kept += 1;
-                continue;
+                return;
             }
             try {
                 unlinkSync(fullPath);
@@ -96,7 +146,7 @@ function pruneDisabledLayerBasesInRoots(spec, roots, expectedAbs, referenced) {
             catch {
                 // skip uncleanable files
             }
-        }
+        });
     }
     return { pruned, kept };
 }
@@ -115,7 +165,7 @@ export function pruneDisabledScaffoldLayerBases(configDir, config, generated, re
             continue;
         const roots = [
             ...collectModularLayerDirs(configDir, config, spec.modularCategory),
-            resolve(configDir, spec.legacyBasePath),
+            { dir: resolve(configDir, spec.legacyBasePath), namespace: spec.layerConfig.baseNamespace },
         ];
         const { pruned, kept } = pruneDisabledLayerBasesInRoots(spec, roots, expectedAbs, referenced);
         if (pruned > 0 || kept > 0) {

package/dist/php/request-generator.js

@@ -3,7 +3,32 @@
  */
 import { toPascalCase, toSnakeCase, toCamelCase, toFkColumnName } from './naming-helper.js';
 import { toStoreRules, toUpdateRules, formatRules, resolveFkRuleType } from './type-mapper.js';
-import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass, nestByGroup, nestEditableByGroup } from './types.js';
+import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveBaseClass, resolveEditableClass, nestByGroup, nestEditableByGroup, resolveGlobalEnumNamespace } from './types.js';
+import { enumClassName } from './enum-generator.js';
+/**
+ * Format rules for an EnumRef property, replacing the generic `'string'` rule
+ * `toStoreRules`/`toUpdateRules` emit for EnumRef with `Rule::enum(<Class>::class)`
+ * — bare `'string'` lets any value through validation while the model cast
+ * and migration column both enforce the enum's set (#265). Duplicates just
+ * enough of `formatRules`' string/rule_unique_ignore branches, since the
+ * `Rule::enum(...)` case can't be added to type-mapper.ts's `Rule` union from
+ * here without editing a file this job does not own.
+ */
+function formatEnumRefRules(rules, enumFqcn) {
+    const parts = [];
+    for (const rule of rules) {
+        if (rule === 'string') {
+            parts.push(`Rule::enum(${enumFqcn}::class)`);
+        }
+        else if (typeof rule === 'string') {
+            parts.push(`'${rule}'`);
+        }
+        else if (Array.isArray(rule) && rule[0] === 'rule_unique_ignore') {
+            parts.push(`Rule::unique('${rule[1]}')->ignore($this->route('${rule[2]}'))`);
+        }
+    }
+    return `[${parts.join(', ')}]`;
+}
 /** Generate Store/Update request classes for all project-owned visible object schemas. */
 export function generateRequests(reader, config) {
     if (!config.requests.enabled)
@@ -142,7 +167,21 @@ function generateBaseRequest(name, schema, reader, config, action) {
         const rules = isUpdate
             ? toUpdateRules(prop, tableName, modelRouteParam)
             : toStoreRules(prop, tableName);
-        rulesLines.push(`            '${snakeName}' => ${formatRules(rules)},`);
+        // EnumRef: validate against the enum's actual value set via Rule::enum()
+        // instead of the bare 'string' toStoreRules/toUpdateRules emit for it —
+        // otherwise an out-of-set string passes validation, hits the DB, and only
+        // explodes later when the model cast reads it back (#265). Use the exact
+        // FQCN the model cast/doc-block already use (model-generator.ts's
+        // buildCasts), so validation and the cast never disagree. Falls back to
+        // the plain rules when the referenced enum schema doesn't exist, matching
+        // toStoreRules' own fallback for that case.
+        const enumName = type === 'EnumRef' ? prop['enum'] : undefined;
+        const enumSchema = typeof enumName === 'string' ? reader.getSchema(enumName) : undefined;
+        const globalEnumNs = type === 'EnumRef' ? resolveGlobalEnumNamespace(config, config.models.namespace) : '';
+        const formattedRules = typeof enumName === 'string' && enumSchema?.kind === 'enum' && globalEnumNs
+            ? formatEnumRefRules(rules, `\\${globalEnumNs}\\${enumClassName(enumName)}`)
+            : formatRules(rules);
+        rulesLines.push(`            '${snakeName}' => ${formattedRules},`);
         attributeKeys.push(snakeName);
         // Translatable: add locale-nested rules (Astrotomic expects {locale}.{field})
         const isTranslatable = prop['translatable'] ?? false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/ts",
-  "version": "7.0.1",
+  "version": "7.0.3",
   "description": "TypeScript model type generator from Omnify schemas.json",
   "type": "module",
   "main": "dist/index.js",
@@ -9,7 +9,7 @@
     "omnify-ts": "dist/cli.js"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\" && tsc",
     "dev": "tsc --watch",
     "generate-l12": "node dist/cli.js --config ../../examples/l12/omnify.yaml",
     "test": "vitest run"

package/dist/php/pint-format.d.ts

@@ -1,57 +0,0 @@
-/**
- * Auto-format generated PHP files via Laravel Pint. Issue #100 v5.8.20.
- *
- * Reporter scenario (godx-jp/godx-kintai 2026-04-26 audit): every
- * `omnify generate --force` produces 150+ PHP files that fail Laravel
- * Pint's standard preset (`vendor/bin/pint --test`):
- *
- *   - ordered_imports — `use` statements not alphabetised
- *   - fully_qualified_strict_types — exception types referenced via FQN
- *   - class_attributes_separation — missing blank lines between members
- *   - function_declaration — function-keyword spacing
- *   - unary_operator_spaces — `! \$x` vs `!\$x`
- *   - no_unused_imports — codegen leaves the occasional dangling import
- *   - single_line_empty_body — empty class bodies on multiple lines
- *   - self_static_accessor — `self::` vs `static::` on enums
- *   - blank_line_before_statement — enum `case` separators
- *
- * Auto-detect: when `<rootPath>/vendor/bin/pint` exists, run it on the
- * files we just wrote. Same Pint preset the project's CI already uses,
- * so no risk of formatter drift between codegen and CI checks.
- *
- * Opt-out: future config field; for now `chmod -x vendor/bin/pint` or
- * deleting it disables the auto-run.
- */
-/**
- * Resolve the `vendor/bin/pint` path for the project. Walks up from
- * the first written file until we find a sibling `vendor/bin/pint`,
- * stopping at filesystem root or after 12 levels (defensive against
- * pathological inputs). Returns the absolute path or null.
- */
-export declare function findPintBinary(anyWrittenPhpPath: string): string | null;
-export interface PintFormatResult {
-    ran: boolean;
-    pintPath: string | null;
-    /** Files passed to pint. */
-    formattedCount: number;
-    /** Pint's exit status if it ran. 0 = success. */
-    exitStatus: number | null;
-    /** Captured stderr when pint failed (status != 0). */
-    errorMessage?: string;
-    /**
-     * Why the run did not happen, when `ran` is false. The caller needs the three apart: only
-     * `pint-not-found` is worth telling a human about, and it is the one that silently changes what
-     * gets written to disk (godx-jp/godx-corebooks#108 — 927 files, reproduced).
-     */
-    skipped?: 'no-php-files' | 'opted-out' | 'pint-not-found';
-}
-/**
- * Run Laravel Pint on the given PHP files (absolute paths). No-op if
- * Pint isn't installed in the project. Pint is invoked with `--quiet`
- * so it stays out of the way unless something breaks.
- *
- * Pint takes a list of files (or directories) and formats them in
- * place. It uses the project's `pint.json` config if present, else the
- * Laravel preset.
- */
-export declare function runPintFormat(writtenPhpPaths: string[]): PintFormatResult;

package/dist/php/pint-format.js

@@ -1,102 +0,0 @@
-/**
- * Auto-format generated PHP files via Laravel Pint. Issue #100 v5.8.20.
- *
- * Reporter scenario (godx-jp/godx-kintai 2026-04-26 audit): every
- * `omnify generate --force` produces 150+ PHP files that fail Laravel
- * Pint's standard preset (`vendor/bin/pint --test`):
- *
- *   - ordered_imports — `use` statements not alphabetised
- *   - fully_qualified_strict_types — exception types referenced via FQN
- *   - class_attributes_separation — missing blank lines between members
- *   - function_declaration — function-keyword spacing
- *   - unary_operator_spaces — `! \$x` vs `!\$x`
- *   - no_unused_imports — codegen leaves the occasional dangling import
- *   - single_line_empty_body — empty class bodies on multiple lines
- *   - self_static_accessor — `self::` vs `static::` on enums
- *   - blank_line_before_statement — enum `case` separators
- *
- * Auto-detect: when `<rootPath>/vendor/bin/pint` exists, run it on the
- * files we just wrote. Same Pint preset the project's CI already uses,
- * so no risk of formatter drift between codegen and CI checks.
- *
- * Opt-out: future config field; for now `chmod -x vendor/bin/pint` or
- * deleting it disables the auto-run.
- */
-import { existsSync, statSync } from 'node:fs';
-import { spawnSync } from 'node:child_process';
-import { dirname, join } from 'node:path';
-/**
- * Resolve the `vendor/bin/pint` path for the project. Walks up from
- * the first written file until we find a sibling `vendor/bin/pint`,
- * stopping at filesystem root or after 12 levels (defensive against
- * pathological inputs). Returns the absolute path or null.
- */
-export function findPintBinary(anyWrittenPhpPath) {
-    let cur = dirname(anyWrittenPhpPath);
-    for (let i = 0; i < 12; i++) {
-        const candidate = join(cur, 'vendor', 'bin', 'pint');
-        if (existsSync(candidate)) {
-            try {
-                const st = statSync(candidate);
-                if (st.isFile())
-                    return candidate;
-            }
-            catch {
-                // ignore stat errors and keep climbing
-            }
-        }
-        const parent = dirname(cur);
-        if (parent === cur)
-            break;
-        cur = parent;
-    }
-    return null;
-}
-/**
- * Run Laravel Pint on the given PHP files (absolute paths). No-op if
- * Pint isn't installed in the project. Pint is invoked with `--quiet`
- * so it stays out of the way unless something breaks.
- *
- * Pint takes a list of files (or directories) and formats them in
- * place. It uses the project's `pint.json` config if present, else the
- * Laravel preset.
- */
-export function runPintFormat(writtenPhpPaths) {
-    if (writtenPhpPaths.length === 0) {
-        return { ran: false, pintPath: null, formattedCount: 0, exitStatus: null, skipped: 'no-php-files' };
-    }
-    // Opt-out (#174). The auto-run hides what the generators actually emit: a
-    // template that Pint rewrites looks fine here and produces churn in every
-    // project where Pint is absent or does not run. `OMNIFY_NO_PINT=1` is how
-    // the repo's own fixture check measures the raw output.
-    if (process.env.OMNIFY_NO_PINT === '1') {
-        return { ran: false, pintPath: null, formattedCount: 0, exitStatus: null, skipped: 'opted-out' };
-    }
-    // Resolution walks up from a written file. Trying only the first one makes
-    // it depend on emission order — a single file outside the Laravel root and
-    // the whole run goes unformatted, silently. Try each until one resolves.
-    const pintPath = writtenPhpPaths.reduce((found, path) => found ?? findPintBinary(path), null);
-    if (!pintPath) {
-        return { ran: false, pintPath: null, formattedCount: 0, exitStatus: null, skipped: 'pint-not-found' };
-    }
-    // Pint's working dir should be the Laravel project root (where
-    // composer.json + pint.json live). The pint binary is at
-    // `<projectRoot>/vendor/bin/pint`, so projectRoot is two parents up.
-    const projectRoot = dirname(dirname(dirname(pintPath)));
-    // Pass each file as its own arg. Pint accepts multiple file/dir
-    // arguments; capping the batch is unnecessary up to a few hundred
-    // files (well under the OS arg limit).
-    const result = spawnSync(pintPath, ['--quiet', ...writtenPhpPaths], {
-        cwd: projectRoot,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        encoding: 'utf-8',
-    });
-    const exitStatus = result.status ?? null;
-    return {
-        ran: true,
-        pintPath,
-        formattedCount: writtenPhpPaths.length,
-        exitStatus,
-        errorMessage: exitStatus !== 0 ? (result.stderr || result.stdout || undefined) : undefined,
-    };
-}

package/dist/prettier-format.d.ts

@@ -1,23 +0,0 @@
-/**
- * Auto-format generated TypeScript files via the consuming project's Prettier.
- * Issue omnify-jp/omnify-go#211 (mirrors php/pint-format.ts).
- */
-/**
- * Resolve `node_modules/.bin/prettier` by walking up from a written `.ts` file.
- */
-export declare function findPrettierBinary(anyWrittenTsPath: string): string | null;
-/** Directory containing the `node_modules` that owns this Prettier binary. */
-export declare function prettierProjectRoot(prettierPath: string): string;
-export interface PrettierFormatResult {
-    ran: boolean;
-    prettierPath: string | null;
-    formattedCount: number;
-    exitStatus: number | null;
-    errorMessage?: string;
-    skipped?: 'no-ts-files' | 'opted-out' | 'prettier-not-found';
-}
-/**
- * Run the project's Prettier on the given TypeScript files (absolute paths).
- * Silent no-op when Prettier is not installed; never throws.
- */
-export declare function runPrettierFormat(writtenTsPaths: string[]): PrettierFormatResult;

package/dist/prettier-format.js

@@ -1,102 +0,0 @@
-/**
- * Auto-format generated TypeScript files via the consuming project's Prettier.
- * Issue omnify-jp/omnify-go#211 (mirrors php/pint-format.ts).
- */
-import { existsSync, statSync } from 'node:fs';
-import { spawnSync } from 'node:child_process';
-import { dirname, join } from 'node:path';
-/** Max file paths per Prettier invocation (stay under typical ARG_MAX). */
-const PRETTIER_BATCH_SIZE = 100;
-/**
- * Resolve `node_modules/.bin/prettier` by walking up from a written `.ts` file.
- */
-export function findPrettierBinary(anyWrittenTsPath) {
-    let cur = dirname(anyWrittenTsPath);
-    for (let i = 0; i < 12; i++) {
-        const candidate = join(cur, 'node_modules', '.bin', 'prettier');
-        if (existsSync(candidate)) {
-            try {
-                const st = statSync(candidate);
-                if (st.isFile())
-                    return candidate;
-            }
-            catch {
-                // ignore stat errors and keep climbing
-            }
-        }
-        const parent = dirname(cur);
-        if (parent === cur)
-            break;
-        cur = parent;
-    }
-    return null;
-}
-/** Directory containing the `node_modules` that owns this Prettier binary. */
-export function prettierProjectRoot(prettierPath) {
-    return dirname(dirname(dirname(prettierPath)));
-}
-function runPrettierBatch(prettierPath, projectRoot, files) {
-    const result = spawnSync(prettierPath, ['--write', ...files], {
-        cwd: projectRoot,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        encoding: 'utf-8',
-    });
-    const exitStatus = result.status ?? null;
-    return {
-        exitStatus,
-        errorMessage: exitStatus !== 0 ? (result.stderr || result.stdout || undefined) : undefined,
-    };
-}
-/**
- * Run the project's Prettier on the given TypeScript files (absolute paths).
- * Silent no-op when Prettier is not installed; never throws.
- */
-export function runPrettierFormat(writtenTsPaths) {
-    if (writtenTsPaths.length === 0) {
-        return {
-            ran: false,
-            prettierPath: null,
-            formattedCount: 0,
-            exitStatus: null,
-            skipped: 'no-ts-files',
-        };
-    }
-    if (process.env.OMNIFY_NO_PRETTIER === '1') {
-        return {
-            ran: false,
-            prettierPath: null,
-            formattedCount: 0,
-            exitStatus: null,
-            skipped: 'opted-out',
-        };
-    }
-    const prettierPath = writtenTsPaths.reduce((found, path) => found ?? findPrettierBinary(path), null);
-    if (!prettierPath) {
-        return {
-            ran: false,
-            prettierPath: null,
-            formattedCount: 0,
-            exitStatus: null,
-            skipped: 'prettier-not-found',
-        };
-    }
-    const projectRoot = prettierProjectRoot(prettierPath);
-    let exitStatus = 0;
-    let errorMessage;
-    for (let i = 0; i < writtenTsPaths.length; i += PRETTIER_BATCH_SIZE) {
-        const batch = writtenTsPaths.slice(i, i + PRETTIER_BATCH_SIZE);
-        const batchResult = runPrettierBatch(prettierPath, projectRoot, batch);
-        if (batchResult.exitStatus !== 0) {
-            exitStatus = batchResult.exitStatus;
-            errorMessage = batchResult.errorMessage;
-            break;
-        }
-    }
-    return {
-        ran: true,
-        prettierPath,
-        formattedCount: writtenTsPaths.length,
-        exitStatus,
-        errorMessage,
-    };
-}