@warlock.js/core 5.0.2 → 5.2.0

package/esm/generations/features/shadcn.feature.mjs

@@ -0,0 +1,397 @@
+import { rootPath, srcPath } from "../../utils/paths.mjs";
+import "../../utils/index.mjs";
+import { colors } from "@mongez/copper";
+import { ensureDirectoryAsync, fileExistsAsync, getFileAsync, putFileAsync } from "@warlock.js/fs";
+
+//#region core/src/generations/features/shadcn.feature.ts
+/**
+* `warlock add shadcn` installs the PREREQUISITES for shadcn/ui. It does not
+* wrap `shadcn add`, and it never will.
+*
+* shadcn/ui is a copy-in generator with its own CLI and its own registry, not a
+* dependency: components are written into your source tree and become yours the
+* moment they land. Wrapping their CLI would make their moving target our bug
+* reports, for a command that adds nothing but a rename.
+*
+* What is worth owning is the part their CLI gets wrong here. Measured against
+* this framework's layout on 2026-08-25, `shadcn add button card` exited 0 and
+* produced components that rendered COMPLETELY UNSTYLED. It writes components
+* that import `cn` and reference `bg-primary` / `ring-ring`, but only
+* `shadcn init` creates `lib/utils` and the theme tokens those names resolve
+* against. The class was in the generated CSS and the element carried it, and
+* the rule still evaluated to an empty `var()` — a silent failure with a zero
+* exit code, which is the worst kind to hand a user.
+*
+* So this feature ships the five things that make `npx shadcn add <component>`
+* work the first time:
+*
+*   1. `components.json` written for OUR layout (their defaults assume `src/app`
+*      or a bare `components/`, neither of which is where pages live here).
+*   2. `src/web/lib/utils.ts` exporting `cn`.
+*   3. The design tokens appended to `src/web/app.css`.
+*   4. A `web/*` entry in tsconfig `paths`, so the generated imports typecheck.
+*   5. The packages `init` would have installed — see `printNextStep` below.
+*      Skipping `init` is correct; skipping its dependency list was a bug, and
+*      it cost a generated button that imports `cva` and cannot compile.
+*
+* After that, the user talks to shadcn directly, and their docs are true.
+*/
+/**
+* The aliases shadcn's CLI rewrites every generated import against.
+*
+* These are the whole reason this feature exists. shadcn's defaults do not fit
+* `src/web`, and no user would guess this mapping: the alias keys are shadcn's
+* vocabulary, the values are tsconfig `paths` prefixes (hence `web/...`, not
+* `src/web/...`), and `tailwind.css` is a real path from the project root
+* (hence `src/web/app.css`, WITH the `src`). Getting one of them wrong produces
+* components in the wrong folder importing `cn` from somewhere that does not
+* exist.
+*
+* `tailwind.config` is deliberately empty: v4 is CSS-first and there is no
+* config file for it to point at. `rsc: false` because these are SSR React
+* pages rendered by the Warlock HTTP server, not React Server Components.
+*/
+const componentsJsonStub = `{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "new-york",
+  "rsc": false,
+  "tsx": true,
+  "tailwind": {
+    "config": "",
+    "css": "src/web/app.css",
+    "baseColor": "neutral",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "aliases": {
+    "components": "web/components",
+    "utils": "web/lib/utils",
+    "ui": "web/components/ui",
+    "lib": "web/lib",
+    "hooks": "web/hooks"
+  },
+  "iconLibrary": "lucide"
+}
+`;
+/**
+* `cn` — the one import every single shadcn component makes.
+*
+* `clsx` resolves the conditional/array/object class syntax, and `tailwind-merge`
+* then de-duplicates conflicting Tailwind utilities so a caller's `className`
+* actually beats the component's own default rather than depending on which one
+* happens to come later in the generated stylesheet. Both halves are required:
+* clsx alone leaves `px-2 px-4` in the attribute and the loser wins at random.
+*/
+const cnUtilStub = `import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+/**
+ * Merge class names, with later Tailwind utilities winning over earlier ones.
+ *
+ * Every shadcn/ui component imports this. Keep the export name and signature.
+ */
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+`;
+/**
+* Marker for "the tokens are already in this stylesheet".
+*
+* A comment rather than a token name, because a user is free to retune every
+* value below and we must still recognise our own block on a re-run.
+*/
+const SHADCN_TOKENS_MARKER = "shadcn/ui design tokens";
+/**
+* The shadcn token set, as a plain `@theme` block with LITERAL values.
+*
+* Not `@theme inline` over `:root` custom properties, which is what shadcn's own
+* `init` writes. That form was verified against this stylesheet pipeline on
+* 2026-08-25 and it produces utilities that resolve to nothing: the class is in
+* the generated CSS, the class is on the element, and the rule still evaluates
+* to an empty `var()`. Literal values in `@theme` are what make `bg-primary`
+* emit a colour instead of a dangling reference.
+*
+* Dark mode still works, and works the way shadcn expects: `@theme` emits these
+* as real custom properties, so the `.dark` block re-declares the same
+* `--color-*` names and the cascade does the rest. `@custom-variant dark` is
+* what points Tailwind's `dark:` prefix at that class instead of the OS setting.
+*
+* Values are shadcn's `neutral` base. They are the starting point, not the
+* answer — this is the block to edit when the project gets a real palette.
+*/
+const shadcnTokensStub = `
+/* ${SHADCN_TOKENS_MARKER} — edit freely, this is your palette now.
+
+   These are LITERAL values in a plain @theme block, on purpose. shadcn's own
+   \`init\` writes \`@theme inline\` over :root custom properties; that form emits
+   utilities which resolve to an empty var() here, so every component renders
+   unstyled while the class sits right there on the element. Do not convert it.
+*/
+@custom-variant dark (&:is(.dark *));
+
+@theme {
+  --color-background: oklch(1 0 0);
+  --color-foreground: oklch(0.145 0 0);
+  --color-card: oklch(1 0 0);
+  --color-card-foreground: oklch(0.145 0 0);
+  --color-popover: oklch(1 0 0);
+  --color-popover-foreground: oklch(0.145 0 0);
+  --color-primary: oklch(0.205 0 0);
+  --color-primary-foreground: oklch(0.985 0 0);
+  --color-secondary: oklch(0.97 0 0);
+  --color-secondary-foreground: oklch(0.205 0 0);
+  --color-muted: oklch(0.97 0 0);
+  --color-muted-foreground: oklch(0.556 0 0);
+  --color-accent: oklch(0.97 0 0);
+  --color-accent-foreground: oklch(0.205 0 0);
+  --color-destructive: oklch(0.577 0.245 27.325);
+  --color-destructive-foreground: oklch(0.985 0 0);
+  --color-border: oklch(0.922 0 0);
+  --color-input: oklch(0.922 0 0);
+  --color-ring: oklch(0.708 0 0);
+
+  --color-chart-1: oklch(0.646 0.222 41.116);
+  --color-chart-2: oklch(0.6 0.118 184.704);
+  --color-chart-3: oklch(0.398 0.07 227.392);
+  --color-chart-4: oklch(0.828 0.189 84.429);
+  --color-chart-5: oklch(0.769 0.188 70.08);
+
+  --color-sidebar: oklch(0.985 0 0);
+  --color-sidebar-foreground: oklch(0.145 0 0);
+  --color-sidebar-primary: oklch(0.205 0 0);
+  --color-sidebar-primary-foreground: oklch(0.985 0 0);
+  --color-sidebar-accent: oklch(0.97 0 0);
+  --color-sidebar-accent-foreground: oklch(0.205 0 0);
+  --color-sidebar-border: oklch(0.922 0 0);
+  --color-sidebar-ring: oklch(0.708 0 0);
+
+  /* shadcn components reach for rounded-lg/md/sm and expect them to track one
+     radius. Changing --radius-lg here also retunes Tailwind's own rounded-lg,
+     which is the intended trade: one radius scale per project, not two. */
+  --radius-sm: 0.375rem;
+  --radius-md: 0.5rem;
+  --radius-lg: 0.625rem;
+  --radius-xl: 1rem;
+}
+
+.dark {
+  --color-background: oklch(0.145 0 0);
+  --color-foreground: oklch(0.985 0 0);
+  --color-card: oklch(0.205 0 0);
+  --color-card-foreground: oklch(0.985 0 0);
+  --color-popover: oklch(0.205 0 0);
+  --color-popover-foreground: oklch(0.985 0 0);
+  --color-primary: oklch(0.922 0 0);
+  --color-primary-foreground: oklch(0.205 0 0);
+  --color-secondary: oklch(0.269 0 0);
+  --color-secondary-foreground: oklch(0.985 0 0);
+  --color-muted: oklch(0.269 0 0);
+  --color-muted-foreground: oklch(0.708 0 0);
+  --color-accent: oklch(0.269 0 0);
+  --color-accent-foreground: oklch(0.985 0 0);
+  --color-destructive: oklch(0.704 0.191 22.216);
+  --color-destructive-foreground: oklch(0.985 0 0);
+  --color-border: oklch(1 0 0 / 10%);
+  --color-input: oklch(1 0 0 / 15%);
+  --color-ring: oklch(0.556 0 0);
+
+  --color-chart-1: oklch(0.488 0.243 264.376);
+  --color-chart-2: oklch(0.696 0.17 162.48);
+  --color-chart-3: oklch(0.769 0.188 70.08);
+  --color-chart-4: oklch(0.627 0.265 303.9);
+  --color-chart-5: oklch(0.645 0.246 16.439);
+
+  --color-sidebar: oklch(0.205 0 0);
+  --color-sidebar-foreground: oklch(0.985 0 0);
+  --color-sidebar-primary: oklch(0.488 0.243 264.376);
+  --color-sidebar-primary-foreground: oklch(0.985 0 0);
+  --color-sidebar-accent: oklch(0.269 0 0);
+  --color-sidebar-accent-foreground: oklch(0.985 0 0);
+  --color-sidebar-border: oklch(1 0 0 / 10%);
+  --color-sidebar-ring: oklch(0.556 0 0);
+}
+`;
+/**
+* Write `components.json` — the sentinel for "this feature already ran".
+*
+* Nothing in the project template creates this file, so its presence means
+* `add shadcn` has been here and a human may since have retuned the aliases,
+* the style, or the base colour. It is never rewritten: shadcn's CLI reads this
+* file on every `add`, so overwriting it would silently relocate a project's
+* component folder out from under the components already in it.
+*/
+async function writeComponentsJson() {
+	const componentsJsonPath = rootPath("components.json");
+	if (await fileExistsAsync(componentsJsonPath)) {
+		console.log(`${colors.yellowBright("components.json")} already exists, skipping...`);
+		return;
+	}
+	await putFileAsync(componentsJsonPath, componentsJsonStub);
+	console.log(`${colors.green("✓")} Created components.json`);
+}
+/**
+* Write `src/web/lib/utils.ts`.
+*
+* Guarded on its own rather than on the sentinel above, because `lib/utils` is
+* a name a project may well already own — and if it does, whatever is in there
+* is user code with other callers. We print instead of merging.
+*/
+async function writeCnUtil() {
+	const utilsFile = srcPath("web/lib/utils.ts");
+	if (await fileExistsAsync(utilsFile)) {
+		const current = await getFileAsync(utilsFile).catch(() => "");
+		if (/export\s+(function|const)\s+cn\b/.test(current)) console.log(`${colors.yellowBright("src/web/lib/utils.ts")} already exports cn, skipping...`);
+		else console.log(`${colors.yellowBright("!")} ${colors.yellowBright("src/web/lib/utils.ts")} exists but does not export ${colors.yellowBright("cn")} — add it yourself:\n  export function cn(...inputs: ClassValue[]) { return twMerge(clsx(inputs)); }
+  Every shadcn component imports it, and none of them will compile until it is there.`);
+		return;
+	}
+	await ensureDirectoryAsync(srcPath("web/lib"));
+	await putFileAsync(utilsFile, cnUtilStub);
+	console.log(`${colors.green("✓")} Created src/web/lib/utils.ts`);
+}
+/**
+* Append the token block to `src/web/app.css`.
+*
+* The stylesheet is guaranteed to exist by the time this runs: `requires:
+* ["tailwind"]` makes the add command resolve `tailwind` first and run its
+* `onExecuting` ahead of this one, and that is what creates the file. The check
+* below is for a stylesheet a human has since moved or deleted — worth a
+* printed instruction, not a failure.
+*
+* Appended, never rewritten. Everything already in that file is either
+* Tailwind's own `@import` or the project's design system.
+*/
+async function appendThemeTokens() {
+	const cssFile = srcPath("web/app.css");
+	if (!await fileExistsAsync(cssFile)) {
+		console.log(`${colors.yellowBright("!")} ${colors.yellowBright("src/web/app.css")} not found — append the shadcn token block to your Tailwind stylesheet yourself.
+  Without the tokens, shadcn components render unstyled: the classes are emitted and applied, but \`bg-primary\` and friends resolve to an empty var().`);
+		return;
+	}
+	const current = await getFileAsync(cssFile);
+	if (current.includes(SHADCN_TOKENS_MARKER) || current.includes("--color-primary-foreground")) {
+		console.log(`${colors.yellowBright("src/web/app.css")} already has the tokens, skipping...`);
+		return;
+	}
+	await putFileAsync(cssFile, `${current.trimEnd()}\n${shadcnTokensStub}`);
+	console.log(`${colors.green("✓")} Appended the shadcn tokens to src/web/app.css`);
+}
+/** The tsconfig `paths` entry the generated imports resolve through. */
+const WEB_PATH_ALIAS = "\"web/*\": [\"./src/web/*\"]";
+/**
+* Add `web/*` to tsconfig `compilerOptions.paths`.
+*
+* The template declares only `app/*`, so every import shadcn generates against
+* the aliases above (`web/lib/utils`, `web/components/ui/button`) would fail to
+* typecheck the moment it lands. This is the first `add` feature to patch
+* `paths` rather than `include`.
+*
+* String surgery, and NOT the parse-and-write that the `include` patches use.
+* The project template's `tsconfig.json` carries `//` comments — it is JSONC,
+* and `JSON.parse` throws on it — so a parse-first patch would fail on exactly
+* the projects this feature is for. Editing the text also preserves those
+* comments, which are load-bearing documentation in that file.
+*/
+async function addWebPathAlias() {
+	const tsconfigPath = rootPath("tsconfig.json");
+	const printManualInstruction = (reason) => {
+		console.log(`${colors.yellowBright("!")} ${colors.yellowBright("tsconfig.json")} ${reason} — add this to \`compilerOptions.paths\` yourself:
+  ${WEB_PATH_ALIAS}\n  Without it, every import shadcn generates against the \`web/*\` aliases fails to typecheck.`);
+	};
+	if (!await fileExistsAsync(tsconfigPath)) {
+		printManualInstruction("not found");
+		return;
+	}
+	const current = await getFileAsync(tsconfigPath);
+	if (/["']web\/\*["']\s*:/.test(current)) {
+		console.log(`${colors.yellowBright("tsconfig.json")} already maps web/*, skipping...`);
+		return;
+	}
+	let next;
+	if (/"paths"\s*:\s*\{/.test(current)) next = current.replace(/"paths"\s*:\s*\{/, `$&\n      ${WEB_PATH_ALIAS},`);
+	else if (/"compilerOptions"\s*:\s*\{/.test(current)) next = current.replace(/"compilerOptions"\s*:\s*\{/, `$&\n    "paths": {\n      ${WEB_PATH_ALIAS}\n    },`);
+	else {
+		printManualInstruction("has no recognisable compilerOptions block");
+		return;
+	}
+	await putFileAsync(tsconfigPath, next);
+	console.log(`${colors.green("✓")} Added ${WEB_PATH_ALIAS} to tsconfig.json paths`);
+}
+/**
+* Tell the user the next command is theirs to run.
+*
+* This is the seam. Everything above is prerequisite; from here the shadcn docs
+* apply verbatim, which is the entire point of not wrapping their CLI.
+*
+* WHY THIS FEATURE DECLARES cva AND lucide-react, and where the list came from.
+*
+* shadcn's registry splits dependencies across two levels. Each component item
+* (`.../new-york-v4/button.json`) declares only what that file pulls beyond the
+* baseline — for button, `radix-ui` and nothing else. Everything the baseline
+* assumes lives on the STYLE INDEX (`.../new-york-v4/index.json`), which is
+* fetched by `init` and only by `init`:
+*
+*   dependencies:    class-variance-authority, lucide-react, radix-ui
+*   devDependencies: tw-animate-css, shadcn
+*
+* We skip `init` on purpose — it would rewrite components.json and replace the
+* literal tokens with the `@theme inline` block that resolves to nothing here.
+* Skipping it is right; inheriting nothing from it was the bug. `shadcn add
+* button` exits 0 and writes `import { cva } from "class-variance-authority"`
+* against a package no one installed. Zero exit code, TS2307, blank page.
+*
+* `radix-ui` stays off our list: it is the one style-index dependency that is
+* ALSO declared per-component, so `add` really does install it on demand, and
+* declaring it here would pull the whole primitive set into projects using two
+* components. `shadcn` itself stays off too — it is the CLI, and the user is
+* invoking it via `npx`.
+*
+* `tw-animate-css` was checked and deliberately EXCLUDED. It is not imported by
+* any component; it is a plain stylesheet whose only entry point is the
+* `@import "tw-animate-css"` line that `init` writes into the CSS — and we do
+* not write that line, so the package would install and never load. Nothing
+* fails to compile or render without it. What you lose is the enter/exit
+* animation on overlay components (dialog, dropdown, tooltip, sheet): their
+* `animate-in` / `fade-in-0` classes are simply never generated, so the overlay
+* appears instantly instead of fading. That is opt-in, and the note below is how
+* a user opts in — the `@import` has to go at the TOP of app.css, next to
+* Tailwind's own, which is why this feature cannot append it to the token block.
+*/
+function printNextStep() {
+	console.log(`\n${colors.green("✓")} shadcn/ui prerequisites are in place. Add components with shadcn's own CLI:\n  ${colors.yellowBright("npx shadcn@latest add button card")}\n  Skip \`shadcn init\` — this feature did its job, and running it would rewrite components.json
+  and replace the theme tokens with an \`@theme inline\` block that resolves to nothing here.
+  ${colors.yellowBright("class-variance-authority")} and ${colors.yellowBright("lucide-react")} are already installed: shadcn declares\n  them on the style index that only \`init\` reads, so \`add\` would never install them for you.
+  ${colors.yellowBright("radix-ui")} (the unified package, not @radix-ui/react-*) IS declared per component,\n  so shadcn's CLI installs that one itself as each component needs it.
+  For overlay animations, add ${colors.yellowBright("tw-animate-css")} and put ${colors.yellowBright("@import \"tw-animate-css\";")}\n  at the TOP of src/web/app.css, under the Tailwind import. Without it dialogs and dropdowns
+  still work, they just appear instantly instead of animating.`);
+}
+/**
+* Lay the ground shadcn's CLI expects to find, and nothing more.
+*
+* Four files, none of which needs `node_modules` to be populated: on the
+* `create-warlock` path this runs under `--no-install`, so the dependencies
+* declared below are only recorded in `package.json` and nothing here may
+* import, resolve, or execute shadcn, clsx, or Tailwind.
+*/
+async function completeShadcnInstallation(_options) {
+	await writeComponentsJson();
+	await writeCnUtil();
+	await appendThemeTokens();
+	await addWebPathAlias();
+	printNextStep();
+}
+const shadcnFeature = {
+	description: "Sets up the prerequisites for shadcn/ui so `npx shadcn add <component>` works first time: components.json aliased to src/web, src/web/lib/utils.ts (cn), the design tokens in src/web/app.css, and a web/* tsconfig path. It does NOT wrap shadcn's CLI — components stay theirs to generate and yours to own.",
+	requires: ["tailwind"],
+	dependencies: {
+		clsx: "^2.1.1",
+		"tailwind-merge": "^3.3.1",
+		"class-variance-authority": "^0.7.1",
+		"lucide-react": "^1.34.0"
+	},
+	onExecuting: completeShadcnInstallation
+};
+
+//#endregion
+export { shadcnFeature };
+//# sourceMappingURL=shadcn.feature.mjs.map

package/esm/generations/features/shadcn.feature.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadcn.feature.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/generations/features/shadcn.feature.ts"],"sourcesContent":["import { colors } from \"@mongez/copper\";\nimport { ensureDirectoryAsync, fileExistsAsync, getFileAsync, putFileAsync } from \"@warlock.js/fs\";\nimport { CommandActionData } from \"../../commands/types\";\nimport { rootPath, srcPath } from \"../../utils\";\nimport { FeatureDefinition } from \"./types\";\n\n/**\n * `warlock add shadcn` installs the PREREQUISITES for shadcn/ui. It does not\n * wrap `shadcn add`, and it never will.\n *\n * shadcn/ui is a copy-in generator with its own CLI and its own registry, not a\n * dependency: components are written into your source tree and become yours the\n * moment they land. Wrapping their CLI would make their moving target our bug\n * reports, for a command that adds nothing but a rename.\n *\n * What is worth owning is the part their CLI gets wrong here. Measured against\n * this framework's layout on 2026-08-25, `shadcn add button card` exited 0 and\n * produced components that rendered COMPLETELY UNSTYLED. It writes components\n * that import `cn` and reference `bg-primary` / `ring-ring`, but only\n * `shadcn init` creates `lib/utils` and the theme tokens those names resolve\n * against. The class was in the generated CSS and the element carried it, and\n * the rule still evaluated to an empty `var()` — a silent failure with a zero\n * exit code, which is the worst kind to hand a user.\n *\n * So this feature ships the five things that make `npx shadcn add <component>`\n * work the first time:\n *\n *   1. `components.json` written for OUR layout (their defaults assume `src/app`\n *      or a bare `components/`, neither of which is where pages live here).\n *   2. `src/web/lib/utils.ts` exporting `cn`.\n *   3. The design tokens appended to `src/web/app.css`.\n *   4. A `web/*` entry in tsconfig `paths`, so the generated imports typecheck.\n *   5. The packages `init` would have installed — see `printNextStep` below.\n *      Skipping `init` is correct; skipping its dependency list was a bug, and\n *      it cost a generated button that imports `cva` and cannot compile.\n *\n * After that, the user talks to shadcn directly, and their docs are true.\n */\n\n/**\n * The aliases shadcn's CLI rewrites every generated import against.\n *\n * These are the whole reason this feature exists. shadcn's defaults do not fit\n * `src/web`, and no user would guess this mapping: the alias keys are shadcn's\n * vocabulary, the values are tsconfig `paths` prefixes (hence `web/...`, not\n * `src/web/...`), and `tailwind.css` is a real path from the project root\n * (hence `src/web/app.css`, WITH the `src`). Getting one of them wrong produces\n * components in the wrong folder importing `cn` from somewhere that does not\n * exist.\n *\n * `tailwind.config` is deliberately empty: v4 is CSS-first and there is no\n * config file for it to point at. `rsc: false` because these are SSR React\n * pages rendered by the Warlock HTTP server, not React Server Components.\n */\nconst componentsJsonStub = `{\n  \"$schema\": \"https://ui.shadcn.com/schema.json\",\n  \"style\": \"new-york\",\n  \"rsc\": false,\n  \"tsx\": true,\n  \"tailwind\": {\n    \"config\": \"\",\n    \"css\": \"src/web/app.css\",\n    \"baseColor\": \"neutral\",\n    \"cssVariables\": true,\n    \"prefix\": \"\"\n  },\n  \"aliases\": {\n    \"components\": \"web/components\",\n    \"utils\": \"web/lib/utils\",\n    \"ui\": \"web/components/ui\",\n    \"lib\": \"web/lib\",\n    \"hooks\": \"web/hooks\"\n  },\n  \"iconLibrary\": \"lucide\"\n}\n`;\n\n/**\n * `cn` — the one import every single shadcn component makes.\n *\n * `clsx` resolves the conditional/array/object class syntax, and `tailwind-merge`\n * then de-duplicates conflicting Tailwind utilities so a caller's `className`\n * actually beats the component's own default rather than depending on which one\n * happens to come later in the generated stylesheet. Both halves are required:\n * clsx alone leaves `px-2 px-4` in the attribute and the loser wins at random.\n */\nconst cnUtilStub = `import { clsx, type ClassValue } from \"clsx\";\nimport { twMerge } from \"tailwind-merge\";\n\n/**\n * Merge class names, with later Tailwind utilities winning over earlier ones.\n *\n * Every shadcn/ui component imports this. Keep the export name and signature.\n */\nexport function cn(...inputs: ClassValue[]) {\n  return twMerge(clsx(inputs));\n}\n`;\n\n/**\n * Marker for \"the tokens are already in this stylesheet\".\n *\n * A comment rather than a token name, because a user is free to retune every\n * value below and we must still recognise our own block on a re-run.\n */\nconst SHADCN_TOKENS_MARKER = \"shadcn/ui design tokens\";\n\n/**\n * The shadcn token set, as a plain `@theme` block with LITERAL values.\n *\n * Not `@theme inline` over `:root` custom properties, which is what shadcn's own\n * `init` writes. That form was verified against this stylesheet pipeline on\n * 2026-08-25 and it produces utilities that resolve to nothing: the class is in\n * the generated CSS, the class is on the element, and the rule still evaluates\n * to an empty `var()`. Literal values in `@theme` are what make `bg-primary`\n * emit a colour instead of a dangling reference.\n *\n * Dark mode still works, and works the way shadcn expects: `@theme` emits these\n * as real custom properties, so the `.dark` block re-declares the same\n * `--color-*` names and the cascade does the rest. `@custom-variant dark` is\n * what points Tailwind's `dark:` prefix at that class instead of the OS setting.\n *\n * Values are shadcn's `neutral` base. They are the starting point, not the\n * answer — this is the block to edit when the project gets a real palette.\n */\nconst shadcnTokensStub = `\n/* ${SHADCN_TOKENS_MARKER} — edit freely, this is your palette now.\n\n   These are LITERAL values in a plain @theme block, on purpose. shadcn's own\n   \\`init\\` writes \\`@theme inline\\` over :root custom properties; that form emits\n   utilities which resolve to an empty var() here, so every component renders\n   unstyled while the class sits right there on the element. Do not convert it.\n*/\n@custom-variant dark (&:is(.dark *));\n\n@theme {\n  --color-background: oklch(1 0 0);\n  --color-foreground: oklch(0.145 0 0);\n  --color-card: oklch(1 0 0);\n  --color-card-foreground: oklch(0.145 0 0);\n  --color-popover: oklch(1 0 0);\n  --color-popover-foreground: oklch(0.145 0 0);\n  --color-primary: oklch(0.205 0 0);\n  --color-primary-foreground: oklch(0.985 0 0);\n  --color-secondary: oklch(0.97 0 0);\n  --color-secondary-foreground: oklch(0.205 0 0);\n  --color-muted: oklch(0.97 0 0);\n  --color-muted-foreground: oklch(0.556 0 0);\n  --color-accent: oklch(0.97 0 0);\n  --color-accent-foreground: oklch(0.205 0 0);\n  --color-destructive: oklch(0.577 0.245 27.325);\n  --color-destructive-foreground: oklch(0.985 0 0);\n  --color-border: oklch(0.922 0 0);\n  --color-input: oklch(0.922 0 0);\n  --color-ring: oklch(0.708 0 0);\n\n  --color-chart-1: oklch(0.646 0.222 41.116);\n  --color-chart-2: oklch(0.6 0.118 184.704);\n  --color-chart-3: oklch(0.398 0.07 227.392);\n  --color-chart-4: oklch(0.828 0.189 84.429);\n  --color-chart-5: oklch(0.769 0.188 70.08);\n\n  --color-sidebar: oklch(0.985 0 0);\n  --color-sidebar-foreground: oklch(0.145 0 0);\n  --color-sidebar-primary: oklch(0.205 0 0);\n  --color-sidebar-primary-foreground: oklch(0.985 0 0);\n  --color-sidebar-accent: oklch(0.97 0 0);\n  --color-sidebar-accent-foreground: oklch(0.205 0 0);\n  --color-sidebar-border: oklch(0.922 0 0);\n  --color-sidebar-ring: oklch(0.708 0 0);\n\n  /* shadcn components reach for rounded-lg/md/sm and expect them to track one\n     radius. Changing --radius-lg here also retunes Tailwind's own rounded-lg,\n     which is the intended trade: one radius scale per project, not two. */\n  --radius-sm: 0.375rem;\n  --radius-md: 0.5rem;\n  --radius-lg: 0.625rem;\n  --radius-xl: 1rem;\n}\n\n.dark {\n  --color-background: oklch(0.145 0 0);\n  --color-foreground: oklch(0.985 0 0);\n  --color-card: oklch(0.205 0 0);\n  --color-card-foreground: oklch(0.985 0 0);\n  --color-popover: oklch(0.205 0 0);\n  --color-popover-foreground: oklch(0.985 0 0);\n  --color-primary: oklch(0.922 0 0);\n  --color-primary-foreground: oklch(0.205 0 0);\n  --color-secondary: oklch(0.269 0 0);\n  --color-secondary-foreground: oklch(0.985 0 0);\n  --color-muted: oklch(0.269 0 0);\n  --color-muted-foreground: oklch(0.708 0 0);\n  --color-accent: oklch(0.269 0 0);\n  --color-accent-foreground: oklch(0.985 0 0);\n  --color-destructive: oklch(0.704 0.191 22.216);\n  --color-destructive-foreground: oklch(0.985 0 0);\n  --color-border: oklch(1 0 0 / 10%);\n  --color-input: oklch(1 0 0 / 15%);\n  --color-ring: oklch(0.556 0 0);\n\n  --color-chart-1: oklch(0.488 0.243 264.376);\n  --color-chart-2: oklch(0.696 0.17 162.48);\n  --color-chart-3: oklch(0.769 0.188 70.08);\n  --color-chart-4: oklch(0.627 0.265 303.9);\n  --color-chart-5: oklch(0.645 0.246 16.439);\n\n  --color-sidebar: oklch(0.205 0 0);\n  --color-sidebar-foreground: oklch(0.985 0 0);\n  --color-sidebar-primary: oklch(0.488 0.243 264.376);\n  --color-sidebar-primary-foreground: oklch(0.985 0 0);\n  --color-sidebar-accent: oklch(0.269 0 0);\n  --color-sidebar-accent-foreground: oklch(0.985 0 0);\n  --color-sidebar-border: oklch(1 0 0 / 10%);\n  --color-sidebar-ring: oklch(0.556 0 0);\n}\n`;\n\n/**\n * Write `components.json` — the sentinel for \"this feature already ran\".\n *\n * Nothing in the project template creates this file, so its presence means\n * `add shadcn` has been here and a human may since have retuned the aliases,\n * the style, or the base colour. It is never rewritten: shadcn's CLI reads this\n * file on every `add`, so overwriting it would silently relocate a project's\n * component folder out from under the components already in it.\n */\nasync function writeComponentsJson(): Promise<void> {\n  const componentsJsonPath = rootPath(\"components.json\");\n\n  if (await fileExistsAsync(componentsJsonPath)) {\n    console.log(`${colors.yellowBright(\"components.json\")} already exists, skipping...`);\n\n    return;\n  }\n\n  await putFileAsync(componentsJsonPath, componentsJsonStub);\n  console.log(`${colors.green(\"✓\")} Created components.json`);\n}\n\n/**\n * Write `src/web/lib/utils.ts`.\n *\n * Guarded on its own rather than on the sentinel above, because `lib/utils` is\n * a name a project may well already own — and if it does, whatever is in there\n * is user code with other callers. We print instead of merging.\n */\nasync function writeCnUtil(): Promise<void> {\n  const utilsFile = srcPath(\"web/lib/utils.ts\");\n\n  if (await fileExistsAsync(utilsFile)) {\n    const current = await getFileAsync(utilsFile).catch(() => \"\");\n\n    if (/export\\s+(function|const)\\s+cn\\b/.test(current)) {\n      console.log(`${colors.yellowBright(\"src/web/lib/utils.ts\")} already exports cn, skipping...`);\n    } else {\n      console.log(\n        `${colors.yellowBright(\"!\")} ${colors.yellowBright(\"src/web/lib/utils.ts\")} exists but does not export ` +\n          `${colors.yellowBright(\"cn\")} — add it yourself:\\n` +\n          \"  export function cn(...inputs: ClassValue[]) { return twMerge(clsx(inputs)); }\\n\" +\n          \"  Every shadcn component imports it, and none of them will compile until it is there.\",\n      );\n    }\n\n    return;\n  }\n\n  await ensureDirectoryAsync(srcPath(\"web/lib\"));\n  await putFileAsync(utilsFile, cnUtilStub);\n  console.log(`${colors.green(\"✓\")} Created src/web/lib/utils.ts`);\n}\n\n/**\n * Append the token block to `src/web/app.css`.\n *\n * The stylesheet is guaranteed to exist by the time this runs: `requires:\n * [\"tailwind\"]` makes the add command resolve `tailwind` first and run its\n * `onExecuting` ahead of this one, and that is what creates the file. The check\n * below is for a stylesheet a human has since moved or deleted — worth a\n * printed instruction, not a failure.\n *\n * Appended, never rewritten. Everything already in that file is either\n * Tailwind's own `@import` or the project's design system.\n */\nasync function appendThemeTokens(): Promise<void> {\n  const cssFile = srcPath(\"web/app.css\");\n\n  if (!(await fileExistsAsync(cssFile))) {\n    console.log(\n      `${colors.yellowBright(\"!\")} ${colors.yellowBright(\"src/web/app.css\")} not found — ` +\n        \"append the shadcn token block to your Tailwind stylesheet yourself.\\n\" +\n        \"  Without the tokens, shadcn components render unstyled: the classes are emitted and applied, \" +\n        \"but `bg-primary` and friends resolve to an empty var().\",\n    );\n\n    return;\n  }\n\n  const current = await getFileAsync(cssFile);\n\n  if (current.includes(SHADCN_TOKENS_MARKER) || current.includes(\"--color-primary-foreground\")) {\n    console.log(`${colors.yellowBright(\"src/web/app.css\")} already has the tokens, skipping...`);\n\n    return;\n  }\n\n  await putFileAsync(cssFile, `${current.trimEnd()}\\n${shadcnTokensStub}`);\n  console.log(`${colors.green(\"✓\")} Appended the shadcn tokens to src/web/app.css`);\n}\n\n/** The tsconfig `paths` entry the generated imports resolve through. */\nconst WEB_PATH_ALIAS = '\"web/*\": [\"./src/web/*\"]';\n\n/**\n * Add `web/*` to tsconfig `compilerOptions.paths`.\n *\n * The template declares only `app/*`, so every import shadcn generates against\n * the aliases above (`web/lib/utils`, `web/components/ui/button`) would fail to\n * typecheck the moment it lands. This is the first `add` feature to patch\n * `paths` rather than `include`.\n *\n * String surgery, and NOT the parse-and-write that the `include` patches use.\n * The project template's `tsconfig.json` carries `//` comments — it is JSONC,\n * and `JSON.parse` throws on it — so a parse-first patch would fail on exactly\n * the projects this feature is for. Editing the text also preserves those\n * comments, which are load-bearing documentation in that file.\n */\nasync function addWebPathAlias(): Promise<void> {\n  const tsconfigPath = rootPath(\"tsconfig.json\");\n\n  const printManualInstruction = (reason: string) => {\n    console.log(\n      `${colors.yellowBright(\"!\")} ${colors.yellowBright(\"tsconfig.json\")} ${reason} — ` +\n        \"add this to `compilerOptions.paths` yourself:\\n\" +\n        `  ${WEB_PATH_ALIAS}\\n` +\n        \"  Without it, every import shadcn generates against the `web/*` aliases fails to typecheck.\",\n    );\n  };\n\n  if (!(await fileExistsAsync(tsconfigPath))) {\n    printManualInstruction(\"not found\");\n\n    return;\n  }\n\n  const current = await getFileAsync(tsconfigPath);\n\n  // Matches the alias whichever quote style and spacing the file uses, so a\n  // re-run against a hand-edited tsconfig does not stack a second entry.\n  if (/[\"']web\\/\\*[\"']\\s*:/.test(current)) {\n    console.log(`${colors.yellowBright(\"tsconfig.json\")} already maps web/*, skipping...`);\n\n    return;\n  }\n\n  let next: string;\n\n  if (/\"paths\"\\s*:\\s*\\{/.test(current)) {\n    next = current.replace(/\"paths\"\\s*:\\s*\\{/, `$&\\n      ${WEB_PATH_ALIAS},`);\n  } else if (/\"compilerOptions\"\\s*:\\s*\\{/.test(current)) {\n    next = current.replace(\n      /\"compilerOptions\"\\s*:\\s*\\{/,\n      `$&\\n    \"paths\": {\\n      ${WEB_PATH_ALIAS}\\n    },`,\n    );\n  } else {\n    printManualInstruction(\"has no recognisable compilerOptions block\");\n\n    return;\n  }\n\n  await putFileAsync(tsconfigPath, next);\n  console.log(`${colors.green(\"✓\")} Added ${WEB_PATH_ALIAS} to tsconfig.json paths`);\n}\n\n/**\n * Tell the user the next command is theirs to run.\n *\n * This is the seam. Everything above is prerequisite; from here the shadcn docs\n * apply verbatim, which is the entire point of not wrapping their CLI.\n *\n * WHY THIS FEATURE DECLARES cva AND lucide-react, and where the list came from.\n *\n * shadcn's registry splits dependencies across two levels. Each component item\n * (`.../new-york-v4/button.json`) declares only what that file pulls beyond the\n * baseline — for button, `radix-ui` and nothing else. Everything the baseline\n * assumes lives on the STYLE INDEX (`.../new-york-v4/index.json`), which is\n * fetched by `init` and only by `init`:\n *\n *   dependencies:    class-variance-authority, lucide-react, radix-ui\n *   devDependencies: tw-animate-css, shadcn\n *\n * We skip `init` on purpose — it would rewrite components.json and replace the\n * literal tokens with the `@theme inline` block that resolves to nothing here.\n * Skipping it is right; inheriting nothing from it was the bug. `shadcn add\n * button` exits 0 and writes `import { cva } from \"class-variance-authority\"`\n * against a package no one installed. Zero exit code, TS2307, blank page.\n *\n * `radix-ui` stays off our list: it is the one style-index dependency that is\n * ALSO declared per-component, so `add` really does install it on demand, and\n * declaring it here would pull the whole primitive set into projects using two\n * components. `shadcn` itself stays off too — it is the CLI, and the user is\n * invoking it via `npx`.\n *\n * `tw-animate-css` was checked and deliberately EXCLUDED. It is not imported by\n * any component; it is a plain stylesheet whose only entry point is the\n * `@import \"tw-animate-css\"` line that `init` writes into the CSS — and we do\n * not write that line, so the package would install and never load. Nothing\n * fails to compile or render without it. What you lose is the enter/exit\n * animation on overlay components (dialog, dropdown, tooltip, sheet): their\n * `animate-in` / `fade-in-0` classes are simply never generated, so the overlay\n * appears instantly instead of fading. That is opt-in, and the note below is how\n * a user opts in — the `@import` has to go at the TOP of app.css, next to\n * Tailwind's own, which is why this feature cannot append it to the token block.\n */\nfunction printNextStep(): void {\n  console.log(\n    `\\n${colors.green(\"✓\")} shadcn/ui prerequisites are in place. Add components with shadcn's own CLI:\\n` +\n      `  ${colors.yellowBright(\"npx shadcn@latest add button card\")}\\n` +\n      \"  Skip `shadcn init` — this feature did its job, and running it would rewrite components.json\\n\" +\n      \"  and replace the theme tokens with an `@theme inline` block that resolves to nothing here.\\n\" +\n      `  ${colors.yellowBright(\"class-variance-authority\")} and ${colors.yellowBright(\"lucide-react\")} are already installed: shadcn declares\\n` +\n      \"  them on the style index that only `init` reads, so `add` would never install them for you.\\n\" +\n      `  ${colors.yellowBright(\"radix-ui\")} (the unified package, not @radix-ui/react-*) IS declared per component,\\n` +\n      \"  so shadcn's CLI installs that one itself as each component needs it.\\n\" +\n      `  For overlay animations, add ${colors.yellowBright(\"tw-animate-css\")} and put ${colors.yellowBright('@import \"tw-animate-css\";')}\\n` +\n      \"  at the TOP of src/web/app.css, under the Tailwind import. Without it dialogs and dropdowns\\n\" +\n      \"  still work, they just appear instantly instead of animating.\",\n  );\n}\n\n/**\n * Lay the ground shadcn's CLI expects to find, and nothing more.\n *\n * Four files, none of which needs `node_modules` to be populated: on the\n * `create-warlock` path this runs under `--no-install`, so the dependencies\n * declared below are only recorded in `package.json` and nothing here may\n * import, resolve, or execute shadcn, clsx, or Tailwind.\n */\nasync function completeShadcnInstallation(_options: CommandActionData) {\n  await writeComponentsJson();\n  await writeCnUtil();\n  await appendThemeTokens();\n  await addWebPathAlias();\n  printNextStep();\n}\n\nexport const shadcnFeature: FeatureDefinition = {\n  description:\n    \"Sets up the prerequisites for shadcn/ui so `npx shadcn add <component>` works first time: components.json aliased to src/web, src/web/lib/utils.ts (cn), the design tokens in src/web/app.css, and a web/* tsconfig path. It does NOT wrap shadcn's CLI — components stay theirs to generate and yours to own.\",\n  // `tailwind` owns src/web/app.css, which the token block is appended to.\n  // Requiring it also fixes the order: the add command resolves requirements\n  // depth-first, so the stylesheet exists before this feature writes into it.\n  requires: [\"tailwind\"],\n  // Everything `shadcn init` would have installed, minus the parts their CLI\n  // genuinely does install per-component. See the note above `printNextStep`\n  // for how this list was derived and what is deliberately NOT in it.\n  dependencies: {\n    // Both are runtime dependencies of `cn`, which every generated component\n    // calls on every render — not build-time tooling.\n    clsx: \"^2.1.1\",\n    // v3 is the Tailwind v4 line; tailwind-merge v2 knows the v3 utility set and\n    // silently fails to de-duplicate against v4 class names.\n    \"tailwind-merge\": \"^3.3.1\",\n    // `cva` is imported on line 2 of the generated button — and of every other\n    // component with a `variant` prop. The registry declares it ONCE, on the\n    // style index that only `init` applies, so `shadcn add button` resolves the\n    // component's own deps, exits 0, and leaves TS2307 on a file it just wrote.\n    // Still 0.x upstream, so this caret pins to 0.7.x; expect 0.7.1 to land.\n    \"class-variance-authority\": \"^0.7.1\",\n    // Same trap, one layer further in. `components.json` declares\n    // `iconLibrary: \"lucide\"`, and dialog/select/checkbox/dropdown-menu all\n    // import `lucide-react` in their source while declaring only `radix-ui` —\n    // verified against the new-york-v4 registry items. So the CLI installs it\n    // for nobody, and the first icon-bearing component fails to resolve.\n    // Peer range covers React 19, which is what `web` brings.\n    \"lucide-react\": \"^1.34.0\",\n  },\n  onExecuting: completeShadcnInstallation,\n};\n"],"mappings":"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"}

package/esm/generations/features/shared/link-ai-package-import.mjs

@@ -0,0 +1,37 @@
+import { srcPath } from "../../../utils/paths.mjs";
+import "../../../utils/index.mjs";
+import { colors } from "@mongez/copper";
+import { fileExistsAsync, getFileAsync, putFileAsync } from "@warlock.js/fs";
+
+//#region core/src/generations/features/shared/link-ai-package-import.ts
+/**
+* Link a satellite AI package into src/config/ai.ts via a side-effect import.
+*
+* The satellites (@warlock.js/ai-tools, ai-panoptic, ai-workspace) augment the
+* `ai` object on import — they register their runtime surface (ai.tools / ai.mcp,
+* ai.workspace, panoptic's ai.config({ panoptic }) wiring) AND the matching TS
+* declaration-merging so ai.* members resolve. config-loader runs config/ai.ts at
+* boot, so dropping a bare `import "<specifier>";` at the top of that file is what
+* actually loads the augmentation before the ai connector applies the config.
+*
+* No-op if config/ai.ts is missing (the `ai` feature ejects it) or the import is
+* already present. Inserts right after the `warlock:ai-packages` marker when it
+* exists so the satellite imports stay grouped; otherwise prepends to the top.
+*/
+async function linkAiPackageImport(specifier) {
+	const aiConfigPath = srcPath("config/ai.ts");
+	if (!await fileExistsAsync(aiConfigPath)) return;
+	const current = await getFileAsync(aiConfigPath);
+	const importLine = `import "${specifier}";`;
+	if (current.includes(importLine)) return;
+	const marker = "// >>> warlock:ai-packages (auto-managed) >>>";
+	let next;
+	if (current.includes(marker)) next = current.replace(marker, `${marker}\n${importLine}`);
+	else next = `${importLine}\n${current}`;
+	await putFileAsync(aiConfigPath, next);
+	console.log(`${colors.green("✓")} Linked ${specifier} in src/config/ai.ts`);
+}
+
+//#endregion
+export { linkAiPackageImport };
+//# sourceMappingURL=link-ai-package-import.mjs.map

package/esm/generations/features/shared/link-ai-package-import.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"link-ai-package-import.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/generations/features/shared/link-ai-package-import.ts"],"sourcesContent":["import { colors } from \"@mongez/copper\";\nimport { fileExistsAsync, getFileAsync, putFileAsync } from \"@warlock.js/fs\";\nimport { srcPath } from \"../../../utils\";\n\n/**\n * Link a satellite AI package into src/config/ai.ts via a side-effect import.\n *\n * The satellites (@warlock.js/ai-tools, ai-panoptic, ai-workspace) augment the\n * `ai` object on import — they register their runtime surface (ai.tools / ai.mcp,\n * ai.workspace, panoptic's ai.config({ panoptic }) wiring) AND the matching TS\n * declaration-merging so ai.* members resolve. config-loader runs config/ai.ts at\n * boot, so dropping a bare `import \"<specifier>\";` at the top of that file is what\n * actually loads the augmentation before the ai connector applies the config.\n *\n * No-op if config/ai.ts is missing (the `ai` feature ejects it) or the import is\n * already present. Inserts right after the `warlock:ai-packages` marker when it\n * exists so the satellite imports stay grouped; otherwise prepends to the top.\n */\nexport async function linkAiPackageImport(specifier: string): Promise<void> {\n  const aiConfigPath = srcPath(\"config/ai.ts\");\n\n  if (!(await fileExistsAsync(aiConfigPath))) {\n    return;\n  }\n\n  const current = await getFileAsync(aiConfigPath);\n  const importLine = `import \"${specifier}\";`;\n\n  if (current.includes(importLine)) {\n    return;\n  }\n\n  const marker = \"// >>> warlock:ai-packages (auto-managed) >>>\";\n  let next: string;\n\n  if (current.includes(marker)) {\n    next = current.replace(marker, `${marker}\\n${importLine}`);\n  } else {\n    next = `${importLine}\\n${current}`;\n  }\n\n  await putFileAsync(aiConfigPath, next);\n\n  console.log(`${colors.green(\"✓\")} Linked ${specifier} in src/config/ai.ts`);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAkBA,eAAsB,oBAAoB,WAAkC;CAC1E,MAAM,eAAe,QAAQ,cAAc;CAE3C,IAAI,CAAE,MAAM,gBAAgB,YAAY,GACtC;CAGF,MAAM,UAAU,MAAM,aAAa,YAAY;CAC/C,MAAM,aAAa,WAAW,UAAU;CAExC,IAAI,QAAQ,SAAS,UAAU,GAC7B;CAGF,MAAM,SAAS;CACf,IAAI;CAEJ,IAAI,QAAQ,SAAS,MAAM,GACzB,OAAO,QAAQ,QAAQ,QAAQ,GAAG,OAAO,IAAI,YAAY;MAEzD,OAAO,GAAG,WAAW,IAAI;CAG3B,MAAM,aAAa,cAAc,IAAI;CAErC,QAAQ,IAAI,GAAG,OAAO,MAAM,GAAG,EAAE,UAAU,UAAU,qBAAqB;AAC5E"}

package/esm/generations/features/shared/migration-timestamp.mjs

@@ -0,0 +1,17 @@
+//#region core/src/generations/features/shared/migration-timestamp.ts
+/**
+* Build a migration filename timestamp prefix in the framework's
+* MM-DD-YYYY_HH-MM-SS form. Cascade infers a migration's createdAt from this
+* prefix and orders migrations deterministically by it. Pass `offsetSeconds` to
+* stamp sibling migrations created in the same scaffold a second apart so they
+* never collide and keep a stable relative order.
+*/
+function migrationTimestamp(offsetSeconds = 0) {
+	const now = new Date(Date.now() + offsetSeconds * 1e3);
+	const pad = (value) => String(value).padStart(2, "0");
+	return `${pad(now.getMonth() + 1)}-${pad(now.getDate())}-${now.getFullYear()}_${pad(now.getHours())}-${pad(now.getMinutes())}-${pad(now.getSeconds())}`;
+}
+
+//#endregion
+export { migrationTimestamp };
+//# sourceMappingURL=migration-timestamp.mjs.map

package/esm/generations/features/shared/migration-timestamp.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-timestamp.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/generations/features/shared/migration-timestamp.ts"],"sourcesContent":["/**\n * Build a migration filename timestamp prefix in the framework's\n * MM-DD-YYYY_HH-MM-SS form. Cascade infers a migration's createdAt from this\n * prefix and orders migrations deterministically by it. Pass `offsetSeconds` to\n * stamp sibling migrations created in the same scaffold a second apart so they\n * never collide and keep a stable relative order.\n */\nexport function migrationTimestamp(offsetSeconds = 0): string {\n  const now = new Date(Date.now() + offsetSeconds * 1000);\n  const pad = (value: number) => String(value).padStart(2, \"0\");\n\n  return (\n    `${pad(now.getMonth() + 1)}-${pad(now.getDate())}-${now.getFullYear()}_` +\n    `${pad(now.getHours())}-${pad(now.getMinutes())}-${pad(now.getSeconds())}`\n  );\n}\n"],"mappings":";;;;;;;;AAOA,SAAgB,mBAAmB,gBAAgB,GAAW;CAC5D,MAAM,MAAM,IAAI,KAAK,KAAK,IAAI,IAAI,gBAAgB,GAAI;CACtD,MAAM,OAAO,UAAkB,OAAO,KAAK,EAAE,SAAS,GAAG,GAAG;CAE5D,OACE,GAAG,IAAI,IAAI,SAAS,IAAI,CAAC,EAAE,GAAG,IAAI,IAAI,QAAQ,CAAC,EAAE,GAAG,IAAI,YAAY,EAAE,GACnE,IAAI,IAAI,SAAS,CAAC,EAAE,GAAG,IAAI,IAAI,WAAW,CAAC,EAAE,GAAG,IAAI,IAAI,WAAW,CAAC;AAE3E"}

package/esm/generations/features/socket.feature.mjs

@@ -0,0 +1,15 @@
+import { socketConfigStub } from "../stubs.mjs";
+
+//#region core/src/generations/features/socket.feature.ts
+const socketFeature = {
+	description: "Installs socket.io for the realtime socket server (Socket Connector)",
+	dependencies: { "socket.io": "^4.8.3" },
+	ejectConfig: {
+		content: socketConfigStub,
+		name: "socket"
+	}
+};
+
+//#endregion
+export { socketFeature };
+//# sourceMappingURL=socket.feature.mjs.map

package/esm/generations/features/socket.feature.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket.feature.mjs","names":[],"sources":["C:/Work/Warlock.js/core/src/generations/features/socket.feature.ts"],"sourcesContent":["import { socketConfigStub } from \"../stubs\";\r\nimport { FeatureDefinition } from \"./types\";\r\n\r\nexport const socketFeature: FeatureDefinition = {\r\n  description: \"Installs socket.io for the realtime socket server (Socket Connector)\",\r\n  dependencies: {\r\n    \"socket.io\": \"^4.8.3\",\r\n  },\r\n  ejectConfig: {\r\n    content: socketConfigStub,\r\n    name: \"socket\",\r\n  },\r\n};\r\n"],"mappings":";;;AAGA,MAAa,gBAAmC;CAC9C,aAAa;CACb,cAAc,EACZ,aAAa,SACf;CACA,aAAa;EACX,SAAS;EACT,MAAM;CACR;AACF"}