@aussieljk/forkbook 0.0.0-stage → 0.0.1-1

package/dist/core-server/index.js

@@ -0,0 +1,4165 @@
+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 {
+  fromMarkdown,
+  mdxFromMarkdown,
+  mdxjs
+} from "../_node-chunks/chunk-CXLL2F6O.js";
+import {
+  require_dist
+} from "../_node-chunks/chunk-HKQEE62W.js";
+import {
+  BananaSlug
+} from "../_node-chunks/chunk-JBCKN6P4.js";
+import {
+  debounce
+} from "../_node-chunks/chunk-IJL5JOLL.js";
+import {
+  require_lib
+} from "../_node-chunks/chunk-BE6ULVPN.js";
+import {
+  Parser,
+  init_acorn,
+  require_acorn_jsx
+} from "../_node-chunks/chunk-DWE36J35.js";
+import {
+  isTelemetryModuleEnabled,
+  telemetry,
+  withSpan
+} from "../_node-chunks/chunk-5WHA37KG.js";
+import "../_node-chunks/chunk-XCGMRAV5.js";
+import {
+  getEffectiveToolAvailability,
+  getManifestStatus,
+  getToolAvailability,
+  isAddonA11yEnabled,
+  isAddonVitestEnabled,
+  isClaudePreviewLaunch,
+  isModuleGraphSupported,
+  resolveSkillInputs
+} from "../_node-chunks/chunk-2JSABFAM.js";
+import {
+  CLAUDE_PREVIEW_AGENT_NAME
+} from "../_node-chunks/chunk-WQ7PSP6H.js";
+import "../_node-chunks/chunk-5J3O7EDY.js";
+import "../_node-chunks/chunk-SVZ6Q3CS.js";
+import "../_node-chunks/chunk-DUOXRUVQ.js";
+import {
+  detectAgent
+} from "../_node-chunks/chunk-M2BRIUUP.js";
+import "../_node-chunks/chunk-NIHZECYO.js";
+import "../_node-chunks/chunk-ASJFOW6O.js";
+import {
+  userOrAutoTitleFromSpecifier
+} from "../_node-chunks/chunk-I2ANCID7.js";
+import "../_node-chunks/chunk-JEC2OK5B.js";
+import "../_node-chunks/chunk-7BVUZZIY.js";
+import "../_node-chunks/chunk-5RNOGGO6.js";
+import {
+  resolveImport,
+  supportedExtensions
+} from "../_node-chunks/chunk-5GN5N22E.js";
+import "../_node-chunks/chunk-XURIZ7IC.js";
+import "../_node-chunks/chunk-RJXEPYEN.js";
+import {
+  require_src
+} from "../_node-chunks/chunk-GP5YLBNS.js";
+import "../_node-chunks/chunk-GT5EHMNM.js";
+import "../_node-chunks/chunk-Y2GH4XO7.js";
+import "../_node-chunks/chunk-Y2DEKWVE.js";
+import "../_node-chunks/chunk-5J3BMBMY.js";
+import "../_node-chunks/chunk-AWXGCPW6.js";
+import {
+  logger,
+  require_pretty_hrtime
+} from "../_node-chunks/chunk-TB6Y6NSL.js";
+import {
+  ChangeDetectionFailureError,
+  ChangeDetectionUnavailableError,
+  GitDiffProvider,
+  MDX_SERVICE_ID,
+  analyzeTestResults,
+  applyServicesPresetOnce,
+  createDocsToolset,
+  createLocalDocsAccess,
+  createManifestDocsAccess,
+  createServiceDocsAccess,
+  createStoriesToolset,
+  defineService,
+  emptyManifests,
+  findStoryIds,
+  fullStatusStore,
+  fullTestProviderStore,
+  getBuilders,
+  getChangeDetectionReadiness,
+  getComponentCandidates,
+  getErrorLevel,
+  getManagerBuilder,
+  getPreviewBuilder,
+  getRefsFromConfig,
+  getStatusStoreByTypeId,
+  getStoryIdsByAbsolutePath,
+  getTestProviderStoreById,
+  getWsToken,
+  loadManifests,
+  mapStaticDir,
+  mdxManifestRef,
+  mdxQueryStaticPath,
+  mdxStaticStorePath,
+  registerManifests,
+  resetChangeDetectionReadiness,
+  resetServicesPresetOnce,
+  resolveChangeDetectionAdapter,
+  reviewToolset,
+  runStoryTests,
+  sendTelemetryError,
+  setChangeDetectionHost,
+  setChangeDetectionReadiness,
+  storyInputArraySchema,
+  toStoryTestResult,
+  universalStatusStore,
+  universalTestProviderStore,
+  useStatics,
+  withTelemetry,
+  writeManifests
+} from "../_node-chunks/chunk-IZISFDKM.js";
+import {
+  UniversalStore
+} from "../_node-chunks/chunk-B6SKX4JF.js";
+import {
+  init_build,
+  parse
+} from "../_node-chunks/chunk-6APBQVEX.js";
+import "../_node-chunks/chunk-ICADUNQM.js";
+import "../_node-chunks/chunk-PBMWZVLD.js";
+import {
+  registerToolset
+} from "../_node-chunks/chunk-MDKFZRYG.js";
+import "../_node-chunks/chunk-QMU5ODXZ.js";
+import "../_node-chunks/chunk-XJSYJTBD.js";
+import "../_node-chunks/chunk-X6OWHTYE.js";
+import {
+  STORY_FILE_TEST_REGEXP,
+  getStoryImportPathFromEntry,
+  require_cross_spawn
+} from "../_node-chunks/chunk-ZBAIFZNB.js";
+import "../_node-chunks/chunk-FUYZNTIS.js";
+import "../_node-chunks/chunk-356LV3NX.js";
+import {
+  getService,
+  registerService,
+  writeOpenServiceStaticFiles
+} from "../_node-chunks/chunk-ULW4SLMN.js";
+import {
+  Channel,
+  describeService,
+  getRegisteredServices,
+  listServices
+} from "../_node-chunks/chunk-YWMICX2T.js";
+import "../_node-chunks/chunk-G6PUNHCI.js";
+import "../_node-chunks/chunk-SRXCCL2O.js";
+import "../_node-chunks/chunk-XTTAS346.js";
+import "../_node-chunks/chunk-ZMEGPR47.js";
+import "../_node-chunks/chunk-2UG3IYCC.js";
+import {
+  Tag
+} from "../_node-chunks/chunk-KGOAOPKR.js";
+import "../_node-chunks/chunk-2XDUXZGI.js";
+import "../_node-chunks/chunk-CWD5A6NI.js";
+import {
+  up2 as up
+} from "../_node-chunks/chunk-NZ3GOT7V.js";
+import {
+  invariant
+} from "../_node-chunks/chunk-7TSL7D5D.js";
+import {
+  resolvePackageDir,
+  safeResolveModule
+} from "../_node-chunks/chunk-ILVD64RB.js";
+import "../_node-chunks/chunk-QVMUIU7S.js";
+import {
+  StorybookError
+} from "../_node-chunks/chunk-CYPPELO4.js";
+import {
+  require_picocolors
+} from "../_node-chunks/chunk-4PK3LUHM.js";
+import {
+  storyIndexPathToAbsolutePath
+} from "../_node-chunks/chunk-EWXASIWR.js";
+import "../_node-chunks/chunk-2BJIHWOK.js";
+import {
+  slash
+} from "../_node-chunks/chunk-RJUHZH32.js";
+import "../_node-chunks/chunk-VQEQ7ZLS.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "../_node-chunks/chunk-NKAUZU4C.js";
+
+// ../../node_modules/@discoveryjs/json-ext/package.json
+var require_package = __commonJS({
+  "../../node_modules/@discoveryjs/json-ext/package.json"(exports, module) {
+    module.exports = {
+      name: "@discoveryjs/json-ext",
+      version: "0.5.7",
+      description: "A set of utilities that extend the use of JSON",
+      keywords: [
+        "json",
+        "utils",
+        "stream",
+        "async",
+        "promise",
+        "stringify",
+        "info"
+      ],
+      author: "Roman Dvornov <rdvornov@gmail.com> (https://github.com/lahmatiy)",
+      license: "MIT",
+      repository: "discoveryjs/json-ext",
+      main: "./src/index",
+      browser: {
+        "./src/stringify-stream.js": "./src/stringify-stream-browser.js",
+        "./src/text-decoder.js": "./src/text-decoder-browser.js",
+        "./src/version.js": "./dist/version.js"
+      },
+      types: "./index.d.ts",
+      scripts: {
+        test: "mocha --reporter progress",
+        lint: "eslint src test",
+        "lint-and-test": "npm run lint && npm test",
+        build: "rollup --config",
+        "test:all": "npm run test:src && npm run test:dist",
+        "test:src": "npm test",
+        "test:dist": "cross-env MODE=dist npm test && cross-env MODE=dist-min npm test",
+        "build-and-test": "npm run build && npm run test:dist",
+        coverage: "c8 --reporter=lcovonly npm test",
+        prepublishOnly: "npm run lint && npm test && npm run build-and-test"
+      },
+      devDependencies: {
+        "@rollup/plugin-commonjs": "^15.1.0",
+        "@rollup/plugin-json": "^4.1.0",
+        "@rollup/plugin-node-resolve": "^9.0.0",
+        c8: "^7.10.0",
+        chalk: "^4.1.0",
+        "cross-env": "^7.0.3",
+        eslint: "^8.10.0",
+        mocha: "^8.4.0",
+        rollup: "^2.28.2",
+        "rollup-plugin-terser": "^7.0.2"
+      },
+      engines: {
+        node: ">=10.0.0"
+      },
+      files: [
+        "dist",
+        "src",
+        "index.d.ts"
+      ]
+    };
+  }
+});
+
+// ../../node_modules/@discoveryjs/json-ext/src/version.js
+var require_version = __commonJS({
+  "../../node_modules/@discoveryjs/json-ext/src/version.js"(exports, module) {
+    module.exports = require_package().version;
+  }
+});
+
+// ../../node_modules/@discoveryjs/json-ext/src/utils.js
+var require_utils = __commonJS({
+  "../../node_modules/@discoveryjs/json-ext/src/utils.js"(exports, module) {
+    var escapableCharCodeSubstitution = {
+      // JSON Single Character Escape Sequences
+      8: "\\b",
+      9: "\\t",
+      10: "\\n",
+      12: "\\f",
+      13: "\\r",
+      34: '\\"',
+      92: "\\\\"
+    };
+    function isLeadingSurrogate(code) {
+      return code >= 55296 && code <= 56319;
+    }
+    function isTrailingSurrogate(code) {
+      return code >= 56320 && code <= 57343;
+    }
+    function isReadableStream(value) {
+      return typeof value.pipe == "function" && typeof value._read == "function" && typeof value._readableState == "object" && value._readableState !== null;
+    }
+    function replaceValue(holder, key, value, replacer) {
+      switch (value && typeof value.toJSON == "function" && (value = value.toJSON()), replacer !== null && (value = replacer.call(holder, String(key), value)), typeof value) {
+        case "function":
+        case "symbol":
+          value = void 0;
+          break;
+        case "object":
+          if (value !== null) {
+            let cls = value.constructor;
+            (cls === String || cls === Number || cls === Boolean) && (value = value.valueOf());
+          }
+          break;
+      }
+      return value;
+    }
+    function getTypeNative(value) {
+      return value === null || typeof value != "object" ? 1 : Array.isArray(value) ? 3 : 2;
+    }
+    function getTypeAsync(value) {
+      return value === null || typeof value != "object" ? 1 : typeof value.then == "function" ? 4 : isReadableStream(value) ? value._readableState.objectMode ? 6 : 5 : Array.isArray(value) ? 3 : 2;
+    }
+    function normalizeReplacer(replacer) {
+      return typeof replacer == "function" ? replacer : Array.isArray(replacer) ? [...new Set(
+        replacer.map((item) => {
+          let cls = item && item.constructor;
+          return cls === String || cls === Number ? String(item) : null;
+        }).filter((item) => typeof item == "string")
+      )] : null;
+    }
+    function normalizeSpace(space) {
+      return typeof space == "number" ? !Number.isFinite(space) || space < 1 ? !1 : " ".repeat(Math.min(space, 10)) : typeof space == "string" && space.slice(0, 10) || !1;
+    }
+    module.exports = {
+      escapableCharCodeSubstitution,
+      isLeadingSurrogate,
+      isTrailingSurrogate,
+      type: {
+        PRIMITIVE: 1,
+        PROMISE: 4,
+        ARRAY: 3,
+        OBJECT: 2,
+        STRING_STREAM: 5,
+        OBJECT_STREAM: 6
+      },
+      isReadableStream,
+      replaceValue,
+      getTypeNative,
+      getTypeAsync,
+      normalizeReplacer,
+      normalizeSpace
+    };
+  }
+});
+
+// ../../node_modules/@discoveryjs/json-ext/src/stringify-info.js
+var require_stringify_info = __commonJS({
+  "../../node_modules/@discoveryjs/json-ext/src/stringify-info.js"(exports, module) {
+    var {
+      normalizeReplacer,
+      normalizeSpace,
+      replaceValue,
+      getTypeNative,
+      getTypeAsync,
+      isLeadingSurrogate,
+      isTrailingSurrogate,
+      escapableCharCodeSubstitution,
+      type: {
+        PRIMITIVE,
+        OBJECT,
+        ARRAY,
+        PROMISE,
+        STRING_STREAM,
+        OBJECT_STREAM
+      }
+    } = require_utils(), charLength2048 = Array.from({ length: 2048 }).map((_, code) => escapableCharCodeSubstitution.hasOwnProperty(code) ? 2 : code < 32 ? 6 : code < 128 ? 1 : 2);
+    function stringLength(str) {
+      let len = 0, prevLeadingSurrogate = !1;
+      for (let i = 0; i < str.length; i++) {
+        let code = str.charCodeAt(i);
+        if (code < 2048)
+          len += charLength2048[code];
+        else if (isLeadingSurrogate(code)) {
+          len += 6, prevLeadingSurrogate = !0;
+          continue;
+        } else isTrailingSurrogate(code) ? len = prevLeadingSurrogate ? len - 2 : len + 6 : len += 3;
+        prevLeadingSurrogate = !1;
+      }
+      return len + 2;
+    }
+    function primitiveLength(value) {
+      switch (typeof value) {
+        case "string":
+          return stringLength(value);
+        case "number":
+          return Number.isFinite(value) ? String(value).length : 4;
+        case "boolean":
+          return value ? 4 : 5;
+        case "undefined":
+        case "object":
+          return 4;
+        /* null */
+        default:
+          return 0;
+      }
+    }
+    function spaceLength(space) {
+      return space = normalizeSpace(space), typeof space == "string" ? space.length : 0;
+    }
+    module.exports = function(value, replacer, space, options) {
+      function walk(holder, key, value2) {
+        if (stop)
+          return;
+        value2 = replaceValue(holder, key, value2, replacer);
+        let type = getType(value2);
+        if (type !== PRIMITIVE && stack.has(value2)) {
+          circular.add(value2), length += 4, options.continueOnCircular || (stop = !0);
+          return;
+        }
+        switch (type) {
+          case PRIMITIVE:
+            value2 !== void 0 || Array.isArray(holder) ? length += primitiveLength(value2) : holder === root && (length += 9);
+            break;
+          case OBJECT: {
+            if (visited.has(value2)) {
+              duplicate.add(value2), length += visited.get(value2);
+              break;
+            }
+            let valueLength = length, entries = 0;
+            length += 2, stack.add(value2);
+            for (let key2 in value2)
+              if (hasOwnProperty.call(value2, key2) && (allowlist === null || allowlist.has(key2))) {
+                let prevLength = length;
+                walk(value2, key2, value2[key2]), prevLength !== length && (length += stringLength(key2) + 1, entries++);
+              }
+            entries > 1 && (length += entries - 1), stack.delete(value2), space > 0 && entries > 0 && (length += (1 + (stack.size + 1) * space + 1) * entries, length += 1 + stack.size * space), visited.set(value2, length - valueLength);
+            break;
+          }
+          case ARRAY: {
+            if (visited.has(value2)) {
+              duplicate.add(value2), length += visited.get(value2);
+              break;
+            }
+            let valueLength = length;
+            length += 2, stack.add(value2);
+            for (let i = 0; i < value2.length; i++)
+              walk(value2, i, value2[i]);
+            value2.length > 1 && (length += value2.length - 1), stack.delete(value2), space > 0 && value2.length > 0 && (length += (1 + (stack.size + 1) * space) * value2.length, length += 1 + stack.size * space), visited.set(value2, length - valueLength);
+            break;
+          }
+          case PROMISE:
+          case STRING_STREAM:
+            async.add(value2);
+            break;
+          case OBJECT_STREAM:
+            length += 2, async.add(value2);
+            break;
+        }
+      }
+      let allowlist = null;
+      replacer = normalizeReplacer(replacer), Array.isArray(replacer) && (allowlist = new Set(replacer), replacer = null), space = spaceLength(space), options = options || {};
+      let visited = /* @__PURE__ */ new Map(), stack = /* @__PURE__ */ new Set(), duplicate = /* @__PURE__ */ new Set(), circular = /* @__PURE__ */ new Set(), async = /* @__PURE__ */ new Set(), getType = options.async ? getTypeAsync : getTypeNative, root = { "": value }, stop = !1, length = 0;
+      return walk(root, "", value), {
+        minLength: isNaN(length) ? 1 / 0 : length,
+        circular: [...circular],
+        duplicate: [...duplicate],
+        async: [...async]
+      };
+    };
+  }
+});
+
+// ../../node_modules/@discoveryjs/json-ext/src/stringify-stream.js
+var require_stringify_stream = __commonJS({
+  "../../node_modules/@discoveryjs/json-ext/src/stringify-stream.js"(exports, module) {
+    var { Readable } = __require("stream"), {
+      normalizeReplacer,
+      normalizeSpace,
+      replaceValue,
+      getTypeAsync,
+      type: {
+        PRIMITIVE,
+        OBJECT,
+        ARRAY,
+        PROMISE,
+        STRING_STREAM,
+        OBJECT_STREAM
+      }
+    } = require_utils(), noop = () => {
+    }, hasOwnProperty2 = Object.prototype.hasOwnProperty, wellformedStringStringify = JSON.stringify("\uD800") === '"\\ud800"' ? JSON.stringify : (s) => JSON.stringify(s).replace(
+      new RegExp("\\p{Surrogate}", "gu"),
+      (m) => `\\u${m.charCodeAt(0).toString(16)}`
+    );
+    function push() {
+      this.push(this._stack.value), this.popStack();
+    }
+    function pushPrimitive(value) {
+      switch (typeof value) {
+        case "string":
+          this.push(this.encodeString(value));
+          break;
+        case "number":
+          this.push(Number.isFinite(value) ? this.encodeNumber(value) : "null");
+          break;
+        case "boolean":
+          this.push(value ? "true" : "false");
+          break;
+        case "undefined":
+        case "object":
+          this.push("null");
+          break;
+        default:
+          this.destroy(new TypeError(`Do not know how to serialize a ${value.constructor && value.constructor.name || typeof value}`));
+      }
+    }
+    function processObjectEntry(key) {
+      let current = this._stack;
+      current.first ? this.push(",") : current.first = !0, this.space ? this.push(`
+${this.space.repeat(this._depth)}${this.encodeString(key)}: `) : this.push(this.encodeString(key) + ":");
+    }
+    function processObject() {
+      let current = this._stack;
+      if (current.index === current.keys.length) {
+        this.space && current.first ? this.push(`
+${this.space.repeat(this._depth - 1)}}`) : this.push("}"), this.popStack();
+        return;
+      }
+      let key = current.keys[current.index];
+      this.processValue(current.value, key, current.value[key], processObjectEntry), current.index++;
+    }
+    function processArrayItem(index) {
+      index !== 0 && this.push(","), this.space && this.push(`
+${this.space.repeat(this._depth)}`);
+    }
+    function processArray() {
+      let current = this._stack;
+      if (current.index === current.value.length) {
+        this.space && current.index > 0 ? this.push(`
+${this.space.repeat(this._depth - 1)}]`) : this.push("]"), this.popStack();
+        return;
+      }
+      this.processValue(current.value, current.index, current.value[current.index], processArrayItem), current.index++;
+    }
+    function createStreamReader(fn) {
+      return function() {
+        let current = this._stack, data = current.value.read(this._readSize);
+        data !== null ? (current.first = !1, fn.call(this, data, current)) : current.first && !current.value._readableState.reading || current.ended ? this.popStack() : (current.first = !0, current.awaiting = !0);
+      };
+    }
+    var processReadableObject = createStreamReader(function(data, current) {
+      this.processValue(current.value, current.index, data, processArrayItem), current.index++;
+    }), processReadableString = createStreamReader(function(data) {
+      this.push(data);
+    }), JsonStringifyStream = class extends Readable {
+      constructor(value, replacer, space) {
+        if (super({
+          autoDestroy: !0
+        }), this.getKeys = Object.keys, this.replacer = normalizeReplacer(replacer), Array.isArray(this.replacer)) {
+          let allowlist = this.replacer;
+          this.getKeys = (value2) => allowlist.filter((key) => hasOwnProperty2.call(value2, key)), this.replacer = null;
+        }
+        this.space = normalizeSpace(space), this._depth = 0, this.error = null, this._processing = !1, this._ended = !1, this._readSize = 0, this._buffer = "", this._stack = null, this._visited = /* @__PURE__ */ new WeakSet(), this.pushStack({
+          handler: () => {
+            this.popStack(), this.processValue({ "": value }, "", value, noop);
+          }
+        });
+      }
+      encodeString(value) {
+        return /[^\x20-\uD799]|[\x22\x5c]/.test(value) ? wellformedStringStringify(value) : '"' + value + '"';
+      }
+      encodeNumber(value) {
+        return value;
+      }
+      processValue(holder, key, value, callback) {
+        value = replaceValue(holder, key, value, this.replacer);
+        let type = getTypeAsync(value);
+        switch (type) {
+          case PRIMITIVE:
+            (callback !== processObjectEntry || value !== void 0) && (callback.call(this, key), pushPrimitive.call(this, value));
+            break;
+          case OBJECT:
+            if (callback.call(this, key), this._visited.has(value))
+              return this.destroy(new TypeError("Converting circular structure to JSON"));
+            this._visited.add(value), this._depth++, this.push("{"), this.pushStack({
+              handler: processObject,
+              value,
+              index: 0,
+              first: !1,
+              keys: this.getKeys(value)
+            });
+            break;
+          case ARRAY:
+            if (callback.call(this, key), this._visited.has(value))
+              return this.destroy(new TypeError("Converting circular structure to JSON"));
+            this._visited.add(value), this.push("["), this.pushStack({
+              handler: processArray,
+              value,
+              index: 0
+            }), this._depth++;
+            break;
+          case PROMISE:
+            this.pushStack({
+              handler: noop,
+              awaiting: !0
+            }), Promise.resolve(value).then((resolved) => {
+              this.popStack(), this.processValue(holder, key, resolved, callback), this.processStack();
+            }).catch((error) => {
+              this.destroy(error);
+            });
+            break;
+          case STRING_STREAM:
+          case OBJECT_STREAM:
+            if (callback.call(this, key), value.readableEnded || value._readableState.endEmitted)
+              return this.destroy(new Error("Readable Stream has ended before it was serialized. All stream data have been lost"));
+            if (value.readableFlowing)
+              return this.destroy(new Error("Readable Stream is in flowing mode, data may have been lost. Trying to pause stream."));
+            type === OBJECT_STREAM && (this.push("["), this.pushStack({
+              handler: push,
+              value: this.space ? `
+` + this.space.repeat(this._depth) + "]" : "]"
+            }), this._depth++);
+            let self = this.pushStack({
+              handler: type === OBJECT_STREAM ? processReadableObject : processReadableString,
+              value,
+              index: 0,
+              first: !1,
+              ended: !1,
+              awaiting: !value.readable || value.readableLength === 0
+            }), continueProcessing = () => {
+              self.awaiting && (self.awaiting = !1, this.processStack());
+            };
+            value.once("error", (error) => this.destroy(error)), value.once("end", () => {
+              self.ended = !0, continueProcessing();
+            }), value.on("readable", continueProcessing);
+            break;
+        }
+      }
+      pushStack(node) {
+        return node.prev = this._stack, this._stack = node;
+      }
+      popStack() {
+        let { handler, value } = this._stack;
+        (handler === processObject || handler === processArray || handler === processReadableObject) && (this._visited.delete(value), this._depth--), this._stack = this._stack.prev;
+      }
+      processStack() {
+        if (!(this._processing || this._ended)) {
+          try {
+            for (this._processing = !0; this._stack !== null && !this._stack.awaiting; )
+              if (this._stack.handler.call(this), !this._processing)
+                return;
+            this._processing = !1;
+          } catch (error) {
+            this.destroy(error);
+            return;
+          }
+          this._stack === null && !this._ended && (this._finish(), this.push(null));
+        }
+      }
+      push(data) {
+        if (data !== null) {
+          if (this._buffer += data, this._buffer.length < this._readSize)
+            return;
+          data = this._buffer, this._buffer = "", this._processing = !1;
+        }
+        super.push(data);
+      }
+      _read(size) {
+        this._readSize = size || this.readableHighWaterMark, this.processStack();
+      }
+      _finish() {
+        this._ended = !0, this._processing = !1, this._stack = null, this._visited = null, this._buffer && this._buffer.length && super.push(this._buffer), this._buffer = "";
+      }
+      _destroy(error, cb) {
+        this.error = this.error || error, this._finish(), cb(error);
+      }
+    };
+    module.exports = function(value, replacer, space) {
+      return new JsonStringifyStream(value, replacer, space);
+    };
+  }
+});
+
+// ../../node_modules/@discoveryjs/json-ext/src/text-decoder.js
+var require_text_decoder = __commonJS({
+  "../../node_modules/@discoveryjs/json-ext/src/text-decoder.js"(exports, module) {
+    module.exports = __require("util").TextDecoder;
+  }
+});
+
+// ../../node_modules/@discoveryjs/json-ext/src/parse-chunked.js
+var require_parse_chunked = __commonJS({
+  "../../node_modules/@discoveryjs/json-ext/src/parse-chunked.js"(exports, module) {
+    var { isReadableStream } = require_utils(), TextDecoder = require_text_decoder(), STACK_OBJECT = 1, STACK_ARRAY = 2, decoder = new TextDecoder();
+    function isObject(value) {
+      return value !== null && typeof value == "object";
+    }
+    function adjustPosition(error, parser) {
+      return error.name === "SyntaxError" && parser.jsonParseOffset && (error.message = error.message.replace(
+        /at position (\d+)/,
+        (_, pos) => "at position " + (Number(pos) + parser.jsonParseOffset)
+      )), error;
+    }
+    function append(array, elements) {
+      let initialLength = array.length;
+      array.length += elements.length;
+      for (let i = 0; i < elements.length; i++)
+        array[initialLength + i] = elements[i];
+    }
+    module.exports = function(chunkEmitter) {
+      let parser = new ChunkParser();
+      if (isObject(chunkEmitter) && isReadableStream(chunkEmitter))
+        return new Promise((resolve9, reject) => {
+          chunkEmitter.on("data", (chunk) => {
+            try {
+              parser.push(chunk);
+            } catch (e) {
+              reject(adjustPosition(e, parser)), parser = null;
+            }
+          }).on("error", (e) => {
+            parser = null, reject(e);
+          }).on("end", () => {
+            try {
+              resolve9(parser.finish());
+            } catch (e) {
+              reject(adjustPosition(e, parser));
+            } finally {
+              parser = null;
+            }
+          });
+        });
+      if (typeof chunkEmitter == "function") {
+        let iterator = chunkEmitter();
+        if (isObject(iterator) && (Symbol.iterator in iterator || Symbol.asyncIterator in iterator))
+          return new Promise(async (resolve9, reject) => {
+            try {
+              for await (let chunk of iterator)
+                parser.push(chunk);
+              resolve9(parser.finish());
+            } catch (e) {
+              reject(adjustPosition(e, parser));
+            } finally {
+              parser = null;
+            }
+          });
+      }
+      throw new Error(
+        "Chunk emitter should be readable stream, generator, async generator or function returning an iterable object"
+      );
+    };
+    var ChunkParser = class {
+      constructor() {
+        this.value = void 0, this.valueStack = null, this.stack = new Array(100), this.lastFlushDepth = 0, this.flushDepth = 0, this.stateString = !1, this.stateStringEscape = !1, this.pendingByteSeq = null, this.pendingChunk = null, this.chunkOffset = 0, this.jsonParseOffset = 0;
+      }
+      parseAndAppend(fragment, wrap) {
+        this.stack[this.lastFlushDepth - 1] === STACK_OBJECT ? (wrap && (this.jsonParseOffset--, fragment = "{" + fragment + "}"), Object.assign(this.valueStack.value, JSON.parse(fragment))) : (wrap && (this.jsonParseOffset--, fragment = "[" + fragment + "]"), append(this.valueStack.value, JSON.parse(fragment)));
+      }
+      prepareAddition(fragment) {
+        let { value } = this.valueStack;
+        if (Array.isArray(value) ? value.length !== 0 : Object.keys(value).length !== 0) {
+          if (fragment[0] === ",")
+            return this.jsonParseOffset++, fragment.slice(1);
+          if (fragment[0] !== "}" && fragment[0] !== "]")
+            return this.jsonParseOffset -= 3, "[[]" + fragment;
+        }
+        return fragment;
+      }
+      flush(chunk, start, end) {
+        let fragment = chunk.slice(start, end);
+        if (this.jsonParseOffset = this.chunkOffset + start, this.pendingChunk !== null && (fragment = this.pendingChunk + fragment, this.jsonParseOffset -= this.pendingChunk.length, this.pendingChunk = null), this.flushDepth === this.lastFlushDepth)
+          this.flushDepth > 0 ? this.parseAndAppend(this.prepareAddition(fragment), !0) : (this.value = JSON.parse(fragment), this.valueStack = {
+            value: this.value,
+            prev: null
+          });
+        else if (this.flushDepth > this.lastFlushDepth) {
+          for (let i = this.flushDepth - 1; i >= this.lastFlushDepth; i--)
+            fragment += this.stack[i] === STACK_OBJECT ? "}" : "]";
+          this.lastFlushDepth === 0 ? (this.value = JSON.parse(fragment), this.valueStack = {
+            value: this.value,
+            prev: null
+          }) : this.parseAndAppend(this.prepareAddition(fragment), !0);
+          for (let i = this.lastFlushDepth || 1; i < this.flushDepth; i++) {
+            let value = this.valueStack.value;
+            if (this.stack[i - 1] === STACK_OBJECT) {
+              let key;
+              for (key in value) ;
+              value = value[key];
+            } else
+              value = value[value.length - 1];
+            this.valueStack = {
+              value,
+              prev: this.valueStack
+            };
+          }
+        } else {
+          fragment = this.prepareAddition(fragment);
+          for (let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--)
+            this.jsonParseOffset--, fragment = (this.stack[i] === STACK_OBJECT ? "{" : "[") + fragment;
+          this.parseAndAppend(fragment, !1);
+          for (let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--)
+            this.valueStack = this.valueStack.prev;
+        }
+        this.lastFlushDepth = this.flushDepth;
+      }
+      push(chunk) {
+        if (typeof chunk != "string") {
+          if (this.pendingByteSeq !== null) {
+            let origRawChunk = chunk;
+            chunk = new Uint8Array(this.pendingByteSeq.length + origRawChunk.length), chunk.set(this.pendingByteSeq), chunk.set(origRawChunk, this.pendingByteSeq.length), this.pendingByteSeq = null;
+          }
+          if (chunk[chunk.length - 1] > 127)
+            for (let seqLength = 0; seqLength < chunk.length; seqLength++) {
+              let byte = chunk[chunk.length - 1 - seqLength];
+              if (byte >> 6 === 3) {
+                seqLength++, (seqLength !== 4 && byte >> 3 === 30 || seqLength !== 3 && byte >> 4 === 14 || seqLength !== 2 && byte >> 5 === 6) && (this.pendingByteSeq = chunk.slice(chunk.length - seqLength), chunk = chunk.slice(0, -seqLength));
+                break;
+              }
+            }
+          chunk = decoder.decode(chunk);
+        }
+        let chunkLength = chunk.length, lastFlushPoint = 0, flushPoint = 0;
+        scan: for (let i = 0; i < chunkLength; i++) {
+          if (this.stateString) {
+            for (; i < chunkLength; i++)
+              if (this.stateStringEscape)
+                this.stateStringEscape = !1;
+              else
+                switch (chunk.charCodeAt(i)) {
+                  case 34:
+                    this.stateString = !1;
+                    continue scan;
+                  case 92:
+                    this.stateStringEscape = !0;
+                }
+            break;
+          }
+          switch (chunk.charCodeAt(i)) {
+            case 34:
+              this.stateString = !0, this.stateStringEscape = !1;
+              break;
+            case 44:
+              flushPoint = i;
+              break;
+            case 123:
+              flushPoint = i + 1, this.stack[this.flushDepth++] = STACK_OBJECT;
+              break;
+            case 91:
+              flushPoint = i + 1, this.stack[this.flushDepth++] = STACK_ARRAY;
+              break;
+            case 93:
+            /* ] */
+            case 125:
+              flushPoint = i + 1, this.flushDepth--, this.flushDepth < this.lastFlushDepth && (this.flush(chunk, lastFlushPoint, flushPoint), lastFlushPoint = flushPoint);
+              break;
+            case 9:
+            /* \t */
+            case 10:
+            /* \n */
+            case 13:
+            /* \r */
+            case 32:
+              lastFlushPoint === i && lastFlushPoint++, flushPoint === i && flushPoint++;
+              break;
+          }
+        }
+        flushPoint > lastFlushPoint && this.flush(chunk, lastFlushPoint, flushPoint), flushPoint < chunkLength && (this.pendingChunk !== null ? this.pendingChunk += chunk : this.pendingChunk = chunk.slice(flushPoint, chunkLength)), this.chunkOffset += chunkLength;
+      }
+      finish() {
+        return this.pendingChunk !== null && (this.flush("", 0, 0), this.pendingChunk = null), this.value;
+      }
+    };
+  }
+});
+
+// ../../node_modules/@discoveryjs/json-ext/src/index.js
+var require_src2 = __commonJS({
+  "../../node_modules/@discoveryjs/json-ext/src/index.js"(exports, module) {
+    module.exports = {
+      version: require_version(),
+      stringifyInfo: require_stringify_info(),
+      stringifyStream: require_stringify_stream(),
+      parseChunked: require_parse_chunked()
+    };
+  }
+});
+
+// ../../node_modules/address/lib/address.js
+var require_address = __commonJS({
+  "../../node_modules/address/lib/address.js"(exports, module) {
+    "use strict";
+    var os3 = __require("os"), fs = __require("fs"), child = __require("child_process"), DEFAULT_RESOLV_FILE = "/etc/resolv.conf";
+    function getInterfaceName() {
+      var val = "eth", platform = os3.platform();
+      return platform === "darwin" ? val = "en" : platform === "win32" && (val = null), val;
+    }
+    function getIfconfigCMD() {
+      return os3.platform() === "win32" ? "ipconfig/all" : "/sbin/ifconfig";
+    }
+    function matchName(actualFamily, expectedFamily) {
+      return expectedFamily === "IPv4" ? actualFamily === "IPv4" || actualFamily === 4 : expectedFamily === "IPv6" ? actualFamily === "IPv6" || actualFamily === 6 : actualFamily === expectedFamily;
+    }
+    function address(interfaceName, callback) {
+      typeof interfaceName == "function" && (callback = interfaceName, interfaceName = null);
+      var addr = {
+        ip: address.ip(interfaceName),
+        ipv6: address.ipv6(interfaceName),
+        mac: null
+      };
+      address.mac(interfaceName, function(err, mac) {
+        mac && (addr.mac = mac), callback(err, addr);
+      });
+    }
+    address.interface = function(family, name) {
+      var interfaces = os3.networkInterfaces(), noName = !name;
+      name = name || getInterfaceName(), family = family || "IPv4";
+      for (var i = -1; i < 8; i++) {
+        var interfaceName = name + (i >= 0 ? i : ""), items = interfaces[interfaceName];
+        if (items)
+          for (var j = 0; j < items.length; j++) {
+            var item = items[j];
+            if (matchName(item.family, family))
+              return item;
+          }
+      }
+      if (noName)
+        for (var k in interfaces)
+          for (var items = interfaces[k], i = 0; i < items.length; i++) {
+            var item = items[i];
+            if (matchName(item.family, family) && !item.address.startsWith("127."))
+              return item;
+          }
+    };
+    address.ip = function(interfaceName) {
+      var item = address.interface("IPv4", interfaceName);
+      return item && item.address;
+    };
+    address.ipv6 = function(interfaceName) {
+      var item = address.interface("IPv6", interfaceName);
+      return item && item.address;
+    };
+    var MAC_OSX_START_LINE = /^(\w+)\:\s+flags=/, MAC_LINUX_START_LINE = /^(\w+)\s{2,}link encap:\w+/i, MAC_RE = address.MAC_RE = /(?:ether|HWaddr)\s+((?:[a-z0-9]{2}\:){5}[a-z0-9]{2})/i, MAC_IP_RE = address.MAC_IP_RE = /inet\s(?:addr\:)?(\d+\.\d+\.\d+\.\d+)/;
+    function getMAC(content, interfaceName, matchIP) {
+      for (var lines = content.split(`
+`), i = 0; i < lines.length; i++) {
+        var line = lines[i].trimRight(), m = MAC_OSX_START_LINE.exec(line) || MAC_LINUX_START_LINE.exec(line);
+        if (m) {
+          var name = m[1];
+          if (name.indexOf(interfaceName) === 0) {
+            var ip = null, mac = null, match = MAC_RE.exec(line);
+            for (match && (mac = match[1]), i++; ; ) {
+              if (line = lines[i], !line || MAC_OSX_START_LINE.exec(line) || MAC_LINUX_START_LINE.exec(line)) {
+                i--;
+                break;
+              }
+              mac || (match = MAC_RE.exec(line), match && (mac = match[1])), ip || (match = MAC_IP_RE.exec(line), match && (ip = match[1])), i++;
+            }
+            if (ip === matchIP)
+              return mac;
+          }
+        }
+      }
+    }
+    address.mac = function(interfaceName, callback) {
+      typeof interfaceName == "function" && (callback = interfaceName, interfaceName = null), interfaceName = interfaceName || getInterfaceName();
+      var item = address.interface("IPv4", interfaceName);
+      if (!item)
+        return callback();
+      if (!process.env.CI && (item.mac === "ff:00:00:00:00:00" || item.mac === "00:00:00:00:00:00") && (item.mac = ""), item.mac)
+        return callback(null, item.mac);
+      child.exec(getIfconfigCMD(), { timeout: 5e3 }, function(err, stdout, stderr) {
+        if (err || !stdout)
+          return callback(err);
+        var mac = getMAC(stdout || "", interfaceName, item.address);
+        callback(null, mac);
+      });
+    };
+    var DNS_SERVER_RE = /^nameserver\s+(\d+\.\d+\.\d+\.\d+)$/i;
+    address.dns = function(filepath, callback) {
+      typeof filepath == "function" && (callback = filepath, filepath = null), filepath = filepath || DEFAULT_RESOLV_FILE, fs.readFile(filepath, "utf8", function(err, content) {
+        if (err)
+          return callback(err);
+        var servers = [];
+        content = content || "";
+        for (var lines = content.split(`
+`), i = 0; i < lines.length; i++) {
+          var line = lines[i].trim(), m = DNS_SERVER_RE.exec(line);
+          m && servers.push(m[1]);
+        }
+        callback(null, servers);
+      });
+    };
+    module.exports = address;
+  }
+});
+
+// ../../node_modules/detect-port/lib/detect-port.js
+var require_detect_port = __commonJS({
+  "../../node_modules/detect-port/lib/detect-port.js"(exports, module) {
+    "use strict";
+    var net4 = __require("net"), address = require_address(), debug = require_src()("detect-port");
+    module.exports = (port, callback) => {
+      let hostname = "";
+      typeof port == "object" && port ? (hostname = port.hostname, callback = port.callback, port = port.port) : typeof port == "function" && (callback = port, port = null), port = parseInt(port) || 0;
+      let maxPort = port + 10;
+      return maxPort > 65535 && (maxPort = 65535), debug("detect free port between [%s, %s)", port, maxPort), typeof callback == "function" ? tryListen(port, maxPort, hostname, callback) : new Promise((resolve9) => {
+        tryListen(port, maxPort, hostname, (_, realPort) => {
+          resolve9(realPort);
+        });
+      });
+    };
+    function tryListen(port, maxPort, hostname, callback) {
+      function handleError() {
+        port++, port >= maxPort && (debug("port: %s >= maxPort: %s, give up and use random port", port, maxPort), port = 0, maxPort = 0), tryListen(port, maxPort, hostname, callback);
+      }
+      hostname ? listen(port, hostname, (err, realPort) => {
+        if (err)
+          return err.code === "EADDRNOTAVAIL" ? callback(new Error("the ip that is not unknown on the machine")) : handleError();
+        callback(null, realPort);
+      }) : listen(port, null, (err, realPort) => {
+        if (port === 0)
+          return callback(err, realPort);
+        if (err)
+          return handleError(err);
+        listen(port, "0.0.0.0", (err2) => {
+          if (err2)
+            return handleError(err2);
+          listen(port, "localhost", (err3) => {
+            if (err3 && err3.code !== "EADDRNOTAVAIL")
+              return handleError(err3);
+            listen(port, address.ip(), (err4, realPort2) => {
+              if (err4)
+                return handleError(err4);
+              callback(null, realPort2);
+            });
+          });
+        });
+      });
+    }
+    function listen(port, hostname, callback) {
+      let server = new net4.Server();
+      server.on("error", (err) => (debug("listen %s:%s error: %s", hostname, port, err), server.close(), err.code === "ENOTFOUND" ? (debug("ignore dns ENOTFOUND error, get free %s:%s", hostname, port), callback(null, port)) : callback(err))), server.listen(port, hostname, () => (port = server.address().port, server.close(), debug("get free %s:%s", hostname, port), callback(null, port)));
+    }
+  }
+});
+
+// ../../node_modules/detect-port/lib/wait-port.js
+var require_wait_port = __commonJS({
+  "../../node_modules/detect-port/lib/wait-port.js"(exports, module) {
+    "use strict";
+    var debug = require_src()("wait-port"), detect = require_detect_port(), sleep = (ms) => new Promise((resolve9) => setTimeout(resolve9, ms));
+    async function waitPort(port, options = {}) {
+      let { retryInterval = 1e3, retries = 1 / 0 } = options, count = 1;
+      async function loop() {
+        if (debug("retries", retries, "count", count), count > retries) {
+          let err = new Error("retries exceeded");
+          throw err.retries = retries, err.count = count, err;
+        }
+        return count++, await detect(port) === port ? (await sleep(retryInterval), loop()) : !0;
+      }
+      return await loop();
+    }
+    module.exports = waitPort;
+  }
+});
+
+// ../../node_modules/detect-port/index.js
+var require_detect_port2 = __commonJS({
+  "../../node_modules/detect-port/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_detect_port();
+    module.exports.waitPort = require_wait_port();
+  }
+});
+
+// src/core-server/index.ts
+import {
+  getPreviewHeadTemplate,
+  getPreviewBodyTemplate
+} from "@aussieljk/forkbook/internal/common";
+
+// src/core-server/build-static.ts
+var import_picocolors3 = __toESM(require_picocolors(), 1);
+import { cp as cp2, mkdir } from "node:fs/promises";
+import { rm } from "node:fs/promises";
+import { Channel as Channel2 } from "@aussieljk/forkbook/internal/channels";
+import {
+  loadAllPresets,
+  loadMainConfig,
+  logConfig,
+  resolveAddonName
+} from "@aussieljk/forkbook/internal/common";
+import { logger as logger4 } from "@aussieljk/forkbook/internal/node-logger";
+import { getPrecedingUpgrade, telemetry as telemetry2 } from "@aussieljk/forkbook/internal/telemetry";
+import { global as global2 } from "@storybook/global";
+import { join as join4, relative as relative3, resolve as resolve3 } from "pathe";
+
+// src/core-server/utils/build-or-throw.ts
+import { NoMatchingExportError } from "@aussieljk/forkbook/internal/server-errors";
+async function buildOrThrow(callback) {
+  try {
+    return await callback();
+  } catch (err) {
+    let builderErrors = err.errors;
+    throw builderErrors && builderErrors.find(
+      (er) => er.text?.includes("No matching export")
+    ) ? new NoMatchingExportError(err) : err;
+  }
+}
+
+// src/core-server/utils/copy-all-static-files.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+import { cp } from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
+import { logger as logger2 } from "@aussieljk/forkbook/internal/node-logger";
+async function copyAllStaticFilesRelativeToMain(staticDirs, outputDir, configDir) {
+  return staticDirs?.reduce(async (acc, dir) => {
+    await acc;
+    let { staticPath: from, targetEndpoint: to } = mapStaticDir(dir, configDir), targetPath = join(outputDir, to), skipPaths = ["index.html", "iframe.html", "index.json", "project.json"].map(
+      (f) => resolve(outputDir, f)
+    );
+    from.includes("node_modules") || logger2.info(
+      `Copying static files: ${import_picocolors.default.cyan(print(from))} at ${import_picocolors.default.cyan(print(targetPath))}`
+    ), await cp(from, targetPath, {
+      dereference: !0,
+      preserveTimestamps: !0,
+      filter: (_, dest) => !skipPaths.includes(resolve(dest)),
+      recursive: !0,
+      force: !0
+    });
+  }, Promise.resolve());
+}
+function print(p) {
+  return relative(process.cwd(), p);
+}
+
+// src/core-server/utils/index-json.ts
+import { writeFile } from "node:fs/promises";
+import { basename as basename2 } from "node:path";
+import { STORY_INDEX_INVALIDATED } from "@aussieljk/forkbook/internal/core-events";
+
+// src/core-server/utils/watch-story-specifiers.ts
+import { lstatSync } from "node:fs";
+import { basename, join as join2, relative as relative2, resolve as resolve2, sep } from "node:path";
+import { commonGlobOptions } from "@aussieljk/forkbook/internal/common";
+import { subscribe } from "@parcel/watcher";
+var isDirectory = (directory) => {
+  try {
+    return lstatSync(directory).isDirectory();
+  } catch {
+    return !1;
+  }
+};
+function watchDirectories(directories, onEvents) {
+  let existing = [...new Set(directories)].filter(isDirectory), roots = existing.filter(
+    (directory) => !existing.some((other) => directory.startsWith(other + sep))
+  ), subscriptions = Promise.all(
+    roots.map(
+      (directory) => subscribe(
+        directory,
+        (error, events2) => {
+          error || onEvents(events2);
+        },
+        { ignore: ["**/.git", "**/node_modules"] }
+      )
+    )
+  );
+  return async () => {
+    await Promise.all((await subscriptions).map((subscription) => subscription.unsubscribe()));
+  };
+}
+function watchStorySpecifiers(specifiers, options, onInvalidate) {
+  let toImportPath = (absolutePath) => {
+    let relativePath = relative2(options.workingDir, absolutePath);
+    return slash(relativePath.startsWith(".") ? relativePath : `./${relativePath}`);
+  };
+  async function onChangeOrRemove(absolutePath, removed) {
+    let importPath = toImportPath(absolutePath);
+    if (specifiers.find((ns) => ns.importPathMatcher.exec(importPath))) {
+      onInvalidate(importPath, removed);
+      return;
+    }
+    !removed && isDirectory(absolutePath) && await Promise.all(
+      specifiers.filter((specifier) => importPath.startsWith(specifier.directory)).map(async (specifier) => {
+        let dirGlob = join2(
+          absolutePath,
+          "**",
+          // files can be e.g. '**/foo/*/*.js' so we just want the last bit,
+          // because the directory could already be within the files part (e.g. './x/foo/bar')
+          basename(specifier.files)
+        ), { globby } = await import("../_node-chunks/globby-HWZL7XSQ.js");
+        (await globby(slash(dirGlob), commonGlobOptions(dirGlob))).forEach((filePath) => {
+          let fileImportPath = toImportPath(filePath);
+          specifier.importPathMatcher.exec(fileImportPath) && onInvalidate(fileImportPath, removed);
+        });
+      })
+    );
+  }
+  return watchDirectories(
+    specifiers.map((ns) => resolve2(options.workingDir, ns.directory)),
+    async (events2) => {
+      let removedByPath = new Map(events2.map(({ path, type }) => [path, type === "delete"]));
+      await Promise.all(
+        Array.from(removedByPath, ([path, removed]) => onChangeOrRemove(path, removed))
+      );
+    }
+  );
+}
+
+// src/core-server/utils/watchConfig.ts
+function watchConfig(configDir, onInvalidate) {
+  return watchDirectories([configDir], async (events2) => {
+    await Promise.all(events2.map(({ path, type }) => onInvalidate(path, type === "delete")));
+  });
+}
+
+// src/core-server/utils/index-json.ts
+var DEBOUNCE = 100;
+async function writeIndexJson(outputFile, initializedStoryIndexGenerator) {
+  let storyIndex = await (await initializedStoryIndexGenerator).getIndex();
+  await writeFile(outputFile, JSON.stringify(storyIndex));
+}
+function registerIndexJsonRoute({
+  app,
+  storyIndexGeneratorPromise,
+  workingDir = process.cwd(),
+  configDir,
+  channel,
+  normalizedStories
+}) {
+  let maybeInvalidate = debounce(
+    () => {
+      channel.emit(STORY_INDEX_INVALIDATED);
+    },
+    DEBOUNCE,
+    { edges: ["leading", "trailing"] }
+  );
+  watchStorySpecifiers(normalizedStories, { workingDir }, async (path, removed) => {
+    (await storyIndexGeneratorPromise).invalidate(path, removed), maybeInvalidate();
+  }), configDir && watchConfig(configDir, async (filePath) => {
+    basename2(filePath).startsWith("preview") && ((await storyIndexGeneratorPromise).invalidateAll(), maybeInvalidate());
+  }), app.use("/index.json", async (_req, res) => {
+    try {
+      let index = await (await storyIndexGeneratorPromise).getIndex();
+      res.setHeader("Content-Type", "application/json"), res.setHeader("Access-Control-Allow-Origin", "*"), res.setHeader(
+        "Access-Control-Allow-Headers",
+        "Origin, X-Requested-With, Content-Type, Accept"
+      ), res.end(JSON.stringify(index));
+    } catch (err) {
+      res.statusCode = 500, res.end(err instanceof Error ? err.toString() : String(err));
+    }
+  });
+}
+
+// src/core-server/utils/metadata.ts
+import { writeFile as writeFile2 } from "node:fs/promises";
+import { getStorybookMetadata } from "@aussieljk/forkbook/internal/telemetry";
+async function extractStorybookMetadata(outputFile, configDir) {
+  let storybookMetadata = await getStorybookMetadata(configDir);
+  await writeFile2(outputFile, JSON.stringify(storybookMetadata));
+}
+function useStorybookMetadata(app, configDir) {
+  app.use("/project.json", async (req, res) => {
+    let storybookMetadata = await getStorybookMetadata(configDir);
+    res.setHeader("Content-Type", "application/json"), res.write(JSON.stringify(storybookMetadata)), res.end();
+  });
+}
+
+// src/core-server/utils/output-stats.ts
+var import_json_ext = __toESM(require_src2(), 1), import_picocolors2 = __toESM(require_picocolors(), 1);
+import { createWriteStream } from "node:fs";
+import { join as join3 } from "node:path";
+import { logger as logger3 } from "@aussieljk/forkbook/internal/node-logger";
+async function outputStats(directory, previewStats, managerStats) {
+  if (previewStats) {
+    let filePath = await writeStats(directory, "preview", previewStats);
+    logger3.info(`Preview stats written to ${import_picocolors2.default.cyan(filePath)}`);
+  }
+  if (managerStats) {
+    let filePath = await writeStats(directory, "manager", managerStats);
+    logger3.info(`Manager stats written to ${import_picocolors2.default.cyan(filePath)}`);
+  }
+}
+var writeStats = async (directory, name, stats) => {
+  let filePath = join3(directory, `${name}-stats.json`), { chunks, ...data } = stats.toJson();
+  return await new Promise((resolve9, reject) => {
+    (0, import_json_ext.stringifyStream)(data, null, 2).on("error", reject).pipe(createWriteStream(filePath)).on("error", reject).on("finish", resolve9);
+  }), filePath;
+};
+
+// src/core-server/utils/summarizeIndex.ts
+import { isExampleStoryId } from "@aussieljk/forkbook/internal/telemetry";
+
+// src/shared/utils/story-index-filters.ts
+function isMdxEntry({ tags }) {
+  return tags?.includes(Tag.UNATTACHED_MDX) || tags?.includes(Tag.ATTACHED_MDX);
+}
+
+// src/core-server/utils/summarizeIndex.ts
+var PAGE_REGEX = /(page|screen)/i, isPageStory = (storyId) => PAGE_REGEX.test(storyId), isCLIExampleEntry = (entry) => [
+  "example-introduction--docs",
+  "configure-your-project--docs",
+  "example-button--docs",
+  "example-button--primary",
+  "example-button--secondary",
+  "example-button--large",
+  "example-button--small",
+  "example-header--docs",
+  "example-header--logged-in",
+  "example-header--logged-out",
+  "example-page--logged-in",
+  "example-page--logged-out"
+].includes(entry.id);
+function summarizeIndex(storyIndex) {
+  let storyCount = 0, componentTitles = /* @__PURE__ */ new Set(), exampleStoryCount = 0, exampleDocsCount = 0, pageStoryCount = 0, playStoryCount = 0, testStoryCount = 0, autodocsCount = 0, mdxCount = 0, testsPerParentStory = /* @__PURE__ */ new Map();
+  Object.values(storyIndex.entries).forEach((entry) => {
+    isCLIExampleEntry(entry) || isExampleStoryId(entry.id) ? (entry.type === "story" && (exampleStoryCount += 1), entry.type === "docs" && (exampleDocsCount += 1)) : entry.type === "story" ? (storyCount += 1, componentTitles.add(entry.title), isPageStory(entry.title) && (pageStoryCount += 1), entry.tags?.includes(Tag.PLAY_FN) && (playStoryCount += 1), entry.tags?.includes(Tag.TEST_FN) && entry.parent && (testStoryCount += 1, testsPerParentStory.set(entry.parent, (testsPerParentStory.get(entry.parent) ?? 0) + 1))) : entry.type === "docs" && (isMdxEntry(entry) ? mdxCount += 1 : entry.tags?.includes(Tag.AUTODOCS) && (autodocsCount += 1));
+  });
+  let componentCount = componentTitles.size, maxTestsPerStory = 0, singleTestStoryCount = 0;
+  return testsPerParentStory.forEach((count) => {
+    count > maxTestsPerStory && (maxTestsPerStory = count), count === 1 && (singleTestStoryCount += 1);
+  }), {
+    storyCount,
+    componentCount,
+    pageStoryCount,
+    playStoryCount,
+    testStoryCount,
+    maxTestsPerStory,
+    singleTestStoryCount,
+    autodocsCount,
+    mdxCount,
+    exampleStoryCount,
+    exampleDocsCount,
+    version: storyIndex.v
+  };
+}
+
+// src/core-server/build-static.ts
+async function buildStaticStandalone(options) {
+  if (options.configType = "PRODUCTION", options.outputDir === "")
+    throw new Error("Won't remove current directory. Check your outputDir!");
+  if (options.outputDir = resolve3(options.outputDir), options.configDir = resolve3(options.configDir), logger4.step(`Cleaning outputDir: ${import_picocolors3.default.cyan(relative3(process.cwd(), options.outputDir))}`), options.outputDir === "/")
+    throw new Error("Won't remove directory '/'. Check your outputDir!");
+  await rm(options.outputDir, { recursive: !0, force: !0 }).catch(() => {
+  }), await mkdir(options.outputDir, { recursive: !0 });
+  let config = await loadMainConfig(options), { framework } = config, corePresets = [], frameworkName = typeof framework == "string" ? framework : framework?.name;
+  frameworkName ? corePresets.push(join4(frameworkName, "preset")) : logger4.warn(`you have not specified a framework in your ${options.configDir}/main.js`);
+  let commonPreset = join4(
+    resolvePackageDir("@aussieljk/forkbook"),
+    "dist/core-server/presets/common-preset.js"
+  ), commonOverridePreset = import.meta.resolve("@aussieljk/forkbook/internal/core-server/presets/common-override-preset");
+  logger4.step("Loading presets");
+  let channel = new Channel2({}), presets = await loadAllPresets({
+    corePresets: [commonPreset, ...corePresets],
+    overridePresets: [commonOverridePreset],
+    isCritical: !0,
+    channel,
+    ...options
+  }), { renderer } = await presets.apply("core", {}), build2 = await presets.apply("build", {}), [previewBuilder, managerBuilder] = await getBuilders({
+    ...options,
+    presets,
+    build: build2,
+    channel
+  }), resolvedRenderer = renderer ? resolveAddonName(options.configDir, renderer, options) : void 0;
+  presets = await loadAllPresets({
+    corePresets: [
+      commonPreset,
+      ...managerBuilder.corePresets || [],
+      ...previewBuilder.corePresets || [],
+      ...resolvedRenderer ? [resolvedRenderer] : [],
+      ...corePresets
+    ],
+    overridePresets: [...previewBuilder.overridePresets || [], commonOverridePreset],
+    build: build2,
+    channel,
+    ...options
+  });
+  let [features, core, staticDirs] = await Promise.all([
+    presets.apply("features"),
+    presets.apply("core"),
+    presets.apply("staticDirs")
+  ]), invokedBy = process.env.FORKBOOK_INVOKED_BY;
+  invokedBy && telemetry2("test-run", { runner: invokedBy, watch: !1 }, { configDir: options.configDir });
+  let fullOptions = {
+    ...options,
+    channel,
+    presets,
+    features,
+    build: build2
+  }, effects = [];
+  global2.FEATURES = features, await applyServicesPresetOnce(presets), options.previewOnly || await buildOrThrow(
+    async () => managerBuilder.build({ startTime: process.hrtime(), options: fullOptions })
+  ), staticDirs && effects.push(
+    copyAllStaticFilesRelativeToMain(staticDirs, options.outputDir, options.configDir)
+  );
+  let coreServerPublicDir = join4(resolvePackageDir("@aussieljk/forkbook"), "assets/browser");
+  effects.push(cp2(coreServerPublicDir, options.outputDir, { recursive: !0, force: !0 }));
+  let hasRegisteredServices = getRegisteredServices().length > 0, shouldWriteManifests = features?.componentsManifest;
+  (hasRegisteredServices || shouldWriteManifests) && effects.push(
+    (async () => {
+      hasRegisteredServices && (logger4.info("Building open services.."), await writeOpenServiceStaticFiles(options.outputDir)), shouldWriteManifests && await writeManifests(options.outputDir, presets);
+    })()
+  );
+  let storyIndexGeneratorPromise = presets.apply("storyIndexGenerator");
+  effects.push(writeIndexJson(join4(options.outputDir, "index.json"), storyIndexGeneratorPromise)), core?.disableProjectJson || effects.push(
+    extractStorybookMetadata(join4(options.outputDir, "project.json"), options.configDir)
+  ), options.debugWebpack && logConfig("Preview webpack config", await previewBuilder.getConfig(fullOptions)), logger4.info("Building preview..");
+  let startTime = process.hrtime();
+  if (await Promise.all([
+    previewBuilder.build({
+      startTime,
+      options: fullOptions
+    }).then(async (previewStats) => {
+      logger4.trace({ message: "Preview built", time: process.hrtime(startTime) });
+      let statsOption = options.statsJson;
+      if (statsOption) {
+        let target = statsOption === !0 ? options.outputDir : statsOption;
+        await outputStats(target, previewStats);
+      }
+    }).catch((error) => {
+      throw logger4.error("Failed to build the preview"), process.exitCode = 1, error;
+    }),
+    ...effects
+  ]), !options.test)
+    try {
+      let storyIndex = await (await storyIndexGeneratorPromise)?.getIndex(), payload = {
+        precedingUpgrade: await getPrecedingUpgrade()
+      };
+      storyIndex && Object.assign(payload, {
+        storyIndex: summarizeIndex(storyIndex)
+      }), await telemetry2("build", payload, { configDir: options.configDir });
+    } catch (e) {
+      logger4.debug?.(`Build telemetry failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  logger4.step(`Output directory: ${options.outputDir}`);
+}
+
+// src/core-server/build-dev.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import {
+  JsPackageManagerFactory,
+  getInterpretedFile,
+  getProjectRoot,
+  isWebContainer,
+  defaultConfigDir,
+  loadAllPresets as loadAllPresets2,
+  loadMainConfig as loadMainConfig2,
+  resolveAddonName as resolveAddonName2,
+  resolvePathInStorybookCache as resolvePathInStorybookCache2,
+  validateFrameworkName,
+  versions
+} from "@aussieljk/forkbook/internal/common";
+import { CLI_COLORS as CLI_COLORS2, deprecate, logger as logger15, prompt as prompt2 } from "@aussieljk/forkbook/internal/node-logger";
+import {
+  MissingBuilderError as MissingBuilderError2,
+  NoStatsForViteDevError
+} from "@aussieljk/forkbook/internal/server-errors";
+import { oneWayHash, telemetry as telemetry4 } from "@aussieljk/forkbook/internal/telemetry";
+import { global as global3 } from "@storybook/global";
+import { join as join8, relative as relative4, resolve as resolve6 } from "pathe";
+import { dedent as dedent5 } from "ts-dedent";
+
+// src/channels/postmessage/index.ts
+var import_telejson = __toESM(require_dist(), 1);
+import { logger as logger6, pretty } from "@aussieljk/forkbook/internal/client-logger";
+import * as EVENTS from "@aussieljk/forkbook/internal/core-events";
+
+// src/shared/utils/local-hosts.ts
+var LOOPBACK_HOSTNAMES = ["localhost", "*.localhost", "127.0.0.1"], matchesHostname = (hostname, patterns) => patterns.some(
+  (pattern) => pattern.startsWith("*.") ? hostname.endsWith(pattern.slice(1)) : hostname === pattern
+);
+
+// src/channels/postmessage/getEventSourceUrl.ts
+import { logger as logger5 } from "@aussieljk/forkbook/internal/client-logger";
+
+// src/channels/postmessage/index.ts
+var { document: document2, location } = globalThis;
+var CHANNEL_OPTIONS = globalThis.CHANNEL_OPTIONS || {};
+
+// src/channels/index.ts
+var channels_default = Channel;
+
+// src/core-server/dev-server.ts
+import { logConfig as logConfig2, normalizeStories } from "@aussieljk/forkbook/internal/common";
+import { logger as logger11 } from "@aussieljk/forkbook/internal/node-logger";
+import { MissingBuilderError } from "@aussieljk/forkbook/internal/server-errors";
+import { CHANGE_DETECTION_STATUS_TYPE_ID as CHANGE_DETECTION_STATUS_TYPE_ID2 } from "@aussieljk/forkbook/internal/types";
+
+// ../../node_modules/@polka/compression/build.mjs
+import zlib from "node:zlib";
+var NOOP = () => {
+}, MIMES = /text|javascript|\/json|xml/i;
+function getChunkSize(chunk, enc) {
+  return chunk ? Buffer.byteLength(chunk, enc) : 0;
+}
+function build_default({ threshold = 1024, level = -1, brotli = !1, gzip = !0, mimes = MIMES } = {}) {
+  let brotliOpts = typeof brotli == "object" && brotli || {}, gzipOpts = typeof gzip == "object" && gzip || {};
+  return zlib.createBrotliCompress || (brotli = !1), (req, res, next = NOOP) => {
+    let accept = req.headers["accept-encoding"] + "", encoding = (brotli && /\bbr\b/.exec(accept) || gzip && /\bgzip\b/.exec(accept) || [])[0];
+    if (req.method === "HEAD" || !encoding) return next();
+    let compress, pendingListeners = [], pendingStatus = 0, started = !1, size = 0;
+    function start() {
+      started = !0, size = res.getHeader("Content-Length") | 0 || size;
+      let compressible = mimes.test(
+        String(res.getHeader("Content-Type") || "text/plain")
+      ), cleartext = !res.getHeader("Content-Encoding"), listeners = pendingListeners || [];
+      compressible && cleartext && size >= threshold ? (res.setHeader("Content-Encoding", encoding), res.removeHeader("Content-Length"), encoding === "br" ? compress = zlib.createBrotliCompress({
+        params: Object.assign({
+          [zlib.constants.BROTLI_PARAM_QUALITY]: level,
+          [zlib.constants.BROTLI_PARAM_SIZE_HINT]: size
+        }, brotliOpts)
+      }) : compress = zlib.createGzip(
+        Object.assign({ level }, gzipOpts)
+      ), compress.on("data", (chunk) => write.call(res, chunk) || compress.pause()), on.call(res, "drain", () => compress.resume()), compress.on("end", () => end.call(res)), listeners.forEach((p) => compress.on.apply(compress, p))) : (pendingListeners = null, listeners.forEach((p) => on.apply(res, p))), writeHead.call(res, pendingStatus || res.statusCode);
+    }
+    let { end, write, on, writeHead } = res;
+    res.writeHead = function(status, reason, headers) {
+      if (typeof reason != "string" && ([headers, reason] = [reason, headers]), headers) for (let k in headers) res.setHeader(k, headers[k]);
+      return pendingStatus = status, this;
+    }, res.write = function(chunk, enc) {
+      return size += getChunkSize(chunk, enc), started || start(), compress ? compress.write.apply(compress, arguments) : write.apply(this, arguments);
+    }, res.end = function(chunk, enc) {
+      return arguments.length > 0 && typeof chunk != "function" && (size += getChunkSize(chunk, enc)), started || start(), compress ? compress.end.apply(compress, arguments) : end.apply(this, arguments);
+    }, res.on = function(type, listener) {
+      return pendingListeners ? compress ? compress.on(type, listener) : pendingListeners.push([type, listener]) : on.call(this, type, listener), this;
+    }, next();
+  };
+}
+
+// ../../node_modules/polka/build.mjs
+import http from "node:http";
+import { setImmediate } from "node:timers";
+
+// ../../node_modules/regexparam/dist/index.mjs
+function parse3(input, loose) {
+  if (input instanceof RegExp) return { keys: !1, pattern: input };
+  var c, o, tmp, ext, keys = [], pattern = "", arr = input.split("/");
+  for (arr[0] || arr.shift(); tmp = arr.shift(); )
+    c = tmp[0], c === "*" ? (keys.push(c), pattern += tmp[1] === "?" ? "(?:/(.*))?" : "/(.*)") : c === ":" ? (o = tmp.indexOf("?", 1), ext = tmp.indexOf(".", 1), keys.push(tmp.substring(1, ~o ? o : ~ext ? ext : tmp.length)), pattern += ~o && !~ext ? "(?:/([^/]+?))?" : "/([^/]+?)", ~ext && (pattern += (~o ? "?" : "") + "\\" + tmp.substring(ext))) : pattern += "/" + tmp;
+  return {
+    keys,
+    pattern: new RegExp("^" + pattern + (loose ? "(?=$|/)" : "/?$"), "i")
+  };
+}
+
+// ../../node_modules/trouter/index.mjs
+var MAP = {
+  "": 0,
+  GET: 1,
+  HEAD: 2,
+  PATCH: 3,
+  OPTIONS: 4,
+  CONNECT: 5,
+  DELETE: 6,
+  TRACE: 7,
+  POST: 8,
+  PUT: 9
+}, Trouter = class {
+  constructor() {
+    this.routes = [], this.all = this.add.bind(this, ""), this.get = this.add.bind(this, "GET"), this.head = this.add.bind(this, "HEAD"), this.patch = this.add.bind(this, "PATCH"), this.options = this.add.bind(this, "OPTIONS"), this.connect = this.add.bind(this, "CONNECT"), this.delete = this.add.bind(this, "DELETE"), this.trace = this.add.bind(this, "TRACE"), this.post = this.add.bind(this, "POST"), this.put = this.add.bind(this, "PUT");
+  }
+  use(route, ...fns) {
+    let handlers = [].concat.apply([], fns), { keys, pattern } = parse3(route, !0);
+    return this.routes.push({ keys, pattern, method: "", handlers, midx: MAP[""] }), this;
+  }
+  add(method, route, ...fns) {
+    let { keys, pattern } = parse3(route), handlers = [].concat.apply([], fns);
+    return this.routes.push({ keys, pattern, method, handlers, midx: MAP[method] }), this;
+  }
+  find(method, url) {
+    let midx = MAP[method], isHEAD = midx === 2, i = 0, j = 0, k, tmp, arr = this.routes, matches = [], params = {}, handlers = [];
+    for (; i < arr.length; i++)
+      if (tmp = arr[i], tmp.midx === midx || tmp.midx === 0 || isHEAD && tmp.midx === 1)
+        if (tmp.keys === !1) {
+          if (matches = tmp.pattern.exec(url), matches === null) continue;
+          if (matches.groups !== void 0) for (k in matches.groups) params[k] = matches.groups[k];
+          tmp.handlers.length > 1 ? handlers = handlers.concat(tmp.handlers) : handlers.push(tmp.handlers[0]);
+        } else if (tmp.keys.length > 0) {
+          if (matches = tmp.pattern.exec(url), matches === null) continue;
+          for (j = 0; j < tmp.keys.length; ) params[tmp.keys[j]] = matches[++j];
+          tmp.handlers.length > 1 ? handlers = handlers.concat(tmp.handlers) : handlers.push(tmp.handlers[0]);
+        } else tmp.pattern.test(url) && (tmp.handlers.length > 1 ? handlers = handlers.concat(tmp.handlers) : handlers.push(tmp.handlers[0]));
+    return { params, handlers };
+  }
+};
+
+// ../../node_modules/polka/build.mjs
+init_build();
+function onError(err, req, res) {
+  let code = typeof err.status == "number" && err.status;
+  code = res.statusCode = code && code >= 100 ? code : 500, typeof err == "string" || Buffer.isBuffer(err) ? res.end(err) : res.end(err.message || http.STATUS_CODES[code]);
+}
+var mount = (fn) => fn instanceof Polka ? fn.attach : fn, Polka = class _Polka extends Trouter {
+  constructor(opts = {}) {
+    super(), this.parse = parse, this.server = opts.server, this.handler = this.handler.bind(this), this.onError = opts.onError || onError, this.onNoMatch = opts.onNoMatch || this.onError.bind(null, { status: 404 }), this.attach = (req, res) => setImmediate(this.handler, req, res);
+  }
+  use(base, ...fns) {
+    return base === "/" ? super.use(base, fns.map(mount)) : typeof base == "function" || base instanceof _Polka ? super.use("/", [base, ...fns].map(mount)) : super.use(
+      base,
+      (req, _, next) => {
+        if (typeof base == "string") {
+          let len = base.length;
+          base.startsWith("/") || len++, req.url = req.url.substring(len) || "/", req.path = req.path.substring(len) || "/";
+        } else
+          req.url = req.url.replace(base, "") || "/", req.path = req.path.replace(base, "") || "/";
+        req.url.charAt(0) !== "/" && (req.url = "/" + req.url), next();
+      },
+      fns.map(mount),
+      (req, _, next) => {
+        req.path = req._parsedUrl.pathname, req.url = req.path + req._parsedUrl.search, next();
+      }
+    ), this;
+  }
+  listen() {
+    return (this.server = this.server || http.createServer()).on("request", this.attach), this.server.listen.apply(this.server, arguments), this;
+  }
+  handler(req, res, next) {
+    let info = this.parse(req), path = info.pathname, obj = this.find(req.method, req.path = path);
+    if (req.url = path + info.search, req.originalUrl = req.originalUrl || req.url, req.query = info.query || {}, req.search = info.search, req.params = obj.params, path.length > 1 && path.indexOf("%", 1) !== -1)
+      for (let k in req.params)
+        try {
+          req.params[k] = decodeURIComponent(req.params[k]);
+        } catch {
+        }
+    let i = 0, arr = obj.handlers.concat(this.onNoMatch), len = arr.length, loop = async () => res.finished || i < len && arr[i++](req, res, next);
+    (next = next || ((err) => err ? this.onError(err, req, res, next) : loop().catch(next)))();
+  }
+};
+function build_default2(opts) {
+  return new Polka(opts);
+}
+
+// src/core-server/change-detection/change-detection-service.ts
+import { join as join5, normalize } from "pathe";
+
+// ../../node_modules/dequal/dist/index.mjs
+var has = Object.prototype.hasOwnProperty;
+function find(iter, tar, key) {
+  for (key of iter.keys())
+    if (dequal(key, tar)) return key;
+}
+function dequal(foo, bar) {
+  var ctor, len, tmp;
+  if (foo === bar) return !0;
+  if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+    if (ctor === Date) return foo.getTime() === bar.getTime();
+    if (ctor === RegExp) return foo.toString() === bar.toString();
+    if (ctor === Array) {
+      if ((len = foo.length) === bar.length)
+        for (; len-- && dequal(foo[len], bar[len]); ) ;
+      return len === -1;
+    }
+    if (ctor === Set) {
+      if (foo.size !== bar.size)
+        return !1;
+      for (len of foo)
+        if (tmp = len, tmp && typeof tmp == "object" && (tmp = find(bar, tmp), !tmp) || !bar.has(tmp)) return !1;
+      return !0;
+    }
+    if (ctor === Map) {
+      if (foo.size !== bar.size)
+        return !1;
+      for (len of foo)
+        if (tmp = len[0], tmp && typeof tmp == "object" && (tmp = find(bar, tmp), !tmp) || !dequal(len[1], bar.get(tmp)))
+          return !1;
+      return !0;
+    }
+    if (ctor === ArrayBuffer)
+      foo = new Uint8Array(foo), bar = new Uint8Array(bar);
+    else if (ctor === DataView) {
+      if ((len = foo.byteLength) === bar.byteLength)
+        for (; len-- && foo.getInt8(len) === bar.getInt8(len); ) ;
+      return len === -1;
+    }
+    if (ArrayBuffer.isView(foo)) {
+      if ((len = foo.byteLength) === bar.byteLength)
+        for (; len-- && foo[len] === bar[len]; ) ;
+      return len === -1;
+    }
+    if (!ctor || typeof foo == "object") {
+      len = 0;
+      for (ctor in foo)
+        if (has.call(foo, ctor) && ++len && !has.call(bar, ctor) || !(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return !1;
+      return Object.keys(bar).length === len;
+    }
+  }
+  return foo !== foo && bar !== bar;
+}
+
+// src/core-server/change-detection/change-detection-service.ts
+import { logger as logger7 } from "@aussieljk/forkbook/internal/node-logger";
+import { CHANGE_DETECTION_STATUS_TYPE_ID } from "@aussieljk/forkbook/internal/types";
+
+// src/core-server/change-detection/IndexBaselineService.ts
+import {
+  createFileSystemCache,
+  resolvePathInStorybookCache
+} from "@aussieljk/forkbook/internal/common";
+var DEFAULT_CACHE_KEY = "index-baseline";
+function extractBaselineEntryIds(storyIndex) {
+  let entryIds = /* @__PURE__ */ new Set();
+  return Object.values(storyIndex.entries).forEach((entry) => {
+    (entry.type === "story" || entry.type === "docs") && !entry.importPath.startsWith("virtual:") && entryIds.add(entry.id);
+  }), entryIds;
+}
+var IndexBaselineService = class {
+  constructor(options) {
+    this.options = options;
+    this.baselineEntryIds = /* @__PURE__ */ new Set();
+    this.syncInFlight = !1;
+    this.cache = options.cache ?? createFileSystemCache({
+      basePath: resolvePathInStorybookCache(DEFAULT_CACHE_KEY),
+      ns: "storybook"
+    });
+  }
+  start() {
+    return this.initializePromise || (this.initializePromise = this.initialize().catch(() => {
+      this.baselineEntryIds = /* @__PURE__ */ new Set();
+    })), this.initializePromise;
+  }
+  async getBaselineEntryIds() {
+    return await this.start(), new Set(this.baselineEntryIds);
+  }
+  async handleGitStateChange() {
+    if (await this.start(), !this.syncInFlight)
+      try {
+        if (this.syncInFlight = !0, !await this.options.gitDiffProvider.isWorkingTreeClean())
+          return;
+        let headCommit = await this.options.gitDiffProvider.getHeadCommit();
+        await this.refreshBaseline(headCommit), this.options.onBaselineUpdated();
+      } finally {
+        this.syncInFlight = !1;
+      }
+  }
+  async initialize() {
+    if (!await this.options.gitDiffProvider.isWorkingTreeClean()) {
+      await this.refreshBaseline();
+      return;
+    }
+    let headCommit = await this.options.gitDiffProvider.getHeadCommit(), cachedSnapshot = await this.cache.get(headCommit);
+    if (cachedSnapshot?.entryIds?.length) {
+      this.baselineEntryIds = new Set(cachedSnapshot.entryIds);
+      return;
+    }
+    await this.refreshBaseline(headCommit);
+  }
+  async refreshBaseline(persistenceKey) {
+    let storyIndex = await (await this.options.storyIndexGeneratorPromise).getIndex(), entryIds = Array.from(extractBaselineEntryIds(storyIndex)).sort();
+    this.baselineEntryIds = new Set(entryIds), persistenceKey && await this.cache.set(persistenceKey, { entryIds });
+  }
+};
+
+// src/core-server/change-detection/change-detection-service.ts
+var CHANGE_DETECTION_DEBOUNCE_MS = 200;
+function errorLikeToError(errorLike) {
+  let error = new Error(errorLike.message, {
+    cause: errorLike.cause ? errorLikeToError(errorLike.cause) : void 0
+  });
+  return error.name = errorLike.name ?? error.name, errorLike.stack && (error.stack = errorLike.stack), error;
+}
+function isSameStatus(a, b) {
+  return a ? a.storyId === b.storyId && a.typeId === b.typeId && a.value === b.value && a.title === b.title && a.description === b.description && a.sidebarContextMenu === b.sidebarContextMenu && dequal(a.data, b.data) : !1;
+}
+function mergeStatusValues(previousValue, nextValue) {
+  return previousValue === "status-value:new" || nextValue === "status-value:new" ? "status-value:new" : previousValue === "status-value:modified" || nextValue === "status-value:modified" ? "status-value:modified" : previousValue === "status-value:affected" || nextValue === "status-value:affected" ? "status-value:affected" : nextValue;
+}
+function mergeChangeDetectionStatuses(existing, incoming) {
+  return {
+    ...incoming,
+    value: mergeStatusValues(existing?.value, incoming.value),
+    title: incoming.title || existing?.title || "",
+    description: incoming.description || existing?.description || "",
+    sidebarContextMenu: incoming.sidebarContextMenu ?? existing?.sidebarContextMenu ?? !1
+  };
+}
+function buildIndexBaselineStatuses(storyIndex, baselineEntryIds) {
+  let statuses = /* @__PURE__ */ new Map();
+  if (baselineEntryIds.size === 0)
+    return statuses;
+  for (let entryId of extractBaselineEntryIds(storyIndex))
+    baselineEntryIds.has(entryId) || statuses.set(entryId, {
+      storyId: entryId,
+      typeId: CHANGE_DETECTION_STATUS_TYPE_ID,
+      value: "status-value:new",
+      title: "",
+      description: "",
+      sidebarContextMenu: !1
+    });
+  return statuses;
+}
+var ChangeDetectionService = class {
+  constructor(options) {
+    this.options = options;
+    this.disposed = !1;
+    this.scanInFlight = !1;
+    this.rerunAfterCurrentScan = !1;
+    this.readinessResolved = !1;
+    this.statusPipelineStarted = !1;
+    this.previousStatuses = /* @__PURE__ */ new Map();
+    this.gitDiffProvider = options.gitDiffProvider, this.indexBaselineService = options.indexBaselineService, this.workingDir = options.workingDir ?? process.cwd(), this.debounceMs = options.debounceMs ?? CHANGE_DETECTION_DEBOUNCE_MS, resetChangeDetectionReadiness();
+  }
+  getModuleGraph() {
+    return getService("core/module-graph", { internal: !0 });
+  }
+  getModuleGraphIndex() {
+    return getService("core/module-graph-index", { internal: !0 });
+  }
+  onGraphReady() {
+    this.disposed || this.startStatusPipeline();
+  }
+  onGraphChange() {
+    this.disposed || this.scheduleScan(this.debounceMs);
+  }
+  onGraphError(error) {
+    this.disposed || (this.resolveReadiness({ status: "error", error }), this.dispose().catch(() => {
+    }));
+  }
+  onGraphUnavailable(reason, error) {
+    this.disposed || (logger7.warn(`Change detection unavailable: ${reason}`), this.resolveReadiness({ status: "unavailable", reason, error }), this.dispose());
+  }
+  onModuleGraphStatus(status) {
+    if (!this.disposed) {
+      if (status.value === "ready") {
+        this.onGraphReady();
+        return;
+      }
+      if (status.value === "error") {
+        this.onGraphError(errorLikeToError(status.error));
+        return;
+      }
+      status.value === "unavailable" && this.onGraphUnavailable(
+        status.reason,
+        status.error ? errorLikeToError(status.error) : void 0
+      );
+    }
+  }
+  start() {
+    let moduleGraph = this.getModuleGraph();
+    this.unsubscribeModuleGraphStatus = moduleGraph.queries.status.subscribe(
+      void 0,
+      ({ data }) => {
+        data !== void 0 && this.onModuleGraphStatus(data);
+      }
+    ), this.unsubscribeFileActivity = moduleGraph.queries.fileActivityRevision.subscribe(
+      void 0,
+      ({ data }) => {
+        (data ?? 0) > 0 && this.onGraphChange();
+      }
+    ), moduleGraph.queries.status.loaded(void 0).then((status) => {
+      this.onModuleGraphStatus(status);
+    }).catch((error) => {
+      this.onGraphError(error instanceof Error ? error : new Error(String(error)));
+    });
+  }
+  /**
+   * Wires the git-diff-driven status pipeline. Runs once the dependency graph is ready (so the
+   * initial scan and every git-state-change scan read a populated reverse index).
+   */
+  startStatusPipeline() {
+    this.disposed || this.statusPipelineStarted || (this.statusPipelineStarted = !0, this.getIndexBaselineService().start(), this.getGitDiffProvider().onGitStateChange(() => {
+      this.disposed || (this.scheduleScan(this.debounceMs), this.getIndexBaselineService().handleGitStateChange().catch(() => {
+      }));
+    }), this.scheduleScan(0));
+  }
+  async dispose() {
+    this.disposed || (this.disposed = !0, this.rerunAfterCurrentScan = !1, this.debounceTimer && (clearTimeout(this.debounceTimer), this.debounceTimer = void 0), this.gitDiffProvider?.dispose(), this.unsubscribeModuleGraphStatus?.(), this.unsubscribeModuleGraphStatus = void 0, this.unsubscribeFileActivity?.(), this.unsubscribeFileActivity = void 0);
+  }
+  scheduleScan(delayMs) {
+    this.debounceTimer && clearTimeout(this.debounceTimer), this.debounceTimer = setTimeout(() => {
+      this.debounceTimer = void 0, this.scan();
+    }, delayMs);
+  }
+  async scan() {
+    if (this.disposed)
+      return;
+    let status = await this.getModuleGraph().queries.status.loaded(void 0);
+    if (!(this.disposed || status.value !== "ready")) {
+      if (this.scanInFlight) {
+        this.rerunAfterCurrentScan = !0;
+        return;
+      }
+      this.scanInFlight = !0;
+      try {
+        let nextStatuses = await this.buildStatuses();
+        if (this.disposed)
+          return;
+        this.applyStatusStorePatch(nextStatuses), this.resolveReadiness({ status: "ready" });
+      } catch (error) {
+        if (this.disposed)
+          return;
+        if (error instanceof ChangeDetectionUnavailableError)
+          logger7.warn(`Change detection unavailable: ${error.message}`), this.resolveReadiness({
+            status: "unavailable",
+            reason: error.message,
+            error
+          }), await this.dispose();
+        else if (error instanceof ChangeDetectionFailureError)
+          logger7.error(`Change detection failed: ${error.message}`), this.resolveReadiness({
+            status: "error",
+            error
+          });
+        else {
+          let failure = new ChangeDetectionFailureError(
+            error instanceof Error ? error.message : String(error),
+            { cause: error instanceof Error ? error : void 0 }
+          );
+          logger7.error(`Change detection failed: ${failure.message}`), this.resolveReadiness({
+            status: "error",
+            error: failure
+          });
+        }
+      } finally {
+        this.scanInFlight = !1, !this.disposed && this.rerunAfterCurrentScan && (this.rerunAfterCurrentScan = !1, this.scan());
+      }
+    }
+  }
+  async buildStatuses() {
+    let gitDiffProvider = this.getGitDiffProvider(), [changes, repoRoot, storyIndexGenerator, baselineEntryIds] = await Promise.all([
+      gitDiffProvider.getChangedFiles(),
+      gitDiffProvider.getRepoRoot(),
+      this.options.storyIndexGeneratorPromise,
+      this.getIndexBaselineService().getBaselineEntryIds()
+    ]), changedFiles = new Set(
+      Array.from(changes.changed).map((path) => normalize(join5(repoRoot, path)))
+    ), newFiles = new Set(
+      Array.from(changes.new).map((path) => normalize(join5(repoRoot, path)))
+    ), scannedFiles = /* @__PURE__ */ new Set([...changedFiles, ...newFiles]), storyIndex = await storyIndexGenerator.getIndex(), baselineStatuses = buildIndexBaselineStatuses(storyIndex, baselineEntryIds), storyIdsByFile = getStoryIdsByAbsolutePath(storyIndex, this.workingDir), statuses = /* @__PURE__ */ new Map(), scannedFilesArray = [...scannedFiles], lookupResults = await this.getModuleGraphIndex().queries.storiesForFiles.loaded({
+      files: scannedFilesArray
+    });
+    for (let i = 0; i < scannedFilesArray.length; i++) {
+      let changedFile = scannedFilesArray[i], allEntries = /* @__PURE__ */ new Map();
+      for (let { storyFile, depth } of lookupResults[i])
+        allEntries.set(storyIndexPathToAbsolutePath(storyFile, this.workingDir), depth);
+      if (storyIdsByFile.has(changedFile) && allEntries.set(changedFile, 0), allEntries.size === 0)
+        continue;
+      let lowestDistance = Number.POSITIVE_INFINITY;
+      for (let distance of allEntries.values())
+        distance < lowestDistance && (lowestDistance = distance);
+      for (let [storyFile, distance] of allEntries.entries()) {
+        let storyIds = storyIdsByFile.get(storyFile);
+        if (!storyIds)
+          continue;
+        let value = newFiles.has(storyFile) ? "status-value:new" : distance === lowestDistance ? "status-value:modified" : "status-value:affected";
+        storyIds.forEach((storyId) => {
+          let existingStatus = statuses.get(storyId), nextStatus = {
+            storyId,
+            typeId: CHANGE_DETECTION_STATUS_TYPE_ID,
+            value: mergeStatusValues(existingStatus?.value, value),
+            title: "",
+            description: "",
+            sidebarContextMenu: !1
+          };
+          statuses.set(storyId, mergeChangeDetectionStatuses(existingStatus, nextStatus));
+        });
+      }
+    }
+    return baselineStatuses.forEach((status, storyId) => {
+      statuses.set(storyId, mergeChangeDetectionStatuses(statuses.get(storyId), status));
+    }), statuses;
+  }
+  getGitDiffProvider() {
+    return this.gitDiffProvider ??= new GitDiffProvider(this.workingDir), this.gitDiffProvider;
+  }
+  getIndexBaselineService() {
+    return this.indexBaselineService ??= new IndexBaselineService({
+      storyIndexGeneratorPromise: this.options.storyIndexGeneratorPromise,
+      gitDiffProvider: this.getGitDiffProvider(),
+      onBaselineUpdated: () => this.scheduleScan(this.debounceMs)
+    }), this.indexBaselineService;
+  }
+  applyStatusStorePatch(nextStatuses) {
+    let removedStoryIds = Array.from(this.previousStatuses.keys()).filter(
+      (storyId) => !nextStatuses.has(storyId)
+    ), changedStatuses = Array.from(nextStatuses.values()).filter(
+      (status) => !isSameStatus(this.previousStatuses.get(status.storyId), status)
+    );
+    removedStoryIds.length === 0 && changedStatuses.length === 0 || (removedStoryIds.length > 0 && this.options.statusStore.unset(removedStoryIds), changedStatuses.length > 0 && this.options.statusStore.set(changedStatuses), this.previousStatuses = new Map(nextStatuses));
+  }
+  resolveReadiness(readiness) {
+    this.readinessResolved || (this.readinessResolved = !0, setChangeDetectionReadiness(readiness));
+  }
+};
+
+// src/core-server/utils/doTelemetry.ts
+import { getPrecedingUpgrade as getPrecedingUpgrade2, telemetry as telemetry3 } from "@aussieljk/forkbook/internal/telemetry";
+
+// src/core-server/utils/versionStatus.ts
+var versionStatus = (versionCheck) => versionCheck.error ? "error" : versionCheck.cached ? "cached" : "success";
+
+// src/core-server/utils/doTelemetry.ts
+async function doTelemetry(app, core, storyIndexGeneratorPromise, options) {
+  let { versionCheck, versionUpdates } = options;
+  invariant(
+    !versionUpdates || versionUpdates && versionCheck,
+    "versionCheck should be defined when versionUpdates is true"
+  ), telemetry3(
+    "dev",
+    async () => {
+      let generator = await storyIndexGeneratorPromise, indexAndStats;
+      try {
+        indexAndStats = await generator?.getIndexAndStats();
+      } catch (err) {
+        return { error: err instanceof Error ? err : new Error("encountered a non-recoverable error") };
+      }
+      let payload = {
+        precedingUpgrade: await getPrecedingUpgrade2()
+      };
+      return indexAndStats && Object.assign(payload, {
+        versionStatus: versionUpdates && versionCheck ? versionStatus(versionCheck) : "disabled",
+        storyIndex: summarizeIndex(indexAndStats.storyIndex),
+        storyStats: indexAndStats.stats
+      }), payload;
+    },
+    { configDir: options.configDir }
+  );
+}
+
+// src/core-server/utils/get-caching-middleware.ts
+function getCachingMiddleware() {
+  return (req, res, next) => {
+    res.setHeader("Cache-Control", "no-store"), next();
+  };
+}
+
+// src/core-server/utils/getAccessControlMiddleware.ts
+function getAccessControlMiddleware(crossOriginIsolated) {
+  return (req, res, next) => {
+    crossOriginIsolated && (res.setHeader("Cross-Origin-Opener-Policy", "same-origin"), res.setHeader("Cross-Origin-Embedder-Policy", "require-corp")), next();
+  };
+}
+
+// src/core-server/utils/getHostValidationMiddleware.ts
+import net2 from "node:net";
+import os from "node:os";
+
+// ../../node_modules/host-validation-middleware/dist/index.js
+import net from "node:net";
+function extractHostNameFromHostHeader(hostHeader) {
+  let trimmedHost = hostHeader.trim();
+  if (trimmedHost[0] === "[") {
+    let endIpv6 = trimmedHost.indexOf("]");
+    return endIpv6 < 0 ? { type: "invalid" } : net.isIP(trimmedHost.slice(1, endIpv6)) === 6 ? { type: "ipv6" } : { type: "invalid" };
+  }
+  let colonPos = trimmedHost.indexOf(":"), hostname = colonPos === -1 ? trimmedHost : trimmedHost.slice(0, colonPos);
+  return net.isIP(hostname) === 4 ? { type: "ipv4" } : {
+    type: "hostname",
+    value: hostname
+  };
+}
+var isFileOrExtensionProtocolRE = /^(?:file|.+-extension):/i;
+function isHostAllowedInternal(hostHeader, allowedHosts) {
+  if (isFileOrExtensionProtocolRE.test(hostHeader)) return !0;
+  let extracted = extractHostNameFromHostHeader(hostHeader);
+  if (extracted.type === "invalid") return !1;
+  if (extracted.type === "ipv4" || extracted.type === "ipv6") return !0;
+  let hostname = extracted.value;
+  if (hostname === "localhost" || hostname.endsWith(".localhost")) return !0;
+  for (let allowedHost of allowedHosts)
+    if (allowedHost === hostname || allowedHost[0] === "." && (allowedHost.slice(1) === hostname || hostname.endsWith(allowedHost))) return !0;
+  return !1;
+}
+var cache = /* @__PURE__ */ new WeakMap();
+function isHostAllowed(hostHeader, allowedHosts) {
+  if (hostHeader === void 0) return !0;
+  let cachedAllowedHosts;
+  if (Object.isFrozen(allowedHosts) && (cache.has(allowedHosts) || cache.set(allowedHosts, /* @__PURE__ */ new Set()), cachedAllowedHosts = cache.get(allowedHosts), cachedAllowedHosts.has(hostHeader)))
+    return !0;
+  let result = isHostAllowedInternal(hostHeader, allowedHosts);
+  return cachedAllowedHosts && result && cachedAllowedHosts.add(hostHeader), result;
+}
+
+// src/core-server/utils/getHostValidationMiddleware.ts
+var DEFAULT_ALLOWED_HOSTS = [], stripBrackets = (hostname) => hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname, toCanonicalIp = (value) => {
+  let ip = stripBrackets(value), version = net2.isIP(ip);
+  if (version)
+    try {
+      return stripBrackets(new URL(version === 6 ? `http://[${ip}]` : `http://${ip}`).hostname);
+    } catch {
+      return;
+    }
+}, ifaces = os.networkInterfaces(), ownAddresses, getOwnAddresses = () => {
+  if (!ownAddresses) {
+    ownAddresses = /* @__PURE__ */ new Set();
+    for (let iface of Object.values(ifaces).flat()) {
+      let ip = iface && toCanonicalIp(iface.address);
+      ip && ownAddresses.add(ip);
+    }
+  }
+  return ownAddresses;
+}, isOwnAddress = (ip) => getOwnAddresses().has(ip), isValidHost = (host, options) => {
+  let allowedHosts = options.allowedHosts ?? DEFAULT_ALLOWED_HOSTS;
+  if (allowedHosts === !0)
+    return !0;
+  if (!host)
+    return !1;
+  try {
+    if (options.host === "0.0.0.0" && allowedHosts.length === 0)
+      return !0;
+    let knownHosts = [
+      ...allowedHosts,
+      ...options.host ? [options.host] : [],
+      ...options.localAddress ? [new URL(options.localAddress).hostname] : [],
+      ...options.networkAddress ? [new URL(options.networkAddress).hostname] : []
+    ], { hostname } = new URL(`http://${host}`);
+    if (matchesHostname(hostname, LOOPBACK_HOSTNAMES))
+      return !0;
+    let ip = toCanonicalIp(hostname);
+    return ip ? knownHosts.some((known) => toCanonicalIp(known) === ip) || isOwnAddress(ip) : isHostAllowed(host, knownHosts);
+  } catch {
+    return !1;
+  }
+};
+function getHostValidationMiddleware(options) {
+  return (req, res, next) => {
+    let host = req.headers.host;
+    if ((options.allowedHosts ?? DEFAULT_ALLOWED_HOSTS) !== !0 && !isValidHost(host, options)) {
+      res.writeHead(403, { "Content-Type": "text/plain" }), res.end("Invalid host");
+      return;
+    }
+    next();
+  };
+}
+
+// src/core-server/utils/getSecurityHeadersMiddleware.ts
+var FRAME_ANCESTORS = [
+  "'self'",
+  ...LOOPBACK_HOSTNAMES.map((hostname) => `http://${hostname}:*`)
+].join(" ");
+function getSecurityHeadersMiddleware(security) {
+  return security?.insecureRemoteIframeEmbed ? (req, res, next) => next() : (req, res, next) => {
+    res.appendHeader("Content-Security-Policy", `frame-ancestors ${FRAME_ANCESTORS}`), next();
+  };
+}
+
+// src/core-server/utils/middleware.ts
+import { existsSync } from "node:fs";
+import { resolve as resolve4 } from "pathe";
+var fileExists = (basename4) => [".js", ".mjs", ".cjs"].reduce((found, ext) => {
+  let filename = `${basename4}${ext}`;
+  return !found && existsSync(filename) ? filename : found;
+}, "");
+async function getMiddleware(configDir) {
+  let middlewarePath = fileExists(resolve4(configDir, "middleware"));
+  if (middlewarePath) {
+    let middlewareModule = await import("file://" + middlewarePath);
+    return middlewareModule.default ?? middlewareModule;
+  }
+  return () => {
+  };
+}
+
+// src/core-server/utils/open-browser/open-in-browser.ts
+import { logger as logger9 } from "@aussieljk/forkbook/internal/node-logger";
+import open2 from "open";
+import { dedent } from "ts-dedent";
+
+// src/core-server/utils/open-browser/opener.ts
+var import_cross_spawn = __toESM(require_cross_spawn(), 1), import_picocolors4 = __toESM(require_picocolors(), 1);
+import { execSync } from "node:child_process";
+import { join as join6 } from "node:path";
+import { logger as logger8 } from "@aussieljk/forkbook/internal/node-logger";
+import open from "open";
+var OSX_CHROME = "google chrome";
+function getBrowserEnv() {
+  let value = process.env.BROWSER, args = process.env.BROWSER_ARGS ? process.env.BROWSER_ARGS.split(" ") : [];
+  return value ? value.toLowerCase() === "none" ? { action: 0 /* NONE */ } : value.toLowerCase().endsWith(".js") || value.toLowerCase().endsWith(".mjs") || value.toLowerCase().endsWith(".cjs") || value.toLowerCase().endsWith(".ts") ? { action: 2 /* SCRIPT */, value, args } : value.toLowerCase().endsWith(".sh") ? { action: 3 /* SHELL_SCRIPT */, value, args } : { action: 1 /* BROWSER */, value, args } : { action: 1 /* BROWSER */, args };
+}
+var BrowserEnvError = class extends StorybookError {
+  constructor(message) {
+    super({
+      category: "CORE_SERVER",
+      code: 1,
+      message,
+      name: "BrowserEnvError"
+    });
+  }
+};
+function attachEventHandlers(child, scriptPath) {
+  child.on("error", (error) => {
+    logger8.error(
+      `Failed to run script specified in BROWSER.
+${import_picocolors4.default.cyan(scriptPath)}: ${error.message}`
+    );
+  }), child.on("close", (code) => {
+    if (code !== 0) {
+      logger8.error(
+        `The script specified as BROWSER environment variable failed.
+${import_picocolors4.default.cyan(scriptPath)} exited with code ${code}.`
+      );
+      return;
+    }
+  });
+}
+function executeNodeScript(scriptPath, url) {
+  let extraArgs = process.argv.slice(2), child = (0, import_cross_spawn.default)(process.execPath, [scriptPath, ...extraArgs, url], {
+    stdio: "inherit"
+  });
+  return attachEventHandlers(child, scriptPath), !0;
+}
+function executeShellScript(scriptPath, url) {
+  let extraArgs = process.argv.slice(2), child = (0, import_cross_spawn.default)("sh", [scriptPath, ...extraArgs, url], {
+    stdio: "inherit"
+  });
+  return attachEventHandlers(child, scriptPath), !0;
+}
+function startBrowserProcess(browser, url, args) {
+  if (process.platform === "darwin" && (typeof browser != "string" || browser === OSX_CHROME)) {
+    let supportedChromiumBrowsers = [
+      "Google Chrome Canary",
+      "Google Chrome Dev",
+      "Google Chrome Beta",
+      "Google Chrome",
+      "Microsoft Edge",
+      "Brave Browser",
+      "Vivaldi",
+      "Chromium"
+    ];
+    for (let chromiumBrowser of supportedChromiumBrowsers)
+      try {
+        execSync(`ps cax | grep "${chromiumBrowser}"`);
+        let command = `osascript "${join6(
+          resolvePackageDir("@aussieljk/forkbook"),
+          "assets",
+          "server",
+          "openBrowser.applescript"
+        )}" "`.concat(encodeURI(url), '" "').concat(
+          process.env.OPEN_MATCH_HOST_ONLY === "true" ? encodeURI(new URL(url).origin) : encodeURI(url),
+          '" "'
+        ).concat(chromiumBrowser, '"');
+        return execSync(command, {
+          cwd: __dirname
+        }), !0;
+      } catch {
+      }
+  }
+  process.platform === "darwin" && browser === "open" && (browser = void 0);
+  try {
+    return open(url, {
+      app: browser ? { name: browser, arguments: args } : void 0,
+      wait: !1,
+      url: !0
+    }).catch(() => {
+    }), !0;
+  } catch {
+    return !1;
+  }
+}
+function openBrowser(url) {
+  let { action, value, args } = getBrowserEnv(), canRunShell = process.platform !== "win32";
+  switch (action) {
+    case 0 /* NONE */:
+      return !1;
+    case 2 /* SCRIPT */:
+      return executeNodeScript(value, url);
+    case 3 /* SHELL_SCRIPT */: {
+      if (canRunShell)
+        return executeShellScript(value, url);
+      throw new BrowserEnvError(
+        "Shell scripts are not supported on Windows PowerShell. Use WSL instead."
+      );
+    }
+    case 1 /* BROWSER */:
+      return startBrowserProcess(value, url, args);
+    default:
+      throw new BrowserEnvError("Not implemented.");
+  }
+}
+
+// src/core-server/utils/open-browser/open-in-browser.ts
+async function openInBrowser(address) {
+  let errorOccurred = !1, openBrowserResult;
+  try {
+    openBrowserResult = await openBrowser(address);
+  } catch {
+    errorOccurred = !0;
+  }
+  if (openBrowserResult !== !1) {
+    try {
+      errorOccurred && (await open2(address), errorOccurred = !1);
+    } catch {
+      errorOccurred = !0;
+    }
+    if (errorOccurred) {
+      let browserEnv = process.env.BROWSER, browserHint = browserEnv ? `
+
+Note: BROWSER environment variable is set to "${browserEnv}". To disable browser opening, use BROWSER=none or the --ci flag.` : "";
+      logger9.error(dedent`
+        Could not open ${address} inside a browser. If you're running this command inside a
+        docker container or on a CI, you need to pass the '--ci' flag to prevent opening a
+        browser by default.${browserHint}
+      `);
+    }
+  }
+}
+
+// src/core-server/utils/server-address.ts
+var import_detect_port = __toESM(require_detect_port2(), 1);
+import net3 from "node:net";
+import os2 from "node:os";
+import { SERVER_CHANNEL_PATH as SERVER_CHANNEL_PATH2 } from "@aussieljk/forkbook/internal/channels";
+import { logger as logger10 } from "@aussieljk/forkbook/internal/node-logger";
+import { NoFreePortError } from "@aussieljk/forkbook/internal/server-errors";
+var getListenHost = (host) => host || "127.0.0.1", COVERS_LOOPBACK = /* @__PURE__ */ new Set(["127.0.0.1", "0.0.0.0", "::"]), addLoopbackListener = async (server) => {
+  let { address, port } = server.address();
+  if (COVERS_LOOPBACK.has(address))
+    return;
+  let loopback = net3.createServer((socket) => server.emit("connection", socket));
+  return server.once("close", () => loopback.close()), await new Promise((resolve9, reject) => {
+    loopback.once("error", reject), loopback.listen({ port, host: "127.0.0.1" }, resolve9);
+  }), loopback;
+};
+function getServerAddresses(port, host, proto, initialPath) {
+  let address = new URL(`${proto}://127.0.0.1:${port}/`), networkAddress = new URL(`${proto}://${host || getLocalIp()}:${port}/`);
+  if (initialPath) {
+    let searchParams = `?path=${decodeURIComponent(
+      initialPath.startsWith("/") ? initialPath : `/${initialPath}`
+    )}`;
+    address.search = searchParams, networkAddress.search = searchParams;
+  }
+  return {
+    address: address.href,
+    networkAddress: networkAddress.href
+  };
+}
+var getServerPort = (port, { exactPort } = {}) => (0, import_detect_port.default)(port).catch((error) => {
+  logger10.error(error), process.exit(-1);
+}).then((freePort) => {
+  if (!freePort)
+    throw new NoFreePortError({ requestedPort: port });
+  return exactPort && port != null && freePort !== port && (logger10.error(`Port ${port} is not available. Exiting because --exact-port was provided.`), process.exit(-1)), freePort;
+}), getServerChannelUrl = (port, { https: https2 }) => `${https2 ? "wss" : "ws"}://127.0.0.1:${port}${SERVER_CHANNEL_PATH2}`, getExternalIpv4Addresses = () => Object.values(os2.networkInterfaces()).flat().filter((ip) => ip && ip.family === "IPv4" && !ip.internal).map((ip) => ip.address), getLocalIp = () => getExternalIpv4Addresses()[0] ?? "0.0.0.0", getReachableNetworkAddresses = (networkAddress) => {
+  if (new URL(networkAddress).hostname !== "0.0.0.0")
+    return [networkAddress];
+  let addresses = getExternalIpv4Addresses().map((ip) => {
+    let url = new URL(networkAddress);
+    return url.hostname = ip, url.href;
+  });
+  return addresses.length ? addresses : [networkAddress];
+};
+
+// src/core-server/dev-server.ts
+async function storybookDevServer(options, server) {
+  let core = await options.presets.apply("core"), security = await options.presets.apply("security"), app = build_default2({ server }), workingDir = process.cwd(), configDir = options.configDir, features = await options.presets.apply("features"), stories = await options.presets.apply("stories"), normalizedStories = normalizeStories(stories, {
+    configDir,
+    workingDir
+  }), storyIndexGeneratorPromise = withSpan(
+    "forkbook.story-index",
+    {},
+    () => options.presets.apply("storyIndexGenerator")
+  ), changeDetectionService = new ChangeDetectionService({
+    storyIndexGeneratorPromise,
+    statusStore: getStatusStoreByTypeId(CHANGE_DETECTION_STATUS_TYPE_ID2),
+    workingDir
+  }), disposeChangeDetectionRuntime = async () => {
+    await changeDetectionService.dispose().catch(() => {
+    });
+  };
+  if (app.use(build_default({ level: 1 })), typeof options.extendServer == "function" && options.extendServer(server), app.use(
+    getHostValidationMiddleware({
+      host: options.host,
+      allowedHosts: core?.allowedHosts,
+      localAddress: options.localAddress,
+      networkAddress: options.networkAddress
+    })
+  ), app.use(getAccessControlMiddleware(core?.crossOriginIsolated ?? !1)), app.use(getSecurityHeadersMiddleware(security)), app.use(getCachingMiddleware()), registerIndexJsonRoute({
+    app,
+    storyIndexGeneratorPromise,
+    normalizedStories,
+    channel: options.channel,
+    workingDir,
+    configDir
+  }), (await getMiddleware(options.configDir))(app), await options.presets.apply("experimental_devServer", app), !core?.builder)
+    throw new MissingBuilderError();
+  let resolvedPreviewBuilder = typeof core?.builder == "string" ? core.builder : core?.builder?.name, [previewBuilder, managerBuilder] = await Promise.all([
+    getPreviewBuilder(resolvedPreviewBuilder),
+    getManagerBuilder(),
+    useStatics(app, options)
+  ]);
+  options.debugWebpack && logConfig2("Preview webpack config", await previewBuilder.getConfig(options)), core?.disableProjectJson || useStorybookMetadata(app, options.configDir);
+  let managerResult = options.previewOnly ? void 0 : await withSpan(
+    "forkbook.manager-start",
+    {},
+    () => managerBuilder.start({
+      startTime: process.hrtime(),
+      options,
+      router: app,
+      server,
+      channel: options.channel
+    })
+  ), previewResult = await Promise.resolve();
+  logger11.debug("Starting preview.."), previewResult = await withSpan(
+    "forkbook.preview-start",
+    {},
+    () => previewBuilder.start({
+      startTime: process.hrtime(),
+      options,
+      router: app,
+      server,
+      channel: options.channel
+    }).catch(async (e) => {
+      throw logger11.error("Failed to build the preview"), process.exitCode = 1, await disposeChangeDetectionRuntime(), await managerBuilder?.bail().catch(() => {
+      }), await previewBuilder?.bail().catch(() => {
+      }), e;
+    })
+  );
+  let adapter;
+  try {
+    adapter = previewBuilder.changeDetectionAdapter?.();
+  } catch (err) {
+    logger11.warn("Change detection: adapter initialisation failed"), logger11.debug(err instanceof Error ? err.stack ?? err.message : String(err));
+  }
+  resolveChangeDetectionAdapter(adapter), changeDetectionService.start();
+  let listening = new Promise((resolve9, reject) => {
+    server.once("error", reject), app.listen({ port: options.port, host: getListenHost(options.host) }, resolve9);
+  }).then(() => addLoopbackListener(server));
+  try {
+    let [indexGenerator] = await Promise.all([storyIndexGeneratorPromise, listening]);
+    if (indexGenerator && !options.ci && !options.smokeTest && options.open) {
+      let url = options.host && options.host !== "0.0.0.0" ? options.networkAddress : options.localAddress;
+      openInBrowser(options.previewOnly ? `${url}iframe.html?navigator=true` : url).catch(() => {
+      });
+    }
+  } catch (e) {
+    throw await disposeChangeDetectionRuntime(), await managerBuilder?.bail().catch(() => {
+    }), await previewBuilder?.bail().catch(() => {
+    }), e;
+  }
+  features?.componentsManifest && registerManifests({ app, presets: options.presets }), doTelemetry(app, core, storyIndexGeneratorPromise, options);
+  async function cancelTelemetry() {
+    try {
+      if (!isTelemetryModuleEnabled())
+        return;
+      let payload = { eventType: "dev" };
+      try {
+        let indexAndStats = await (await storyIndexGeneratorPromise)?.getIndexAndStats();
+        indexAndStats && Object.assign(payload, {
+          storyIndex: summarizeIndex(indexAndStats.storyIndex),
+          storyStats: indexAndStats.stats
+        });
+      } catch {
+      }
+      await telemetry("canceled", payload, { immediate: !0 });
+    } finally {
+      await disposeChangeDetectionRuntime(), process.exit(0);
+    }
+  }
+  return process.on("SIGINT", cancelTelemetry), process.on("SIGTERM", cancelTelemetry), { previewResult, managerResult };
+}
+
+// src/core-server/utils/get-server-channel.ts
+var import_telejson2 = __toESM(require_dist(), 1);
+import {
+  Channel as Channel3,
+  HEARTBEAT_INTERVAL as HEARTBEAT_INTERVAL2,
+  SERVER_CHANNEL_PATH as SERVER_CHANNEL_PATH3,
+  setChannel as setChannel2
+} from "@aussieljk/forkbook/internal/channels";
+import { WebSocket, WebSocketServer } from "ws";
+
+// src/core-server/utils/event-senders.ts
+import events from "@aussieljk/forkbook/internal/core-events";
+var CORE_EVENT_SENDERS = {
+  [events.CHANNEL_WS_DISCONNECT]: "any",
+  [events.CHANNEL_CREATED]: "manager",
+  [events.CONFIG_ERROR]: "preview",
+  [events.STORY_INDEX_INVALIDATED]: "server",
+  [events.STORY_SPECIFIED]: "preview",
+  [events.SET_CONFIG]: "manager",
+  [events.SET_STORIES]: "preview",
+  [events.SET_INDEX]: "preview",
+  [events.SET_CURRENT_STORY]: "manager",
+  [events.CURRENT_STORY_WAS_SET]: "preview",
+  [events.FORCE_RE_RENDER]: "any",
+  [events.FORCE_REMOUNT]: "any",
+  [events.PRELOAD_ENTRIES]: "manager",
+  [events.STORY_PREPARED]: "preview",
+  [events.DOCS_PREPARED]: "preview",
+  [events.STORY_CHANGED]: "preview",
+  [events.STORY_UNCHANGED]: "preview",
+  [events.STORY_RENDERED]: "preview",
+  [events.STORY_FINISHED]: "preview",
+  [events.STORY_MISSING]: "preview",
+  [events.STORY_ERRORED]: "preview",
+  [events.STORY_THREW_EXCEPTION]: "preview",
+  [events.STORY_RENDER_PHASE_CHANGED]: "preview",
+  [events.STORY_HOT_UPDATED]: "any",
+  [events.PLAY_FUNCTION_THREW_EXCEPTION]: "preview",
+  [events.UNHANDLED_ERRORS_WHILE_PLAYING]: "preview",
+  [events.UPDATE_STORY_ARGS]: "any",
+  [events.STORY_ARGS_UPDATED]: "preview",
+  [events.RESET_STORY_ARGS]: "any",
+  [events.SET_FILTER]: "manager",
+  [events.SET_GLOBALS]: "preview",
+  [events.UPDATE_GLOBALS]: "any",
+  [events.GLOBALS_UPDATED]: "preview",
+  [events.REGISTER_SUBSCRIPTION]: "any",
+  [events.PREVIEW_INITIALIZED]: "preview",
+  [events.PREVIEW_KEYDOWN]: "preview",
+  [events.PREVIEW_BUILDER_PROGRESS]: "server",
+  [events.SELECT_STORY]: "preview",
+  [events.STORIES_COLLAPSE_ALL]: "manager",
+  [events.STORIES_EXPAND_ALL]: "manager",
+  [events.DOCS_RENDERED]: "preview",
+  [events.SHARED_STATE_CHANGED]: "any",
+  [events.SHARED_STATE_SET]: "any",
+  [events.NAVIGATE_URL]: "any",
+  [events.UPDATE_QUERY_PARAMS]: "manager",
+  [events.REQUEST_WHATS_NEW_DATA]: "manager",
+  [events.RESULT_WHATS_NEW_DATA]: "server",
+  [events.SET_WHATS_NEW_CACHE]: "manager",
+  [events.TOGGLE_WHATS_NEW_NOTIFICATIONS]: "manager",
+  [events.TELEMETRY_ERROR]: "any",
+  [events.SAVE_STORY_REQUEST]: "manager",
+  [events.SAVE_STORY_RESPONSE]: "server",
+  [events.ARGTYPES_INFO_REQUEST]: "manager",
+  [events.ARGTYPES_INFO_RESPONSE]: "preview",
+  [events.GHOST_STORIES_REQUEST]: "manager",
+  [events.GHOST_STORIES_RESPONSE]: "server",
+  [events.AI_SETUP_ANALYTICS_RESPONSE]: "server",
+  [events.AI_SETUP_ANALYTICS_REQUEST]: "server",
+  [events.OPEN_IN_EDITOR_REQUEST]: "manager",
+  [events.OPEN_IN_EDITOR_RESPONSE]: "server",
+  [events.MANAGER_INERT_ATTRIBUTE_CHANGED]: "manager",
+  [events.SHARE_ISOLATE_MODE]: "manager",
+  [events.AI_PROMPT_NUDGE]: "manager",
+  [events.SIDEBAR_FILTER_CHANGED]: "manager"
+};
+
+// src/core-server/utils/validate-token.ts
+import { timingSafeEqual } from "node:crypto";
+function isValidToken(requestToken, expectedToken) {
+  if (!requestToken || !expectedToken)
+    return !1;
+  let a = new Uint8Array(Buffer.from(requestToken, "utf8")), b = new Uint8Array(Buffer.from(expectedToken, "utf8"));
+  try {
+    return a.length === b.length && timingSafeEqual(a, b);
+  } catch {
+    return !1;
+  }
+}
+
+// src/core-server/utils/get-server-channel.ts
+var ServerChannelTransport = class {
+  constructor(server, options) {
+    this.closed = !1;
+    this.onSigterm = () => {
+      this.socket.clients.forEach((client) => {
+        client.readyState === WebSocket.OPEN && client.close(1001, "Server is shutting down");
+      }), this.socket.close(() => process.exit(0));
+    };
+    this.rejectedEvents = /* @__PURE__ */ new Set();
+    this.socket = new WebSocketServer({ noServer: !0 }), server.on("upgrade", (request, socket, head) => {
+      try {
+        let url = request.url && new URL(request.url, options.localAddress);
+        if (!url || url.pathname !== SERVER_CHANNEL_PATH3)
+          return;
+        if (!options.skipValidation) {
+          let { origin } = request.headers;
+          if (origin && !isValidHost(new URL(origin).host, options)) {
+            socket.end(`HTTP/1.1 403 Forbidden\r
+Connection: close\r
+\r
+`);
+            return;
+          }
+          let requestToken = url.searchParams.get("token");
+          if (!isValidToken(requestToken, options.token)) {
+            socket.end(`HTTP/1.1 401 Unauthorized\r
+Connection: close\r
+\r
+`);
+            return;
+          }
+        }
+        let page = url.searchParams.get("page");
+        if (page !== null && page !== "manager" && page !== "preview") {
+          socket.end(`HTTP/1.1 400 Bad Request\r
+Connection: close\r
+\r
+`);
+          return;
+        }
+        if (page === null && request.headers.origin !== void 0) {
+          socket.end(`HTTP/1.1 400 Bad Request\r
+Connection: close\r
+\r
+`);
+          return;
+        }
+        let role = page ?? "server";
+        this.socket.handleUpgrade(request, socket, head, (ws) => {
+          this.addClient(ws, role);
+        });
+      } catch (error) {
+        logger.warn(`Rejecting WebSocket connection: ${error}`), socket.end(`HTTP/1.1 403 Forbidden\r
+Connection: close\r
+\r
+`);
+      }
+    });
+    let interval = setInterval(() => {
+      this.send({ type: "ping" });
+    }, HEARTBEAT_INTERVAL2);
+    this.socket.on("close", function() {
+      clearInterval(interval);
+    }), process.on("SIGTERM", this.onSigterm);
+  }
+  close() {
+    this.closed || (this.closed = !0, process.removeListener("SIGTERM", this.onSigterm), this.socket.close());
+  }
+  setHandler(handler) {
+    this.handler = handler;
+  }
+  addClient(ws, role) {
+    ws.on("error", (error) => {
+      logger.warn(`WebSocket error on server channel: ${error}`);
+    }), ws.on("message", (raw) => {
+      let data = raw.toString(), event = typeof data == "string" && (0, import_telejson2.isJSON)(data) ? (0, import_telejson2.parse)(data, {}) : data;
+      this.isEventAllowedFrom(event, role) && this.handler?.(event);
+    });
+  }
+  isEventAllowedFrom(event, role) {
+    let type = typeof event == "object" && event && "type" in event ? event?.type : null;
+    if (typeof type != "string")
+      return !0;
+    let sender = CORE_EVENT_SENDERS[type];
+    if (sender === void 0 || sender === "any" || sender === role)
+      return !0;
+    let key = `${role}:${type}`;
+    return this.rejectedEvents.has(key) || (this.rejectedEvents.add(key), logger.warn(
+      `Ignored "${type}" event from a ${role} connection: only the ${sender} sends this event.`
+    )), !1;
+  }
+  send(event) {
+    let data = (0, import_telejson2.stringify)(event, { maxDepth: 15 });
+    Array.from(this.socket.clients).filter((c) => c.readyState === WebSocket.OPEN).forEach((client) => client.send(data));
+  }
+};
+function getServerChannel(server, options) {
+  let transports = [new ServerChannelTransport(server, options)], channel = new Channel3({ transports, async: !0 });
+  return setChannel2(channel), UniversalStore.__prepare(channel, UniversalStore.Environment.SERVER), channel;
+}
+function prepareHeadlessUniversalStores() {
+  let channel = new Channel3({});
+  return UniversalStore.__prepare(channel, UniversalStore.Environment.SERVER), channel;
+}
+
+// src/core-server/utils/host-validation-warning.ts
+import { cache as cache2, isCI } from "@aussieljk/forkbook/internal/common";
+import { logger as logger12, prompt } from "@aussieljk/forkbook/internal/node-logger";
+import { dedent as dedent2 } from "ts-dedent";
+var DOCS_URL = "https://storybook.js.org/docs/api/main-config/main-config-core#allowedhosts", getHostValidationWarning = ({
+  host,
+  allowedHosts
+}) => {
+  if (allowedHosts === !0)
+    return {
+      id: "allowed-hosts",
+      message: dedent2`
+        Host validation is disabled because core.allowedHosts is set to true.
+        Any website open in your browser can send requests to this Forkbook.
+        Such a website can read your stories and source files. It can also write files in your project through the WebSocket channel and the MCP server.
+
+        Set core.allowedHosts to a list of hostnames in .forkbook/main.ts to restrict access.
+        Learn more: ${DOCS_URL}
+      `
+    };
+  if (host === "0.0.0.0" && (!allowedHosts || allowedHosts.length === 0))
+    return {
+      id: "all-interfaces",
+      message: dedent2`
+        Forkbook is listening on all network interfaces because --host is set to 0.0.0.0.
+        Anyone on your network can open this Forkbook. They can read your stories and source files, and they can write files in your project through the WebSocket channel and the MCP server.
+
+        Remove --host 0.0.0.0 to listen on localhost only. Also set core.allowedHosts to a list of hostnames in .forkbook/main.ts to keep host validation enabled.
+        Learn more: ${DOCS_URL}
+      `
+    };
+}, isInteractiveTerminal = () => !!(process.stdin.isTTY && process.stdout.isTTY) && !isCI();
+async function warnOnDisabledHostValidation(options) {
+  let warning = getHostValidationWarning(options);
+  if (!warning || (logger12.warn(warning.message), options.ci || options.smokeTest || !isInteractiveTerminal()))
+    return;
+  let skipPromptKey = `host-validation-prompt-skipped-${warning.id}-${options.cacheKey}`;
+  if (await cache2.get(skipPromptKey).catch(() => !1))
+    return;
+  let choice = await prompt.select({
+    message: "How do you want to proceed?",
+    options: [
+      {
+        value: "continue",
+        label: "Continue",
+        hint: "Start Forkbook with host validation disabled"
+      },
+      {
+        value: "dont-ask",
+        label: "Continue and don't ask again",
+        hint: "Start Forkbook and skip this question in the future"
+      },
+      { value: "abort", label: "Abort" }
+    ],
+    initialValue: "continue"
+  });
+  choice === "abort" && process.exit(1), choice === "dont-ask" && await cache2.set(skipPromptKey, !0).catch(() => {
+  });
+}
+
+// src/core-server/utils/output-startup-information.ts
+var import_picocolors6 = __toESM(require_picocolors(), 1), import_pretty_hrtime = __toESM(require_pretty_hrtime(), 1);
+import { CLI_COLORS, logger as logger13 } from "@aussieljk/forkbook/internal/node-logger";
+import { dedent as dedent4 } from "ts-dedent";
+
+// src/core-server/utils/update-check.ts
+var import_picocolors5 = __toESM(require_picocolors(), 1);
+import { cache as cache3 } from "@aussieljk/forkbook/internal/common";
+import { colors } from "@aussieljk/forkbook/internal/node-logger";
+import semver from "semver";
+import { dedent as dedent3 } from "ts-dedent";
+var { FORKBOOK_VERSION_BASE = "https://storybook.js.org", CI } = process.env, updateCheck = async (version) => {
+  let result, time = Date.now();
+  try {
+    let fromCache = await cache3.get("lastUpdateCheck", { success: !1, time: 0 });
+    time - 864e5 > fromCache.time && !CI ? (result = { success: !0, cached: !1, data: await (await Promise.race([
+      fetch(`${FORKBOOK_VERSION_BASE}/versions.json?current=${version}`),
+      // if fetch is too slow, we won't wait for it
+      new Promise((res, rej) => global.setTimeout(rej, 1500))
+    ])).json(), time }, await cache3.set("lastUpdateCheck", result)) : result = { ...fromCache, cached: !0 };
+  } catch (error) {
+    result = { success: !1, cached: !1, error, time };
+  }
+  return result;
+};
+function createUpdateMessage(updateInfo, version) {
+  let updateMessage;
+  try {
+    let upgradeCommand = `npx storybook@${semver.prerelease(updateInfo.data.latest.version) ? "next" : "latest"} upgrade`;
+    updateMessage = updateInfo.success && semver.lt(version, updateInfo.data.latest.version) ? dedent3`
+          ${colors.orange(
+      `A new version (${import_picocolors5.default.bold(updateInfo.data.latest.version)}) is available!`
+    )}
+
+          ${import_picocolors5.default.gray("Upgrade now:")} ${colors.green(upgradeCommand)}
+
+          ${import_picocolors5.default.gray("Read full changelog:")} ${import_picocolors5.default.gray(
+      import_picocolors5.default.underline("https://github.com/storybookjs/storybook/blob/main/CHANGELOG.md")
+    )}
+        ` : "";
+  } catch {
+    updateMessage = "";
+  }
+  return updateMessage;
+}
+
+// src/core-server/utils/output-startup-information.ts
+function outputStartupInformation(options) {
+  let {
+    updateInfo,
+    version,
+    name,
+    address,
+    host,
+    networkAddress,
+    allowedHosts,
+    managerTotalTime,
+    previewTotalTime
+  } = options, otherAllowedHosts = allowedHosts === !0 ? "all (insecure)" : allowedHosts?.length ? allowedHosts.join(", ") : void 0, updateMessage = createUpdateMessage(updateInfo, version), networkLabel = "- On your network:      ", serverMessages = [
+    `- Local:                ${address}`,
+    host ? networkLabel + getReachableNetworkAddresses(networkAddress).join(`
+${" ".repeat(networkLabel.length)}`) : `${networkLabel}run with --host <ip> to expose to local network`,
+    otherAllowedHosts && `- Other allowed hosts:  ${otherAllowedHosts}`
+  ];
+  logger13.logBox(
+    dedent4`
+      Forkbook ready!
+
+      ${serverMessages.join(`
+`)}${updateMessage ? `
+
+${updateMessage}` : ""}
+    `,
+    {
+      formatBorder: CLI_COLORS.storybook,
+      contentPadding: 3,
+      rounded: !0
+    }
+  );
+  let timeStatement = [
+    managerTotalTime && `${import_picocolors6.default.underline((0, import_pretty_hrtime.default)(managerTotalTime))} for manager`,
+    previewTotalTime && `${import_picocolors6.default.underline((0, import_pretty_hrtime.default)(previewTotalTime))} for preview`
+  ].filter(Boolean).join(" and ");
+  logger13.info(timeStatement);
+}
+
+// src/core-server/utils/runtime-instance-registry.ts
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync as existsSync2, rmSync } from "node:fs";
+import { chmod, mkdir as mkdir2, readFile, readdir, rename, rm as rm2, stat, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir, userInfo } from "node:os";
+import { findStorybookPackageRoot, normalizeAddonName } from "@aussieljk/forkbook/internal/common";
+import { join as join7, resolve as resolve5 } from "pathe";
+var FORKBOOK_MCP_ADDON = "@aussieljk/forkbook/addon-mcp", DEFAULT_MCP_ENDPOINT = "/mcp", ONE_DAY_MS = 1440 * 60 * 1e3, SEVEN_DAYS_MS = 7 * ONE_DAY_MS, REGISTRY_DIR_MODE = 448, RECORD_FILE_MODE = 384;
+function execFileAsync(file, args) {
+  return new Promise((resolveExec, rejectExec) => {
+    execFile(file, [...args], (error) => {
+      if (error) {
+        rejectExec(error);
+        return;
+      }
+      resolveExec();
+    });
+  });
+}
+async function restrictOwnerAccess(targetPath, mode) {
+  if (await chmod(targetPath, mode), process.platform !== "win32")
+    return;
+  let { username } = userInfo();
+  try {
+    await execFileAsync("icacls", [targetPath, "/inheritance:r", "/grant:r", `${username}:(F)`]);
+  } catch (error) {
+    throw new Error(
+      `Could not restrict ${targetPath} to the current Windows user. The instance record would be readable by other accounts.`,
+      { cause: error }
+    );
+  }
+}
+function getDefaultRuntimeInstanceRegistryDir() {
+  return join7(homedir(), ".forkbook", "instances");
+}
+function getStorybookBaseUrl(address) {
+  let url = new URL(address);
+  return `${url.origin}${url.pathname.replace(/\/$/, "")}`;
+}
+function getMcpMetadataFromMainConfig(mainConfig) {
+  let addon = mainConfig.addons?.find(
+    (entry) => normalizeAddonName(entry) === FORKBOOK_MCP_ADDON
+  );
+  return addon ? { status: "ready", endpoint: typeof addon == "object" && typeof addon.options?.endpoint == "string" ? addon.options.endpoint : DEFAULT_MCP_ENDPOINT } : { status: "not-installed" };
+}
+function detectRuntimeInstanceAgent() {
+  return isClaudePreviewLaunch() ? CLAUDE_PREVIEW_AGENT_NAME : detectAgent()?.name;
+}
+function createRuntimeInstanceRecord({
+  address,
+  agent,
+  configDir,
+  cwd = process.cwd(),
+  instanceId = randomUUID(),
+  mcp = { status: "not-installed" },
+  now = /* @__PURE__ */ new Date(),
+  pid = process.pid,
+  port,
+  storybookPath = findStorybookPackageRoot(),
+  storybookVersion,
+  token
+}) {
+  let storybookBaseUrl = getStorybookBaseUrl(address), timestamp = now.toISOString();
+  return {
+    schemaVersion: 1,
+    instanceId,
+    pid,
+    cwd: resolve5(cwd),
+    ...configDir ? { configDir: resolve5(cwd, configDir) } : {},
+    url: storybookBaseUrl,
+    port,
+    ...token ? { token } : {},
+    ...agent ? { agent } : {},
+    storybookVersion,
+    ...storybookPath ? { storybookPath } : {},
+    startedAt: timestamp,
+    updatedAt: timestamp,
+    mcp
+  };
+}
+async function writeRuntimeInstanceRecord(record, registryDir = getDefaultRuntimeInstanceRegistryDir()) {
+  await mkdir2(registryDir, { recursive: !0, mode: REGISTRY_DIR_MODE }), await restrictOwnerAccess(registryDir, REGISTRY_DIR_MODE), await cleanupRuntimeInstanceRegistry(registryDir);
+  let recordPath = join7(registryDir, `${record.instanceId}.json`), tempPath = join7(
+    registryDir,
+    `${record.instanceId}.${record.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`
+  );
+  try {
+    await writeFile3(tempPath, `${JSON.stringify(record, null, 2)}
+`, {
+      encoding: "utf-8",
+      mode: RECORD_FILE_MODE
+    }), await restrictOwnerAccess(tempPath, RECORD_FILE_MODE), await rename(tempPath, recordPath);
+  } catch (error) {
+    throw await rm2(tempPath, { force: !0 }).catch(() => {
+    }), error;
+  }
+  return recordPath;
+}
+function isRecordObject(value) {
+  return typeof value == "object" && value !== null;
+}
+function getTimestampMs(record, key) {
+  let value = record[key];
+  if (typeof value != "string")
+    return;
+  let timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? timestamp : void 0;
+}
+function getRecordAgeMs(record, fileModifiedAtMs, nowMs) {
+  let recordTimestampMs = isRecordObject(record) ? getTimestampMs(record, "updatedAt") ?? getTimestampMs(record, "startedAt") : void 0;
+  return nowMs - (recordTimestampMs ?? fileModifiedAtMs);
+}
+function getRecordPid(record) {
+  if (!(!isRecordObject(record) || typeof record.pid != "number"))
+    return Number.isInteger(record.pid) && record.pid > 0 ? record.pid : void 0;
+}
+function isErrnoException(error) {
+  return typeof error == "object" && error !== null && "code" in error;
+}
+function getRuntimeInstanceRegistryCleanupDecision(entry) {
+  if (entry.kind === "temp-file")
+    return entry.nowMs - entry.fileModifiedAtMs > ONE_DAY_MS ? { action: "remove" } : { action: "keep" };
+  if (entry.kind === "malformed-json")
+    return entry.nowMs - entry.fileModifiedAtMs > SEVEN_DAYS_MS ? { action: "remove" } : { action: "keep" };
+  let recordAgeMs = getRecordAgeMs(entry.record, entry.fileModifiedAtMs, entry.nowMs);
+  if (recordAgeMs > SEVEN_DAYS_MS)
+    return { action: "remove" };
+  if (recordAgeMs < ONE_DAY_MS)
+    return { action: "keep" };
+  let recordPid = getRecordPid(entry.record);
+  return recordPid === void 0 ? { action: "keep" } : { action: "check-pid", pid: recordPid };
+}
+function isPidInactive(pid) {
+  try {
+    return process.kill(pid, 0), !1;
+  } catch (error) {
+    return isErrnoException(error) && error.code === "ESRCH";
+  }
+}
+async function applyCleanupDecision(recordPath, decision) {
+  (decision.action === "remove" || decision.action === "check-pid" && isPidInactive(decision.pid)) && await rm2(recordPath, { force: !0 });
+}
+async function cleanupRuntimeInstanceRegistry(registryDir) {
+  let nowMs = Date.now(), entries = await readdir(registryDir, { withFileTypes: !0 }).catch(() => []);
+  await Promise.all(
+    entries.map(async (entry) => {
+      if (!entry.isFile())
+        return;
+      let recordPath = join7(registryDir, entry.name);
+      try {
+        let { mtimeMs } = await stat(recordPath);
+        if (entry.name.endsWith(".tmp")) {
+          await applyCleanupDecision(
+            recordPath,
+            getRuntimeInstanceRegistryCleanupDecision({
+              kind: "temp-file",
+              fileModifiedAtMs: mtimeMs,
+              nowMs
+            })
+          );
+          return;
+        }
+        if (!entry.name.endsWith(".json"))
+          return;
+        let content = await readFile(recordPath, "utf-8"), record;
+        try {
+          record = JSON.parse(content);
+        } catch {
+          await applyCleanupDecision(
+            recordPath,
+            getRuntimeInstanceRegistryCleanupDecision({
+              kind: "malformed-json",
+              fileModifiedAtMs: mtimeMs,
+              nowMs
+            })
+          );
+          return;
+        }
+        await applyCleanupDecision(
+          recordPath,
+          getRuntimeInstanceRegistryCleanupDecision({
+            kind: "record",
+            fileModifiedAtMs: mtimeMs,
+            nowMs,
+            record
+          })
+        );
+      } catch {
+      }
+    })
+  );
+}
+function registerProcessCleanup(recordPath) {
+  let cleanupSync = () => {
+    existsSync2(recordPath) && rmSync(recordPath, { force: !0 });
+  };
+  return process.once("exit", cleanupSync), process.prependOnceListener("SIGINT", cleanupSync), process.prependOnceListener("SIGTERM", cleanupSync), () => {
+    process.off("exit", cleanupSync), process.off("SIGINT", cleanupSync), process.off("SIGTERM", cleanupSync);
+  };
+}
+async function writeStorybookRuntimeInstanceRecord({
+  address,
+  agent = detectRuntimeInstanceAgent(),
+  configDir,
+  cwd,
+  mcp,
+  pid,
+  port,
+  registryDir,
+  registerCleanup = !0,
+  storybookVersion,
+  token
+}) {
+  let record = createRuntimeInstanceRecord({
+    address,
+    agent,
+    configDir,
+    cwd,
+    mcp,
+    pid,
+    port,
+    storybookVersion,
+    token
+  }), recordPath = await writeRuntimeInstanceRecord(record, registryDir), unregisterProcessCleanup = registerCleanup ? registerProcessCleanup(recordPath) : () => {
+  };
+  return {
+    record,
+    recordPath,
+    unregisterProcessCleanup,
+    cleanup: async () => {
+      unregisterProcessCleanup(), await rm2(recordPath, { force: !0 });
+    }
+  };
+}
+
+// src/core-server/utils/server-init.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { logger as logger14 } from "@aussieljk/forkbook/internal/node-logger";
+import http2 from "http";
+import https from "https";
+async function getServer(options) {
+  if (!options.https)
+    return http2.createServer();
+  options.sslCert || (logger14.error("Error: --ssl-cert is required with --https"), process.exit(-1)), options.sslKey || (logger14.error("Error: --ssl-key is required with --https"), process.exit(-1));
+  let sslOptions = {
+    ca: await Promise.all((options.sslCa || []).map((ca) => readFile2(ca, { encoding: "utf8" }))),
+    cert: await readFile2(options.sslCert, { encoding: "utf8" }),
+    key: await readFile2(options.sslKey, { encoding: "utf8" })
+  };
+  return https.createServer(sslOptions);
+}
+
+// src/core-server/utils/strip-comments-and-strings.ts
+function stripCommentsAndStrings(code) {
+  let result = code.replace(/(['"`])(?:\\.|(?!\1)[\s\S])*?\1/g, '""');
+  return result = result.replace(/\/\*[\s\S]*?\*\//g, ""), result = result.split(`
+`).map((line) => line.split("//")[0]).join(`
+`), result;
+}
+
+// src/core-server/build-dev.ts
+async function buildDevStandalone(options) {
+  let { packageJson, versionUpdates } = options, { storybookVersion } = options, configDir = resolve6(options.configDir);
+  packageJson ? (invariant(
+    packageJson.version !== void 0,
+    `Expected package.json#version to be defined in the "${packageJson.name}" package}`
+  ), storybookVersion = packageJson.version) : storybookVersion || (storybookVersion = versions["@aussieljk/forkbook"]);
+  let [port, versionCheck] = await Promise.all([
+    getServerPort(options.port, { exactPort: options.exactPort }),
+    versionUpdates ? updateCheck(storybookVersion) : Promise.resolve({ success: !1, cached: !1, data: {}, time: Date.now() })
+  ]);
+  !options.ci && !options.smokeTest && options.port != null && port !== options.port && (await prompt2.confirm({
+    message: dedent5`
+        Port ${options.port} is not available. 
+        Would you like to run Forkbook on port ${port} instead?
+      `,
+    initialValue: !0
+  }) || process.exit(1));
+  let cacheKey = oneWayHash(relative4(getProjectRoot(), configDir));
+  invariant(port, "expected options to have a port");
+  let { address: localAddress, networkAddress } = getServerAddresses(
+    port,
+    options.host,
+    options.https ? "https" : "http",
+    options.initialPath
+  ), cacheOutputDir = resolvePathInStorybookCache2("public", cacheKey), outputDir = resolve6(options.outputDir || cacheOutputDir);
+  options.smokeTest && (outputDir = cacheOutputDir), options.port = port, options.versionCheck = versionCheck, options.configType = "DEVELOPMENT", options.configDir = configDir, options.cacheKey = cacheKey, options.outputDir = outputDir, options.serverChannelUrl = getServerChannelUrl(port, options), options.localAddress = localAddress, options.networkAddress = networkAddress;
+  let config = await loadMainConfig2(options), { core, framework } = config, corePresets = [], frameworkName = typeof framework == "string" ? framework : framework?.name;
+  validateFrameworkName(frameworkName), frameworkName && corePresets.push(join8(frameworkName, "preset")), frameworkName = frameworkName || "custom";
+  let packageManager = JsPackageManagerFactory.getPackageManager({
+    configDir: options.configDir
+  }), server = await getServer(options), presets = await loadAllPresets2({
+    corePresets,
+    overridePresets: [
+      import.meta.resolve("@aussieljk/forkbook/internal/core-server/presets/common-override-preset")
+    ],
+    ...options,
+    isCritical: !0,
+    channel: new channels_default({
+      transports: [
+        {
+          setHandler: () => () => console.error("CHANNEL IS NOT READY YET"),
+          send: () => () => console.error("CHANNEL IS NOT READY YET")
+        }
+      ]
+    })
+  }), { allowedHosts, renderer, builder } = await presets.apply("core", {});
+  if (await warnOnDisabledHostValidation({
+    host: options.host,
+    allowedHosts,
+    ci: options.ci,
+    smokeTest: options.smokeTest,
+    cacheKey
+  }), !builder)
+    throw new MissingBuilderError2();
+  versionCheck.success && !versionCheck.cached && telemetry4("version-update");
+  let resolvedPreviewBuilder = typeof builder == "string" ? builder : builder.name, [previewBuilder, managerBuilder] = await Promise.all([
+    getPreviewBuilder(resolvedPreviewBuilder),
+    getManagerBuilder()
+  ]);
+  if (resolvedPreviewBuilder.includes("builder-vite")) {
+    let deprecationMessage = dedent5(`Using CommonJS in your main configuration file is deprecated with Vite.
+              - Refer to the migration guide at https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#commonjs-with-vite-is-deprecated`), mainJsPath = getInterpretedFile(
+      resolve6(options.configDir || defaultConfigDir(), "main")
+    );
+    /\.c[jt]s$/.test(mainJsPath) && deprecate(deprecationMessage);
+    let mainJsContent = await readFile3(mainJsPath, { encoding: "utf8" }), CJS_CONTENT_REGEX = /\bmodule\.exports\b|\bexports[.[]|\brequire\s*\(|\bObject\.(?:defineProperty|defineProperties|assign)\s*\(\s*exports\b/, strippedContent = stripCommentsAndStrings(mainJsContent);
+    CJS_CONTENT_REGEX.test(strippedContent) && deprecate(deprecationMessage);
+  }
+  let resolvedRenderer = renderer && resolveAddonName2(options.configDir, renderer, options), channel = getServerChannel(server, {
+    token: getWsToken(),
+    host: options.host,
+    allowedHosts,
+    skipValidation: isWebContainer(),
+    localAddress,
+    networkAddress
+  });
+  presets = await loadAllPresets2({
+    corePresets: [
+      join8(resolvePackageDir("@aussieljk/forkbook"), "dist/core-server/presets/common-preset.js"),
+      ...managerBuilder.corePresets || [],
+      ...previewBuilder.corePresets || [],
+      ...resolvedRenderer ? [resolvedRenderer] : [],
+      ...corePresets
+    ],
+    overridePresets: [
+      ...previewBuilder.overridePresets || [],
+      import.meta.resolve("@aussieljk/forkbook/internal/core-server/presets/common-override-preset")
+    ],
+    ...options,
+    channel
+  });
+  let features = await presets.apply("features");
+  global3.FEATURES = features, await presets.apply("experimental_serverChannel", channel);
+  let fullOptions = {
+    ...options,
+    presets,
+    features,
+    channel
+  }, { managerResult, previewResult } = await buildOrThrow(
+    async () => storybookDevServer(fullOptions, server)
+  ), mcp = getMcpMetadataFromMainConfig(config);
+  await writeStorybookRuntimeInstanceRecord({
+    address: localAddress,
+    configDir: options.configDir,
+    mcp,
+    port,
+    storybookVersion,
+    token: getWsToken()
+  }).catch((error) => {
+    logger15.warn("Forkbook failed to write its runtime instance registry record."), logger15.debug(error instanceof Error ? error.stack ?? error.message : String(error));
+  });
+  let previewTotalTime = previewResult?.totalTime, managerTotalTime = managerResult?.totalTime, previewStats = previewResult?.stats, managerStats = managerResult?.stats, statsOption = options.statsJson;
+  if (statsOption) {
+    let target = statsOption === !0 ? options.outputDir : statsOption;
+    await outputStats(target, previewStats);
+  }
+  if (options.smokeTest) {
+    let warnings = [];
+    warnings.push(...managerStats?.toJson()?.warnings || []);
+    try {
+      warnings.push(...previewStats?.toJson()?.warnings || []);
+    } catch (err) {
+      if (!(err instanceof NoStatsForViteDevError))
+        throw err;
+    }
+    let problems = warnings.filter((warning) => !warning.message.includes("export 'useInsertionEffect'")).filter((warning) => !warning.message.includes("compilation but it's unused")).filter(
+      (warning) => !warning.message.includes("Conflicting values for 'process.env.NODE_ENV'")
+    );
+    problems.length > 0 ? (logger15.error("Smoke tests failed."), logger15.log(problems.map((p) => p.stack).join(`
+`))) : logger15.step(CLI_COLORS2.success("Smoke tests passed, exiting.")), logger15.outro(""), process.exit(problems.length > 0 ? 1 : 0);
+  } else {
+    let name = frameworkName.split("@storybook/").length > 1 ? frameworkName.split("@storybook/")[1] : frameworkName;
+    options.quiet || outputStartupInformation({
+      updateInfo: versionCheck,
+      version: storybookVersion,
+      name,
+      address: localAddress,
+      host: options.host,
+      networkAddress,
+      allowedHosts,
+      managerTotalTime,
+      previewTotalTime
+    });
+  }
+  return { port, address: localAddress, networkAddress };
+}
+
+// src/core-server/build-index.ts
+import { writeFile as writeFile4 } from "node:fs/promises";
+import { normalizeStories as normalizeStories2 } from "@aussieljk/forkbook/internal/common";
+import { logger as logger17 } from "@aussieljk/forkbook/internal/node-logger";
+
+// src/core-server/load.ts
+import { fileURLToPath } from "node:url";
+import { Channel as Channel4, setChannel as setChannel3 } from "@aussieljk/forkbook/internal/channels";
+import {
+  getProjectRoot as getProjectRoot2,
+  loadAllPresets as loadAllPresets3,
+  loadMainConfig as loadMainConfig3,
+  resolveAddonName as resolveAddonName3,
+  validateFrameworkName as validateFrameworkName2
+} from "@aussieljk/forkbook/internal/common";
+import { oneWayHash as oneWayHash2 } from "@aussieljk/forkbook/internal/telemetry";
+import { global as global4 } from "@storybook/global";
+import { dirname, isAbsolute, join as join9, relative as relative5, resolve as resolve7 } from "pathe";
+async function loadStorybook(options) {
+  let configDir = resolve7(options.configDir), cacheKey = oneWayHash2(relative5(getProjectRoot2(), configDir));
+  options.configType = "DEVELOPMENT", options.configDir = configDir, options.cacheKey = cacheKey;
+  let channel = options.channel ?? new Channel4({});
+  setChannel3(channel);
+  let config = await loadMainConfig3(options), { framework } = config, corePresets = [], frameworkName = typeof framework == "string" ? framework : framework?.name;
+  validateFrameworkName2(frameworkName), frameworkName && corePresets.push(join9(frameworkName, "preset")), frameworkName = frameworkName || "custom";
+  let presets = await loadAllPresets3({
+    corePresets,
+    overridePresets: [
+      import.meta.resolve("@aussieljk/forkbook/internal/core-server/presets/common-override-preset")
+    ],
+    ...options,
+    isCritical: !0,
+    channel
+  }), { renderer, builder } = await presets.apply("core", {}), resolvedRenderer = renderer && resolveAddonName3(options.configDir, renderer, options), builderName = typeof builder == "string" ? builder : builder?.name;
+  if (builderName) {
+    let builderEntry = builderName.startsWith("file:") ? fileURLToPath(builderName) : builderName, builderPresetDir = isAbsolute(builderEntry) ? dirname(builderEntry) : resolvePackageDir(builderEntry), builderPreset = safeResolveModule({ specifier: join9(builderPresetDir, "preset.js") });
+    builderPreset && corePresets.push(builderPreset);
+  }
+  presets = await loadAllPresets3({
+    corePresets: [
+      join9(resolvePackageDir("@aussieljk/forkbook"), "dist/core-server/presets/common-preset.js"),
+      ...resolvedRenderer ? [resolvedRenderer] : [],
+      ...corePresets
+    ],
+    overridePresets: [
+      import.meta.resolve("@aussieljk/forkbook/internal/core-server/presets/common-override-preset")
+    ],
+    ...options,
+    channel
+  });
+  let features = await presets.apply("features");
+  return global4.FEATURES = features, await applyServicesPresetOnce(presets), {
+    ...options,
+    // the resolved channel — the one the presets received — never the possibly-absent option
+    channel,
+    presets,
+    features
+  };
+}
+
+// src/core-server/utils/StoryIndexGenerator.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { readFile as readFile4 } from "node:fs/promises";
+import { dirname as dirname2, extname, join as join10, normalize as normalize2, relative as relative6, resolve as resolve8, sep as sep2 } from "node:path";
+import {
+  commonGlobOptions as commonGlobOptions2,
+  getProjectRoot as getProjectRoot3,
+  getTsconfigPathsBaseDir,
+  normalizeStoryPath
+} from "@aussieljk/forkbook/internal/common";
+import { combineTags, storyNameFromExport, toId } from "@aussieljk/forkbook/internal/csf/csf-utils";
+import { loadConfig } from "@aussieljk/forkbook/internal/csf-tools";
+import { logger as logger16, once } from "@aussieljk/forkbook/internal/node-logger";
+import { isExampleStoryId as isExampleStoryId2 } from "@aussieljk/forkbook/internal/telemetry";
+var import_picocolors7 = __toESM(require_picocolors(), 1);
+var TsconfigPaths = __toESM(require_lib(), 1);
+import { dedent as dedent7 } from "ts-dedent";
+
+// src/docs-tools/shared.ts
+var ADDON_ID = "@aussieljk/forkbook/docs", PANEL_ID = `${ADDON_ID}/panel`;
+var anchorBlockIdFromId = (storyId) => `anchor--${storyId}`, SNIPPET_RENDERED = `${ADDON_ID}/snippet-rendered`;
+
+// src/shared/story-index/sortStories.ts
+import { dedent as dedent6 } from "ts-dedent";
+
+// src/shared/story-index/storySort.ts
+var STORY_KIND_PATH_SEPARATOR = /\s*\/\s*/, storySort = (options = {}) => (a, b) => {
+  if (a.title === b.title && !options.includeNames)
+    return 0;
+  let method = options.method || "configure", order = options.order || [], storyTitleA = a.title.trim().split(STORY_KIND_PATH_SEPARATOR), storyTitleB = b.title.trim().split(STORY_KIND_PATH_SEPARATOR);
+  options.includeNames && (storyTitleA.push(a.name), storyTitleB.push(b.name));
+  let depth = 0;
+  for (; storyTitleA[depth] || storyTitleB[depth]; ) {
+    if (!storyTitleA[depth])
+      return -1;
+    if (!storyTitleB[depth])
+      return 1;
+    let nameA = storyTitleA[depth], nameB = storyTitleB[depth];
+    if (nameA !== nameB) {
+      let indexA = order.indexOf(nameA), indexB = order.indexOf(nameB), indexWildcard = order.indexOf("*");
+      return indexA !== -1 || indexB !== -1 ? (indexA === -1 && (indexWildcard !== -1 ? indexA = indexWildcard : indexA = order.length), indexB === -1 && (indexWildcard !== -1 ? indexB = indexWildcard : indexB = order.length), indexA - indexB) : method === "configure" ? 0 : nameA.localeCompare(nameB, options.locales ? options.locales : void 0, {
+        numeric: !0,
+        sensitivity: "accent"
+      });
+    }
+    let index = order.indexOf(nameA);
+    index === -1 && (index = order.indexOf("*"));
+    let nestedOrder = order[index + 1];
+    order = index !== -1 && Array.isArray(nestedOrder) ? nestedOrder : [], depth += 1;
+  }
+  return 0;
+};
+
+// src/shared/story-index/sortStories.ts
+var toComparator = (storySortParameter) => typeof storySortParameter == "function" ? storySortParameter : storySort(
+  Array.isArray(storySortParameter) ? { order: storySortParameter } : storySortParameter
+), combineStorySorts = (storySorts) => {
+  if (storySorts.length <= 1)
+    return storySorts[0];
+  let comparators = storySorts.map(toComparator);
+  return (a, b) => {
+    for (let comparator of comparators) {
+      let result = Number(comparator(a, b)) || 0;
+      if (result !== 0)
+        return result;
+    }
+    return 0;
+  };
+}, sortStoriesCommon = (stories, storySortParameter, fileNameOrder) => (storySortParameter ? stories.sort(toComparator(storySortParameter)) : stories.sort(
+  (s1, s2) => fileNameOrder.indexOf(s1.importPath) - fileNameOrder.indexOf(s2.importPath)
+), stories), sortStoriesV7 = (stories, storySortParameter, fileNameOrder) => {
+  try {
+    return sortStoriesCommon(stories, storySortParameter, fileNameOrder);
+  } catch (err) {
+    throw new Error(dedent6`
+    Error sorting stories with sort parameter ${storySortParameter}:
+
+    > ${err.message}
+
+    Are you using a V6-style sort function in V7 mode?
+
+    More info: https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#v7-style-story-sort
+  `);
+  }
+};
+
+// src/core-server/utils/IndexingError.ts
+var IndexingError = class extends Error {
+  constructor(message, importPaths, stack) {
+    super(), this.message = message, this.importPaths = importPaths, stack && (this.stack = stack);
+  }
+  pathsString() {
+    return this.importPaths.length === 1 ? `${slash(this.importPaths[0])}` : `${this.importPaths.map(slash).join(",")}`;
+  }
+  toString() {
+    return `${this.pathsString()}: ${this.message}`;
+  }
+}, MultipleIndexingError = class extends Error {
+  constructor(indexingErrors) {
+    super();
+    this.indexingErrors = indexingErrors;
+    if (this.indexingErrors.length === 0)
+      throw new Error("Unexpected empty error list");
+    if (this.indexingErrors.length === 1) {
+      let [err] = this.indexingErrors;
+      this.message = `Unable to index ${err.pathsString()}`;
+    } else
+      this.message = `Unable to index files:
+${this.indexingErrors.map((err) => `- ${err}`).join(`
+`)}`;
+  }
+  toString() {
+    return this.indexingErrors.length === 1 ? `${this.message}:
+  ${this.indexingErrors[0].stack}` : this.message;
+  }
+};
+
+// src/core-server/utils/autoName.ts
+import { basename as basename3 } from "node:path";
+function autoName(mdxImportPath, csfImportPath, defaultName) {
+  let mdxBasename = basename3(mdxImportPath), csfBasename = basename3(csfImportPath), [mdxFilename] = mdxBasename.split("."), [csfFilename] = csfBasename.split(".");
+  return mdxFilename === csfFilename ? defaultName : mdxFilename;
+}
+
+// src/core-server/utils/analyze-mdx.ts
+init_acorn();
+var import_acorn_jsx = __toESM(require_acorn_jsx(), 1);
+var mdxSyntaxOptions = {
+  acorn: Parser.extend((0, import_acorn_jsx.default)()),
+  acornOptions: { ecmaVersion: 2024, sourceType: "module" },
+  addResult: !0
+}, parseMdx = (code) => fromMarkdown(code, {
+  extensions: [mdxjs(mdxSyntaxOptions)],
+  mdastExtensions: [mdxFromMarkdown()]
+}), createEmptyMdxMetadata = () => ({
+  title: void 0,
+  of: void 0,
+  name: void 0,
+  id: void 0,
+  summary: void 0,
+  isTemplate: !1,
+  metaTags: void 0
+}), isMdxJsxAttribute = (node) => node.type === "mdxJsxAttribute", isMetaElement = (node) => node.type === "mdxJsxFlowElement" && node.name === "Meta", isStringLiteral = (value) => value?.type === "Literal" && typeof value.value == "string", getAttribute = (metaElement, attributeName) => metaElement.attributes.find(
+  (node) => isMdxJsxAttribute(node) && node.name === attributeName
+), getAttributeValue = (metaElement, attributeName) => getAttribute(metaElement, attributeName)?.value, getExpression = (attributeValue) => {
+  let expressionStatement = attributeValue.data?.estree?.body[0];
+  if (expressionStatement?.type === "ExpressionStatement")
+    return expressionStatement.expression;
+  throw new Error("Expected JSX expression, received unknown");
+}, getStringAttribute = (metaElement, attributeName) => {
+  let attributeValue = getAttributeValue(metaElement, attributeName);
+  if (attributeValue) {
+    if (typeof attributeValue == "string")
+      return attributeValue;
+    throw new Error(`Expected string literal ${attributeName}, received JSXExpressionContainer`);
+  }
+}, getOfImportPath = (metaElement, importMap) => {
+  let attributeValue = getAttributeValue(metaElement, "of");
+  if (!attributeValue)
+    return;
+  if (typeof attributeValue == "string")
+    throw new Error("Expected JSX expression, received Literal");
+  let expression = getExpression(attributeValue);
+  if (expression.type !== "Identifier")
+    throw new Error(`Expected identifier, received ${expression.type}`);
+  let importPath = importMap[expression.name];
+  if (importPath)
+    return importPath;
+  throw new Error(`Unknown identifier ${expression.name}`);
+}, getMetaTags = (metaElement) => {
+  let attribute = getAttribute(metaElement, "tags");
+  if (!attribute)
+    return;
+  let attributeValue = attribute.value;
+  if (!attributeValue)
+    throw new Error("Expected JSX expression tags, received null");
+  if (typeof attributeValue == "string")
+    throw new Error("Expected JSX expression tags, received Literal");
+  let expression = getExpression(attributeValue);
+  if (expression.type !== "ArrayExpression")
+    throw new Error(`Expected tags array, received ${expression.type}`);
+  return expression.elements.map((element) => {
+    if (isStringLiteral(element))
+      return element.value;
+    throw new Error(`Expected string literal tag, received ${element?.type ?? "null"}`);
+  });
+}, getIsTemplate = (metaElement) => {
+  let attribute = getAttribute(metaElement, "isTemplate");
+  if (!attribute)
+    return !1;
+  let attributeValue = attribute.value;
+  if (attributeValue == null)
+    return !0;
+  if (typeof attributeValue == "string")
+    throw new Error("Expected expression isTemplate, received Literal");
+  let expression = getExpression(attributeValue);
+  if (expression.type === "Literal" && typeof expression.value == "boolean")
+    return expression.value;
+  throw new Error(
+    `Expected boolean isTemplate, received ${typeof expression.value}`
+  );
+}, extractMeta = (metaElement, importMap) => ({
+  title: getStringAttribute(metaElement, "title"),
+  of: getOfImportPath(metaElement, importMap),
+  name: getStringAttribute(metaElement, "name"),
+  id: getStringAttribute(metaElement, "id"),
+  summary: getStringAttribute(metaElement, "summary"),
+  isTemplate: getIsTemplate(metaElement),
+  metaTags: getMetaTags(metaElement)
+}), getHeadingText = (node) => node.children ? node.children.map((child) => {
+  let c = child;
+  return c.type === "text" ? c.value ?? "" : c.children ? getHeadingText(c) : "";
+}).join("") : "", getAnchors = (root) => {
+  let anchors = [], slugger = new BananaSlug(), walk = (nodes) => {
+    for (let node of nodes) {
+      let n = node;
+      if (n.type === "heading" && typeof n.depth == "number") {
+        let title = getHeadingText(n);
+        if (title) {
+          let id = slugger.slug(title);
+          n.depth <= 4 && anchors.push({ id, title });
+        }
+      }
+      n.children && walk(n.children);
+    }
+  };
+  return walk(root.children), anchors;
+}, extractImports = (root) => {
+  let importMap = {};
+  for (let child of root.body) {
+    if (child.type !== "ImportDeclaration")
+      continue;
+    let importPath = child.source.value;
+    if (child.source.type !== "Literal" || typeof importPath != "string")
+      throw new Error("MDX: unexpected import source");
+    for (let specifier of child.specifiers)
+      importMap[specifier.local.name] = importPath;
+  }
+  return importMap;
+}, analyzeParsedMdx = (root) => {
+  let importMap = {}, metaElement;
+  for (let child of root.children)
+    if (child.type === "mdxjsEsm" && child.data?.estree && Object.assign(importMap, extractImports(child.data.estree)), isMetaElement(child)) {
+      if (metaElement)
+        throw new Error("Meta can only be declared once");
+      metaElement = child;
+    }
+  return {
+    ...metaElement ? extractMeta(metaElement, importMap) : createEmptyMdxMetadata(),
+    imports: Array.from(new Set(Object.values(importMap))),
+    anchors: getAnchors(root)
+  };
+}, analyzeMdx = async (code) => analyzeParsedMdx(parseMdx(code));
+
+// src/core-server/utils/summarizeStats.ts
+var addStats = (stat2, acc) => {
+  Object.entries(stat2).forEach(([key, value]) => {
+    let statsKey = key;
+    acc[statsKey] || (acc[statsKey] = 0), acc[statsKey] += value ? 1 : 0;
+  });
+};
+
+// src/core-server/utils/StoryIndexGenerator.ts
+var makeAbsolute = (otherImport, normalizedPath, workingDir) => otherImport.startsWith(".") ? slash(resolve8(workingDir, normalizeStoryPath(join10(dirname2(normalizedPath), otherImport)))) : otherImport, StoryIndexGenerator = class _StoryIndexGenerator {
+  constructor(specifiers, options) {
+    this.specifiers = specifiers;
+    this.options = options;
+    this.invalidationListeners = /* @__PURE__ */ new Set();
+    this.specifierToCache = /* @__PURE__ */ new Map();
+  }
+  static {
+    /** Cache for findMatchingFiles results */
+    this.findMatchingFilesCache = /* @__PURE__ */ new Map();
+  }
+  /** Generate a cache key for findMatchingFiles */
+  static getFindMatchingFilesCacheKey(specifier, workingDir, ignoreWarnings) {
+    return JSON.stringify({
+      directory: specifier.directory,
+      files: specifier.files,
+      workingDir,
+      ignoreWarnings
+    });
+  }
+  /** Clear the findMatchingFiles cache */
+  static clearFindMatchingFilesCache() {
+    this.findMatchingFilesCache.clear();
+  }
+  static async findMatchingFiles(specifier, workingDir, ignoreWarnings = !1) {
+    let cacheKey = this.getFindMatchingFilesCacheKey(specifier, workingDir, ignoreWarnings), cached = this.findMatchingFilesCache.get(cacheKey);
+    if (cached)
+      return cached;
+    let pathToSubIndex = {}, globCwd = slash(resolve8(workingDir, specifier.directory)), globPattern = specifier.files.startsWith("!") ? `./${specifier.files}` : specifier.files, { globby } = await import("../_node-chunks/globby-HWZL7XSQ.js"), files = await globby(globPattern, {
+      absolute: !0,
+      cwd: globCwd,
+      ...commonGlobOptions2(globPattern),
+      onlyFiles: !0
+    });
+    return files.length === 0 && !ignoreWarnings && once.warn(
+      `No story files found for the specified pattern: ${import_picocolors7.default.blue(
+        join10(specifier.directory, specifier.files)
+      )}`
+    ), files.sort().forEach((absolutePath) => {
+      let ext = extname(absolutePath);
+      if (ext === ".storyshot") {
+        let relativePath = relative6(workingDir, absolutePath);
+        logger16.info(`Skipping ${ext} file ${relativePath}`);
+        return;
+      }
+      pathToSubIndex[absolutePath] = !1;
+    }), this.findMatchingFilesCache.set(cacheKey, pathToSubIndex), pathToSubIndex;
+  }
+  static async findMatchingFilesForSpecifiers(specifiers, workingDir, ignoreWarnings = !1) {
+    return Promise.all(
+      specifiers.map(async (specifier) => {
+        let pathToSubIndex = await _StoryIndexGenerator.findMatchingFiles(
+          specifier,
+          workingDir,
+          ignoreWarnings
+        );
+        return [specifier, pathToSubIndex];
+      })
+    );
+  }
+  async initialize() {
+    (await _StoryIndexGenerator.findMatchingFilesForSpecifiers(
+      this.specifiers,
+      this.options.workingDir
+    )).forEach(
+      ([specifier, cache4]) => this.specifierToCache.set(specifier, cache4)
+    );
+    let previewCode = await this.getPreviewCode(), projectTags = this.getProjectTags(previewCode);
+    await this.ensureExtracted({ projectTags });
+  }
+  /** Run the updater function over all the empty cache entries */
+  async updateExtracted(updater, overwrite = !1) {
+    await Promise.all(
+      this.specifiers.map(async (specifier) => {
+        let entry = this.specifierToCache.get(specifier);
+        return invariant(
+          entry,
+          `specifier does not have a matching cache entry in specifierToCache: ${JSON.stringify(
+            specifier
+          )}`
+        ), Promise.all(
+          Object.keys(entry).map(async (absolutePath) => {
+            if (!(entry[absolutePath] && !overwrite))
+              try {
+                entry[absolutePath] = await updater(specifier, absolutePath, entry[absolutePath]);
+              } catch (err) {
+                let relativePath = `.${sep2}${relative6(this.options.workingDir, absolutePath)}`;
+                entry[absolutePath] = {
+                  type: "error",
+                  err: new IndexingError(
+                    err instanceof Error ? err.message : String(err),
+                    [relativePath],
+                    err instanceof Error ? err.stack : void 0
+                  )
+                };
+              }
+          })
+        );
+      })
+    );
+  }
+  isDocsMdx(absolutePath) {
+    return /(?<!\.stories)\.mdx$/i.test(absolutePath);
+  }
+  async ensureExtracted({
+    projectTags
+  }) {
+    await this.updateExtracted(
+      async (specifier, absolutePath) => this.isDocsMdx(absolutePath) ? !1 : this.extractStories(specifier, absolutePath, projectTags)
+    ), await this.updateExtracted(
+      async (specifier, absolutePath) => this.extractDocs(specifier, absolutePath, projectTags)
+    );
+    let statsSummary = {};
+    return { entries: this.specifiers.flatMap((specifier) => {
+      let cache4 = this.specifierToCache.get(specifier);
+      return invariant(
+        cache4,
+        `specifier does not have a matching cache entry in specifierToCache: ${JSON.stringify(
+          specifier
+        )}`
+      ), Object.values(cache4).flatMap((entry) => entry ? entry.type === "docs" ? [entry] : entry.type === "error" ? [entry] : entry.entries.map((item) => {
+        if (item.type === "docs")
+          return item;
+        isExampleStoryId2(item.id) || addStats(item.extra.stats, statsSummary);
+        let { extra, ...existing } = item;
+        return existing;
+      }) : []);
+    }), stats: statsSummary };
+  }
+  findDependencies(absoluteImports) {
+    return [...this.specifierToCache.values()].flatMap(
+      (cache4) => Object.entries(cache4).filter(([fileName, cacheEntry]) => !cacheEntry || cacheEntry.type !== "stories" ? !1 : !!absoluteImports.find(
+        (storyImport) => fileName.match(
+          new RegExp(`^${storyImport.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(\\.[^.]+)?$`)
+        )
+      )).map(([_, cacheEntry]) => cacheEntry)
+    );
+  }
+  /**
+   * Try to find the component path from a raw import string and return it in the same format as
+   * `importPath`. Respect tsconfig paths if available.
+   *
+   * If no such file exists, assume that the import is from a package and return the raw
+   */
+  resolveComponentPath(rawComponentPath, absolutePath, matchPath) {
+    let matchedPath = matchPath?.(rawComponentPath, void 0, void 0, supportedExtensions) ?? rawComponentPath, resolved;
+    try {
+      resolved = resolveImport(matchedPath, { basedir: dirname2(absolutePath) });
+    } catch {
+      return matchedPath;
+    }
+    let relativePath = relative6(this.options.workingDir, resolved);
+    return slash(normalizeStoryPath(relativePath));
+  }
+  async extractStories(specifier, absolutePath, projectTags = []) {
+    let relativePath = relative6(this.options.workingDir, absolutePath), importPath = slash(normalizeStoryPath(relativePath)), defaultMakeTitle = (userTitle) => {
+      let title = userOrAutoTitleFromSpecifier(importPath, specifier, userTitle);
+      return invariant(
+        title,
+        "makeTitle created an undefined title. This happens when the fileName doesn't match any specifier from main.js"
+      ), title;
+    }, indexer = this.options.indexers.find((ind) => ind.test.exec(absolutePath));
+    invariant(indexer, `No matching indexer found for ${absolutePath}`);
+    let indexInputs = await indexer.createIndex(absolutePath, {
+      makeTitle: defaultMakeTitle
+    }), tsconfigPath = up("tsconfig.json", {
+      cwd: this.options.workingDir,
+      last: getProjectRoot3()
+    }), tsconfig = TsconfigPaths.loadConfig(tsconfigPath), matchPath;
+    tsconfig.resultType === "success" && (matchPath = TsconfigPaths.createMatchPath(
+      getTsconfigPathsBaseDir(tsconfig.configFileAbsolutePath),
+      tsconfig.paths,
+      ["browser", "module", "main"]
+    ));
+    let toImportPath = (path) => path ? path.startsWith("virtual:") ? path : slash(normalizeStoryPath(relative6(this.options.workingDir, path))) : importPath, storyEntries = indexInputs.map((input) => {
+      let name = input.name ?? storyNameFromExport(input.exportName), componentPath = input.rawComponentPath && this.resolveComponentPath(input.rawComponentPath, absolutePath, matchPath), title = input.title ?? defaultMakeTitle(), id = input.__id ?? toId(input.metaId ?? title, storyNameFromExport(input.exportName)), tags = combineTags(...projectTags, ...input.tags ?? []), subtype = input.subtype ?? "story", entry = {
+        type: "story",
+        subtype,
+        id,
+        extra: {
+          metaId: input.metaId,
+          stats: input.__stats ?? {}
+        },
+        name,
+        title,
+        importPath: toImportPath(input.importPath),
+        componentPath,
+        tags
+      };
+      return subtype === "test" && (entry.parent = input.parent, entry.parentName = input.parentName), input.exportName && (entry.exportName = input.exportName), entry;
+    });
+    if (storyEntries.some((entry) => entry.tags.includes(Tag.AUTODOCS)) && !!this.options.docs && this.options.build?.test?.disableAutoDocs !== !0) {
+      let name = this.options.docs?.defaultName ?? "Docs", { metaId } = indexInputs[0], entry = storyEntries[0], id = toId(metaId ?? entry.title, name), tags = combineTags(...projectTags, ...indexInputs[0].tags ?? []);
+      return {
+        entries: [{
+          id,
+          title: entry.title,
+          name,
+          importPath: entry.importPath,
+          type: "docs",
+          tags,
+          storiesImports: [],
+          ...this.options.features?.experimentalSearchDocsHeadings && {
+            // Each story in an autodocs page is wrapped in an `Anchor` block whose DOM id is
+            // derived from the story id, so those are the reliable in-page navigation targets.
+            anchors: storyEntries.map((e) => ({ id: anchorBlockIdFromId(e.id), title: e.name }))
+          }
+        }, ...storyEntries],
+        dependents: [],
+        type: "stories"
+      };
+    }
+    return {
+      entries: storyEntries,
+      dependents: [],
+      type: "stories"
+    };
+  }
+  async extractDocs(specifier, absolutePath, projectTags = []) {
+    let relativePath = relative6(this.options.workingDir, absolutePath);
+    try {
+      let normalizedPath = normalizeStoryPath(relativePath), importPath = slash(normalizedPath), content = await readFile4(absolutePath, { encoding: "utf8" }), result = await analyzeMdx(content);
+      if (result.isTemplate)
+        return !1;
+      let absoluteImports = result.imports.map(
+        (p) => makeAbsolute(p, normalizedPath, this.options.workingDir)
+      ), dependencies = this.findDependencies(absoluteImports), sortedDependencies = dependencies, csfEntry;
+      if (result.of) {
+        let absoluteOf = makeAbsolute(result.of, normalizedPath, this.options.workingDir), metaDependency;
+        dependencies.forEach((dep) => {
+          if (dep.entries.length > 0) {
+            let first = dep.entries.find((e) => e.type !== "docs");
+            normalize2(resolve8(this.options.workingDir, first.importPath)).startsWith(
+              normalize2(absoluteOf)
+            ) && (csfEntry = first, metaDependency = dep);
+          }
+        }), metaDependency && (sortedDependencies = [
+          metaDependency,
+          ...dependencies.filter((d) => d !== metaDependency)
+        ]), invariant(
+          csfEntry,
+          dedent7`
+            Could not find or load CSF file at path "${result.of}" referenced by \`of={}\` in docs file "${relativePath}".
+
+            - Does that file exist?
+            - If so, is it a CSF file (\`.stories.*\`)?
+            - If so, is it matched by the \`stories\` glob in \`main.js\`?
+            - If so, has the file successfully loaded in Forkbook and are its stories visible?
+          `
+        );
+      }
+      dependencies.forEach((dep) => {
+        dep.dependents.push(absolutePath);
+      });
+      let title = csfEntry?.title || userOrAutoTitleFromSpecifier(importPath, specifier, result.title);
+      invariant(
+        title,
+        "makeTitle created an undefined title. This happens when a specifier's doesn't have any matches in its fileName"
+      );
+      let defaultName = this.options.docs?.defaultName ?? "Docs", name = result.name || (csfEntry ? autoName(importPath, csfEntry.importPath, defaultName) : defaultName), id = toId(csfEntry?.extra.metaId || result.id || title, name), tags = combineTags(
+        ...projectTags,
+        ...csfEntry?.tags ?? [],
+        ...result.metaTags ?? [],
+        csfEntry ? Tag.ATTACHED_MDX : Tag.UNATTACHED_MDX
+      );
+      return {
+        id,
+        title,
+        name,
+        importPath,
+        storiesImports: sortedDependencies.map((dep) => dep.entries[0].importPath),
+        type: "docs",
+        tags,
+        ...this.options.features?.experimentalSearchDocsHeadings && { anchors: result.anchors }
+      };
+    } catch (err) {
+      throw err && err.source?.match(/mdast-util-mdx-jsx/g) && logger16.warn(
+        `\u{1F4A1} This seems to be an MDX2 syntax error. Please refer to the MDX section in the following resource for assistance on how to fix this: ${import_picocolors7.default.yellow(
+          "https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#mdx2-upgrade"
+        )}`
+      ), err;
+    }
+  }
+  chooseDuplicate(firstEntry, secondEntry, projectTags) {
+    if (firstEntry.importPath === secondEntry.importPath)
+      return firstEntry;
+    let firstIsBetter = !0;
+    (secondEntry.type === "story" || isMdxEntry(secondEntry) && firstEntry.type === "docs" && !isMdxEntry(firstEntry)) && (firstIsBetter = !1);
+    let betterEntry = firstIsBetter ? firstEntry : secondEntry, worseEntry = firstIsBetter ? secondEntry : firstEntry, changeDocsName = 'Use `<Meta of={} name="Other Name">` to distinguish them.';
+    if (worseEntry.type === "story")
+      throw new IndexingError(`Duplicate stories with id: ${firstEntry.id}`, [
+        firstEntry.importPath,
+        secondEntry.importPath
+      ]);
+    if (betterEntry.type === "story") {
+      let worseDescriptor = isMdxEntry(worseEntry) ? "component docs page" : "automatically generated docs page", docsName = this.options.docs?.defaultName ?? "Docs";
+      throw betterEntry.name === docsName ? new IndexingError(
+        `You have a story for ${betterEntry.title} with the same name as your default docs entry name (${betterEntry.name}), so the docs page is being dropped. Consider changing the story name.`,
+        [firstEntry.importPath, secondEntry.importPath]
+      ) : new IndexingError(
+        `You have a story for ${betterEntry.title} with the same name as your ${worseDescriptor} (${worseEntry.name}), so the docs page is being dropped. ${changeDocsName}`,
+        [firstEntry.importPath, secondEntry.importPath]
+      );
+    } else if (isMdxEntry(betterEntry)) {
+      if (isMdxEntry(worseEntry))
+        throw new IndexingError(
+          `You have two component docs pages with the same name ${betterEntry.title}:${betterEntry.name}. ${changeDocsName}`,
+          [firstEntry.importPath, secondEntry.importPath]
+        );
+      if (worseEntry.tags?.includes(Tag.AUTODOCS) && !projectTags?.includes(Tag.AUTODOCS))
+        throw new IndexingError(
+          `You created a component docs page for '${worseEntry.title}', but also tagged the CSF file with '${Tag.AUTODOCS}'. This is probably a mistake.`,
+          [betterEntry.importPath, worseEntry.importPath]
+        );
+    } else
+      return {
+        ...betterEntry,
+        storiesImports: [
+          ...betterEntry.storiesImports,
+          worseEntry.importPath,
+          ...worseEntry.storiesImports
+        ]
+      };
+    return betterEntry;
+  }
+  async sortStories(entries, storySortParameter) {
+    let sortableStories = Object.values(entries), fileNameOrder = _StoryIndexGenerator.storyFileNames(this.specifierToCache);
+    return sortStoriesV7(sortableStories, storySortParameter, fileNameOrder), sortableStories.reduce(
+      (acc, item) => (acc[item.id] = item, acc),
+      {}
+    );
+  }
+  async getIndex() {
+    return (await this.getIndexAndStats()).storyIndex;
+  }
+  async getIndexAndStats() {
+    if (this.lastIndex && this.lastStats)
+      return { storyIndex: this.lastIndex, stats: this.lastStats };
+    if (this.lastError)
+      throw this.lastError;
+    let previewCode = await this.getPreviewCode(), projectTags = this.getProjectTags(previewCode), { entries: storiesList, stats } = await this.ensureExtracted({ projectTags });
+    try {
+      let errorEntries = storiesList.filter((entry) => entry.type === "error");
+      if (errorEntries.length)
+        throw new MultipleIndexingError(errorEntries.map((entry) => entry.err));
+      let duplicateErrors = [], indexEntries = {};
+      if (storiesList.forEach((entry) => {
+        try {
+          let existing = indexEntries[entry.id];
+          existing ? indexEntries[entry.id] = this.chooseDuplicate(existing, entry, projectTags) : indexEntries[entry.id] = entry;
+        } catch (err) {
+          err instanceof IndexingError && duplicateErrors.push(err);
+        }
+      }), duplicateErrors.length)
+        throw new MultipleIndexingError(duplicateErrors);
+      let sorted = await this.sortStories(
+        indexEntries,
+        combineStorySorts(this.options.storySorts ?? [])
+      );
+      return this.lastStats = stats, this.lastIndex = {
+        v: 5,
+        entries: sorted
+      }, { storyIndex: this.lastIndex, stats: this.lastStats };
+    } catch (err) {
+      throw this.lastError = err == null || err instanceof Error ? err : void 0, invariant(this.lastError), logger16.warn(`\u{1F6A8} ${this.lastError.toString()}`), this.lastError;
+    }
+  }
+  invalidateAll() {
+    this.specifierToCache.forEach((cache4) => {
+      Object.keys(cache4).forEach((key) => {
+        cache4[key] = !1;
+      });
+    }), this.lastIndex = null, this.lastError = null, this.invalidationListeners.forEach((listener) => listener());
+  }
+  invalidate(importPath, removed) {
+    let absolutePath = slash(resolve8(this.options.workingDir, importPath)), specifier = Array.from(this.specifierToCache.keys()).find(
+      (ns) => ns.importPathMatcher.exec(importPath)
+    );
+    if (!specifier)
+      return;
+    let cache4 = this.specifierToCache.get(specifier);
+    invariant(
+      cache4,
+      `specifier does not have a matching cache entry in specifierToCache: ${JSON.stringify(
+        specifier
+      )}`
+    );
+    let cacheEntry = cache4[absolutePath];
+    if (cacheEntry && cacheEntry.type === "stories") {
+      let { dependents } = cacheEntry, invalidated = /* @__PURE__ */ new Set();
+      this.specifierToCache.forEach((otherCache) => {
+        dependents.forEach((dep) => {
+          otherCache[dep] && (invalidated.add(dep), otherCache[dep] = !1);
+        });
+      });
+    }
+    if (removed) {
+      if (cacheEntry && cacheEntry.type === "docs") {
+        let absoluteImports = cacheEntry.storiesImports.map(
+          (p) => resolve8(this.options.workingDir, p)
+        );
+        this.findDependencies(absoluteImports).forEach(
+          (dep) => dep.dependents.splice(dep.dependents.indexOf(absolutePath), 1)
+        );
+      }
+      delete cache4[absolutePath];
+    } else
+      cache4[absolutePath] = !1;
+    this.lastIndex = null, this.lastError = null, this.invalidationListeners.forEach((listener) => listener());
+  }
+  onInvalidated(listener) {
+    return this.invalidationListeners.add(listener), () => {
+      this.invalidationListeners.delete(listener);
+    };
+  }
+  async getPreviewCode() {
+    let previewFile = ["js", "jsx", "ts", "tsx", "mjs", "cjs", "mts"].map((ext) => join10(this.options.configDir, `preview.${ext}`)).find((fname) => existsSync3(fname));
+    return previewFile && (await readFile4(previewFile, { encoding: "utf8" })).toString();
+  }
+  getProjectTags(previewCode) {
+    let projectTags = [], defaultTags = [Tag.DEV, Tag.TEST, Tag.MANIFEST];
+    if (previewCode)
+      try {
+        let projectAnnotations = loadConfig(previewCode).parse(), tags = projectAnnotations.getValue(["tags"]) ?? [];
+        invariant(
+          !projectAnnotations.mutationDiagnostics.some(
+            ({ code }) => code === "unsupported-value"
+          ) && Array.isArray(tags) && tags.every((tag) => typeof tag == "string"),
+          "Preview tags must be a static array of strings"
+        ), projectTags = tags;
+      } catch {
+        once.warn(dedent7`
+          Unable to parse tags from project configuration. If defined, tags should be specified inline, e.g.
+
+          export default {
+            tags: ['foo'],
+          }
+
+          ---
+
+          Received:
+
+          ${previewCode}
+        `);
+      }
+    return [...defaultTags, ...projectTags];
+  }
+  // Get the story file names in "imported order"
+  static storyFileNames(specifierToCache) {
+    return Array.from(specifierToCache.values()).flatMap((r) => Object.keys(r));
+  }
+};
+
+// src/core-server/build-index.ts
+var buildIndex = async (options) => {
+  let { presets } = await loadStorybook(options), [indexers, stories, docsOptions, features] = await Promise.all([
+    presets.apply("experimental_indexers", []),
+    presets.apply("stories", []),
+    presets.apply("docs"),
+    presets.apply("features")
+  ]), { configDir } = options, workingDir = process.cwd(), directories = {
+    configDir,
+    workingDir
+  }, normalizedStories = normalizeStories2(stories, directories), generator = new StoryIndexGenerator(normalizedStories, {
+    ...directories,
+    indexers,
+    docs: docsOptions,
+    build: {},
+    features,
+    storySorts: await presets.apply("storySorts", [])
+  });
+  return await generator.initialize(), generator.getIndex();
+}, buildIndexStandalone = async (options) => {
+  let index = await buildIndex(options);
+  logger17.info(`Writing index to ${options.outputFile}`), await writeFile4(options.outputFile, JSON.stringify(index));
+};
+
+// src/core-server/standalone.ts
+async function build(options = {}, frameworkOptions = {}) {
+  let { mode = "dev" } = options, { default: packageJson } = await import("@aussieljk/forkbook/package.json", { with: { type: "json" } }), commonOptions = {
+    ...options,
+    ...frameworkOptions,
+    frameworkPresets: [
+      ...options.frameworkPresets || [],
+      ...frameworkOptions.frameworkPresets || []
+    ],
+    packageJson
+  };
+  if (mode === "dev")
+    return buildDevStandalone(commonOptions);
+  if (mode === "static")
+    return buildStaticStandalone(commonOptions);
+  if (mode === "index")
+    return buildIndexStandalone(commonOptions);
+  throw new Error("'mode' parameter should be either 'dev', 'static', or 'index'");
+}
+var standalone_default = build;
+
+// src/core-server/utils/get-stories-paths-from-config.ts
+import { normalizeStories as normalizeStories3 } from "@aussieljk/forkbook/internal/common";
+var getStoriesPathsFromConfig = async ({
+  stories,
+  configDir,
+  workingDir
+}) => {
+  if (stories.length === 0)
+    return [];
+  let normalizedStories = normalizeStories3(stories, { configDir, workingDir });
+  return (await StoryIndexGenerator.findMatchingFilesForSpecifiers(
+    normalizedStories,
+    workingDir,
+    !0
+  )).flatMap(
+    ([specifier, cache4]) => StoryIndexGenerator.storyFileNames(/* @__PURE__ */ new Map([[specifier, cache4]]))
+  );
+};
+
+// src/shared/open-service/services/story-docs/provider.ts
+import { logger as logger18 } from "@aussieljk/forkbook/internal/node-logger";
+function createWorkerGatedStoryDocsProvider({
+  label,
+  docgenWorker,
+  storyFileTest = STORY_FILE_TEST_REGEXP,
+  build: build2
+}) {
+  return async (nextStoryDocs, options) => (await options.presets.apply(
+    "experimental_docgenProvider",
+    []
+  )).some((descriptor) => descriptor.moduleSpecifier === docgenWorker) ? async (input) => {
+    let storyImportPath = getStoryImportPathFromEntry(input.entry);
+    if (!storyImportPath || !storyFileTest.test(storyImportPath))
+      return nextStoryDocs(input);
+    let ours;
+    try {
+      ours = await build2(input);
+    } catch (error) {
+      return logger18.debug(
+        `${label} story snippets are unavailable for ${storyImportPath}: ${error instanceof Error ? error.message : String(error)}`
+      ), nextStoryDocs(input);
+    }
+    return ours ? { ...await nextStoryDocs(input), ...ours } : nextStoryDocs(input);
+  } : nextStoryDocs;
+}
+
+// src/shared/universal-store/mock.ts
+import { Channel as Channel5 } from "@aussieljk/forkbook/internal/channels";
+import { dedent as dedent8 } from "ts-dedent";
+var MockUniversalStore = class _MockUniversalStore extends UniversalStore {
+  constructor(options, testUtils) {
+    UniversalStore.isInternalConstructing = !0, super(
+      { ...options, leader: !0 },
+      { channel: new Channel5({}), environment: UniversalStore.Environment.MOCK }
+    ), UniversalStore.isInternalConstructing = !1, typeof testUtils?.fn == "function" && (this.testUtils = testUtils, this.getState = testUtils.fn(this.getState), this.setState = testUtils.fn(this.setState), this.subscribe = testUtils.fn(this.subscribe), this.onStateChange = testUtils.fn(this.onStateChange), this.send = testUtils.fn(this.send));
+  }
+  /** Create a mock universal store. This is just an alias for the constructor */
+  static create(options, testUtils) {
+    return new _MockUniversalStore(options, testUtils);
+  }
+  unsubscribeAll() {
+    if (!this.testUtils)
+      throw new Error(
+        dedent8`Cannot call unsubscribeAll on a store that does not have testUtils.
+        Please provide testUtils as the second argument when creating the store.`
+      );
+    let callReturnedUnsubscribeFn = (result) => {
+      try {
+        result.value();
+      } catch {
+      }
+    };
+    this.subscribe.mock?.results.forEach(callReturnedUnsubscribeFn), this.onStateChange.mock?.results.forEach(callReturnedUnsubscribeFn);
+  }
+};
+export {
+  ChangeDetectionFailureError,
+  ChangeDetectionService,
+  ChangeDetectionUnavailableError,
+  MDX_SERVICE_ID,
+  StoryIndexGenerator,
+  Tag,
+  analyzeMdx,
+  analyzeTestResults,
+  standalone_default as build,
+  buildDevStandalone,
+  buildIndex,
+  buildIndexStandalone,
+  buildStaticStandalone,
+  createDocsToolset,
+  createLocalDocsAccess,
+  createManifestDocsAccess,
+  createServiceDocsAccess,
+  createStoriesToolset,
+  createWorkerGatedStoryDocsProvider,
+  describeService,
+  emptyManifests,
+  MockUniversalStore as experimental_MockUniversalStore,
+  defineService as experimental_defineService,
+  getChangeDetectionReadiness as experimental_getChangeDetectionReadiness,
+  getStatusStoreByTypeId as experimental_getStatusStore,
+  getTestProviderStoreById as experimental_getTestProviderStore,
+  loadStorybook as experimental_loadStorybook,
+  registerService as experimental_registerService,
+  resetChangeDetectionReadiness as experimental_resetChangeDetectionReadiness,
+  resetServicesPresetOnce as experimental_resetServicesPresetOnce,
+  setChangeDetectionHost as experimental_setChangeDetectionHost,
+  findStoryIds,
+  getBuilders,
+  getComponentCandidates,
+  getEffectiveToolAvailability,
+  getErrorLevel,
+  getManifestStatus,
+  getPreviewBodyTemplate,
+  getPreviewHeadTemplate,
+  getRefsFromConfig,
+  getServerPort,
+  getService,
+  getStoriesPathsFromConfig,
+  getToolAvailability,
+  UniversalStore as internal_UniversalStore,
+  fullStatusStore as internal_fullStatusStore,
+  fullTestProviderStore as internal_fullTestProviderStore,
+  universalStatusStore as internal_universalStatusStore,
+  universalTestProviderStore as internal_universalTestProviderStore,
+  isAddonA11yEnabled,
+  isAddonVitestEnabled,
+  isModuleGraphSupported,
+  isValidHost,
+  listServices,
+  loadManifests,
+  mapStaticDir,
+  mdxManifestRef,
+  mdxQueryStaticPath,
+  mdxStaticStorePath,
+  prepareHeadlessUniversalStores,
+  registerToolset,
+  resolveChangeDetectionAdapter,
+  resolveSkillInputs,
+  reviewToolset,
+  runStoryTests,
+  sendTelemetryError,
+  storyInputArraySchema,
+  toStoryTestResult,
+  withTelemetry
+};