@olegkuibar/plunk 0.2.0-canary.04ff96f

package/dist/chunk-KYDBD2KQ.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};

package/dist/chunk-LKQINKH4.mjs

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+import {
+  consola
+} from "./chunk-I6SN7BBN.mjs";
+
+// src/core/watcher.ts
+import { spawn } from "child_process";
+import { platform } from "os";
+var activeChild = null;
+var activeWatcher = null;
+function killActiveBuild() {
+  if (activeChild && !activeChild.killed) {
+    activeChild.kill("SIGTERM");
+    activeChild = null;
+  }
+}
+async function startWatcher(watchDir, options, onChange) {
+  const { watch } = await import("./chokidar-XGAEDN45.mjs");
+  const patterns = options.patterns ?? ["src", "lib", "dist"];
+  const watchPaths = patterns.map(
+    (p) => p.startsWith("/") || p.includes(":") ? p : `${watchDir}/${p}`
+  );
+  const debounceMs = options.debounce ?? 100;
+  let coalesceTimer = null;
+  let running = false;
+  let pendingWhileRunning = false;
+  const scheduleFlush = () => {
+    if (coalesceTimer) return;
+    coalesceTimer = setTimeout(async () => {
+      coalesceTimer = null;
+      if (running) {
+        pendingWhileRunning = true;
+        return;
+      }
+      running = true;
+      try {
+        if (options.buildCmd) {
+          const success = await runBuildCommand(options.buildCmd, watchDir);
+          if (!success) {
+            consola.warn("Build failed, skipping push");
+            return;
+          }
+        }
+        await onChange();
+      } catch (err) {
+        consola.error("Push failed:", err);
+      } finally {
+        running = false;
+        if (pendingWhileRunning) {
+          pendingWhileRunning = false;
+          scheduleFlush();
+        }
+      }
+    }, debounceMs);
+  };
+  const onFileEvent = (_path) => {
+    if (coalesceTimer) {
+      clearTimeout(coalesceTimer);
+      coalesceTimer = null;
+    }
+    scheduleFlush();
+  };
+  const awfOption = options.buildCmd ? false : options.awaitWriteFinish ?? {
+    stabilityThreshold: 200,
+    pollInterval: 50
+  };
+  const watcher = watch(watchPaths, {
+    ignoreInitial: true,
+    ignored: [
+      "**/node_modules/**",
+      "**/.git/**",
+      "**/.plunk/**"
+    ],
+    awaitWriteFinish: awfOption
+  });
+  watcher.on("change", onFileEvent);
+  watcher.on("add", onFileEvent);
+  watcher.on("unlink", onFileEvent);
+  const watcherHandle = {
+    close: async () => {
+      if (coalesceTimer) clearTimeout(coalesceTimer);
+      killActiveBuild();
+      await watcher.close();
+      activeWatcher = null;
+    }
+  };
+  activeWatcher = watcherHandle;
+  const cleanup = async () => {
+    consola.info("Stopping watcher...");
+    await watcherHandle.close();
+    process.exit(0);
+  };
+  process.once("SIGINT", cleanup);
+  process.once("SIGTERM", cleanup);
+  consola.info(`Watching for changes in: ${patterns.join(", ")}`);
+  return watcherHandle;
+}
+function runBuildCommand(cmd, cwd) {
+  return new Promise((resolve) => {
+    const isWin = platform() === "win32";
+    const shell = isWin ? "cmd" : "sh";
+    const shellFlag = isWin ? "/c" : "-c";
+    consola.start(`Running: ${cmd}`);
+    const child = spawn(shell, [shellFlag, cmd], {
+      cwd,
+      stdio: "inherit"
+    });
+    activeChild = child;
+    child.on("close", (code) => {
+      activeChild = null;
+      if (code === 0) {
+        consola.success("Build succeeded");
+        resolve(true);
+      } else {
+        consola.error(`Build failed with code ${code}`);
+        resolve(false);
+      }
+    });
+    child.on("error", (err) => {
+      activeChild = null;
+      consola.error(`Build error: ${err.message}`);
+      resolve(false);
+    });
+  });
+}
+
+export {
+  startWatcher
+};

package/dist/chunk-PUSXMPOF.mjs

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+import {
+  __commonJS
+} from "./chunk-KYDBD2KQ.mjs";
+
+// node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js"(exports, module) {
+    "use strict";
+    var p = process || {};
+    var argv = p.argv || [];
+    var env = p.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module.exports = createColors();
+    module.exports.createColors = createColors;
+  }
+});
+
+export {
+  require_picocolors
+};

package/dist/chunk-S4HJSJ32.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+import {
+  require_picocolors
+} from "./chunk-PUSXMPOF.mjs";
+import {
+  consola
+} from "./chunk-I6SN7BBN.mjs";
+import {
+  __toESM
+} from "./chunk-KYDBD2KQ.mjs";
+
+// src/utils/errors.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+var SUGGESTIONS = [
+  {
+    pattern: /not found in store/i,
+    message: "Run 'plunk publish' in the package directory first, or use --from <path>."
+  },
+  {
+    pattern: /is not linked/i,
+    message: "Run 'plunk add <package>' to link it first."
+  },
+  {
+    pattern: /No package\.json/i,
+    message: "Make sure you're in a valid package directory with a package.json."
+  },
+  {
+    pattern: /missing 'name'/i,
+    message: "Add a 'name' field to your package.json."
+  },
+  {
+    pattern: /missing 'version'/i,
+    message: "Add a 'version' field to your package.json."
+  },
+  {
+    pattern: /store entry missing/i,
+    message: "Re-publish the package with 'plunk publish'."
+  },
+  {
+    pattern: /EACCES|EPERM/i,
+    message: "Permission denied. Try running with elevated privileges or check file ownership."
+  },
+  {
+    pattern: /ENOSPC/i,
+    message: "Disk is full. Free up some space and try again."
+  },
+  {
+    pattern: /No publishable files/i,
+    message: "Check the 'files' field in package.json, or ensure the build output exists."
+  },
+  {
+    pattern: /private.*package/i,
+    message: "Use --private flag to publish private packages."
+  }
+];
+function errorWithSuggestion(message) {
+  consola.error(message);
+  for (const { pattern, message: suggestion } of SUGGESTIONS) {
+    if (pattern.test(message)) {
+      consola.info(`${import_picocolors.default.dim("Suggestion:")} ${suggestion}`);
+      break;
+    }
+  }
+}
+
+export {
+  errorWithSuggestion
+};

package/dist/chunk-W3C72UKC.mjs

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+import {
+  decodePackageName,
+  encodePackageName,
+  getStoreEntryPath,
+  getStoreMetaPath,
+  getStorePackagePath,
+  getStorePath,
+  isPlunkMeta
+} from "./chunk-EDUXIQ5W.mjs";
+import {
+  exists,
+  isNodeError,
+  removeDir
+} from "./chunk-HKNM3UWU.mjs";
+import {
+  consola
+} from "./chunk-I6SN7BBN.mjs";
+
+// src/core/store.ts
+import { readFile, readdir } from "fs/promises";
+import "path";
+async function readMeta(name, version) {
+  const metaPath = getStoreMetaPath(name, version);
+  try {
+    const content = await readFile(metaPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!isPlunkMeta(parsed)) {
+      consola.warn(`Invalid metadata for ${name}@${version}, ignoring`);
+      return null;
+    }
+    return parsed;
+  } catch (err) {
+    if (isNodeError(err) && err.code !== "ENOENT") {
+      consola.warn(`Failed to read metadata for ${name}@${version}: ${err}`);
+    }
+    return null;
+  }
+}
+async function getStoreEntry(name, version) {
+  const packageDir = getStorePackagePath(name, version);
+  const meta = await readMeta(name, version);
+  if (!meta) return null;
+  if (!await exists(packageDir)) return null;
+  return { name, version, packageDir, meta };
+}
+async function findStoreEntry(name) {
+  const storePath = getStorePath();
+  if (!await exists(storePath)) return null;
+  const encodedPrefix = encodePackageName(name) + "@";
+  const dirs = await readdir(storePath, { withFileTypes: true });
+  const candidates = dirs.filter(
+    (d) => d.isDirectory() && d.name.startsWith(encodedPrefix)
+  );
+  const results = await Promise.all(
+    candidates.map(async (dir) => {
+      const version = dir.name.slice(encodedPrefix.length);
+      const meta = await readMeta(name, version);
+      if (!meta) return null;
+      return {
+        name,
+        version,
+        packageDir: getStorePackagePath(name, version),
+        meta
+      };
+    })
+  );
+  const matching = results.filter((r) => r !== null);
+  if (matching.length === 0) return null;
+  matching.sort(
+    (a, b) => new Date(b.meta.publishedAt).getTime() - new Date(a.meta.publishedAt).getTime()
+  );
+  return matching[0];
+}
+async function listStoreEntries() {
+  const storePath = getStorePath();
+  if (!await exists(storePath)) return [];
+  const dirs = await readdir(storePath, { withFileTypes: true });
+  const candidates = dirs.filter((d) => {
+    if (!d.isDirectory()) return false;
+    const atIdx = d.name.lastIndexOf("@");
+    return atIdx > 0;
+  });
+  const results = await Promise.all(
+    candidates.map(async (dir) => {
+      const atIdx = dir.name.lastIndexOf("@");
+      const encodedName = dir.name.slice(0, atIdx);
+      const version = dir.name.slice(atIdx + 1);
+      const name = decodePackageName(encodedName);
+      const meta = await readMeta(name, version);
+      if (!meta) return null;
+      return {
+        name,
+        version,
+        packageDir: getStorePackagePath(name, version),
+        meta
+      };
+    })
+  );
+  return results.filter((r) => r !== null);
+}
+async function removeStoreEntry(name, version) {
+  await removeDir(getStoreEntryPath(name, version));
+}
+
+export {
+  readMeta,
+  getStoreEntry,
+  findStoreEntry,
+  listStoreEntries,
+  removeStoreEntry
+};

package/dist/chunk-WSECI6M7.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+
+// src/utils/nextjs-config.ts
+import { readFile, writeFile } from "fs/promises";
+function detectIndent(content) {
+  const match = content.match(/^(\s+)\S/m);
+  return match?.[1] || "  ";
+}
+function parseArrayItems(str) {
+  const items = [];
+  const regex = /['"]([^'"]*)['"]/g;
+  let match;
+  while ((match = regex.exec(str)) !== null) {
+    items.push(match[1]);
+  }
+  return items;
+}
+function formatArray(items, indent) {
+  if (items.length === 0) return "[]";
+  if (items.length <= 3) {
+    return `[${items.map((i) => `'${i}'`).join(", ")}]`;
+  }
+  const inner = items.map((i) => `${indent}${indent}'${i}',`).join("\n");
+  return `[
+${inner}
+${indent}]`;
+}
+async function addToTranspilePackages(configPath, packageName) {
+  let content;
+  try {
+    content = await readFile(configPath, "utf-8");
+  } catch {
+    return { modified: false, error: "could not read config file" };
+  }
+  const indent = detectIndent(content);
+  const transpileRegex = /transpilePackages\s*:\s*\[([^\]]*)\]/s;
+  const transpileMatch = transpileRegex.exec(content);
+  if (transpileMatch) {
+    const items = parseArrayItems(transpileMatch[1]);
+    if (items.includes(packageName)) {
+      return { modified: false };
+    }
+    items.push(packageName);
+    const newArray = formatArray(items, indent);
+    const updated = content.replace(transpileRegex, `transpilePackages: ${newArray}`);
+    await writeFile(configPath, updated);
+    return { modified: true };
+  }
+  const configObjRegex = /(?:module\.exports\s*=\s*\{|export\s+default\s+\{|nextConfig\s*=\s*\{)/;
+  const configObjMatch = configObjRegex.exec(content);
+  if (configObjMatch) {
+    const insertPos = configObjMatch.index + configObjMatch[0].length;
+    const newSection = `
+${indent}transpilePackages: ['${packageName}'],`;
+    const updated = content.slice(0, insertPos) + newSection + content.slice(insertPos);
+    await writeFile(configPath, updated);
+    return { modified: true };
+  }
+  return { modified: false, error: "unrecognized config pattern" };
+}
+async function removeFromTranspilePackages(configPath, packageName) {
+  let content;
+  try {
+    content = await readFile(configPath, "utf-8");
+  } catch {
+    return { modified: false };
+  }
+  const indent = detectIndent(content);
+  const transpileRegex = /transpilePackages\s*:\s*\[([^\]]*)\]/s;
+  const transpileMatch = transpileRegex.exec(content);
+  if (!transpileMatch) return { modified: false };
+  const items = parseArrayItems(transpileMatch[1]);
+  const filtered = items.filter((i) => i !== packageName);
+  if (filtered.length === items.length) return { modified: false };
+  const newArray = formatArray(filtered, indent);
+  const updated = content.replace(transpileRegex, `transpilePackages: ${newArray}`);
+  await writeFile(configPath, updated);
+  return { modified: true };
+}
+
+export {
+  addToTranspilePackages,
+  removeFromTranspilePackages
+};

package/dist/chunk-XMIZ7OUZ.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+
+// src/utils/build-detect.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+async function detectBuildCommand(packageDir, pm) {
+  const runPrefix = pm === "npm" ? "npm run " : `${pm} `;
+  try {
+    const pkg = JSON.parse(
+      await readFile(join(packageDir, "package.json"), "utf-8")
+    );
+    const scripts = pkg.scripts || {};
+    for (const name of ["build", "compile", "bundle", "tsc"]) {
+      if (scripts[name]) {
+        return `${runPrefix}${name}`;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+
+export {
+  detectBuildCommand
+};

package/dist/chunk-XZK5T4GK.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+
+// src/utils/timer.ts
+var Timer = class {
+  start = performance.now();
+  /** Return elapsed time in ms */
+  elapsedMs() {
+    return performance.now() - this.start;
+  }
+  /** Return human-readable elapsed time (e.g., "1.2s" or "150ms") */
+  elapsed() {
+    const ms = this.elapsedMs();
+    if (ms >= 1e3) {
+      return `${(ms / 1e3).toFixed(1)}s`;
+    }
+    return `${Math.round(ms)}ms`;
+  }
+};
+
+export {
+  Timer
+};

package/dist/chunk-ZOYNYK5Y.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+import {
+  consola,
+  isJsonOutput
+} from "./chunk-I6SN7BBN.mjs";
+
+// src/utils/output.ts
+function output(data) {
+  if (isJsonOutput()) {
+    console.log(JSON.stringify(data, null, 2));
+  }
+}
+function suppressHumanOutput() {
+  if (isJsonOutput()) {
+    consola.level = -1;
+  }
+}
+
+export {
+  output,
+  suppressHumanOutput
+};

package/dist/chunk-ZQCGJUBJ.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+import {
+  readConsumerState,
+  writeConsumerState
+} from "./chunk-GAAB2TLH.mjs";
+import {
+  require_picocolors
+} from "./chunk-PUSXMPOF.mjs";
+import {
+  getConsumerPlunkDir,
+  getConsumerStatePath
+} from "./chunk-EDUXIQ5W.mjs";
+import {
+  ensureDir,
+  exists
+} from "./chunk-HKNM3UWU.mjs";
+import {
+  consola
+} from "./chunk-I6SN7BBN.mjs";
+import {
+  __toESM
+} from "./chunk-KYDBD2KQ.mjs";
+
+// src/utils/init-helpers.ts
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+var import_picocolors = __toESM(require_picocolors(), 1);
+async function ensureGitignore(gitignorePath) {
+  let content = "";
+  try {
+    content = await readFile(gitignorePath, "utf-8");
+  } catch {
+  }
+  const lines = content.split("\n");
+  const alreadyIgnored = lines.some(
+    (line) => line.trim() === ".plunk/" || line.trim() === ".plunk" || line.trim() === "/.plunk/" || line.trim() === "/.plunk"
+  );
+  if (alreadyIgnored) return false;
+  const separator = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
+  const section = content.length > 0 ? "\n# plunk local links\n.plunk/\n" : "# plunk local links\n.plunk/\n";
+  await writeFile(gitignorePath, content + separator + section);
+  return true;
+}
+async function addPostinstall(pkgPath) {
+  const content = await readFile(pkgPath, "utf-8");
+  const pkg = JSON.parse(content);
+  if (pkg.scripts?.postinstall) {
+    if (pkg.scripts.postinstall.includes("plunk")) return false;
+    consola.warn(
+      `Existing postinstall script found. Add ${import_picocolors.default.cyan("plunk restore")} manually if needed.`
+    );
+    return false;
+  }
+  if (!pkg.scripts) pkg.scripts = {};
+  pkg.scripts.postinstall = "plunk restore || true";
+  const indent = content.match(/^(\s+)"/m)?.[1] || "  ";
+  await writeFile(pkgPath, JSON.stringify(pkg, null, indent) + "\n");
+  return true;
+}
+async function ensureConsumerInit(projectDir, pm) {
+  const plunkDir = getConsumerPlunkDir(projectDir);
+  const statePath = getConsumerStatePath(projectDir);
+  if (!await exists(statePath)) {
+    await ensureDir(plunkDir);
+    await writeConsumerState(projectDir, {
+      version: "1",
+      packageManager: pm,
+      role: "consumer",
+      links: {}
+    });
+  } else {
+    const state = await readConsumerState(projectDir);
+    if (!state.packageManager) {
+      state.packageManager = pm;
+      state.role = state.role ?? "consumer";
+      await writeConsumerState(projectDir, state);
+    }
+  }
+  const gitignorePath = join(projectDir, ".gitignore");
+  await ensureGitignore(gitignorePath);
+  const pkgPath = join(projectDir, "package.json");
+  if (await exists(pkgPath)) {
+    await addPostinstall(pkgPath);
+  }
+}
+
+export {
+  ensureGitignore,
+  addPostinstall,
+  ensureConsumerInit
+};