@aussieljk/forkbook 0.0.0-stage → 0.0.1-1

package/dist/_node-chunks/chunk-5WHA37KG.js

@@ -0,0 +1,1297 @@
+import CJS_COMPAT_NODE_URL_5ewvyy4zw6m from 'node:url';
+import CJS_COMPAT_NODE_PATH_5ewvyy4zw6m from 'node:path';
+import CJS_COMPAT_NODE_MODULE_5ewvyy4zw6m from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_5ewvyy4zw6m.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_5ewvyy4zw6m.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_5ewvyy4zw6m.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  getSessionId
+} from "./chunk-XCGMRAV5.js";
+import {
+  getMonorepoType
+} from "./chunk-SVZ6Q3CS.js";
+import {
+  version
+} from "./chunk-DUOXRUVQ.js";
+import {
+  detectAgent
+} from "./chunk-M2BRIUUP.js";
+import {
+  createFileSystemCache,
+  resolvePathInStorybookCache
+} from "./chunk-I2ANCID7.js";
+import {
+  require_dist
+} from "./chunk-JEC2OK5B.js";
+import {
+  up
+} from "./chunk-7BVUZZIY.js";
+import {
+  RN_STORYBOOK_DIR
+} from "./chunk-XURIZ7IC.js";
+import {
+  globalSettings
+} from "./chunk-Y2DEKWVE.js";
+import {
+  BUNDLER_PACKAGES,
+  DATA_FETCHING_PACKAGES,
+  I18N_PACKAGES,
+  ROUTER_PACKAGES,
+  STATE_MANAGEMENT_PACKAGES,
+  STYLING_PACKAGES,
+  TEST_PACKAGES,
+  UI_LIBRARY_PACKAGES,
+  matchesPackagePattern
+} from "./chunk-ICADUNQM.js";
+import {
+  execa
+} from "./chunk-ZBAIFZNB.js";
+import {
+  getProjectRoot
+} from "./chunk-ULW4SLMN.js";
+import {
+  nanoid
+} from "./chunk-G6PUNHCI.js";
+import {
+  resolvePackageDir
+} from "./chunk-ILVD64RB.js";
+import {
+  slash
+} from "./chunk-RJUHZH32.js";
+import {
+  __toESM
+} from "./chunk-NKAUZU4C.js";
+
+// src/telemetry/index.ts
+import { logger as logger3 } from "@aussieljk/forkbook/internal/node-logger";
+
+// src/telemetry/notify.ts
+import { cache } from "@aussieljk/forkbook/internal/common";
+import { logger as logger2 } from "@aussieljk/forkbook/internal/node-logger";
+
+// src/telemetry/otel.ts
+import { logger } from "@aussieljk/forkbook/internal/node-logger";
+var OTEL_PACKAGES = [
+  "@opentelemetry/api",
+  "@opentelemetry/context-async-hooks",
+  "@opentelemetry/sdk-trace-base",
+  "@opentelemetry/sdk-logs",
+  "@opentelemetry/exporter-trace-otlp-http",
+  "@opentelemetry/exporter-logs-otlp-http",
+  "@opentelemetry/resources"
+], loading, isOtelEnabled = () => !!process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+async function startOtel() {
+  let [
+    api,
+    { AsyncLocalStorageContextManager },
+    { BasicTracerProvider, SimpleSpanProcessor },
+    { LoggerProvider, SimpleLogRecordProcessor },
+    { OTLPTraceExporter },
+    { OTLPLogExporter },
+    { resourceFromAttributes }
+  ] = await Promise.all([
+    import("@opentelemetry/api"),
+    import("@opentelemetry/context-async-hooks"),
+    import("@opentelemetry/sdk-trace-base"),
+    import("@opentelemetry/sdk-logs"),
+    import("@opentelemetry/exporter-trace-otlp-http"),
+    import("@opentelemetry/exporter-logs-otlp-http"),
+    import("@opentelemetry/resources")
+  ]), resource = resourceFromAttributes({
+    "service.name": process.env.OTEL_SERVICE_NAME ?? "forkbook",
+    "service.version": version
+  }), tracerProvider = new BasicTracerProvider({
+    resource,
+    spanProcessors: [new SimpleSpanProcessor(new OTLPTraceExporter())]
+  }), loggerProvider = new LoggerProvider({
+    resource,
+    processors: [new SimpleLogRecordProcessor({ exporter: new OTLPLogExporter() })]
+  });
+  return api.context.setGlobalContextManager(new AsyncLocalStorageContextManager().enable()), {
+    tracer: tracerProvider.getTracer("forkbook", version),
+    eventLogger: loggerProvider.getLogger("forkbook", version),
+    errorStatus: api.SpanStatusCode.ERROR,
+    flush: async () => {
+      await Promise.all([tracerProvider.forceFlush(), loggerProvider.forceFlush()]);
+    }
+  };
+}
+function loadOtel() {
+  return isOtelEnabled() ? (loading ??= startOtel().catch((error) => {
+    logger.warn(
+      `OTEL_EXPORTER_OTLP_ENDPOINT is set, but OpenTelemetry did not start (${String(error)}). Install these packages: ${OTEL_PACKAGES.join(" ")}`
+    );
+  }), loading) : Promise.resolve(void 0);
+}
+function toAttributes(value, prefix = "", attributes = {}) {
+  if (value == null)
+    return attributes;
+  if (Array.isArray(value))
+    attributes[prefix] = value.every((item) => typeof item == "string") ? value : JSON.stringify(value);
+  else if (typeof value == "object")
+    for (let [key, item] of Object.entries(value))
+      toAttributes(item, prefix ? `${prefix}.${key}` : key, attributes);
+  else ["string", "number", "boolean"].includes(typeof value) ? attributes[prefix] = value : attributes[prefix] = String(value);
+  return attributes;
+}
+async function emitOtelEvent(eventType, body) {
+  let otel = await loadOtel();
+  otel && (otel.eventLogger.emit({
+    eventName: `forkbook.${eventType}`,
+    body: eventType,
+    attributes: toAttributes(body)
+  }), await otel.flush());
+}
+async function withSpan(name, attributes, run) {
+  let otel = await loadOtel();
+  return otel ? otel.tracer.startActiveSpan(name, { attributes }, async (span) => {
+    try {
+      return await run();
+    } catch (error) {
+      throw span.recordException(error), span.setStatus({ code: otel.errorStatus }), error;
+    } finally {
+      span.end();
+    }
+  }) : run();
+}
+
+// src/telemetry/notify.ts
+var TELEMETRY_KEY_NOTIFY_DATE = "telemetry-notification-date", called = !1, notify = async () => {
+  !called && isOtelEnabled() && (called = !0, await cache.get(TELEMETRY_KEY_NOTIFY_DATE, null) || (cache.set(TELEMETRY_KEY_NOTIFY_DATE, Date.now()), logger2.info(
+    `Forkbook sends anonymous usage telemetry to ${process.env.OTEL_EXPORTER_OTLP_ENDPOINT}. To stop it, remove OTEL_EXPORTER_OTLP_ENDPOINT.`
+  )));
+};
+
+// src/telemetry/sanitize.ts
+import os from "node:os";
+import path from "node:path";
+function regexpEscape(str) {
+  return str.replace(/[-[/{}()*+?.\\^$|]/g, "\\$&");
+}
+function removeAnsiEscapeCodes(input = "") {
+  return input.replace(/\u001B\[[0-9;]*m/g, "");
+}
+function cleanPaths(str, separator = path.sep) {
+  if (!str)
+    return str;
+  let separators = Array.from(/* @__PURE__ */ new Set([separator, "/", "\\"]));
+  return [process.cwd(), os.homedir()].filter(Boolean).flatMap(
+    (basePath) => separators.map((sep2) => ({
+      separator: sep2,
+      normalizedPath: basePath.split(/[\\/]/).join(sep2)
+    }))
+  ).forEach(({ separator: sep2, normalizedPath }) => {
+    let stack = normalizedPath.split(sep2);
+    for (; stack.length > 1; ) {
+      let currentPath = stack.join(sep2), currentRegex = new RegExp(regexpEscape(currentPath), "gi");
+      str = str.replace(currentRegex, "$SNIP");
+      let doubledSeparatorPath = stack.join(sep2 + sep2), doubledSeparatorRegex = new RegExp(regexpEscape(doubledSeparatorPath), "gi");
+      str = str.replace(doubledSeparatorRegex, "$SNIP"), stack.pop();
+    }
+  }), str;
+}
+function sanitizeError(error, pathSeparator = path.sep) {
+  try {
+    error = {
+      ...JSON.parse(JSON.stringify(error)),
+      message: removeAnsiEscapeCodes(error.message),
+      stack: removeAnsiEscapeCodes(error.stack),
+      cause: error.cause,
+      name: error.name
+    };
+    let errorString = cleanPaths(JSON.stringify(error), pathSeparator);
+    return JSON.parse(errorString);
+  } catch (err) {
+    return `Sanitization error: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+
+// src/telemetry/storybook-metadata.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync3 } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname as dirname2, resolve } from "node:path";
+import {
+  getStorybookConfiguration,
+  getStorybookInfo as getStorybookInfo2,
+  isCI,
+  loadMainConfig,
+  versions
+} from "@aussieljk/forkbook/internal/common";
+import { getInterpretedFile } from "@aussieljk/forkbook/internal/common";
+import { readConfig } from "@aussieljk/forkbook/internal/csf-tools";
+
+// src/telemetry/get-application-file-count.ts
+import { sep } from "node:path";
+
+// src/telemetry/exec-command-count-lines.ts
+import { createInterface } from "node:readline";
+async function execCommandCountLines(command, args, options) {
+  let process3 = execa(command, args, { buffer: !1, ...options });
+  if (!process3.stdout)
+    throw new Error("Unexpected missing stdout");
+  let lineCount = 0, rl = createInterface(process3.stdout);
+  return rl.on("line", () => {
+    lineCount += 1;
+  }), await process3, rl.close(), lineCount;
+}
+
+// src/telemetry/run-telemetry-operation.ts
+var cache2 = createFileSystemCache({
+  basePath: resolvePathInStorybookCache("telemetry"),
+  ns: "storybook",
+  ttl: 1440 * 60 * 1e3
+  // 24h
+}), runTelemetryOperation = async (cacheKey, operation) => {
+  let cached = await cache2.get(cacheKey);
+  return cached === void 0 && (cached = await operation(), cached !== void 0 && await cache2.set(cacheKey, cached)), cached;
+};
+
+// src/telemetry/get-application-file-count.ts
+var nameMatches = ["page", "screen"], extensions = ["js", "jsx", "ts", "tsx"], getApplicationFilesCountUncached = async (basePath) => {
+  let globs = nameMatches.flatMap((match) => [
+    match,
+    [match[0].toUpperCase(), ...match.slice(1)].join("")
+  ]).flatMap(
+    (match) => extensions.map((extension) => `${basePath}${sep}*${match}*.${extension}`)
+  );
+  try {
+    return await execCommandCountLines("git", ["ls-files", "--", ...globs]);
+  } catch {
+    return;
+  }
+}, getApplicationFileCount = async (path3) => runTelemetryOperation(
+  "applicationFiles",
+  async () => getApplicationFilesCountUncached(path3)
+);
+
+// src/telemetry/get-chromatic-version.ts
+function getChromaticVersionSpecifier(packageJson) {
+  let dependency = packageJson.dependencies?.chromatic || packageJson.devDependencies?.chromatic || packageJson.peerDependencies?.chromatic;
+  return dependency || (packageJson.scripts && Object.values(packageJson.scripts).find((s) => s?.match(/chromatic/)) ? "latest" : void 0);
+}
+
+// src/telemetry/get-framework-info.ts
+import { getStorybookInfo } from "@aussieljk/forkbook/internal/common";
+var cleanAndSanitizePath = (path3) => {
+  let cleaned = cleanPaths(path3).replace(/.*node_modules[\\/]/, ""), pnpmDir = cleaned.match(/^\.pnpm\/(.+?)@[^/]+$/);
+  return pnpmDir ? pnpmDir[1].replace("+", "/") : cleaned;
+};
+async function getFrameworkInfo(mainConfig, configDir) {
+  let { frameworkPackage, rendererPackage, builderPackage } = await getStorybookInfo(configDir), frameworkOptions = typeof mainConfig.framework == "object" ? mainConfig.framework.options : {};
+  return {
+    framework: {
+      name: frameworkPackage ? cleanAndSanitizePath(frameworkPackage) : void 0,
+      options: frameworkOptions
+    },
+    builder: builderPackage ? cleanAndSanitizePath(builderPackage) : void 0,
+    renderer: rendererPackage ? cleanAndSanitizePath(rendererPackage) : void 0
+  };
+}
+
+// src/telemetry/get-has-module-federation.ts
+var MODULE_FEDERATION_PACKAGES = ["@module-federation/*", "@originjs/vite-plugin-federation"];
+function getHasModuleFederation(packageJson) {
+  let allDependencies = {
+    ...packageJson?.dependencies,
+    ...packageJson?.devDependencies
+  };
+  return Object.keys(allDependencies).some(
+    (depName) => matchesPackagePattern(depName, MODULE_FEDERATION_PACKAGES)
+  );
+}
+
+// src/telemetry/get-has-router-package.ts
+var routerPackages = /* @__PURE__ */ new Set([
+  "react-router",
+  "react-router-dom",
+  "remix",
+  "@tanstack/react-router",
+  "expo-router",
+  "@reach/router",
+  "react-easy-router",
+  "@remix-run/router",
+  "wouter",
+  // metaframeworks that imply routing
+  "next",
+  "react-scripts",
+  "gatsby"
+]);
+function getHasRouterPackage(packageJson) {
+  return Object.keys(packageJson?.dependencies ?? {}).some(
+    (depName) => routerPackages.has(depName)
+  );
+}
+
+// src/telemetry/get-has-next-custom-webpack.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var NEXT_CONFIG_FILES = [
+  "next.config.js",
+  "next.config.mjs",
+  "next.config.cjs",
+  "next.config.ts",
+  "next.config.mts"
+];
+function getHasNextCustomWebpack(projectRoot) {
+  for (let configFile of NEXT_CONFIG_FILES) {
+    let configPath = join(projectRoot, configFile);
+    if (existsSync(configPath))
+      try {
+        return /(?<![\w$-])['"]?webpack['"]?\s*[:(=]/.test(readFileSync(configPath, "utf8"));
+      } catch {
+        return !1;
+      }
+  }
+  return !1;
+}
+
+// src/telemetry/get-renderer-packages.ts
+var RENDERER_RUNTIME_PACKAGES = {
+  "@aussieljk/forkbook/react": ["react", "react-dom"],
+  "@storybook/react-native": ["react-native", "react"]
+};
+function getRendererPackages(renderer) {
+  return renderer ? RENDERER_RUNTIME_PACKAGES[renderer] ?? [] : [];
+}
+
+// src/telemetry/get-has-turbopack.ts
+function getHasTurbopack(packageJson) {
+  let nextCommand = /(?<![\w/.-])next\s+(?:dev|build)(?![\w.-])/, scripts = Object.values(packageJson?.scripts ?? {}).filter(
+    (script) => typeof script == "string" && nextCommand.test(script)
+  );
+  if (scripts.length !== 0) {
+    if (scripts.some((script) => /--turbopack\b/.test(script)))
+      return !0;
+    if (scripts.some((script) => /--webpack\b/.test(script)))
+      return !1;
+  }
+}
+
+// src/telemetry/get-known-packages.ts
+import semver from "semver";
+
+// src/telemetry/package-json.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join as join2 } from "node:path";
+import { pathToFileURL } from "node:url";
+var getActualPackageVersions = async (packages) => {
+  let packageNames = Object.keys(packages);
+  return Promise.all(packageNames.map(getActualPackageVersion));
+}, getActualPackageVersion = async (packageName) => {
+  try {
+    let packageJson = await getActualPackageJson(packageName);
+    return {
+      name: packageJson?.name || packageName,
+      version: packageJson?.version || null
+    };
+  } catch {
+    return {
+      name: packageName,
+      version: null
+    };
+  }
+}, getActualPackageJson = async (packageName) => {
+  let resolvedPackageJsonPath = resolvePackageJsonPath(packageName);
+  if (resolvedPackageJsonPath)
+    try {
+      let { default: packageJson } = await import(pathToFileURL(resolvedPackageJsonPath).href, {
+        with: { type: "json" }
+      });
+      return packageJson;
+    } catch {
+      return;
+    }
+}, attempt = (fn) => {
+  try {
+    return fn();
+  } catch {
+    return;
+  }
+}, resolvePackageJsonPath = (packageName) => {
+  let projectRequire = createRequire(join2(process.cwd(), "package.json"));
+  return attempt(() => projectRequire.resolve(`${packageName}/package.json`)) ?? attempt(() => up({ cwd: projectRequire.resolve(packageName) }) || void 0) ?? findPackageJsonInNodeModules(packageName);
+}, findPackageJsonInNodeModules = (packageName) => {
+  for (let dir = process.cwd(); ; dir = dirname(dir)) {
+    let candidate = join2(dir, "node_modules", packageName, "package.json");
+    if (existsSync2(candidate))
+      return candidate;
+    if (dirname(dir) === dir)
+      return;
+  }
+};
+
+// src/telemetry/get-known-packages.ts
+function getSafeVersionSpecifier(version2) {
+  if (!version2)
+    return null;
+  if (version2 === "*")
+    return "latest";
+  if (version2.includes(":"))
+    return "custom-protocol";
+  if ([
+    "latest",
+    "next",
+    "canary",
+    "beta",
+    "alpha",
+    "rc",
+    "nightly",
+    "dev",
+    "stable",
+    "experimental",
+    "insiders",
+    "preview"
+  ].includes(version2))
+    return version2;
+  try {
+    let operator = version2.trim().match(/^[~^]/)?.[0] ?? "", coerced = semver.coerce(version2);
+    return coerced ? `${operator}${coerced.version}` : null;
+  } catch {
+    return "could-not-be-parsed-by-semver";
+  }
+}
+async function analyzeEcosystemPackages(packageJson) {
+  let allDependencies = {
+    ...packageJson?.dependencies,
+    ...packageJson?.devDependencies,
+    ...packageJson?.peerDependencies
+  }, depNames = Object.keys(allDependencies), pickMatches = (packages) => depNames.filter((dep) => matchesPackagePattern(dep, packages)), pickDepsObject = (packages) => {
+    let result = Object.fromEntries(
+      pickMatches(packages).map((dep) => {
+        let rawVersion = allDependencies[dep], version2 = getSafeVersionSpecifier(rawVersion);
+        return [dep, version2];
+      })
+    );
+    return Object.keys(result).length === 0 ? null : result;
+  }, pickResolvedDepsObject = async (packages) => {
+    let result = Object.fromEntries(
+      await Promise.all(
+        pickMatches(packages).map(async (dep) => {
+          let resolved = (await getActualPackageVersion(dep))?.version ?? allDependencies[dep], version2 = getSafeVersionSpecifier(resolved);
+          return [dep, version2];
+        })
+      )
+    );
+    return Object.keys(result).length === 0 ? null : result;
+  }, testPackages = await pickResolvedDepsObject(TEST_PACKAGES), bundlerPackages = await pickResolvedDepsObject(BUNDLER_PACKAGES), stylingPackages = pickDepsObject(STYLING_PACKAGES), stateManagementPackages = pickDepsObject(STATE_MANAGEMENT_PACKAGES), dataFetchingPackages = pickDepsObject(DATA_FETCHING_PACKAGES), uiLibraryPackages = pickDepsObject(UI_LIBRARY_PACKAGES), i18nPackages = pickDepsObject(I18N_PACKAGES), routerPackages2 = pickDepsObject(ROUTER_PACKAGES);
+  return {
+    ...testPackages && { testPackages },
+    ...bundlerPackages && { bundlerPackages },
+    ...stylingPackages && { stylingPackages },
+    ...stateManagementPackages && {
+      stateManagementPackages
+    },
+    ...dataFetchingPackages && { dataFetchingPackages },
+    ...uiLibraryPackages && { uiLibraryPackages },
+    ...i18nPackages && { i18nPackages },
+    ...routerPackages2 && { routerPackages: routerPackages2 }
+  };
+}
+
+// src/telemetry/get-package-manager-info.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+
+// ../../node_modules/package-manager-detector/dist/commands.mjs
+function splitRunArgs(args, valueFlags = []) {
+  for (let i = 0; i < args.length; i++)
+    if (!args[i].startsWith("-") && !(i > 0 && valueFlags.includes(args[i - 1])))
+      return { before: args.slice(0, i), script: args[i], after: args.slice(i + 1) };
+  return { before: args, script: void 0, after: [] };
+}
+function dashDashArg(agent, agentCommand, valueFlags = []) {
+  return (args) => {
+    let { before, script, after } = splitRunArgs(args, valueFlags);
+    return script === void 0 ? [agent, agentCommand, ...before] : after.length > 0 ? [agent, agentCommand, ...before, script, "--", ...after] : [agent, agentCommand, ...before, script];
+  };
+}
+var npm = {
+  agent: ["npm", 0],
+  run: dashDashArg("npm", "run", ["-w", "--workspace"]),
+  install: ["npm", "i", 0],
+  frozen: ["npm", "ci", 0],
+  global: ["npm", "i", "-g", 0],
+  add: ["npm", "i", 0],
+  upgrade: ["npm", "update", 0],
+  "upgrade-interactive": null,
+  dedupe: ["npm", "dedupe", 0],
+  why: ["npm", "why", 0],
+  execute: ["npx", 0],
+  "execute-local": ["npx", 0],
+  uninstall: ["npm", "uninstall", 0],
+  global_uninstall: ["npm", "uninstall", "-g", 0]
+}, yarn = {
+  agent: ["yarn", 0],
+  run: ["yarn", "run", 0],
+  install: ["yarn", "install", 0],
+  frozen: ["yarn", "install", "--frozen-lockfile", 0],
+  global: ["yarn", "global", "add", 0],
+  add: ["yarn", "add", 0],
+  upgrade: ["yarn", "upgrade", 0],
+  "upgrade-interactive": ["yarn", "upgrade-interactive", 0],
+  dedupe: null,
+  why: ["yarn", "why", 0],
+  execute: ["npx", 0],
+  "execute-local": dashDashArg("yarn", "exec"),
+  uninstall: ["yarn", "remove", 0],
+  global_uninstall: ["yarn", "global", "remove", 0]
+}, yarnBerry = {
+  ...yarn,
+  frozen: ["yarn", "install", "--immutable", 0],
+  upgrade: ["yarn", "up", 0],
+  "upgrade-interactive": ["yarn", "up", "-i", 0],
+  dedupe: ["yarn", "dedupe", 0],
+  execute: ["yarn", "dlx", 0],
+  "execute-local": ["yarn", "exec", 0],
+  // Yarn 2+ removed 'global', see https://github.com/yarnpkg/berry/issues/821
+  global: ["npm", "i", "-g", 0],
+  global_uninstall: ["npm", "uninstall", "-g", 0]
+};
+function createPnpmCommands(cli) {
+  return {
+    agent: [cli, 0],
+    run: [cli, "run", 0],
+    install: [cli, "i", 0],
+    frozen: [cli, "i", "--frozen-lockfile", 0],
+    global: [cli, "add", "-g", 0],
+    add: [cli, "add", 0],
+    upgrade: [cli, "update", 0],
+    "upgrade-interactive": [cli, "update", "-i", 0],
+    dedupe: [cli, "dedupe", 0],
+    why: [cli, "why", 0],
+    execute: [cli, "dlx", 0],
+    "execute-local": [cli, "exec", 0],
+    uninstall: [cli, "remove", 0],
+    global_uninstall: [cli, "remove", "--global", 0]
+  };
+}
+var pnpm = createPnpmCommands("pnpm"), pnpmRush = createPnpmCommands("rush-pnpm"), bun = {
+  agent: ["bun", 0],
+  run: ["bun", "run", 0],
+  install: ["bun", "install", 0],
+  frozen: ["bun", "install", "--frozen-lockfile", 0],
+  global: ["bun", "add", "-g", 0],
+  add: ["bun", "add", 0],
+  upgrade: ["bun", "update", 0],
+  "upgrade-interactive": ["bun", "update", "-i", 0],
+  dedupe: null,
+  why: ["bun", "why", 0],
+  execute: ["bun", "x", 0],
+  "execute-local": ["bun", "x", 0],
+  uninstall: ["bun", "remove", 0],
+  global_uninstall: ["bun", "remove", "-g", 0]
+}, aube = {
+  agent: ["aube", 0],
+  run: ["aube", "run", 0],
+  install: ["aube", "install", 0],
+  frozen: ["aube", "install", "--frozen-lockfile", 0],
+  global: ["aube", "add", "-g", 0],
+  add: ["aube", "add", 0],
+  upgrade: ["aube", "update", 0],
+  "upgrade-interactive": ["aube", "update", "-i", 0],
+  dedupe: ["aube", "dedupe", 0],
+  why: ["aube", "why", 0],
+  execute: ["aube", "dlx", 0],
+  "execute-local": ["aube", "exec", 0],
+  uninstall: ["aube", "remove", 0],
+  global_uninstall: ["aube", "remove", "-g", 0]
+};
+function denoAdd(args) {
+  return args.includes("--npm") || args.includes("--jsr") ? ["deno", "add", ...args] : ["deno", "add", ...args.map((arg) => arg.startsWith("-") || arg.includes(":") ? arg : `npm:${arg}`)];
+}
+var deno = {
+  agent: ["deno", 0],
+  run: ["deno", "task", 0],
+  install: ["deno", "install", 0],
+  frozen: ["deno", "install", "--frozen", 0],
+  global: ["deno", "install", "-g", 0],
+  add: denoAdd,
+  upgrade: ["deno", "outdated", "--update", 0],
+  "upgrade-interactive": ["deno", "outdated", "--update", 0],
+  dedupe: null,
+  why: ["deno", "why", 0],
+  execute: ["deno", "x", 0],
+  "execute-local": ["deno", "task", "--eval", 0],
+  uninstall: ["deno", "remove", 0],
+  global_uninstall: ["deno", "uninstall", "-g", 0]
+}, nub = {
+  agent: ["nub", 0],
+  run: ["nub", "run", 0],
+  install: ["nub", "install", 0],
+  frozen: ["nub", "install", "--frozen-lockfile", 0],
+  global: ["nub", "add", "-g", 0],
+  add: ["nub", "add", 0],
+  upgrade: ["nub", "update", 0],
+  "upgrade-interactive": ["nub", "update", "-i", 0],
+  dedupe: ["nub", "dedupe", 0],
+  why: ["nub", "why", 0],
+  execute: ["nubx", 0],
+  "execute-local": ["nub", "exec", 0],
+  uninstall: ["nub", "remove", 0],
+  global_uninstall: ["nub", "remove", "-g", 0]
+}, upm = {
+  agent: ["upm", 0],
+  run: ["upm", "run", 0],
+  install: ["upm", "install", 0],
+  frozen: ["upm", "install", "--frozen-lockfile", 0],
+  global: null,
+  add: ["upm", "add", 0],
+  upgrade: null,
+  "upgrade-interactive": null,
+  dedupe: ["upm", "dedupe", 0],
+  execute: ["upx", 0],
+  "execute-local": ["upm", "exec", 0],
+  uninstall: ["upm", "remove", 0],
+  global_uninstall: null,
+  why: null
+}, COMMANDS = {
+  npm,
+  yarn,
+  "yarn@berry": yarnBerry,
+  pnpm,
+  // pnpm v6.x or below
+  "pnpm@6": {
+    ...pnpm,
+    run: dashDashArg("pnpm", "run", ["-F", "--filter"])
+  },
+  "pnpm-rush": pnpmRush,
+  bun,
+  aube,
+  deno,
+  nub,
+  upm
+};
+
+// ../../node_modules/package-manager-detector/dist/constants.mjs
+var AGENTS = [
+  "npm",
+  "yarn",
+  "yarn@berry",
+  "pnpm",
+  "pnpm@6",
+  "pnpm-rush",
+  "bun",
+  "deno",
+  "nub",
+  "aube",
+  "upm"
+], LOCKS = {
+  "aube-lock.yaml": "aube",
+  "aube-workspace.yaml": "aube",
+  "bun.lock": "bun",
+  "bun.lockb": "bun",
+  "deno.lock": "deno",
+  "nub.lock": "nub",
+  "upm.lock": "upm",
+  "pnpm-lock.yaml": "pnpm",
+  "pnpm-workspace.yaml": "pnpm",
+  "yarn.lock": "yarn",
+  "package-lock.json": "npm",
+  "npm-shrinkwrap.json": "npm"
+}, INSTALL_METADATA = {
+  "node_modules/.aube/": "aube",
+  "node_modules/.deno/": "deno",
+  "node_modules/.pnpm/": "pnpm",
+  "node_modules/.upm/": "upm",
+  "node_modules/.yarn-state.yml": "yarn",
+  // yarn v2+ (node-modules)
+  "node_modules/.yarn_integrity": "yarn",
+  // yarn v1
+  "node_modules/.package-lock.json": "npm",
+  ".pnp.cjs": "yarn",
+  // yarn v3+ (pnp)
+  ".pnp.js": "yarn",
+  // yarn v2 (pnp)
+  "bun.lock": "bun",
+  "bun.lockb": "bun"
+};
+
+// ../../node_modules/package-manager-detector/dist/detect.mjs
+import fs from "node:fs/promises";
+import path2 from "node:path";
+import process2 from "node:process";
+async function pathExists(path22, type) {
+  try {
+    let stat = await fs.stat(path22);
+    return type === "file" ? stat.isFile() : stat.isDirectory();
+  } catch {
+    return !1;
+  }
+}
+function* lookup(cwd = process2.cwd()) {
+  let directory = path2.resolve(cwd), { root } = path2.parse(directory);
+  for (; directory && directory !== root; )
+    yield directory, directory = path2.dirname(directory);
+}
+async function parsePackageJson(filepath, options) {
+  return !filepath || !await pathExists(filepath, "file") ? null : await handlePackageManager(filepath, options);
+}
+async function detect(options = {}) {
+  let {
+    cwd,
+    strategies = ["lockfile", "packageManager-field", "devEngines-field"]
+  } = options, stopDir;
+  if (typeof options.stopDir == "string") {
+    let resolved = path2.resolve(options.stopDir);
+    stopDir = (dir) => dir === resolved;
+  } else
+    stopDir = options.stopDir;
+  for (let directory of lookup(cwd)) {
+    for (let strategy of strategies)
+      switch (strategy) {
+        case "lockfile": {
+          if (await pathExists(path2.join(directory, "rush.json"), "file"))
+            return { name: "pnpm", agent: "pnpm-rush" };
+          for (let lock of Object.keys(LOCKS))
+            if (await pathExists(path2.join(directory, lock), "file")) {
+              let name = LOCKS[lock], result = await parsePackageJson(path2.join(directory, "package.json"), options);
+              return result || { name, agent: name };
+            }
+          break;
+        }
+        case "packageManager-field":
+        case "devEngines-field": {
+          let result = await parsePackageJson(path2.join(directory, "package.json"), options);
+          if (result)
+            return result;
+          break;
+        }
+        case "install-metadata": {
+          for (let metadata of Object.keys(INSTALL_METADATA)) {
+            let fileOrDir = metadata.endsWith("/") ? "dir" : "file";
+            if (await pathExists(path2.join(directory, metadata), fileOrDir)) {
+              let name = INSTALL_METADATA[metadata], agent = name === "yarn" ? isMetadataYarnClassic(metadata) ? "yarn" : "yarn@berry" : name;
+              return { name, agent };
+            }
+          }
+          break;
+        }
+      }
+    if (stopDir?.(directory))
+      break;
+  }
+  return null;
+}
+function normalizeAgentVersion(version2) {
+  return version2?.match(/\d+(\.\d+){0,2}/)?.[0] ?? version2;
+}
+function getNameAndVer(pkg) {
+  if (typeof pkg.packageManager == "string") {
+    let [name, ver] = pkg.packageManager.replace(/^\^/, "").split("@");
+    return { name, ver: normalizeAgentVersion(ver) };
+  }
+  if (typeof pkg.devEngines?.packageManager?.name == "string")
+    return {
+      name: pkg.devEngines.packageManager.name,
+      ver: normalizeAgentVersion(pkg.devEngines.packageManager.version)
+    };
+}
+async function handlePackageManager(filepath, options) {
+  try {
+    let content = await fs.readFile(filepath, "utf8"), pkg = options.packageJsonParser ? await options.packageJsonParser(content, filepath) : JSON.parse(content), nameAndVer = getNameAndVer(pkg);
+    if (nameAndVer)
+      return resolveAgent(nameAndVer.name, nameAndVer.ver) ?? options.onUnknown?.(pkg.packageManager) ?? null;
+  } catch {
+  }
+  return null;
+}
+function resolveAgent(name, ver) {
+  let agent, version2 = ver;
+  if (name === "yarn" && ver && Number.parseInt(ver) > 1)
+    return agent = "yarn@berry", version2 = "berry", { name, agent, version: version2 };
+  if (name === "pnpm" && ver && Number.parseInt(ver) < 7)
+    return agent = "pnpm@6", { name, agent, version: version2 };
+  if (AGENTS.includes(name))
+    return agent = name, { name, agent, version: version2 };
+}
+function isMetadataYarnClassic(metadataPath) {
+  return metadataPath.endsWith(".yarn_integrity");
+}
+
+// src/telemetry/get-package-manager-info.ts
+var import_yaml = __toESM(require_dist(), 1);
+var YARN_LINKERS = ["node-modules", "pnp", "pnpm"], PNPM_LINKERS = ["isolated", "hoisted", "pnp"], readYamlNodeLinker = (content) => (0, import_yaml.parse)(content)?.nodeLinker, readNpmrcNodeLinker = (content) => content.match(/^\s*node-linker\s*=\s*(?:"([^"]*)"|'([^']*)'|(\S+))/m)?.slice(1).find(Boolean), getPackageManagerInfo = async () => {
+  let projectRoot = getProjectRoot(), packageManager = await detect({ cwd: projectRoot });
+  if (packageManager)
+    return {
+      type: packageManager.name,
+      version: packageManager.version,
+      agent: packageManager.agent,
+      nodeLinker: readNodeLinker(packageManager, projectRoot)
+    };
+};
+function readNodeLinker(packageManager, projectRoot) {
+  let directories = [process.cwd(), projectRoot];
+  if (packageManager.name === "yarn" && packageManager.agent === "yarn@berry")
+    return [
+      process.env.YARN_NODE_LINKER,
+      ...directories.map((dir) => readSetting(join3(dir, ".yarnrc.yml"), readYamlNodeLinker))
+    ].find((value) => YARN_LINKERS.some((linker) => linker === value)) ?? "pnp";
+  if (packageManager.name === "pnpm") {
+    let legacy = !(Number(packageManager.version?.split(".")[0]) >= 11);
+    return [
+      process.env.pnpm_config_node_linker,
+      legacy ? process.env.npm_config_node_linker : void 0,
+      ...directories.map(
+        (dir) => readSetting(join3(dir, "pnpm-workspace.yaml"), readYamlNodeLinker)
+      ),
+      ...legacy ? directories.map((dir) => readSetting(join3(dir, ".npmrc"), readNpmrcNodeLinker)) : []
+    ].find((value) => PNPM_LINKERS.some((linker) => linker === value)) ?? "isolated";
+  }
+  return "node_modules";
+}
+function readSetting(filePath, extract) {
+  try {
+    return extract(readFileSync2(filePath, "utf8"));
+  } catch {
+    return;
+  }
+}
+
+// src/telemetry/get-portable-stories-usage.ts
+var getPortableStoriesFileCountUncached = async (path3) => {
+  try {
+    return await execCommandCountLines("git", [
+      "grep",
+      "-l",
+      "composeStor",
+      ...path3 ? ["--", path3] : []
+    ]);
+  } catch (err) {
+    return err.exitCode === 1 ? 0 : void 0;
+  }
+}, getPortableStoriesFileCount = async (path3) => runTelemetryOperation(
+  "portableStories",
+  async () => getPortableStoriesFileCountUncached(path3)
+);
+
+// src/telemetry/storybook-metadata.ts
+var metaFrameworks = {
+  next: "Next",
+  "react-scripts": "CRA",
+  gatsby: "Gatsby",
+  "@nrwl/storybook": "nx",
+  "@tanstack/react-router": "tanstack-react",
+  "@react-router/dev": "react-router",
+  "@remix-run/dev": "remix",
+  expo: "expo",
+  "vike-react": "vike-react"
+}, sanitizeAddonName = (name) => {
+  let normalized = name.replace(/\\/g, "/"), candidate = normalized;
+  normalized.includes("/node_modules/") && (candidate = normalized.split("/node_modules/").pop() ?? normalized);
+  let cleaned = cleanPaths(candidate).replace(/^file:\/\//i, "").replace(/\/+$/, "").replace(/\/dist\/.*/, "").replace(/\.[mc]?[tj]?s[x]?$/, "").replace(/\/(register|manager|preset|index)$/, "").replace(/\$SNIP?/g, ""), prefix = "";
+  (cleaned.startsWith("file") || cleaned.startsWith(".") || cleaned.startsWith("/") || cleaned.includes(":")) && (prefix = "CUSTOM:");
+  let scopedMatches = cleaned.match(/@[^/]+\/[^/]+/g);
+  if (scopedMatches?.length)
+    return scopedMatches.at(-1);
+  let parts = cleaned.split("/").filter(Boolean), addonLike = [...parts].reverse().find((part) => part.includes("addon-") || part.includes("-addon"));
+  return addonLike ? `${prefix}${addonLike}` : parts.length >= 2 && parts[parts.length - 2].startsWith("@") ? `${prefix}${parts[parts.length - 2]}/${parts[parts.length - 1]}` : parts.length ? `${prefix}${parts[parts.length - 1]}` : `${prefix}${candidate}`;
+}, computeStorybookMetadata = async ({
+  packageJsonPath,
+  packageJson,
+  mainConfig,
+  configDir
+}) => {
+  let settings = isCI() && !detectAgent() ? void 0 : await globalSettings(), metadata = {
+    generatedAt: (/* @__PURE__ */ new Date()).getTime(),
+    userSince: settings?.value.userSince,
+    hasCustomBabel: !1,
+    hasCustomWebpack: !1,
+    hasCustomVite: !1,
+    hasStaticDirs: !1,
+    hasStorybookEslint: !1,
+    refCount: 0
+  }, allDependencies = {
+    ...packageJson?.dependencies,
+    ...packageJson?.devDependencies,
+    ...packageJson?.peerDependencies
+  }, metaFramework = Object.keys(allDependencies).find((dep) => !!metaFrameworks[dep]);
+  if (metaFramework) {
+    let { version: version2 } = await getActualPackageVersion(metaFramework);
+    metadata.metaFramework = {
+      name: metaFrameworks[metaFramework],
+      packageName: metaFramework,
+      version: version2 || "unknown"
+    };
+  }
+  metadata.knownPackages = await analyzeEcosystemPackages(packageJson), metadata.hasRouterPackage = getHasRouterPackage(packageJson), metadata.hasTurbopack = getHasTurbopack(packageJson), metadata.hasModuleFederation = getHasModuleFederation(packageJson);
+  let monorepoType = getMonorepoType();
+  monorepoType && (metadata.monorepo = monorepoType), metadata.packageManager = await getPackageManagerInfo();
+  let language = allDependencies.typescript ? "typescript" : "javascript";
+  if (!mainConfig)
+    return {
+      ...metadata,
+      storybookVersionSpecifier: versions["@aussieljk/forkbook"],
+      language
+    };
+  metadata.hasCustomBabel = !!mainConfig.babel, metadata.hasCustomWebpack = !!allDependencies.next && getHasNextCustomWebpack(dirname2(packageJsonPath)), metadata.hasCustomVite = !!mainConfig.viteFinal, metadata.hasStaticDirs = !!mainConfig.staticDirs, typeof mainConfig.typescript == "object" && (metadata.typescriptOptions = mainConfig.typescript);
+  let frameworkInfo = await getFrameworkInfo(mainConfig, configDir), rendererPackages = Object.fromEntries(
+    await Promise.all(
+      getRendererPackages(frameworkInfo.renderer).map(async (packageName) => {
+        let { version: version2 } = await getActualPackageVersion(packageName);
+        return [packageName, version2 || "unknown"];
+      })
+    )
+  );
+  Object.keys(rendererPackages).length > 0 && (metadata.knownPackages = { ...metadata.knownPackages, rendererPackages }), typeof mainConfig.refs == "object" && (metadata.refCount = Object.keys(mainConfig.refs).length), typeof mainConfig.features == "object" && (metadata.features = mainConfig.features);
+  let addons = {};
+  mainConfig.addons && mainConfig.addons.forEach((addon) => {
+    let addonName, options;
+    typeof addon == "string" ? addonName = sanitizeAddonName(addon) : (addon.name.includes("addon-essentials") && (options = addon.options), addonName = sanitizeAddonName(addon.name)), addons[addonName] = {
+      options,
+      version: void 0
+    };
+  });
+  let chromaticVersionSpecifier = getChromaticVersionSpecifier(packageJson);
+  chromaticVersionSpecifier && (addons.chromatic = {
+    version: void 0,
+    versionSpecifier: chromaticVersionSpecifier,
+    options: void 0
+  }), (await getActualPackageVersions(addons)).forEach(({ name, version: version2 }) => {
+    addons[name] = addons[name] || {
+      name,
+      version: version2
+    }, addons[name].version = version2 || void 0;
+  });
+  let addonNames = Object.keys(addons), storybookPackages = Object.keys(allDependencies).filter(
+    (dep) => (dep.includes("storybook") || dep.includes("forkbook")) && !addonNames.includes(dep)
+  ).reduce((acc, dep) => ({
+    ...acc,
+    [dep]: { version: void 0 }
+  }), {});
+  (await getActualPackageVersions(storybookPackages)).forEach(({ name, version: version2 }) => {
+    storybookPackages[name] = storybookPackages[name] || {
+      name,
+      version: version2
+    }, storybookPackages[name].version = version2 || void 0;
+  });
+  let hasStorybookEslint = !!allDependencies["eslint-plugin-storybook"], storybookInfo = await getStorybookInfo2(configDir);
+  try {
+    let { previewConfigPath: previewConfig } = storybookInfo;
+    if (previewConfig) {
+      let config = await readConfig(previewConfig), usesGlobals = !!(config.getFieldNode(["globals"]) || config.getFieldNode(["globalTypes"]));
+      metadata.preview = { ...metadata.preview, usesGlobals };
+    }
+  } catch {
+  }
+  let portableStoriesFileCount = await getPortableStoriesFileCount(), applicationFileCount = await getApplicationFileCount(dirname2(packageJsonPath));
+  return {
+    ...metadata,
+    ...frameworkInfo,
+    portableStoriesFileCount,
+    applicationFileCount,
+    storybookVersion: version,
+    storybookVersionSpecifier: storybookInfo.versionSpecifier ?? "",
+    language,
+    storybookPackages,
+    addons,
+    hasStorybookEslint,
+    packageJsonType: packageJson.type ?? "unknown"
+  };
+};
+async function getPackageJsonDetails() {
+  let packageJsonPath = up();
+  return packageJsonPath ? {
+    packageJsonPath,
+    packageJson: JSON.parse(await readFile(packageJsonPath, "utf8"))
+  } : {
+    packageJsonPath: process.cwd(),
+    packageJson: {}
+  };
+}
+var metadataCache = /* @__PURE__ */ new Map();
+async function hashMainConfig(configDir) {
+  try {
+    let mainPath = getInterpretedFile(resolve(configDir, "main"));
+    if (!mainPath || !existsSync3(mainPath))
+      return "missing";
+    let content = await readFile(mainPath);
+    return createHash("sha256").update(new Uint8Array(content)).digest("hex");
+  } catch {
+    return "unknown";
+  }
+}
+function resolveDefaultConfigDir(packageJson) {
+  let fromScript = getStorybookConfiguration(
+    String(packageJson?.scripts?.storybook || ""),
+    "-c",
+    "--config-dir"
+  );
+  return fromScript || (existsSync3(resolve(RN_STORYBOOK_DIR)) ? RN_STORYBOOK_DIR : ".forkbook");
+}
+var getStorybookMetadata = async (_configDir) => {
+  let { packageJson, packageJsonPath } = await getPackageJsonDetails(), configDir = _configDir || resolveDefaultConfigDir(packageJson), contentHash = await hashMainConfig(configDir), cacheKey = `${configDir}::${contentHash}`, cached = metadataCache.get(cacheKey);
+  if (cached)
+    return cached;
+  let mainConfig = await loadMainConfig({ configDir }).catch(() => {
+  }), computed = await computeStorybookMetadata({
+    mainConfig,
+    packageJson,
+    packageJsonPath,
+    configDir
+  });
+  return metadataCache.set(cacheKey, computed), computed;
+};
+
+// src/telemetry/telemetry.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import * as os2 from "node:os";
+import { join as join4 } from "node:path";
+import { isCI as isCI2 } from "@aussieljk/forkbook/internal/common";
+
+// src/telemetry/anonymous-id.ts
+import { relative } from "node:path";
+import { executeCommandSync, getProjectRoot as getProjectRoot2 } from "@aussieljk/forkbook/internal/common";
+
+// src/telemetry/one-way-hash.ts
+import { createHash as createHash2 } from "crypto";
+var oneWayHash = (payload) => {
+  let hash = createHash2("sha256");
+  return hash.update("storybook-telemetry-salt"), hash.update(payload), hash.digest("hex");
+};
+
+// src/telemetry/anonymous-id.ts
+function normalizeGitUrl(rawUrl) {
+  let urlWithoutScheme = rawUrl.trim().replace(/#.*$/, "").replace(/^.*@/, "").replace(/^.*\/\//, "");
+  return (urlWithoutScheme.endsWith(".git") ? urlWithoutScheme : `${urlWithoutScheme}.git`).replace(":", "/");
+}
+function unhashedProjectId(remoteUrl, projectRootPath) {
+  return `${normalizeGitUrl(remoteUrl)}${slash(projectRootPath)}`;
+}
+var anonymousProjectId, getProjectSinceResult, getAnonymousProjectId = () => {
+  if (anonymousProjectId)
+    return anonymousProjectId;
+  try {
+    let projectRootPath = relative(getProjectRoot2(), process.cwd()), result = executeCommandSync({
+      command: "git",
+      args: ["config", "--get", "remote.origin.url"],
+      timeout: 1e3
+    });
+    anonymousProjectId = oneWayHash(unhashedProjectId(result, projectRootPath));
+  } catch {
+  }
+  return anonymousProjectId;
+}, getProjectSince = () => {
+  try {
+    if (getProjectSinceResult)
+      return getProjectSinceResult;
+    let dateBuffer = executeCommandSync({
+      command: "git",
+      args: ["log", "--reverse", "--format=%cd", "--date=iso"],
+      timeout: 1e3
+    }), firstLine = String(dateBuffer).trim().split(`
+`)[0], date = new Date(firstLine);
+    return Number.isNaN(date.getTime()) ? void 0 : (getProjectSinceResult = date, date);
+  } catch {
+  }
+};
+
+// src/telemetry/event-cache.ts
+import { cache as cache3 } from "@aussieljk/forkbook/internal/common";
+var processingPromise = Promise.resolve(), setHelper = async (eventType, body) => {
+  let lastEvents = await cache3.get("lastEvents") || {};
+  lastEvents[eventType] = { body, timestamp: Date.now() }, await cache3.set("lastEvents", lastEvents);
+}, set = (eventType, body) => {
+  let run = processingPromise.then(async () => {
+    await setHelper(eventType, body);
+  });
+  return processingPromise = run.catch(() => {
+  }), run;
+};
+var getLastEvents = async () => (await processingPromise, await cache3.get("lastEvents") || {}), upgradeFields = (event) => {
+  let { body, timestamp } = event;
+  return {
+    timestamp,
+    eventType: body?.eventType,
+    eventId: body?.eventId,
+    sessionId: body?.sessionId
+  };
+}, UPGRADE_EVENTS = ["init"], RUN_EVENTS = ["build", "dev", "error"], lastEvent = (lastEvents, eventTypes) => {
+  let descendingEvents = eventTypes.map((eventType) => lastEvents?.[eventType]).filter((event) => !!event).sort((a, b) => b.timestamp - a.timestamp);
+  return descendingEvents.length > 0 ? descendingEvents[0] : void 0;
+}, getPrecedingUpgrade = async (events = void 0) => {
+  let lastEvents = events || await cache3.get("lastEvents") || {}, lastUpgradeEvent = lastEvent(lastEvents, UPGRADE_EVENTS), lastRunEvent = lastEvent(lastEvents, RUN_EVENTS);
+  if (lastUpgradeEvent)
+    return !lastRunEvent?.timestamp || lastUpgradeEvent.timestamp > lastRunEvent.timestamp ? upgradeFields(lastUpgradeEvent) : void 0;
+};
+async function isWithinInitialSession(events) {
+  try {
+    let eventTypes = Array.isArray(events) ? events : [events], lastEvents = await getLastEvents(), lastRelevantEvent = lastEvent(lastEvents, eventTypes);
+    if (!lastRelevantEvent)
+      return !1;
+    let { getSessionId: getSessionId2 } = await import("./session-id-OO2WQF5N.js"), sessionId = await getSessionId2();
+    return !(lastRelevantEvent.body?.sessionId && lastRelevantEvent.body.sessionId !== sessionId);
+  } catch {
+    return !1;
+  }
+}
+
+// src/telemetry/telemetry.ts
+var tasks = [], addToGlobalContext = (key, value) => {
+  globalContext[key] = value;
+}, getOperatingSystem = () => {
+  try {
+    let platform2 = os2.platform();
+    return platform2 === "win32" ? "Windows" : platform2 === "darwin" ? "macOS" : platform2 === "linux" ? "Linux" : `Other: ${platform2}`;
+  } catch {
+    return "Unknown";
+  }
+}, inCI = isCI2(), agentDetection = detectAgent(), globalContext = {
+  inCI,
+  isTTY: process.stdout.isTTY,
+  agent: agentDetection,
+  platform: getOperatingSystem(),
+  nodeVersion: process.versions.node,
+  storybookVersion: getVersionNumber()
+}, prepareRequest = async (data, context) => {
+  let { eventType, payload, metadata, ...rest } = data, sessionId = await getSessionId(), eventId = nanoid();
+  return emitOtelEvent(eventType, { ...rest, eventId, sessionId, metadata, payload, context });
+};
+function getVersionNumber() {
+  try {
+    return JSON.parse(
+      readFileSync3(join4(resolvePackageDir("@aussieljk/forkbook"), "package.json"), "utf8")
+    ).version;
+  } catch {
+    return version;
+  }
+}
+async function sendTelemetry(data, options = { retryDelay: 1e3, immediate: !1 }) {
+  let { eventType, payload, metadata, ...rest } = data, context = options.stripMetadata ? globalContext : {
+    ...globalContext,
+    anonymousId: getAnonymousProjectId(),
+    projectSince: getProjectSince()?.getTime()
+  }, request;
+  try {
+    request = prepareRequest(data, context), tasks.push(request);
+    let sessionId = await getSessionId(), eventId = nanoid(), body = { ...rest, eventType, eventId, sessionId, metadata, payload, context }, waitFor = options.immediate ? tasks : [request];
+    await Promise.all([...waitFor, set(eventType, body)]);
+  } catch {
+  } finally {
+    tasks = tasks.filter((task) => task !== request);
+  }
+}
+
+// src/telemetry/error-collector.ts
+var ErrorCollector = class _ErrorCollector {
+  constructor() {
+    this.errors = [];
+  }
+  static getInstance() {
+    return _ErrorCollector.instance || (_ErrorCollector.instance = new _ErrorCollector()), _ErrorCollector.instance;
+  }
+  static addError(error) {
+    this.getInstance().errors.push(error);
+  }
+  static getErrors() {
+    return this.getInstance().errors;
+  }
+};
+
+// src/telemetry/ai-setup-utils.ts
+function isStoryCreatedByAISetup(entry) {
+  return entry.type === "story" && (entry.tags?.includes("ai-generated") ?? !1);
+}
+
+// src/telemetry/index.ts
+var isExampleStoryId = (storyId) => storyId.startsWith("example-button--") || storyId.startsWith("example-header--") || storyId.startsWith("example-page--");
+"SB_TELEMETRY_STATE" in globalThis || (globalThis.SB_TELEMETRY_STATE = void 0);
+"SB_TELEMETRY_QUEUE" in globalThis || (globalThis.SB_TELEMETRY_QUEUE = []);
+var isPayloadFactory = (payload) => typeof payload == "function", resolvePayload = async (payload) => isPayloadFactory(payload) ? await payload() : payload;
+async function setTelemetryEnabled(enabled) {
+  let previousState = globalThis.SB_TELEMETRY_STATE;
+  if (globalThis.SB_TELEMETRY_STATE = enabled ? "enabled" : "disabled", enabled && previousState === void 0) {
+    let pending = globalThis.SB_TELEMETRY_QUEUE;
+    globalThis.SB_TELEMETRY_QUEUE = [];
+    for (let event of pending)
+      try {
+        await _processAndSend(event.eventType, event.payload, {
+          ...event.options,
+          timestamp: event.timestamp
+        });
+      } catch (error) {
+        logger3.warn("Failed to flush queued telemetry event"), logger3.debug(error);
+      }
+  } else
+    globalThis.SB_TELEMETRY_QUEUE = [];
+}
+function isTelemetryModuleEnabled() {
+  return globalThis.SB_TELEMETRY_STATE === "enabled";
+}
+function isTelemetryStateResolved() {
+  return globalThis.SB_TELEMETRY_STATE !== void 0;
+}
+"PAYLOAD_ERROR_HANDLER" in globalThis || (globalThis.PAYLOAD_ERROR_HANDLER = void 0);
+function onPayloadError(handler) {
+  globalThis.PAYLOAD_ERROR_HANDLER = handler;
+}
+async function _processAndSend(eventType, payloadInput, options = {}) {
+  let payload;
+  try {
+    payload = await resolvePayload(payloadInput);
+  } catch (err) {
+    if (eventType !== "error" && globalThis.PAYLOAD_ERROR_HANDLER) {
+      let error = err instanceof Error ? err : new Error(String(err));
+      await globalThis.PAYLOAD_ERROR_HANDLER(error, eventType);
+    }
+    return;
+  }
+  if (payload.error && eventType !== "error" && globalThis.PAYLOAD_ERROR_HANDLER) {
+    let error = payload.error instanceof Error ? payload.error : new Error(String(payload.error));
+    await globalThis.PAYLOAD_ERROR_HANDLER(error, eventType);
+    return;
+  }
+  eventType !== "boot" && options.notify !== !1 && await notify();
+  let telemetryData = {
+    eventType,
+    payload
+  };
+  try {
+    options?.stripMetadata || (telemetryData.metadata = await getStorybookMetadata(options?.configDir));
+  } catch (error) {
+    payload.metadataErrorMessage = sanitizeError(error).message, options?.enableCrashReports && (payload.metadataError = sanitizeError(error));
+  } finally {
+    let { error } = payload;
+    error && (payload.error = sanitizeError(error)), (!payload.error || options?.enableCrashReports) && (process.env?.FORKBOOK_TELEMETRY_DEBUG && (logger3.info("[telemetry]"), logger3.info(JSON.stringify(telemetryData, null, 2))), await sendTelemetry(telemetryData, options));
+  }
+}
+var telemetry = async (eventType, payload = {}, options = {}) => {
+  if (!(globalThis.SB_TELEMETRY_STATE === "disabled" && !options.force)) {
+    if (globalThis.SB_TELEMETRY_STATE === void 0 && !options.force) {
+      globalThis.SB_TELEMETRY_QUEUE.push({ eventType, payload, options, timestamp: Date.now() });
+      return;
+    }
+    await _processAndSend(eventType, payload, options);
+  }
+};
+
+export {
+  withSpan,
+  removeAnsiEscapeCodes,
+  cleanPaths,
+  sanitizeError,
+  metaFrameworks,
+  sanitizeAddonName,
+  computeStorybookMetadata,
+  getStorybookMetadata,
+  oneWayHash,
+  getLastEvents,
+  getPrecedingUpgrade,
+  isWithinInitialSession,
+  addToGlobalContext,
+  ErrorCollector,
+  isStoryCreatedByAISetup,
+  isExampleStoryId,
+  setTelemetryEnabled,
+  isTelemetryModuleEnabled,
+  isTelemetryStateResolved,
+  onPayloadError,
+  telemetry
+};