flavor-code 1.4.2 → 1.4.3

package/dist/chunk-ONRY3C2L.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+import { createRequire as createFlavorRequire } from "node:module"; const require = createFlavorRequire(import.meta.url);
+import {
+  external_exports
+} from "./chunk-EWD7FWTH.js";
+
+// src/config/schema.ts
+var PERMISSION_MODES = [
+  "default",
+  "acceptEdits",
+  "plan",
+  "bypassPermissions",
+  "auto",
+  "bubble"
+];
+function normalizePermissionMode(value) {
+  if (value === "safe" || value === "workspace") return "default";
+  if (value === "full") return "bypassPermissions";
+  return value;
+}
+var PermissionModeSchema = external_exports.preprocess(
+  normalizePermissionMode,
+  external_exports.enum(PERMISSION_MODES).default("default")
+);
+var ProviderConfigSchema = external_exports.object({
+  type: external_exports.string(),
+  baseURL: external_exports.string().url().optional(),
+  apiKey: external_exports.string().optional(),
+  defaultModel: external_exports.string().min(1).optional(),
+  cheapModel: external_exports.string().min(1).optional(),
+  models: external_exports.array(external_exports.string().min(1)).max(100).optional(),
+  maxOutputTokens: external_exports.number().int().positive().optional(),
+  // Extended-thinking budget in output tokens for the Anthropic protocol.
+  // Defaults to DEFAULT_THINKING_BUDGET; set to 0 to disable the request
+  // parameter. Provider thinking deltas are forwarded whenever they arrive.
+  thinkingBudget: external_exports.number().int().min(0).optional(),
+  // Anthropic explicit prompt-cache lifetime. Omitted keeps the broadly
+  // compatible provider default (5 minutes); 1h trades higher writes for
+  // better reuse across longer pauses.
+  cacheTtl: external_exports.enum(["5m", "1h"]).optional(),
+  // Reasoning effort requested from the OpenAI Responses protocol (sent as
+  // reasoning.effort). The adapter defaults an omitted value to high.
+  thinkingEffort: external_exports.enum(["minimal", "low", "medium", "high", "xhigh", "ultra"]).optional(),
+  // Send the Claude Code client fingerprint (User-Agent/x-app) with Anthropic requests,
+  // for gateways that restrict the Anthropic protocol to Claude clients.
+  claudeClient: external_exports.boolean().optional(),
+  // OAuth PKCE fields
+  apiType: external_exports.enum(["openai", "anthropic"]).optional(),
+  authorizationUrl: external_exports.string().url().optional(),
+  tokenUrl: external_exports.string().url().optional(),
+  clientId: external_exports.string().min(1).optional(),
+  scope: external_exports.string().optional()
+});
+var McpServerCommonShape = {
+  disabled: external_exports.boolean().default(false),
+  timeoutMs: external_exports.number().int().min(100).max(30 * 6e4).default(6e4)
+};
+var McpStdioServerConfigSchema = external_exports.object({
+  command: external_exports.string().min(1),
+  args: external_exports.array(external_exports.string()).default([]),
+  env: external_exports.record(external_exports.string(), external_exports.string()).default({}),
+  cwd: external_exports.string().min(1).optional(),
+  ...McpServerCommonShape
+}).strict();
+var McpHttpServerConfigSchema = external_exports.object({
+  url: external_exports.string().url().refine((value) => {
+    const protocol = new URL(value).protocol;
+    return protocol === "http:" || protocol === "https:";
+  }, "MCP HTTP URLs must use http or https"),
+  headers: external_exports.record(external_exports.string(), external_exports.string()).default({}),
+  ...McpServerCommonShape
+}).strict();
+var McpServerConfigSchema = external_exports.union([
+  McpStdioServerConfigSchema,
+  McpHttpServerConfigSchema
+]);
+var McpServerNameSchema = external_exports.string().min(1).max(32).regex(/^[A-Za-z0-9_-]+$/, "MCP server names may contain only letters, digits, underscores, and hyphens");
+var SkillNameSchema = external_exports.string().min(1).max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Skill names must use lowercase letters, digits, and single hyphens");
+var FlavorConfigSchema = external_exports.object({
+  sleep: external_exports.boolean().default(false),
+  providers: external_exports.record(external_exports.string(), ProviderConfigSchema).default({}),
+  mcpServers: external_exports.record(McpServerNameSchema, McpServerConfigSchema).default({}),
+  skills: external_exports.object({
+    disabled: external_exports.array(SkillNameSchema).max(1e3).default([])
+  }).prefault({}),
+  globalInstructions: external_exports.object({
+    enabled: external_exports.boolean().default(true)
+  }).prefault({}),
+  agents: external_exports.object({
+    main: external_exports.object({ model: external_exports.string() }).optional(),
+    subagent: external_exports.object({ model: external_exports.string() }).optional()
+  }).optional(),
+  maxSubagents: external_exports.number().int().min(1).max(16).default(3),
+  maxSessions: external_exports.number().int().min(1).max(1e3).default(50),
+  memory: external_exports.object({
+    enabled: external_exports.boolean().default(true),
+    autoExtract: external_exports.boolean().default(true),
+    autoExtractMinChars: external_exports.number().int().min(200).max(1e5).default(200),
+    scoreThreshold: external_exports.number().int().min(0).max(12).default(9),
+    autoStoreThreshold: external_exports.number().int().min(0).max(12).default(11),
+    ignoreStreakLimit: external_exports.number().int().min(2).max(100).default(5),
+    reviewAutoDismissSeconds: external_exports.number().int().min(0).max(300).default(5),
+    // One candidate per task is a deliberate memory-quality boundary, not a tunable range.
+    maxCandidatesPerTask: external_exports.literal(1).default(1),
+    retrievalTopK: external_exports.number().int().min(1).max(20).default(5),
+    maxEntries: external_exports.number().int().min(1).max(1e4).default(200),
+    maxEntryChars: external_exports.number().int().min(32).max(2e4).default(1e3),
+    maxPromptChars: external_exports.number().int().min(256).max(2e5).default(12e3)
+  }).prefault({}),
+  permissionMode: PermissionModeSchema,
+  execution: external_exports.object({
+    mode: external_exports.enum(["local", "docker"]).default("local"),
+    image: external_exports.string().trim().min(1).default("node:24-bookworm-slim"),
+    network: external_exports.boolean().default(false),
+    memory: external_exports.string().regex(/^[1-9][0-9]*(?:[kKmMgG])?$/).default("2g"),
+    cpus: external_exports.number().positive().max(64).default(2)
+  }).prefault({}),
+  language: external_exports.string().regex(/^[a-z]{2}(-[A-Z]{2})?$/, "language must be a BCP47 tag like zh-CN or en-US").optional(),
+  hallucination: external_exports.object({
+    showWarnings: external_exports.boolean().default(false),
+    evaluationTimeoutMs: external_exports.number().int().min(100).max(3e4).default(2e3)
+  }).prefault({}),
+  maxIterations: external_exports.object({
+    main: external_exports.number().int().min(10).max(500).default(300),
+    subagent: external_exports.number().int().min(10).max(200).default(100),
+    softLimitFactor: external_exports.number().min(0.5).max(1).default(0.8),
+    extendBy: external_exports.number().int().min(5).max(100).default(50)
+  }).prefault({}),
+  loop: external_exports.object({
+    maxCycles: external_exports.number().int().positive().max(1e4).default(100),
+    maxTokens: external_exports.number().int().positive().max(Number.MAX_SAFE_INTEGER).default(5e5),
+    isolation: external_exports.literal("auto").default("auto")
+  }).prefault({}),
+  goal: external_exports.object({
+    maxRounds: external_exports.number().int().positive().max(1e4).default(100),
+    maxStallStreak: external_exports.number().int().positive().max(100).default(3)
+  }).prefault({}),
+  context: external_exports.object({
+    windowTokens: external_exports.number().int().positive().default(2e5),
+    reservedOutputTokens: external_exports.number().int().nonnegative().default(2e4),
+    autoCompactBufferTokens: external_exports.number().int().nonnegative().default(27e3),
+    warningBufferTokens: external_exports.number().int().nonnegative().default(2e4),
+    blockingBufferTokens: external_exports.number().int().nonnegative().default(3e3),
+    microcompactKeepRecentToolResults: external_exports.number().int().nonnegative().default(5),
+    recentTokens: external_exports.number().int().nonnegative().default(1e4),
+    recentTextMessages: external_exports.number().int().nonnegative().default(5),
+    maxRecentTokens: external_exports.number().int().nonnegative().default(4e4),
+    /** @deprecated Character threshold retained for configuration compatibility. */
+    compactAtChars: external_exports.number().int().positive().optional(),
+    toolOutputChars: external_exports.number().int().positive().default(3e4)
+  }).superRefine((context, issue) => {
+    if (context.reservedOutputTokens >= context.windowTokens) issue.addIssue({
+      code: "custom",
+      path: ["reservedOutputTokens"],
+      message: "reservedOutputTokens must be below windowTokens"
+    });
+    if (context.maxRecentTokens < context.recentTokens) issue.addIssue({
+      code: "custom",
+      path: ["maxRecentTokens"],
+      message: "maxRecentTokens must be at least recentTokens"
+    });
+  }).prefault({}),
+  incidents: external_exports.object({
+    enabled: external_exports.boolean().default(false),
+    webhookUrl: external_exports.string().url().optional()
+  }).prefault({}),
+  evolve: external_exports.object({
+    promptTop: external_exports.number().int().min(1).max(10).default(3),
+    minRepeats: external_exports.number().int().min(2).max(100).default(2),
+    testCommand: external_exports.string().trim().min(1).default("npm test"),
+    testTimeoutMs: external_exports.number().int().min(1e3).max(6e5).default(12e4)
+  }).prefault({})
+});
+var CONFIG_TOP_LEVEL_KEYS = Object.keys(FlavorConfigSchema.shape);
+function configPathSegments(key) {
+  const segments = key.split(".");
+  if (segments.length === 0 || segments.some((segment) => segment.length === 0)) {
+    throw new Error(`Invalid configuration key: "${key}". Use dot notation like "maxSessions" or "context.windowTokens".`);
+  }
+  if (!CONFIG_TOP_LEVEL_KEYS.includes(segments[0])) {
+    throw new Error(`Unknown configuration key: "${segments[0]}". Known keys: ${CONFIG_TOP_LEVEL_KEYS.join(", ")}.`);
+  }
+  return segments;
+}
+
+export {
+  PERMISSION_MODES,
+  normalizePermissionMode,
+  PermissionModeSchema,
+  ProviderConfigSchema,
+  McpServerConfigSchema,
+  McpServerNameSchema,
+  SkillNameSchema,
+  FlavorConfigSchema,
+  configPathSegments
+};

package/dist/chunk-PULWAH6E.js

@@ -0,0 +1,474 @@
+#!/usr/bin/env node
+import { createRequire as createFlavorRequire } from "node:module"; const require = createFlavorRequire(import.meta.url);
+import {
+  __commonJS
+} from "./chunk-ZKKVSR37.js";
+
+// node_modules/react/cjs/react.production.js
+var require_react_production = __commonJS({
+  "node_modules/react/cjs/react.production.js"(exports) {
+    "use strict";
+    var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element");
+    var REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal");
+    var REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment");
+    var REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for("react.strict_mode");
+    var REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for("react.profiler");
+    var REACT_CONSUMER_TYPE = /* @__PURE__ */ Symbol.for("react.consumer");
+    var REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.context");
+    var REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref");
+    var REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for("react.suspense");
+    var REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo");
+    var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
+    var REACT_ACTIVITY_TYPE = /* @__PURE__ */ Symbol.for("react.activity");
+    var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+    function getIteratorFn(maybeIterable) {
+      if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
+      maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+      return "function" === typeof maybeIterable ? maybeIterable : null;
+    }
+    var ReactNoopUpdateQueue = {
+      isMounted: function() {
+        return false;
+      },
+      enqueueForceUpdate: function() {
+      },
+      enqueueReplaceState: function() {
+      },
+      enqueueSetState: function() {
+      }
+    };
+    var assign = Object.assign;
+    var emptyObject = {};
+    function Component(props, context, updater) {
+      this.props = props;
+      this.context = context;
+      this.refs = emptyObject;
+      this.updater = updater || ReactNoopUpdateQueue;
+    }
+    Component.prototype.isReactComponent = {};
+    Component.prototype.setState = function(partialState, callback) {
+      if ("object" !== typeof partialState && "function" !== typeof partialState && null != partialState)
+        throw Error(
+          "takes an object of state variables to update or a function which returns an object of state variables."
+        );
+      this.updater.enqueueSetState(this, partialState, callback, "setState");
+    };
+    Component.prototype.forceUpdate = function(callback) {
+      this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
+    };
+    function ComponentDummy() {
+    }
+    ComponentDummy.prototype = Component.prototype;
+    function PureComponent(props, context, updater) {
+      this.props = props;
+      this.context = context;
+      this.refs = emptyObject;
+      this.updater = updater || ReactNoopUpdateQueue;
+    }
+    var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
+    pureComponentPrototype.constructor = PureComponent;
+    assign(pureComponentPrototype, Component.prototype);
+    pureComponentPrototype.isPureReactComponent = true;
+    var isArrayImpl = Array.isArray;
+    function noop() {
+    }
+    var ReactSharedInternals = { H: null, A: null, T: null, S: null };
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+    function ReactElement(type, key, props) {
+      var refProp = props.ref;
+      return {
+        $$typeof: REACT_ELEMENT_TYPE,
+        type,
+        key,
+        ref: void 0 !== refProp ? refProp : null,
+        props
+      };
+    }
+    function cloneAndReplaceKey(oldElement, newKey) {
+      return ReactElement(oldElement.type, newKey, oldElement.props);
+    }
+    function isValidElement(object) {
+      return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    function escape(key) {
+      var escaperLookup = { "=": "=0", ":": "=2" };
+      return "$" + key.replace(/[=:]/g, function(match) {
+        return escaperLookup[match];
+      });
+    }
+    var userProvidedKeyEscapeRegex = /\/+/g;
+    function getElementKey(element, index) {
+      return "object" === typeof element && null !== element && null != element.key ? escape("" + element.key) : index.toString(36);
+    }
+    function resolveThenable(thenable) {
+      switch (thenable.status) {
+        case "fulfilled":
+          return thenable.value;
+        case "rejected":
+          throw thenable.reason;
+        default:
+          switch ("string" === typeof thenable.status ? thenable.then(noop, noop) : (thenable.status = "pending", thenable.then(
+            function(fulfilledValue) {
+              "pending" === thenable.status && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
+            },
+            function(error) {
+              "pending" === thenable.status && (thenable.status = "rejected", thenable.reason = error);
+            }
+          )), thenable.status) {
+            case "fulfilled":
+              return thenable.value;
+            case "rejected":
+              throw thenable.reason;
+          }
+      }
+      throw thenable;
+    }
+    function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+      var type = typeof children;
+      if ("undefined" === type || "boolean" === type) children = null;
+      var invokeCallback = false;
+      if (null === children) invokeCallback = true;
+      else
+        switch (type) {
+          case "bigint":
+          case "string":
+          case "number":
+            invokeCallback = true;
+            break;
+          case "object":
+            switch (children.$$typeof) {
+              case REACT_ELEMENT_TYPE:
+              case REACT_PORTAL_TYPE:
+                invokeCallback = true;
+                break;
+              case REACT_LAZY_TYPE:
+                return invokeCallback = children._init, mapIntoArray(
+                  invokeCallback(children._payload),
+                  array,
+                  escapedPrefix,
+                  nameSoFar,
+                  callback
+                );
+            }
+        }
+      if (invokeCallback)
+        return callback = callback(children), invokeCallback = "" === nameSoFar ? "." + getElementKey(children, 0) : nameSoFar, isArrayImpl(callback) ? (escapedPrefix = "", null != invokeCallback && (escapedPrefix = invokeCallback.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function(c) {
+          return c;
+        })) : null != callback && (isValidElement(callback) && (callback = cloneAndReplaceKey(
+          callback,
+          escapedPrefix + (null == callback.key || children && children.key === callback.key ? "" : ("" + callback.key).replace(
+            userProvidedKeyEscapeRegex,
+            "$&/"
+          ) + "/") + invokeCallback
+        )), array.push(callback)), 1;
+      invokeCallback = 0;
+      var nextNamePrefix = "" === nameSoFar ? "." : nameSoFar + ":";
+      if (isArrayImpl(children))
+        for (var i = 0; i < children.length; i++)
+          nameSoFar = children[i], type = nextNamePrefix + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(
+            nameSoFar,
+            array,
+            escapedPrefix,
+            type,
+            callback
+          );
+      else if (i = getIteratorFn(children), "function" === typeof i)
+        for (children = i.call(children), i = 0; !(nameSoFar = children.next()).done; )
+          nameSoFar = nameSoFar.value, type = nextNamePrefix + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(
+            nameSoFar,
+            array,
+            escapedPrefix,
+            type,
+            callback
+          );
+      else if ("object" === type) {
+        if ("function" === typeof children.then)
+          return mapIntoArray(
+            resolveThenable(children),
+            array,
+            escapedPrefix,
+            nameSoFar,
+            callback
+          );
+        array = String(children);
+        throw Error(
+          "Objects are not valid as a React child (found: " + ("[object Object]" === array ? "object with keys {" + Object.keys(children).join(", ") + "}" : array) + "). If you meant to render a collection of children, use an array instead."
+        );
+      }
+      return invokeCallback;
+    }
+    function mapChildren(children, func, context) {
+      if (null == children) return children;
+      var result = [], count = 0;
+      mapIntoArray(children, result, "", "", function(child) {
+        return func.call(context, child, count++);
+      });
+      return result;
+    }
+    function lazyInitializer(payload) {
+      if (-1 === payload._status) {
+        var ctor = payload._result;
+        ctor = ctor();
+        ctor.then(
+          function(moduleObject) {
+            if (0 === payload._status || -1 === payload._status)
+              payload._status = 1, payload._result = moduleObject;
+          },
+          function(error) {
+            if (0 === payload._status || -1 === payload._status)
+              payload._status = 2, payload._result = error;
+          }
+        );
+        -1 === payload._status && (payload._status = 0, payload._result = ctor);
+      }
+      if (1 === payload._status) return payload._result.default;
+      throw payload._result;
+    }
+    var reportGlobalError = "function" === typeof reportError ? reportError : function(error) {
+      if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
+        var event = new window.ErrorEvent("error", {
+          bubbles: true,
+          cancelable: true,
+          message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
+          error
+        });
+        if (!window.dispatchEvent(event)) return;
+      } else if ("object" === typeof process && "function" === typeof process.emit) {
+        process.emit("uncaughtException", error);
+        return;
+      }
+      console.error(error);
+    };
+    var Children = {
+      map: mapChildren,
+      forEach: function(children, forEachFunc, forEachContext) {
+        mapChildren(
+          children,
+          function() {
+            forEachFunc.apply(this, arguments);
+          },
+          forEachContext
+        );
+      },
+      count: function(children) {
+        var n = 0;
+        mapChildren(children, function() {
+          n++;
+        });
+        return n;
+      },
+      toArray: function(children) {
+        return mapChildren(children, function(child) {
+          return child;
+        }) || [];
+      },
+      only: function(children) {
+        if (!isValidElement(children))
+          throw Error(
+            "React.Children.only expected to receive a single React element child."
+          );
+        return children;
+      }
+    };
+    exports.Activity = REACT_ACTIVITY_TYPE;
+    exports.Children = Children;
+    exports.Component = Component;
+    exports.Fragment = REACT_FRAGMENT_TYPE;
+    exports.Profiler = REACT_PROFILER_TYPE;
+    exports.PureComponent = PureComponent;
+    exports.StrictMode = REACT_STRICT_MODE_TYPE;
+    exports.Suspense = REACT_SUSPENSE_TYPE;
+    exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
+    exports.__COMPILER_RUNTIME = {
+      __proto__: null,
+      c: function(size) {
+        return ReactSharedInternals.H.useMemoCache(size);
+      }
+    };
+    exports.cache = function(fn) {
+      return function() {
+        return fn.apply(null, arguments);
+      };
+    };
+    exports.cacheSignal = function() {
+      return null;
+    };
+    exports.cloneElement = function(element, config, children) {
+      if (null === element || void 0 === element)
+        throw Error(
+          "The argument must be a React element, but you passed " + element + "."
+        );
+      var props = assign({}, element.props), key = element.key;
+      if (null != config)
+        for (propName in void 0 !== config.key && (key = "" + config.key), config)
+          !hasOwnProperty.call(config, propName) || "key" === propName || "__self" === propName || "__source" === propName || "ref" === propName && void 0 === config.ref || (props[propName] = config[propName]);
+      var propName = arguments.length - 2;
+      if (1 === propName) props.children = children;
+      else if (1 < propName) {
+        for (var childArray = Array(propName), i = 0; i < propName; i++)
+          childArray[i] = arguments[i + 2];
+        props.children = childArray;
+      }
+      return ReactElement(element.type, key, props);
+    };
+    exports.createContext = function(defaultValue) {
+      defaultValue = {
+        $$typeof: REACT_CONTEXT_TYPE,
+        _currentValue: defaultValue,
+        _currentValue2: defaultValue,
+        _threadCount: 0,
+        Provider: null,
+        Consumer: null
+      };
+      defaultValue.Provider = defaultValue;
+      defaultValue.Consumer = {
+        $$typeof: REACT_CONSUMER_TYPE,
+        _context: defaultValue
+      };
+      return defaultValue;
+    };
+    exports.createElement = function(type, config, children) {
+      var propName, props = {}, key = null;
+      if (null != config)
+        for (propName in void 0 !== config.key && (key = "" + config.key), config)
+          hasOwnProperty.call(config, propName) && "key" !== propName && "__self" !== propName && "__source" !== propName && (props[propName] = config[propName]);
+      var childrenLength = arguments.length - 2;
+      if (1 === childrenLength) props.children = children;
+      else if (1 < childrenLength) {
+        for (var childArray = Array(childrenLength), i = 0; i < childrenLength; i++)
+          childArray[i] = arguments[i + 2];
+        props.children = childArray;
+      }
+      if (type && type.defaultProps)
+        for (propName in childrenLength = type.defaultProps, childrenLength)
+          void 0 === props[propName] && (props[propName] = childrenLength[propName]);
+      return ReactElement(type, key, props);
+    };
+    exports.createRef = function() {
+      return { current: null };
+    };
+    exports.forwardRef = function(render) {
+      return { $$typeof: REACT_FORWARD_REF_TYPE, render };
+    };
+    exports.isValidElement = isValidElement;
+    exports.lazy = function(ctor) {
+      return {
+        $$typeof: REACT_LAZY_TYPE,
+        _payload: { _status: -1, _result: ctor },
+        _init: lazyInitializer
+      };
+    };
+    exports.memo = function(type, compare) {
+      return {
+        $$typeof: REACT_MEMO_TYPE,
+        type,
+        compare: void 0 === compare ? null : compare
+      };
+    };
+    exports.startTransition = function(scope) {
+      var prevTransition = ReactSharedInternals.T, currentTransition = {};
+      ReactSharedInternals.T = currentTransition;
+      try {
+        var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
+        null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
+        "object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && returnValue.then(noop, reportGlobalError);
+      } catch (error) {
+        reportGlobalError(error);
+      } finally {
+        null !== prevTransition && null !== currentTransition.types && (prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
+      }
+    };
+    exports.unstable_useCacheRefresh = function() {
+      return ReactSharedInternals.H.useCacheRefresh();
+    };
+    exports.use = function(usable) {
+      return ReactSharedInternals.H.use(usable);
+    };
+    exports.useActionState = function(action, initialState, permalink) {
+      return ReactSharedInternals.H.useActionState(action, initialState, permalink);
+    };
+    exports.useCallback = function(callback, deps) {
+      return ReactSharedInternals.H.useCallback(callback, deps);
+    };
+    exports.useContext = function(Context) {
+      return ReactSharedInternals.H.useContext(Context);
+    };
+    exports.useDebugValue = function() {
+    };
+    exports.useDeferredValue = function(value, initialValue) {
+      return ReactSharedInternals.H.useDeferredValue(value, initialValue);
+    };
+    exports.useEffect = function(create, deps) {
+      return ReactSharedInternals.H.useEffect(create, deps);
+    };
+    exports.useEffectEvent = function(callback) {
+      return ReactSharedInternals.H.useEffectEvent(callback);
+    };
+    exports.useId = function() {
+      return ReactSharedInternals.H.useId();
+    };
+    exports.useImperativeHandle = function(ref, create, deps) {
+      return ReactSharedInternals.H.useImperativeHandle(ref, create, deps);
+    };
+    exports.useInsertionEffect = function(create, deps) {
+      return ReactSharedInternals.H.useInsertionEffect(create, deps);
+    };
+    exports.useLayoutEffect = function(create, deps) {
+      return ReactSharedInternals.H.useLayoutEffect(create, deps);
+    };
+    exports.useMemo = function(create, deps) {
+      return ReactSharedInternals.H.useMemo(create, deps);
+    };
+    exports.useOptimistic = function(passthrough, reducer) {
+      return ReactSharedInternals.H.useOptimistic(passthrough, reducer);
+    };
+    exports.useReducer = function(reducer, initialArg, init) {
+      return ReactSharedInternals.H.useReducer(reducer, initialArg, init);
+    };
+    exports.useRef = function(initialValue) {
+      return ReactSharedInternals.H.useRef(initialValue);
+    };
+    exports.useState = function(initialState) {
+      return ReactSharedInternals.H.useState(initialState);
+    };
+    exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
+      return ReactSharedInternals.H.useSyncExternalStore(
+        subscribe,
+        getSnapshot,
+        getServerSnapshot
+      );
+    };
+    exports.useTransition = function() {
+      return ReactSharedInternals.H.useTransition();
+    };
+    exports.version = "19.2.7";
+  }
+});
+
+// node_modules/react/index.js
+var require_react = __commonJS({
+  "node_modules/react/index.js"(exports, module) {
+    if (true) {
+      module.exports = require_react_production();
+    } else {
+      module.exports = null;
+    }
+  }
+});
+
+export {
+  require_react
+};
+/*! Bundled license information:
+
+react/cjs/react.production.js:
+  (**
+   * @license React
+   * react.production.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+*/