@trackunit/iris-app 2.5.11 → 2.5.13

package/migrations/p-content-space-codemod/rewrite-page-content.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rewritePageContent = rewritePageContent;
+const css_classname_utils_1 = require("@trackunit/css-classname-utils");
+const classname_ast_rewrite_1 = require("../utils/classname-ast-rewrite");
+const PAGE_CONTENT_PATTERN = "page-content";
+const CONTENT_SPACE_TOKEN = "p-content-space";
+const OVERFLOW_AUTO_TOKEN = "overflow-auto";
+/**
+ * True when `token` is already present as a whole class token, including when
+ * wrapped in Tailwind variant prefixes (e.g. `xl:overflow-hidden`).
+ */
+function hasOverflowToken(classes) {
+    return classes.some(cls => /(^|:)overflow-/.test(cls));
+}
+/**
+ * Rewrites the legacy `page-content` Tailwind class to
+ * `overflow-auto p-content-space` across every rewritable file under a
+ * single resolved extension's `sourceRoot`.
+ *
+ * When the classname already declares its own `overflow-*` token, only
+ * `p-content-space` is inserted — emitting a second `overflow-auto` would be
+ * dead (or, when an identical `overflow-auto` is already present, a
+ * duplicate). Scroll ownership stays with the element's existing overflow
+ * declaration.
+ *
+ * Scoped to one extension per call — the caller (the orchestrator) loops
+ * over every Asset Home/Site Home/Admin extension.
+ *
+ * Only performs the `page-content` classname rewrite: it does not touch
+ * `pb-*`/`pb-responsive-space` classes or produce a report, both of which are
+ * separate migration steps.
+ */
+function rewritePageContent(tree, extension) {
+    return (0, classname_ast_rewrite_1.transformClassnamesUnderSourceRoot)(tree, extension.sourceRoot, content => content.includes(PAGE_CONTENT_PATTERN), value => {
+        const replacement = hasOverflowToken((0, css_classname_utils_1.splitClasses)(value))
+            ? CONTENT_SPACE_TOKEN
+            : `${OVERFLOW_AUTO_TOKEN} ${CONTENT_SPACE_TOKEN}`;
+        return (0, css_classname_utils_1.replaceClassToken)(value, PAGE_CONTENT_PATTERN, replacement);
+    });
+}
+//# sourceMappingURL=rewrite-page-content.js.map

package/migrations/p-content-space-codemod/shell-skip-reason.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Why invent/resolve declined to pick an ASA content shell. Surfaced in
+ * migration console output and UnresolvedSurfaceReport so humans (and
+ * third parties) can plan manual `p-content-space` placement.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shellSkipReason = void 0;
+const MESSAGES = {
+    "entry-missing": "extension entry file was not found under sourceRoot",
+    "parse-failed": "extension entry/source could not be parsed as TypeScript/TSX",
+    "no-root-jsx": "could not find a root JSX return in the entry component",
+    "empty-wrapper": "provider/Suspense/Fragment wrappers had no JSX child to walk into",
+    cycle: "component graph walked into a cycle while resolving the content shell",
+    "dynamic-component": "content shell is behind a dynamic import / lazy component (not followed)",
+    "unresolvable-import": "could not resolve a static local import for the host component",
+    "non-host-element": "leaf JSX is not a div/main/section with an inventable className host",
+    "router-prop-unresolved": "RouterProvider router={...} prop was not a simple identifier",
+    "router-inline-arrow-components": "TanStack routes use inline arrow `component: () => <...>` instead of a named component identifier — invent cannot follow them",
+    "router-no-analysable-leaves": "router graph had no analysable named route leaves with a clear overflow content shell",
+    "no-editable-classname": "div/main/section host has no editable className/class (literal or bound Tailwind helper)",
+    "no-overflow-on-host": "host has a className but does not itself own scrollable overflow (overflow-auto/scroll/overlay) — invent only pads the scroll owner",
+    "multiple-overflow-candidates": "host has more than one inventable overflow classname binding (ambiguous)",
+    "header-on-shell": "host also renders PageHeader/Topbar/Header — pad the body below the header, not this shell",
+    "descendant-owns-scroll": "a descendant owns overflow scrolling — pad that scroll owner, not the outer wrapper",
+    "clipping-overflow-on-host": "host uses overflow-hidden/clip (full-bleed / clipping shell) — not inventable as a content inset",
+    "unclear-graph": "content-shell graph was unclear; invent refused to guess a first-div",
+};
+/**
+ * Builds a structured skip reason for invent/resolve console + report output.
+ *
+ * @param code - Stable skip-reason code from the inventable-shell contract
+ * @param detail - Optional path / leaf list / host name appended in parentheses
+ * @returns {ShellSkipReason} Structured reason with a human-readable message
+ */
+const shellSkipReason = (code, detail) => ({
+    code,
+    message: detail === undefined || detail.length === 0 ? MESSAGES[code] : `${MESSAGES[code]} (${detail})`,
+});
+exports.shellSkipReason = shellSkipReason;
+//# sourceMappingURL=shell-skip-reason.js.map

package/migrations/utils/classname-ast-rewrite.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRewritableFile = void 0;
+exports.parseTsestreeSource = parseTsestreeSource;
+exports.findClassnameLocations = findClassnameLocations;
+exports.buildClassnameEdits = buildClassnameEdits;
+exports.buildEditsForLocation = buildEditsForLocation;
+exports.applyEdits = applyEdits;
+exports.transformClassnamesUnderSourceRoot = transformClassnamesUnderSourceRoot;
+exports.visitRewritableFiles = visitRewritableFiles;
+const devkit_1 = require("@nx/devkit");
+const css_classname_utils_1 = require("@trackunit/css-classname-utils");
+const types_1 = require("@typescript-eslint/types");
+const typescript_estree_1 = require("@typescript-eslint/typescript-estree");
+/**
+ * Shared TSESTree parsing/traversal/splice helpers for classname-rewriting Nx
+ * migrations (the `p-content-space-codemod` and any future codemod that needs
+ * to detect and rewrite Tailwind classnames across a Tree).
+ *
+ * `@trackunit/css-classname-utils`'s detection helpers
+ * (`findClassnameStringsInAttribute`/`InCall`/`InVariable`) expect TSESTree AST
+ * nodes, which today only ESLint's parser produces in this repo. Nx migrations
+ * run outside of ESLint, so this module wraps
+ * `@typescript-eslint/typescript-estree`'s `parse` (the same underlying parser
+ * `@typescript-eslint/parser` delegates to) to turn a raw source string into an
+ * equivalent TSESTree `Program`, then re-splices edits directly against the
+ * original source string by AST node range (mirroring the range-splice
+ * approach `insertAttributeIntoOpeningTag` in
+ * `libs/react/components/migrations/utils/jsx-utils.ts` uses for the
+ * TypeScript-compiler-API case).
+ */
+/**
+ * Parses raw TypeScript/TSX source into a TSESTree `Program` AST.
+ *
+ * `jsx: true` is always passed (harmless for plain `.ts` files) so callers
+ * don't need to branch on file extension before parsing.
+ */
+function parseTsestreeSource(content) {
+    return (0, typescript_estree_1.parse)(content, { jsx: true, loc: true, range: true });
+}
+/**
+ * Finds every classname string location in a parsed source: JSX
+ * `className`/`class` attributes, Tailwind-function calls (`cva`, `cn`,
+ * `clsx`, etc. — see `TAILWIND_FUNCTIONS`), and
+ * `*Class`/`*ClassName`/`*Classes`-suffixed variable declarators.
+ *
+ * Walks the AST with `simpleTraverse` (shipped by
+ * `@typescript-eslint/typescript-estree`) instead of a hand-rolled
+ * visitor-keys walker, since it already knows every node type's visitor keys
+ * for the resolved parser version.
+ */
+function findClassnameLocations(program) {
+    const locations = [];
+    (0, typescript_estree_1.simpleTraverse)(program, {
+        enter: node => {
+            if (node.type === types_1.AST_NODE_TYPES.JSXAttribute) {
+                locations.push(...(0, css_classname_utils_1.findClassnameStringsInAttribute)(node));
+            }
+            else if (node.type === types_1.AST_NODE_TYPES.CallExpression) {
+                locations.push(...(0, css_classname_utils_1.findClassnameStringsInCall)(node));
+            }
+            else if (node.type === types_1.AST_NODE_TYPES.VariableDeclarator) {
+                locations.push(...(0, css_classname_utils_1.findClassnameStringsInVariable)(node));
+            }
+        },
+    });
+    return locations;
+}
+/**
+ * Builds the edit(s) needed to apply `transform` to a `ClassnameLocation`'s
+ * `fixNode`, splicing by the node's own `.range` against the original source
+ * (there is no ESLint `SourceCode`/fixer available outside of rule
+ * execution).
+ *
+ * - `Literal`: one edit replacing the whole quoted literal, preserving the
+ *   original quote style via `quoteString`.
+ * - `TemplateLiteral`: one edit per quasi whose raw text changes, splicing
+ *   only the text between the surrounding backtick/`${`/`}` delimiters so the
+ *   template's interpolated expressions are left untouched.
+ *
+ * Returns an empty array when `transform` doesn't change the value, so
+ * callers can cheaply detect "no-op" locations.
+ *
+ * Prefer {@link buildEditsForLocation} when the caller has a full
+ * `ClassnameLocation` — that path can drop an emptied JSX `className`
+ * attribute entirely instead of leaving `className=""`.
+ */
+function buildClassnameEdits(fixNode, transform) {
+    if (fixNode.type === types_1.AST_NODE_TYPES.Literal) {
+        if (typeof fixNode.value !== "string")
+            return [];
+        const newValue = transform(fixNode.value);
+        if (newValue === fixNode.value)
+            return [];
+        return [{ range: fixNode.range, text: (0, css_classname_utils_1.quoteString)(newValue, fixNode) }];
+    }
+    const edits = [];
+    for (const quasi of fixNode.quasis) {
+        const newRaw = transform(quasi.value.raw);
+        if (newRaw === quasi.value.raw)
+            continue;
+        const start = quasi.range[0] + 1;
+        const end = quasi.range[1] - (quasi.tail ? 1 : 2);
+        edits.push({ range: [start, end], text: newRaw });
+    }
+    return edits;
+}
+/**
+ * Like {@link buildClassnameEdits}, but when a JSX `className`/`class`
+ * attribute's token list becomes empty, removes the whole attribute
+ * (including a single run of preceding horizontal whitespace) instead of
+ * writing `className=""`.
+ *
+ * Non-JSX locations (cva/cn/clsx calls, `*ClassName` variables) still fall
+ * through to an empty-string literal — deleting those would require
+ * statement-level surgery we deliberately do not attempt here.
+ */
+function buildEditsForLocation(location, transform, sourceContent) {
+    const { fixNode, context, reportNode } = location;
+    if (context.type === "jsx-attribute" &&
+        reportNode.type === types_1.AST_NODE_TYPES.JSXAttribute &&
+        fixNode.type === types_1.AST_NODE_TYPES.Literal &&
+        typeof fixNode.value === "string") {
+        const newValue = transform(fixNode.value);
+        if (newValue === fixNode.value)
+            return [];
+        if (newValue === "") {
+            return [buildJsxAttributeRemovalEdit(reportNode, sourceContent)];
+        }
+        return [{ range: fixNode.range, text: (0, css_classname_utils_1.quoteString)(newValue, fixNode) }];
+    }
+    return buildClassnameEdits(fixNode, transform);
+}
+/**
+ * Removes a JSX attribute, swallowing the horizontal whitespace immediately
+ * before it so `<div className="x">` becomes `<div>` rather than `<div >`.
+ */
+function buildJsxAttributeRemovalEdit(attribute, sourceContent) {
+    let start = attribute.range[0];
+    while (start > 0 && /[ \t]/.test(sourceContent[start - 1] ?? "")) {
+        start -= 1;
+    }
+    return { range: [start, attribute.range[1]], text: "" };
+}
+/**
+ * Applies a batch of range-based edits to `content`, splicing in
+ * reverse-offset order so that an earlier edit's range is never invalidated
+ * by one applied after it.
+ */
+function applyEdits(content, edits) {
+    const byDescendingStart = [...edits].sort((a, b) => b.range[0] - a.range[0]);
+    let result = content;
+    for (const edit of byDescendingStart) {
+        const [start, end] = edit.range;
+        result = result.slice(0, start) + edit.text + result.slice(end);
+    }
+    return result;
+}
+const REWRITABLE_EXTENSIONS = [".ts", ".tsx"];
+/**
+ * Manifest files must never be mutated by a classname-rewriting migration
+ * (a hard Success Criterion of GLU-1570). No in-repo extension currently
+ * declares a `sourceRoot` that overlaps its own manifest file, but this
+ * filename guard is defense-in-depth so that invariant doesn't depend
+ * entirely on that data convention holding forever.
+ */
+const MANIFEST_FILENAME_PATTERN = /(^|\/)(iris-app-manifest|extension-manifest)\.ts$/;
+/**
+ * `true` for `.ts`/`.tsx` files a classname-rewriting migration is allowed
+ * to read/write — excludes `iris-app-manifest.ts`/`extension-manifest.ts`
+ * files. Shared by every transform/report module in this codemod so the
+ * file-extension allowlist and manifest exclusion live in exactly one place.
+ */
+const isRewritableFile = (filePath) => REWRITABLE_EXTENSIONS.some(ext => filePath.endsWith(ext)) && !MANIFEST_FILENAME_PATTERN.test(filePath);
+exports.isRewritableFile = isRewritableFile;
+/**
+ * Walks every rewritable file under `sourceRoot`, and for files passing the
+ * cheap `shouldConsider` substring pre-check, parses them, finds every
+ * classname location, applies `transform` to each, and writes back any file
+ * that actually changed.
+ *
+ * Shared by `rewritePageContent` and `removeRedundantPadding` so the
+ * walk → pre-filter → parse → find → edit → write skeleton lives in exactly
+ * one place instead of being duplicated per transform.
+ */
+function transformClassnamesUnderSourceRoot(tree, sourceRoot, shouldConsider, transform) {
+    const filesChanged = [];
+    (0, devkit_1.visitNotIgnoredFiles)(tree, sourceRoot, filePath => {
+        if (!(0, exports.isRewritableFile)(filePath))
+            return;
+        const content = tree.read(filePath, "utf-8");
+        if (content === null || !shouldConsider(content))
+            return;
+        const program = parseTsestreeSource(content);
+        const locations = findClassnameLocations(program);
+        const edits = locations.flatMap(location => buildEditsForLocation(location, transform, content));
+        if (edits.length === 0)
+            return;
+        tree.write(filePath, applyEdits(content, edits));
+        filesChanged.push(filePath);
+    });
+    return { filesChanged };
+}
+/**
+ * Read-only walk of every rewritable file under `sourceRoot`, invoking
+ * `visitor` with each file's path and content. Never writes. Shared by
+ * `findUnresolvedSurface`'s detection pass, which only needs to inspect
+ * content, not rewrite it.
+ */
+function visitRewritableFiles(tree, sourceRoot, visitor) {
+    (0, devkit_1.visitNotIgnoredFiles)(tree, sourceRoot, filePath => {
+        if (!(0, exports.isRewritableFile)(filePath))
+            return;
+        const content = tree.read(filePath, "utf-8");
+        if (content === null)
+            return;
+        visitor(filePath, content);
+    });
+}
+//# sourceMappingURL=classname-ast-rewrite.js.map

package/migrations/utils/resolve-extension-types.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExtensionTypes = resolveExtensionTypes;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const ts = tslib_1.__importStar(require("typescript"));
+const APPS_MANIFEST_PATTERN = /^apps\/([^/]+)\/iris-app-manifest\.ts$/;
+const DEFAULT_ENTRY_COMPONENT_FILE = "index.tsx";
+/**
+ * Statically resolves every `apps/*\/iris-app-manifest.ts`'s declared
+ * `extensions` to a concrete `type` + `sourceRoot`, deduping extensions
+ * shared by multiple apps into a single entry.
+ *
+ * Uses the TypeScript compiler API against the Nx `Tree` (not `fs`/dynamic
+ * `import()`), so uncommitted edits held only in the Tree are seen and the
+ * migration stays deterministic.
+ */
+function resolveExtensionTypes(tree) {
+    const tsconfigPaths = readTsconfigPaths(tree);
+    const resolvedByPath = new Map();
+    const unresolved = [];
+    (0, devkit_1.visitNotIgnoredFiles)(tree, "apps", filePath => {
+        const match = APPS_MANIFEST_PATTERN.exec(filePath);
+        if (match === null)
+            return;
+        const appName = match[1];
+        if (appName === undefined)
+            return;
+        const content = tree.read(filePath, "utf-8");
+        if (content === null)
+            return;
+        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+        const manifestObject = resolveDefaultExportObjectLiteral(sourceFile);
+        if (manifestObject === null)
+            return;
+        const extensionIdentifiers = getExtensionIdentifiers(manifestObject, filePath);
+        if (extensionIdentifiers.length === 0)
+            return;
+        const importSpecifiersByLocalName = getImportSpecifiersByLocalName(sourceFile);
+        for (const identifierName of extensionIdentifiers) {
+            const specifier = importSpecifiersByLocalName.get(identifierName);
+            if (specifier === undefined) {
+                devkit_1.logger.warn(`[resolve-extension-types] Could not find an import for "${identifierName}" referenced in ${filePath}'s extensions array.`);
+                continue;
+            }
+            const extensionManifestPath = tsconfigPaths.get(specifier);
+            if (extensionManifestPath === undefined) {
+                devkit_1.logger.warn(`[resolve-extension-types] Could not resolve module specifier "${specifier}" (from ${filePath}) via tsconfig.base.json paths.`);
+                unresolved.push({ app: appName, specifier });
+                continue;
+            }
+            const existing = resolvedByPath.get(extensionManifestPath);
+            if (existing !== undefined) {
+                if (!existing.ownerApps.includes(appName))
+                    existing.ownerApps.push(appName);
+                continue;
+            }
+            const resolvedExtension = resolveExtensionManifest(tree, extensionManifestPath);
+            if (resolvedExtension === null) {
+                devkit_1.logger.warn(`[resolve-extension-types] Could not resolve extension manifest fields from "${extensionManifestPath}" (imported as "${specifier}" in ${filePath}).`);
+                continue;
+            }
+            resolvedByPath.set(extensionManifestPath, { ...resolvedExtension, ownerApps: [appName] });
+        }
+    });
+    return { resolved: [...resolvedByPath.values()], unresolved };
+}
+function resolveExtensionManifest(tree, extensionManifestPath) {
+    const content = tree.read(extensionManifestPath, "utf-8");
+    if (content === null)
+        return null;
+    const sourceFile = ts.createSourceFile(extensionManifestPath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const extensionObject = resolveDefaultExportObjectLiteral(sourceFile);
+    if (extensionObject === null)
+        return null;
+    const id = getStringLiteralProperty(extensionObject, "id");
+    const type = getStringLiteralProperty(extensionObject, "type");
+    const sourceRoot = getStringLiteralProperty(extensionObject, "sourceRoot");
+    if (id === null || type === null || sourceRoot === null)
+        return null;
+    const main = getStringLiteralProperty(extensionObject, "main") ?? DEFAULT_ENTRY_COMPONENT_FILE;
+    return { id, type, sourceRoot, extensionManifestPath, main };
+}
+/**
+ * Finds the object literal behind `export default <expr>;`, following a
+ * single level of identifier indirection (e.g. `const x = {...}; export
+ * default x;`) since that's the shape every real manifest in this repo uses.
+ */
+function resolveDefaultExportObjectLiteral(sourceFile) {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isExportAssignment(statement) || statement.isExportEquals)
+            continue;
+        const expr = statement.expression;
+        if (ts.isObjectLiteralExpression(expr))
+            return expr;
+        if (ts.isIdentifier(expr))
+            return findObjectLiteralVariable(sourceFile, expr.text);
+    }
+    return null;
+}
+function findObjectLiteralVariable(sourceFile, name) {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement))
+            continue;
+        for (const declaration of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(declaration.name) || declaration.name.text !== name)
+                continue;
+            if (declaration.initializer !== undefined && ts.isObjectLiteralExpression(declaration.initializer)) {
+                return declaration.initializer;
+            }
+        }
+    }
+    return null;
+}
+function getExtensionIdentifiers(manifestObject, filePath) {
+    for (const property of manifestObject.properties) {
+        if (!ts.isPropertyAssignment(property))
+            continue;
+        if (!ts.isIdentifier(property.name) || property.name.text !== "extensions")
+            continue;
+        if (!ts.isArrayLiteralExpression(property.initializer))
+            return [];
+        const identifiers = [];
+        for (const element of property.initializer.elements) {
+            if (ts.isIdentifier(element)) {
+                identifiers.push(element.text);
+            }
+            else {
+                devkit_1.logger.warn(`[resolve-extension-types] Skipping a non-identifier element of the "extensions" array in ${filePath} (only \`import x from "..."\`-style identifiers can be statically resolved).`);
+            }
+        }
+        return identifiers;
+    }
+    return [];
+}
+function getImportSpecifiersByLocalName(sourceFile) {
+    const result = new Map();
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement))
+            continue;
+        const moduleSpecifier = statement.moduleSpecifier;
+        if (!ts.isStringLiteral(moduleSpecifier))
+            continue;
+        const specifier = moduleSpecifier.text;
+        const importClause = statement.importClause;
+        if (importClause === undefined)
+            continue;
+        if (importClause.name !== undefined) {
+            result.set(importClause.name.text, specifier);
+        }
+        const namedBindings = importClause.namedBindings;
+        if (namedBindings !== undefined && ts.isNamedImports(namedBindings)) {
+            for (const element of namedBindings.elements) {
+                result.set(element.name.text, specifier);
+            }
+        }
+    }
+    return result;
+}
+function getStringLiteralProperty(objectLiteral, propertyName) {
+    for (const property of objectLiteral.properties) {
+        if (!ts.isPropertyAssignment(property))
+            continue;
+        if (!ts.isIdentifier(property.name) || property.name.text !== propertyName)
+            continue;
+        return ts.isStringLiteral(property.initializer) ? property.initializer.text : null;
+    }
+    return null;
+}
+function readTsconfigPaths(tree) {
+    const result = new Map();
+    const content = tree.read("tsconfig.base.json", "utf-8");
+    if (content === null) {
+        devkit_1.logger.warn("[resolve-extension-types] tsconfig.base.json not found; no extension imports will resolve.");
+        return result;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(stripJsonComments(content));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        devkit_1.logger.warn(`[resolve-extension-types] Failed to parse tsconfig.base.json: ${message}`);
+        return result;
+    }
+    const paths = parsed.compilerOptions?.paths ?? {};
+    for (const [specifier, targets] of Object.entries(paths)) {
+        const target = targets[0];
+        if (target === undefined)
+            continue;
+        result.set(specifier, normalizeRepoRelativePath(target));
+    }
+    return result;
+}
+/**
+ * `tsconfig.base.json` is committed without comments today, but strip
+ * line comments and block comments defensively in case that changes, so a
+ * stray comment doesn't hard-fail `JSON.parse`. The line-comment regex
+ * requires the preceding character not be `:` so it doesn't mangle URL-like
+ * string values (e.g. `"https://..."`).
+ */
+function stripJsonComments(content) {
+    return content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+}
+function normalizeRepoRelativePath(pathValue) {
+    return pathValue.replace(/^\.\//, "");
+}
+//# sourceMappingURL=resolve-extension-types.js.map

package/migrations.json

@@ -1,3 +1,9 @@
 {
-  "generators": {}
+  "generators": {
+    "v2-5-12-p-content-space-codemod": {
+      "version": "2.5.12",
+      "description": "Rewrite the legacy page-content Tailwind class to overflow-auto p-content-space, invent p-content-space on high-confidence Asset Home/Site Home/Admin content shells, and remove now-redundant bottom-inset classes.",
+      "implementation": "./migrations/p-content-space-codemod/orchestrator"
+    }
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trackunit/iris-app",
-  "version": "2.5.11",
+  "version": "2.5.13",
   "license": "SEE LICENSE IN LICENSE.txt",
   "main": "src/index.js",
   "generators": "./generators.json",
@@ -10,7 +10,9 @@
     "node": ">=24.x"
   },
   "dependencies": {
-    "@trackunit/css-classname-utils": "0.0.18",
+    "@trackunit/css-classname-utils": "0.0.20",
+    "@typescript-eslint/types": "8.58.1",
+    "@typescript-eslint/typescript-estree": "8.58.1",
     "pacote": "^21.0.4",
     "libnpmpublish": "^11.1.3",
     "open": "^10.2.0",
@@ -24,10 +26,10 @@
     "@nx/react": "23.1.0",
     "@npmcli/arborist": "^9.1.9",
     "win-ca": "^3.5.1",
-    "@trackunit/iris-app-build-utilities": "2.4.11",
-    "@trackunit/react-graphql-tools": "1.15.15",
-    "@trackunit/shared-utils": "1.16.18",
-    "@trackunit/iris-app-api": "2.4.7",
+    "@trackunit/iris-app-build-utilities": "2.4.13",
+    "@trackunit/react-graphql-tools": "1.15.17",
+    "@trackunit/shared-utils": "1.16.20",
+    "@trackunit/iris-app-api": "2.4.9",
     "tslib": "^2.6.2",
     "@clack/prompts": "^1.0.0",
     "@npm/types": "^1.0.2",