@slicemedia/create-devkit 0.0.0-bootstrap.0 → 0.1.1

package/README.md

@@ -1,4 +1,46 @@
-# @slicemedia/create-devkit bootstrap placeholder
+# `@slicemedia/create-devkit`
 
-This is a non-functional identity placeholder used only to configure npm trusted publishing.
-Do not install this version. Use a later Slice Media project creator release from the `next` or `latest` tag.
+Starts an interactive wizard for a new neutral TypeScript Webflow project. The optional directory
+argument follows the convention used by established project creators. Run the `0.1.0` release
+candidate through the npm `next` tag with any supported package manager:
+
+```sh
+npm create @slicemedia/devkit@next my-webflow-project
+pnpm dlx @slicemedia/create-devkit@next my-webflow-project
+yarn dlx @slicemedia/create-devkit@next my-webflow-project
+```
+
+Without a directory argument, the wizard proposes `webflow-project`. A literal `.` selects the
+current directory, which must be empty. The wizard asks for the npm name, package manager (pnpm,
+npm, or Yarn), optional capabilities, agent instruction targets, dependency installation, and final
+confirmation. Use Space to select or clear items in the multi-select lists, then press Enter to
+continue. It never overwrites a non-empty directory. Capabilities are opt-in and generate typed
+integration modules that remain disconnected from the project entry until the project chooses to
+compose them.
+
+Agent targets add the independent `@slicemedia/agent-kit` package and a deterministic
+`agents:generate` script. Run it through the selected package manager after installation to create
+only the selected platform files; DevKit does not bundle the Agent Kit source.
+
+The **Webflow Agent Instructions** target does not install another AI service or MCP server. It
+generates an importable Markdown ZIP and integrity manifest under `.slicemedia/agent-kit/`. After
+review, the ZIP can be imported into the intended Webflow site's Instructions panel so Webflow AI
+and external agents connected through the official Webflow MCP server can use the site-stored rules
+and skills.
+
+The package also exports the deterministic `scaffoldProject()` API with schema-v2 options and
+receipts for programmatic consumers, including the chosen package manager. DevKit source is MIT
+licensed; generated client projects remain project-owned and receive no automatic license.
+
+## Support and security
+
+See Slice Media's [support policy](https://github.com/slicemedia/.github/blob/main/SUPPORT.md) for
+help and maintenance expectations. Report vulnerabilities through the
+[DevKit security policy](../../SECURITY.md), not a public issue.
+
+## Project notice
+
+This package is independently developed by Slice Media and is not affiliated with, endorsed by, or
+sponsored by Webflow, Inc. Webflow and related marks belong to their respective owners. AI tools
+materially assisted its implementation and documentation; production use still requires human
+review, accessibility and security checks, and project-specific testing.

package/bin/create-slicemedia-devkit.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/bin.js";

package/dist/bin.d.ts

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { type PackageManager } from "./scaffold.js";
+export declare const usage = "Usage: create-slicemedia-devkit [directory]\n\nStarts an interactive wizard for a new Webflow project. If no directory is provided, the wizard\nsuggests webflow-project. Use . to initialize the current directory. Existing non-empty directories\nare never overwritten.\n\nOptions:\n  -h, --help  Show this help message.";
+export interface ParsedCliArgs {
+    readonly help: boolean;
+    readonly targetDirectory?: string;
+}
+export interface SpawnedCommand {
+    once(event: "error", listener: (error: Error) => void): this;
+    once(event: "close", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+}
+export type CommandSpawner = (command: string, args: string[], options: {
+    cwd: string;
+    shell: false;
+    stdio: "inherit";
+}) => SpawnedCommand;
+export declare function parseCliArgs(argv: readonly string[]): ParsedCliArgs;
+export declare function multiSelectPromptMessage(label: string): string;
+export declare function installProjectDependencies(packageManager: PackageManager, targetDirectory: string, spawnCommand?: CommandSpawner): Promise<void>;
+export declare function followUpCommands(packageManager: PackageManager, options: {
+    readonly includeInstall: boolean;
+    readonly includeAgentGeneration: boolean;
+}): string[];
+export declare function installFailureMessage(packageManager: PackageManager, targetDirectory: string, error: unknown): string;
+export declare function runWizard(cliTargetDirectory?: string): Promise<void>;
+export declare function runCli(argv: readonly string[]): Promise<void>;
+//# sourceMappingURL=bin.d.ts.map

package/dist/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":";AAMA,OAAO,EAML,KAAK,cAAc,EAEpB,MAAM,eAAe,CAAC;AAEvB,eAAO,MAAM,KAAK,mUAOoB,CAAC;AAEvC,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI,CAAC;IAC7D,IAAI,CACF,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,KAAK,IAAI,GACrE,IAAI,CAAC;CACT;AAED,MAAM,MAAM,cAAc,GAAG,CAC3B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE;IACP,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,KAAK,CAAC;IACb,KAAK,EAAE,SAAS,CAAC;CAClB,KACE,cAAc,CAAC;AAgDpB,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,aAAa,CA8BnE;AAYD,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE9D;AAUD,wBAAsB,0BAA0B,CAC9C,cAAc,EAAE,cAAc,EAC9B,eAAe,EAAE,MAAM,EACvB,YAAY,GAAE,cAAoC,GACjD,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED,wBAAgB,gBAAgB,CAC9B,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE;IAAE,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,sBAAsB,EAAE,OAAO,CAAA;CAAE,GACtF,MAAM,EAAE,CAOV;AAED,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,cAAc,EAC9B,eAAe,EAAE,MAAM,EACvB,KAAK,EAAE,OAAO,GACb,MAAM,CAGR;AAED,wBAAsB,SAAS,CAAC,kBAAkB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAwG1E;AAED,wBAAsB,MAAM,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAOnE"}

package/dist/bin.js

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+import Enquirer from "enquirer";
+import { spawn } from "node:child_process";
+import { basename, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { AGENT_TARGETS, PACKAGE_MANAGERS, PROJECT_CAPABILITIES, scaffoldProject, } from "./scaffold.js";
+export const usage = `Usage: create-slicemedia-devkit [directory]
+
+Starts an interactive wizard for a new Webflow project. If no directory is provided, the wizard
+suggests webflow-project. Use . to initialize the current directory. Existing non-empty directories
+are never overwritten.
+
+Options:
+  -h, --help  Show this help message.`;
+const capabilityLabels = {
+    slider: "Responsive slider (Swiper)",
+    animations: "Animations (GSAP)",
+    tooltips: "Tooltips (Tippy.js)",
+    "digitalocean-spaces": "DigitalOcean Spaces deployment",
+};
+const agentTargetLabels = {
+    codex: "Codex",
+    claude: "Claude",
+    cursor: "Cursor",
+    copilot: "GitHub Copilot",
+    webflow: "Webflow Agent Instructions",
+};
+const agentTargetHints = {
+    webflow: "Importable Markdown ZIP stored with the Webflow site",
+};
+const packageManagerLabels = {
+    pnpm: "pnpm",
+    npm: "npm",
+    yarn: "Yarn",
+};
+const packageManagerCommands = {
+    pnpm: {
+        install: "pnpm install",
+        agentsGenerate: "pnpm agents:generate",
+        dev: "pnpm dev",
+    },
+    npm: {
+        install: "npm install",
+        agentsGenerate: "npm run agents:generate",
+        dev: "npm run dev",
+    },
+    yarn: {
+        install: "yarn install",
+        agentsGenerate: "yarn agents:generate",
+        dev: "yarn dev",
+    },
+};
+export function parseCliArgs(argv) {
+    const positionals = [];
+    let help = false;
+    let positionalOnly = false;
+    for (const value of argv) {
+        if (!positionalOnly && value === "--") {
+            positionalOnly = true;
+            continue;
+        }
+        if (!positionalOnly && (value === "--help" || value === "-h")) {
+            help = true;
+            continue;
+        }
+        if (!positionalOnly && value.startsWith("-")) {
+            throw new Error(`Unknown option: ${value}`);
+        }
+        if (value.trim() === "")
+            throw new Error("Project directory must not be empty.");
+        positionals.push(value);
+    }
+    if (positionals.length > 1) {
+        throw new Error("Expected at most one project directory.");
+    }
+    const targetDirectory = positionals[0];
+    return {
+        help,
+        ...(targetDirectory === undefined ? {} : { targetDirectory }),
+    };
+}
+function npmProjectName(value) {
+    return /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/u.test(value)
+        ? true
+        : "Enter a valid lowercase npm package name.";
+}
+function selectedLabel(values) {
+    return values.length === 0 ? "none" : values.join(", ");
+}
+export function multiSelectPromptMessage(label) {
+    return `${label} (use Space to select one or more; press Enter to continue)`;
+}
+function defaultSpawnCommand(command, args, options) {
+    return spawn(command, args, options);
+}
+export async function installProjectDependencies(packageManager, targetDirectory, spawnCommand = defaultSpawnCommand) {
+    await new Promise((resolvePromise, rejectPromise) => {
+        const child = spawnCommand(packageManager, ["install"], {
+            cwd: resolve(targetDirectory),
+            shell: false,
+            stdio: "inherit",
+        });
+        child.once("error", rejectPromise);
+        child.once("close", (code, signal) => {
+            if (code === 0) {
+                resolvePromise();
+                return;
+            }
+            const outcome = code === null ? `signal ${signal ?? "unknown"}` : `exit code ${code}`;
+            rejectPromise(new Error(`${packageManager} install failed with ${outcome}.`));
+        });
+    });
+}
+export function followUpCommands(packageManager, options) {
+    const commands = packageManagerCommands[packageManager];
+    return [
+        ...(options.includeInstall ? [commands.install] : []),
+        ...(options.includeAgentGeneration ? [commands.agentsGenerate] : []),
+        commands.dev,
+    ];
+}
+export function installFailureMessage(packageManager, targetDirectory, error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return `Project was created at ${targetDirectory}, but dependency installation failed: ${detail}\nThe generated files remain in place. Run "${packageManagerCommands[packageManager].install}" manually in ${targetDirectory}.`;
+}
+export async function runWizard(cliTargetDirectory) {
+    const targetDirectory = cliTargetDirectory ??
+        (await Enquirer.prompt({
+            type: "input",
+            name: "targetDirectory",
+            message: "Project directory",
+            initial: "webflow-project",
+            validate: (value) => (value.trim() === "" ? "Enter a project directory." : true),
+        })).targetDirectory;
+    const { projectName } = await Enquirer.prompt({
+        type: "input",
+        name: "projectName",
+        message: "npm project name",
+        initial: basename(resolve(targetDirectory)),
+        validate: npmProjectName,
+    });
+    const { capabilities } = await Enquirer.prompt({
+        type: "multiselect",
+        name: "capabilities",
+        message: multiSelectPromptMessage("Optional capabilities"),
+        choices: PROJECT_CAPABILITIES.map((capability) => ({
+            name: capability,
+            message: capabilityLabels[capability],
+        })),
+    });
+    const { agentTargets } = await Enquirer.prompt({
+        type: "multiselect",
+        name: "agentTargets",
+        message: multiSelectPromptMessage("Agent instruction targets"),
+        choices: AGENT_TARGETS.map((target) => ({
+            name: target,
+            message: agentTargetLabels[target],
+            ...(agentTargetHints[target] === undefined ? {} : { hint: agentTargetHints[target] }),
+        })),
+    });
+    const { packageManager } = await Enquirer.prompt({
+        type: "select",
+        name: "packageManager",
+        message: "Package manager",
+        choices: PACKAGE_MANAGERS.map((manager) => ({
+            name: manager,
+            message: packageManagerLabels[manager],
+        })),
+        initial: PACKAGE_MANAGERS.indexOf("pnpm"),
+    });
+    const { shouldInstall } = await Enquirer.prompt({
+        type: "confirm",
+        name: "shouldInstall",
+        message: `Install dependencies with ${packageManager}?`,
+        initial: true,
+    });
+    const destination = resolve(targetDirectory);
+    const { confirmed } = await Enquirer.prompt({
+        type: "confirm",
+        name: "confirmed",
+        message: `Create ${projectName} at ${destination}? Capabilities: ${selectedLabel(capabilities.map((capability) => capabilityLabels[capability]))}. Agents: ${selectedLabel(agentTargets.map((target) => agentTargetLabels[target]))}. Package manager: ${packageManager}. Install dependencies: ${shouldInstall ? "yes" : "no"}.`,
+        initial: true,
+    });
+    if (!confirmed) {
+        console.info("Project creation cancelled; no files were written.");
+        return;
+    }
+    const receipt = await scaffoldProject({
+        targetDirectory: destination,
+        projectName,
+        capabilities,
+        agentTargets,
+        packageManager,
+    });
+    console.info(`Created ${receipt.projectName} at ${receipt.targetDirectory} with ${selectedLabel(receipt.capabilities.map((capability) => capabilityLabels[capability]))} capabilities.`);
+    if (shouldInstall) {
+        console.info(`Installing dependencies with ${packageManager}...`);
+        try {
+            await installProjectDependencies(packageManager, receipt.targetDirectory);
+        }
+        catch (error) {
+            throw new Error(installFailureMessage(packageManager, receipt.targetDirectory, error), {
+                cause: error,
+            });
+        }
+        console.info(`Installed dependencies with ${packageManager}.`);
+    }
+    const commands = followUpCommands(packageManager, {
+        includeInstall: !shouldInstall,
+        includeAgentGeneration: receipt.agentTargets.length > 0,
+    });
+    console.info(`Next steps (run in ${receipt.targetDirectory}):\n${commands
+        .map((command) => `  ${command}`)
+        .join("\n")}`);
+}
+export async function runCli(argv) {
+    const parsed = parseCliArgs(argv);
+    if (parsed.help) {
+        console.info(usage);
+        return;
+    }
+    await runWizard(parsed.targetDirectory);
+}
+function isCliEntrypoint() {
+    const invokedPath = process.argv[1];
+    if (invokedPath === undefined)
+        return false;
+    if (resolve(invokedPath) === resolve(fileURLToPath(import.meta.url)))
+        return true;
+    return /^create-slicemedia-devkit(?:\.js)?$/u.test(basename(invokedPath));
+}
+if (isCliEntrypoint()) {
+    try {
+        await runCli(process.argv.slice(2));
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { AGENT_TARGETS, PACKAGE_MANAGERS, PROJECT_CAPABILITIES, scaffoldProject, type AgentTarget, type PackageManager, type ProjectCapability, type ScaffoldOptions, type ScaffoldReceipt, } from "./scaffold.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,oBAAoB,EACpB,eAAe,EACf,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,eAAe,GACrB,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export { AGENT_TARGETS, PACKAGE_MANAGERS, PROJECT_CAPABILITIES, scaffoldProject, } from "./scaffold.js";

package/dist/scaffold.d.ts

@@ -0,0 +1,33 @@
+export declare const PROJECT_CAPABILITIES: readonly ["slider", "animations", "tooltips", "digitalocean-spaces"];
+export type ProjectCapability = (typeof PROJECT_CAPABILITIES)[number];
+export declare const AGENT_TARGETS: readonly ["codex", "claude", "cursor", "copilot", "webflow"];
+export type AgentTarget = (typeof AGENT_TARGETS)[number];
+export declare const PACKAGE_MANAGERS: readonly ["pnpm", "npm", "yarn"];
+export type PackageManager = (typeof PACKAGE_MANAGERS)[number];
+export interface ScaffoldOptions {
+    targetDirectory: string;
+    projectName: string;
+    packageManager: PackageManager;
+    capabilities: readonly ProjectCapability[];
+    agentTargets: readonly AgentTarget[];
+    devkitVersion?: string;
+    agentKitVersion?: string;
+    swiperAdapterVersion?: string;
+    spacesDeployerVersion?: string;
+    templateRoot?: string;
+}
+export interface ScaffoldReceipt {
+    schemaVersion: 2;
+    projectName: string;
+    targetDirectory: string;
+    packageManager: PackageManager;
+    capabilities: readonly ProjectCapability[];
+    agentTargets: readonly AgentTarget[];
+    dependencies: Readonly<Record<string, string>>;
+    devDependencies: Readonly<Record<string, string>>;
+    integrationFiles: readonly string[];
+    agentGenerateCommand?: string;
+    writtenFiles: readonly string[];
+}
+export declare function scaffoldProject(options: ScaffoldOptions): Promise<ScaffoldReceipt>;
+//# sourceMappingURL=scaffold.d.ts.map

package/dist/scaffold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaffold.d.ts","sourceRoot":"","sources":["../src/scaffold.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,oBAAoB,sEAKvB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEtE,eAAO,MAAM,aAAa,8DAA+D,CAAC;AAE1F,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzD,eAAO,MAAM,gBAAgB,kCAAmC,CAAC;AAEjE,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/D,MAAM,WAAW,eAAe;IAC9B,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,cAAc,CAAC;IAC/B,YAAY,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC3C,YAAY,EAAE,SAAS,WAAW,EAAE,CAAC;IACrC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,CAAC,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,cAAc,CAAC;IAC/B,YAAY,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC3C,YAAY,EAAE,SAAS,WAAW,EAAE,CAAC;IACrC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC/C,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAClD,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC;AAkcD,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,CAyDxF"}

package/dist/scaffold.js

@@ -0,0 +1,408 @@
+import { lstat, mkdir, readdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, join, parse, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { DEFAULT_DEVKIT_VERSION_RANGE, EXTERNAL_PRODUCT_VERSION_RANGES, } from "./versions.generated.js";
+const requireModule = createRequire(import.meta.url);
+const semver = requireModule("semver");
+const explicitSemverVersion = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u;
+const explicitSemverComparator = /^(?:[<>]=?|[=~^])?(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u;
+export const PROJECT_CAPABILITIES = [
+    "slider",
+    "animations",
+    "tooltips",
+    "digitalocean-spaces",
+];
+export const AGENT_TARGETS = ["codex", "claude", "cursor", "copilot", "webflow"];
+export const PACKAGE_MANAGERS = ["pnpm", "npm", "yarn"];
+const packageManagerMetadata = {
+    pnpm: "pnpm@11.21.0",
+    npm: "npm@10.9.8",
+    yarn: "yarn@4.18.0",
+};
+const packageManagerCommands = {
+    pnpm: {
+        install: "pnpm install",
+        dev: "pnpm dev",
+        typecheck: "pnpm typecheck",
+        build: "pnpm build",
+        catalog: "pnpm catalog -- --json",
+        devkit: "pnpm devkit -- <command>",
+        agentsGenerate: "pnpm agents:generate",
+    },
+    npm: {
+        install: "npm install",
+        dev: "npm run dev",
+        typecheck: "npm run typecheck",
+        build: "npm run build",
+        catalog: "npm run catalog -- --json",
+        devkit: "npm run devkit -- <command>",
+        agentsGenerate: "npm run agents:generate",
+    },
+    yarn: {
+        install: "yarn install",
+        dev: "yarn dev",
+        typecheck: "yarn typecheck",
+        build: "yarn build",
+        catalog: "yarn catalog --json",
+        devkit: "yarn devkit <command>",
+        agentsGenerate: "yarn agents:generate",
+    },
+};
+const baseDependencies = (versions) => ({
+    "@slicemedia/devkit-core": versions.devkit,
+});
+const capabilityDefinitions = {
+    slider: {
+        dependencies: (versions) => ({
+            "@slicemedia/swiper-adapter": versions.swiperAdapter,
+            swiper: "^14.1.0",
+        }),
+        integrationFile: "src/integrations/slider.ts",
+        renderIntegration: () => `import {
+  createResponsiveSwiper,
+  type ResponsiveSwiperController,
+  type ResponsiveSwiperOptions,
+} from "@slicemedia/swiper-adapter";
+import "swiper/css";
+
+export const PROJECT_SLIDER_SELECTOR = "[data-wft-slider]" as const;
+
+export type ProjectSliderOptions = Omit<ResponsiveSwiperOptions, "target"> & {
+  target?: ResponsiveSwiperOptions["target"];
+};
+
+export function createProjectSlider(
+  options: ProjectSliderOptions = {},
+): ResponsiveSwiperController {
+  const { target = PROJECT_SLIDER_SELECTOR, ...swiperOptions } = options;
+  return createResponsiveSwiper({
+    target,
+    observeMutations: true,
+    ...swiperOptions,
+  });
+}
+`,
+    },
+    animations: {
+        dependencies: () => ({ gsap: "^3.13.0" }),
+        integrationFile: "src/integrations/animations.ts",
+        renderIntegration: () => `import { gsap } from "gsap";
+
+/** Project-owned GSAP entry point. Import this module from main.ts when the composition is ready. */
+export { gsap };
+`,
+    },
+    tooltips: {
+        dependencies: () => ({ "tippy.js": "^6.3.7" }),
+        integrationFile: "src/integrations/tooltips.ts",
+        renderIntegration: () => `import tippy, { type Instance, type MultipleTargets, type Props } from "tippy.js";
+import "tippy.js/dist/tippy.css";
+
+export const PROJECT_TOOLTIP_SELECTOR = "[data-wft-tooltip]" as const;
+
+export function createProjectTooltips(
+  targets: MultipleTargets = PROJECT_TOOLTIP_SELECTOR,
+  options: Partial<Props> = {},
+): Instance[] {
+  return tippy(targets, options);
+}
+`,
+    },
+    "digitalocean-spaces": {
+        dependencies: (versions) => ({
+            "@slicemedia/spaces-deployer": versions.spacesDeployer,
+        }),
+        environmentVariables: [
+            "DIGITALOCEAN_SPACES_ACCESS_KEY_ID",
+            "DIGITALOCEAN_SPACES_SECRET_ACCESS_KEY",
+            "DIGITALOCEAN_SPACES_SESSION_TOKEN",
+        ],
+        integrationFile: "src/integrations/spaces-deployment.ts",
+        renderIntegration: () => `import {
+  applyDeploymentPlan,
+  createDeploymentPlan,
+  type SpacesDeploymentPlan,
+  type SpacesDeploymentReceipt,
+} from "@slicemedia/spaces-deployer";
+
+export interface ProjectSpacesPlanConfig {
+  directory: string;
+  endpoint: string;
+  region: string;
+  bucket: string;
+  prefix: string;
+  releaseVersion: string;
+}
+
+/** All deployment values are explicit; this helper supplies no account or project defaults. */
+export function createProjectDeploymentPlan(
+  config: ProjectSpacesPlanConfig,
+): Promise<SpacesDeploymentPlan> {
+  return createDeploymentPlan(config);
+}
+
+export { applyDeploymentPlan };
+export type { SpacesDeploymentPlan, SpacesDeploymentReceipt };
+`,
+    },
+};
+function assertProjectName(name) {
+    if (!/^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/u.test(name)) {
+        throw new Error(`Invalid npm project name: ${name}`);
+    }
+}
+function hasExplicitSemverSyntax(value) {
+    const clauses = value.split(/\s*\|\|\s*/u);
+    return clauses.every((clause) => {
+        if (clause === "")
+            return false;
+        const hyphenRange = clause.match(/^(\S+)\s+-\s+(\S+)$/u);
+        if (hyphenRange !== null) {
+            return (explicitSemverVersion.test(hyphenRange[1] ?? "") &&
+                explicitSemverVersion.test(hyphenRange[2] ?? ""));
+        }
+        return clause.split(/\s+/u).every((token) => explicitSemverComparator.test(token));
+    });
+}
+function assertNpmSemverRange(value, label) {
+    if (typeof value !== "string" || value !== value.trim() || !hasExplicitSemverSyntax(value)) {
+        throw new Error(`${label} must be a controlled npm semantic-version range.`);
+    }
+    const normalizedRange = semver.validRange(value);
+    if (normalizedRange === null || normalizedRange === "*") {
+        throw new Error(`${label} must be a controlled npm semantic-version range.`);
+    }
+}
+function resolveVersions(options) {
+    const versions = {
+        devkit: options.devkitVersion ?? DEFAULT_DEVKIT_VERSION_RANGE,
+        agentKit: options.agentKitVersion ?? EXTERNAL_PRODUCT_VERSION_RANGES.agentKit,
+        swiperAdapter: options.swiperAdapterVersion ?? EXTERNAL_PRODUCT_VERSION_RANGES.swiperAdapter,
+        spacesDeployer: options.spacesDeployerVersion ?? EXTERNAL_PRODUCT_VERSION_RANGES.spacesDeployer,
+    };
+    for (const [name, version] of Object.entries(versions)) {
+        assertNpmSemverRange(version, `${name} version`);
+    }
+    return versions;
+}
+function defaultTemplateRoot() {
+    return resolve(dirname(fileURLToPath(import.meta.url)), "template");
+}
+function isMissing(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ENOENT");
+}
+function selectKnown(requested, supported, label) {
+    const unsupported = requested.filter((value) => !supported.includes(value));
+    if (unsupported.length > 0)
+        throw new Error(`Unsupported ${label}: ${unsupported.join(", ")}`);
+    const selected = new Set(requested);
+    return supported.filter((value) => selected.has(value));
+}
+async function assertNewProjectTarget(target) {
+    const targetStat = await lstat(target).catch((error) => {
+        if (isMissing(error))
+            return undefined;
+        throw error;
+    });
+    if (targetStat === undefined)
+        return;
+    if (!targetStat.isDirectory() || targetStat.isSymbolicLink()) {
+        throw new Error("Target must be a new directory or an existing empty directory.");
+    }
+    if ((await readdir(target)).length > 0) {
+        throw new Error("Target directory is not empty. Choose a new project directory.");
+    }
+}
+async function copyTree(source, destination) {
+    await mkdir(destination, { recursive: true });
+    for (const entry of await readdir(source, { withFileTypes: true })) {
+        if (["node_modules", "dist", ".slicemedia"].includes(entry.name))
+            continue;
+        const from = join(source, entry.name);
+        const destinationName = entry.name === "gitignore.template"
+            ? ".gitignore"
+            : entry.name === "npmrc.template"
+                ? ".npmrc"
+                : entry.name;
+        const to = join(destination, destinationName);
+        if (entry.isDirectory()) {
+            await copyTree(from, to);
+            continue;
+        }
+        await mkdir(dirname(to), { recursive: true });
+        await writeFile(to, await readFile(from), { flag: "wx" });
+    }
+}
+async function listFiles(root) {
+    const files = [];
+    async function visit(directory) {
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            const path = join(directory, entry.name);
+            if (entry.isDirectory())
+                await visit(path);
+            else if (entry.isFile())
+                files.push(relative(root, path));
+        }
+    }
+    await visit(root);
+    return files.sort();
+}
+async function removeFileIfPresent(path) {
+    await unlink(path).catch((error) => {
+        if (!isMissing(error))
+            throw error;
+    });
+}
+async function configurePackageManagerFiles(target, packageManager) {
+    const npmrcPath = join(target, ".npmrc");
+    const yarnrcPath = join(target, ".yarnrc.yml");
+    if (packageManager === "pnpm") {
+        await removeFileIfPresent(yarnrcPath);
+        await writeFile(npmrcPath, "engine-strict=true\nminimum-release-age-strict=true\nsave-exact=true\n");
+        return;
+    }
+    if (packageManager === "npm") {
+        await removeFileIfPresent(yarnrcPath);
+        await writeFile(npmrcPath, "engine-strict=true\nsave-exact=true\n");
+        return;
+    }
+    await removeFileIfPresent(npmrcPath);
+    await writeFile(yarnrcPath, "nodeLinker: node-modules\n");
+    const gitignorePath = join(target, ".gitignore");
+    const gitignore = await readFile(gitignorePath, "utf8");
+    if (!gitignore.split(/\r?\n/u).includes(".yarn/install-state.gz")) {
+        const separator = gitignore.endsWith("\n") ? "" : "\n";
+        await writeFile(gitignorePath, `${gitignore}${separator}.yarn/install-state.gz\n`);
+    }
+}
+async function configureReadme(target, packageManager) {
+    if (packageManager === "pnpm")
+        return;
+    const readmePath = join(target, "README.md");
+    let readme = await readFile(readmePath, "utf8");
+    const pnpmCommands = packageManagerCommands.pnpm;
+    const selectedCommands = packageManagerCommands[packageManager];
+    const replacements = Object.keys(pnpmCommands).map((command) => [pnpmCommands[command], selectedCommands[command]]);
+    replacements.sort(([left], [right]) => right.length - left.length);
+    for (const [pnpmCommand, selectedCommand] of replacements) {
+        readme = readme.replaceAll(pnpmCommand, selectedCommand);
+    }
+    await writeFile(readmePath, readme);
+}
+function capabilityDependencies(capabilities, versions) {
+    const dependencies = Object.assign({}, baseDependencies(versions), ...capabilities.map((capability) => capabilityDefinitions[capability].dependencies(versions)));
+    return Object.fromEntries(Object.entries(dependencies).sort(([left], [right]) => left.localeCompare(right)));
+}
+async function configureEnvironment(target, capabilities) {
+    const variables = capabilities.flatMap((capability) => capabilityDefinitions[capability].environmentVariables ?? []);
+    if (variables.length === 0)
+        return;
+    const environmentPath = join(target, ".env.example");
+    const source = await readFile(environmentPath, "utf8");
+    const separator = source.endsWith("\n") ? "\n" : "\n\n";
+    await writeFile(environmentPath, `${source}${separator}${variables.map((variable) => `${variable}=`).join("\n")}\n`);
+}
+async function configurePackage(target, projectName, packageManager, capabilities, agentTargets, versions) {
+    const packagePath = join(target, "package.json");
+    const packageJson = JSON.parse(await readFile(packagePath, "utf8"));
+    const dependencies = capabilityDependencies(capabilities, versions);
+    const devDependencies = { ...packageJson.devDependencies };
+    for (const dependency of Object.keys(devDependencies)) {
+        if (dependency.startsWith("@slicemedia/"))
+            delete devDependencies[dependency];
+    }
+    devDependencies["@slicemedia/devkit-cli"] = versions.devkit;
+    const agentGenerateCommand = agentTargets.length === 0
+        ? undefined
+        : `slicemedia-agent-kit generate --root . --profile project --targets ${agentTargets.join(",")}`;
+    if (agentGenerateCommand !== undefined) {
+        devDependencies["@slicemedia/agent-kit"] = versions.agentKit;
+    }
+    packageJson.name = projectName;
+    packageJson.packageManager = packageManagerMetadata[packageManager];
+    packageJson.dependencies = dependencies;
+    packageJson.devDependencies = Object.fromEntries(Object.entries(devDependencies).sort(([left], [right]) => left.localeCompare(right)));
+    packageJson.scripts = { ...packageJson.scripts };
+    if (agentGenerateCommand === undefined)
+        delete packageJson.scripts["agents:generate"];
+    else
+        packageJson.scripts["agents:generate"] = agentGenerateCommand;
+    await writeFile(packagePath, `${JSON.stringify(packageJson, null, 2)}\n`);
+    return {
+        dependencies,
+        devDependencies: packageJson.devDependencies,
+        ...(agentGenerateCommand === undefined ? {} : { agentGenerateCommand }),
+    };
+}
+async function writeIntegrations(target, capabilities) {
+    const files = [];
+    for (const capability of capabilities) {
+        const definition = capabilityDefinitions[capability];
+        const path = join(target, definition.integrationFile);
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, definition.renderIntegration(), { flag: "wx" });
+        files.push(definition.integrationFile);
+    }
+    return files;
+}
+async function configureDevKitEntry(target, capabilities) {
+    const configPath = join(target, "devkit.config.json");
+    const config = JSON.parse(await readFile(configPath, "utf8"));
+    if (config.entries?.length !== 1 || config.entries[0] === undefined) {
+        throw new Error("Starter devkit.config.json must declare exactly one project entry.");
+    }
+    config.entries[0].api = { ...config.entries[0].api, capabilities };
+    await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`);
+}
+export async function scaffoldProject(options) {
+    if (options.targetDirectory.trim() === "")
+        throw new Error("Target directory must not be empty.");
+    const target = resolve(options.targetDirectory);
+    if (target === parse(target).root) {
+        throw new Error("Refusing to scaffold into a filesystem root.");
+    }
+    assertProjectName(options.projectName);
+    if (options.packageManager === undefined)
+        throw new Error("Package manager must be selected.");
+    const [packageManager] = selectKnown([options.packageManager], PACKAGE_MANAGERS, "package manager");
+    if (packageManager === undefined)
+        throw new Error("Package manager must be selected.");
+    const capabilities = selectKnown(options.capabilities, PROJECT_CAPABILITIES, "capabilities");
+    const agentTargets = selectKnown(options.agentTargets, AGENT_TARGETS, "agent targets");
+    const versions = resolveVersions(options);
+    await assertNewProjectTarget(target);
+    await mkdir(target, { recursive: true });
+    await copyTree(options.templateRoot ?? defaultTemplateRoot(), target);
+    await configurePackageManagerFiles(target, packageManager);
+    await configureReadme(target, packageManager);
+    const configuredPackage = await configurePackage(target, options.projectName, packageManager, capabilities, agentTargets, versions);
+    const integrationFiles = await writeIntegrations(target, capabilities);
+    await configureEnvironment(target, capabilities);
+    await configureDevKitEntry(target, capabilities);
+    const receiptPath = ".slicemedia/devkit/scaffold-receipt.json";
+    await mkdir(join(target, ".slicemedia", "devkit"), { recursive: true });
+    const writtenFiles = [...(await listFiles(target)), receiptPath].sort();
+    const receipt = {
+        schemaVersion: 2,
+        projectName: options.projectName,
+        targetDirectory: target,
+        packageManager,
+        capabilities,
+        agentTargets,
+        dependencies: configuredPackage.dependencies,
+        devDependencies: configuredPackage.devDependencies,
+        integrationFiles,
+        ...(configuredPackage.agentGenerateCommand === undefined
+            ? {}
+            : { agentGenerateCommand: configuredPackage.agentGenerateCommand }),
+        writtenFiles,
+    };
+    await writeFile(join(target, receiptPath), `${JSON.stringify(receipt, null, 2)}\n`, {
+        flag: "wx",
+    });
+    return receipt;
+}

package/dist/sync-template.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sync-template.d.ts.map

package/dist/sync-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-template.d.ts","sourceRoot":"","sources":["../src/sync-template.ts"],"names":[],"mappings":""}

package/dist/sync-template.js

@@ -0,0 +1,25 @@
+import { cp, mkdir, readdir, rm } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const output = resolve(dirname(fileURLToPath(import.meta.url)), "template");
+const source = resolve(dirname(fileURLToPath(import.meta.url)), "../../../templates/starter");
+async function copy(sourceDirectory, outputDirectory) {
+    await mkdir(outputDirectory, { recursive: true });
+    for (const entry of await readdir(sourceDirectory, { withFileTypes: true })) {
+        if (["node_modules", "dist", ".slicemedia"].includes(entry.name))
+            continue;
+        const from = join(sourceDirectory, entry.name);
+        const packagedName = entry.name === ".gitignore"
+            ? "gitignore.template"
+            : entry.name === ".npmrc"
+                ? "npmrc.template"
+                : entry.name;
+        const to = join(outputDirectory, packagedName);
+        if (entry.isDirectory())
+            await copy(from, to);
+        else
+            await cp(from, to);
+    }
+}
+await rm(output, { recursive: true, force: true });
+await copy(source, output);

package/dist/template/.env.example

@@ -0,0 +1,4 @@
+SLICEMEDIA_WEBFLOW_SITE_ID=
+WEBFLOW_STAGING_DOMAIN=
+WEBFLOW_OAUTH_ACCESS_TOKEN=
+WEBFLOW_API_TOKEN=

package/dist/template/.nvmrc

@@ -0,0 +1 @@
+22.23.2

package/dist/template/README.md

@@ -0,0 +1,30 @@
+# Webflow project
+
+This project owns its Webflow markup, composition, configuration, and deployment choices. The base
+starter is deliberately neutral: no optional capability is imported by `src/main.ts`.
+
+## Local development
+
+1. Run `pnpm install`.
+2. Run `pnpm dev` for the CORS-enabled local development server.
+3. Author the Webflow markup contract with `data-wft-*` behavior hooks.
+4. Import only the generated files under `src/integrations/` that the project is ready to compose.
+5. Run `pnpm typecheck` and `pnpm build`.
+
+The build emits one project-owned ES2018 IIFE at `dist/project.js` and, when styles are imported,
+`dist/project.css`. `pnpm catalog -- --json` inspects the single project entry. Use
+`pnpm devkit -- <command>` for other DevKit commands.
+
+The project-owned `WEBFLOW_PROJECT.md` is always present. If agent targets were selected, run
+`pnpm agents:generate` after installation. Slice Media Agent Kit preserves that guide and creates
+only the requested Codex, Claude, Cursor, Copilot, or Webflow files; it is maintained in a separate
+repository.
+
+Connect an AI client to the official Webflow MCP server at `https://mcp.webflow.com/mcp`. Generated
+Agent Kit guidance directs most page, component, style, CMS, asset, and script work through
+headless tools. Open the Webflow MCP Bridge App only for live selection, canvas, mode, branch,
+breakpoint, or visual snapshot context. Remote writes and publishing require an explicit request
+and the matching generated skill.
+
+Copy `.env.example` to an ignored local file only when needed, and load it through your shell or CI.
+Never commit site IDs, domains, tokens, deployment credentials, or client fixtures.

package/dist/template/WEBFLOW_PROJECT.md

@@ -0,0 +1,15 @@
+# Webflow project guidance
+
+Webflow owns editable structure, components, styles, CMS content, forms, and native interactions.
+This project owns only the browser enhancements explicitly composed in `src/main.ts`.
+
+- Prefer native Webflow features before adding code.
+- Use documented, scoped `data-wft-*` hooks instead of generated classes or guessed identifiers.
+- Keep optional files under `src/integrations/` disconnected until their markup contract is ready.
+- Make initialization idempotent and restore owned DOM, attributes, listeners, observers, and timers
+  during teardown.
+- Inspect before remote work. Webflow writes and publishing require an explicit request, review,
+  read-back, and verification through the official Webflow MCP server.
+
+Install Slice Media Agent Kit only when this project needs platform-specific agent instructions.
+Generate only the targets used by the team.

package/dist/template/devkit.config.json

@@ -0,0 +1,18 @@
+{
+  "entries": [
+    {
+      "name": "project",
+      "input": "src/main.ts",
+      "version": "0.1.0",
+      "description": "Project-owned Webflow browser entry.",
+      "placement": "body-end",
+      "dependencies": [],
+      "attributes": [],
+      "scriptAttributes": {},
+      "api": {
+        "entry": "webflow-project",
+        "capabilities": []
+      }
+    }
+  ]
+}

package/dist/template/gitignore.template

@@ -0,0 +1,8 @@
+node_modules/
+dist/
+.env
+.env.*
+!.env.example
+.webflow/
+.slicemedia/
+*.local

package/dist/template/index.html

@@ -0,0 +1,11 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Webflow project</title>
+  </head>
+  <body>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

package/dist/template/npmrc.template

@@ -0,0 +1,3 @@
+engine-strict=true
+minimum-release-age-strict=true
+save-exact=true

package/dist/template/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "webflow-project",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Neutral project generated by Slice Media DevKit.",
+  "type": "module",
+  "packageManager": "pnpm@11.21.0",
+  "scripts": {
+    "build": "slicemedia-devkit build --entry src/main.ts --out-dir dist --script-file project.js --css-file project.css",
+    "catalog": "slicemedia-devkit catalog --root .",
+    "dev": "slicemedia-devkit dev",
+    "sanitize": "slicemedia-devkit sanitize --root .",
+    "devkit": "slicemedia-devkit",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@slicemedia/devkit-core": "workspace:*"
+  },
+  "devDependencies": {
+    "@slicemedia/devkit-cli": "workspace:*",
+    "typescript": "6.0.3"
+  },
+  "engines": {
+    "node": ">=22.13.0 <23 || >=24.0.0 <25"
+  }
+}

package/dist/template/src/main.ts

@@ -0,0 +1,12 @@
+import "./styles.css";
+import { initProject } from "./project.js";
+
+const start = (): void => {
+  initProject();
+};
+
+if (document.readyState === "loading") {
+  document.addEventListener("DOMContentLoaded", start, { once: true });
+} else {
+  start();
+}

package/dist/template/src/project.ts

@@ -0,0 +1,16 @@
+let initialized = false;
+
+/** Compose project-owned integrations here when their Webflow markup contract is ready. */
+export function initProject(): void {
+  if (initialized) return;
+  initialized = true;
+}
+
+export function refreshProject(): void {
+  if (!initialized) return;
+}
+
+export function destroyProject(): void {
+  if (!initialized) return;
+  initialized = false;
+}

package/dist/template/src/styles.css

@@ -0,0 +1 @@
+/* Add project-owned styles only when the Webflow composition requires them. */

package/dist/template/src/styles.d.ts

@@ -0,0 +1 @@
+declare module "*.css";

package/dist/template/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "exactOptionalPropertyTypes": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "noEmit": true,
+    "noUncheckedIndexedAccess": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "verbatimModuleSyntax": true
+  },
+  "include": ["src/**/*.ts"]
+}

package/dist/versions.generated.d.ts

@@ -0,0 +1,9 @@
+/** Generated by scripts/sync-versions.mjs. Do not edit by hand. */
+export declare const DEVKIT_PACKAGE_VERSION = "0.1.1";
+export declare const DEFAULT_DEVKIT_VERSION_RANGE = "^0.1.1";
+export declare const EXTERNAL_PRODUCT_VERSION_RANGES: {
+    readonly agentKit: "^0.1.0";
+    readonly swiperAdapter: "^0.1.0";
+    readonly spacesDeployer: "^0.1.0";
+};
+//# sourceMappingURL=versions.generated.d.ts.map

package/dist/versions.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"versions.generated.d.ts","sourceRoot":"","sources":["../src/versions.generated.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,eAAO,MAAM,sBAAsB,UAAU,CAAC;AAC9C,eAAO,MAAM,4BAA4B,WAAW,CAAC;AAErD,eAAO,MAAM,+BAA+B;;;;CAIlC,CAAC"}

package/dist/versions.generated.js

@@ -0,0 +1,8 @@
+/** Generated by scripts/sync-versions.mjs. Do not edit by hand. */
+export const DEVKIT_PACKAGE_VERSION = "0.1.1";
+export const DEFAULT_DEVKIT_VERSION_RANGE = "^0.1.1";
+export const EXTERNAL_PRODUCT_VERSION_RANGES = {
+    agentKit: "^0.1.0",
+    swiperAdapter: "^0.1.0",
+    spacesDeployer: "^0.1.0",
+};

package/package.json

@@ -1,20 +1,60 @@
 {
   "name": "@slicemedia/create-devkit",
-  "version": "0.0.0-bootstrap.0",
-  "description": "Bootstrap placeholder for the @slicemedia/create-devkit package identity; not a functional release.",
-  "private": false,
-  "license": "MIT",
+  "version": "0.1.1",
+  "description": "Interactive project wizard for Slice Media DevKit.",
   "author": "Slice Media",
-  "files": ["README.md", "LICENSE"],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/slicemedia/devkit.git"
+    "url": "git+https://github.com/slicemedia/devkit.git",
+    "directory": "packages/create-devkit"
   },
-  "homepage": "https://github.com/slicemedia/devkit#readme",
+  "homepage": "https://github.com/slicemedia/devkit/tree/main/packages/create-devkit#readme",
   "bugs": {
     "url": "https://github.com/slicemedia/devkit/issues"
   },
+  "keywords": [
+    "slicemedia",
+    "webflow",
+    "starter",
+    "scaffolding",
+    "typescript"
+  ],
+  "type": "module",
+  "private": false,
+  "license": "MIT",
+  "files": [
+    "bin",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "create-slicemedia-devkit": "./bin/create-slicemedia-devkit.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "enquirer": "2.4.1",
+    "semver": "7.8.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.1"
+  },
+  "engines": {
+    "node": ">=22.13.0 <23 || >=24.0.0 <25"
+  },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node dist/sync-template.js",
+    "lint": "eslint src",
+    "test": "vitest run --root ../.. packages/create-devkit/src",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
   }
-}
+}