@apicircle/shared 1.0.0

package/LICENSE

@@ -0,0 +1,110 @@
+APICircle Studio License
+Custom Source-Available License, v1.0
+
+Copyright (c) 2026 Deva Prakash ("Licensor")
+
+The source code in this repository ("the Software") is made available for
+the purposes of transparency, security review, contribution, and personal
+evaluation. This is NOT an open-source license as defined by the Open
+Source Initiative.
+
+0. Definitions
+
+   "Commercial Use" means any use of the Software that is intended for
+   or directed toward commercial advantage or monetary compensation,
+   whether direct or indirect, including without limitation:
+
+   (a) using the Software to build, test, develop, deploy, or operate
+       any product, service, application, or system that is sold,
+       licensed, hosted, distributed, or otherwise made available to
+       any third party for a fee or other consideration;
+   (b) using the Software in the course of paid employment, paid
+       consulting, paid contracting, freelance work, or any other
+       revenue-generating activity, regardless of whether the Software
+       itself is sold or transferred;
+   (c) using the Software internally within a for-profit organization
+       beyond the Evaluation Period defined below;
+   (d) integrating the Software, or any portion of it, into any tool,
+       pipeline, automation, or workflow that supports the commercial
+       operations of any business;
+   (e) using the Software to provide a hosted, managed, or embedded
+       service of any kind to a third party, whether free or paid.
+
+   "Non-Commercial Use" means any use that is not Commercial Use,
+   including personal hobby projects, individual learning, academic
+   research, classroom instruction, and good-faith contribution to
+   this repository.
+
+   "Evaluation Period" means a single, continuous period of up to
+   thirty (30) days during which a for-profit organization may
+   internally evaluate the Software at no charge. After the Evaluation
+   Period expires, any further use of the Software by that organization
+   constitutes Commercial Use and requires a separate commercial
+   license from the Licensor.
+
+1. Permitted Use
+
+   You may, without charge:
+
+   (a) view, read, and study the source code of the Software;
+   (b) run the Software, in source or compiled form, for your own
+       Non-Commercial Use, or for Commercial Use solely within the
+       Evaluation Period;
+   (c) submit improvements to the Software back to this repository via
+       pull request, subject to Section 3 (Contributions).
+
+2. Prohibited Use
+
+   Without prior written permission from the Licensor, you may NOT:
+
+   (a) make any Commercial Use of the Software, in whole or in part,
+       except during the Evaluation Period as defined in Section 0;
+   (b) redistribute the Software, in source or compiled form, whether
+       modified or unmodified, to any third party;
+   (c) sublicense, sell, rent, lease, or otherwise transfer the
+       Software or any rights granted herein;
+   (d) remove, obscure, or alter any copyright, trademark, attribution,
+       or license notice contained in the Software;
+   (e) use the names "APICircle", "API Circle Studio", or any related
+       logos or trademarks, except as required for accurate attribution.
+
+3. Contributions
+
+   By submitting any contribution (including but not limited to code,
+   documentation, or assets) to this repository, you grant the Licensor
+   a perpetual, worldwide, irrevocable, royalty-free, sublicensable
+   license to use, modify, distribute, and relicense your contribution
+   under any terms, including the terms of this license or any future
+   version thereof.
+
+4. No Trademark License
+
+   This license does not grant permission to use the trade names,
+   trademarks, service marks, or product names of the Licensor, except
+   as required for reasonable and customary use in describing the
+   origin of the Software.
+
+5. Termination
+
+   The rights granted in Section 1 terminate automatically if you
+   breach any term of this license. Upon termination, you must cease
+   all use of the Software and destroy all copies in your possession.
+
+6. Disclaimer of Warranty
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE, AND
+   NON-INFRINGEMENT.
+
+7. Limitation of Liability
+
+   IN NO EVENT SHALL THE LICENSOR BE LIABLE FOR ANY CLAIM, DAMAGES, OR
+   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR
+   OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE
+   OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+8. Commercial Licensing
+
+   For commercial licensing, redistribution, or any use not permitted
+   under Section 1, contact: apicircle365@gmail.com

package/README.md

@@ -0,0 +1,27 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/apicircle/studio/main/assets/logo.png" alt="APICircle Studio" width="120" height="120" />
+</p>
+
+<h1 align="center">@apicircle/shared</h1>
+
+Shared foundation for [APICircle Studio](https://github.com/apicircle/studio) — the TypeScript types, ID generation, validators, and encryption helpers every other `@apicircle/*` package builds on.
+
+## Install
+
+```bash
+npm install @apicircle/shared
+```
+
+## What's inside
+
+- **Workspace types** — the canonical `WorkspaceSynced` / `WorkspaceLocal` schema and every entity type (requests, folders, environments, mock servers, plans, releases).
+- **`generateId()`** — collision-resistant ID generation; the only sanctioned way to mint entity IDs.
+- **Validators** — shape checks for workspace documents and imported specs.
+- **Encryption helpers** — AES-GCM via WebCrypto for at-rest secret material.
+- **MCP envelopes** — the request/response envelope types shared with `@apicircle/mcp-server`.
+
+This package is mostly consumed indirectly through the other APICircle packages — install it directly when you are building tooling against the workspace format.
+
+## License
+
+Released under the **APICircle Studio License** — a custom source-available license, not an OSI-approved open-source license. Free for personal, educational, and non-commercial use, plus a 30-day commercial evaluation period; ongoing commercial use requires a separate license. See [LICENSE](./LICENSE) for the full terms, or contact **apicircle365@gmail.com** for commercial licensing.

package/dist/index.cjs

@@ -0,0 +1,547 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DEFAULT_WORKSPACE_NAME: () => DEFAULT_WORKSPACE_NAME,
+  FONT_SIZE_PERCENT_DEFAULT: () => FONT_SIZE_PERCENT_DEFAULT,
+  FONT_SIZE_PERCENT_MAX: () => FONT_SIZE_PERCENT_MAX,
+  FONT_SIZE_PERCENT_MIN: () => FONT_SIZE_PERCENT_MIN,
+  FONT_SIZE_PERCENT_STEP: () => FONT_SIZE_PERCENT_STEP,
+  MCP_TOOL_NAMES: () => MCP_TOOL_NAMES,
+  REQUEST_AUTH_TYPES: () => REQUEST_AUTH_TYPES,
+  RUN_BODY_PREVIEW_LIMIT: () => RUN_BODY_PREVIEW_LIMIT,
+  coerceMockResponseBodyTypeForStatus: () => coerceMockResponseBodyTypeForStatus,
+  defaultAuthFor: () => defaultAuthFor,
+  envPriorityDisplayName: () => envPriorityDisplayName,
+  envPriorityKey: () => envPriorityKey,
+  envPriorityRefEqual: () => envPriorityRefEqual,
+  formatBytes: () => formatBytes,
+  generateId: () => generateId,
+  getAllowedMockResponseBodyTypes: () => getAllowedMockResponseBodyTypes,
+  makeDefaultMockResponse: () => makeDefaultMockResponse,
+  makeDefaultMockResponseBody: () => makeDefaultMockResponseBody,
+  makeDefaultRequestSchema: () => makeDefaultRequestSchema,
+  normalizeAuth: () => normalizeAuth,
+  parseEnvPriorityKey: () => parseEnvPriorityKey,
+  safeExternalHref: () => safeExternalHref,
+  utf8ByteLength: () => utf8ByteLength,
+  validateAwsRegion: () => validateAwsRegion,
+  validateEnvVarName: () => validateEnvVarName,
+  validateHttpHeaderName: () => validateHttpHeaderName,
+  validateJsonPath: () => validateJsonPath,
+  validateJsonString: () => validateJsonString,
+  validateMockPath: () => validateMockPath,
+  validatePRTitle: () => validatePRTitle,
+  validatePlanName: () => validatePlanName,
+  validatePositiveDuration: () => validatePositiveDuration,
+  validateRegex: () => validateRegex,
+  validateUrl: () => validateUrl
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/ids.ts
+function generateId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  if (typeof crypto !== "undefined") {
+    crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 16; i++) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+// src/validators.ts
+var OK = { ok: true };
+var fail = (reason) => ({ ok: false, reason });
+function validateUrl(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return fail("URL is required.");
+  if (/^\s*\{\{\s*[^{}]+\s*\}\}/.test(trimmed)) return OK;
+  const probe = trimmed.replace(/\{\{[^{}]+\}\}/g, "placeholder");
+  try {
+    const u = new URL(probe);
+    if (!/^https?:|^file:$/i.test(u.protocol)) {
+      return fail(`Unsupported scheme "${u.protocol}". Use http(s):// or file://.`);
+    }
+    if (u.protocol !== "file:" && !u.host) return fail("URL is missing a host.");
+    return OK;
+  } catch {
+    return fail("Not a valid URL. Expected http(s)://host/path.");
+  }
+}
+var AWS_DIRECTIONS = /* @__PURE__ */ new Set([
+  "east",
+  "west",
+  "north",
+  "south",
+  "central",
+  "northeast",
+  "northwest",
+  "southeast",
+  "southwest"
+]);
+function validateAwsRegion(value) {
+  const v = value.trim().toLowerCase();
+  if (!v) return fail("Region is required (e.g. us-east-1).");
+  const m = /^([a-z]{2,3})-(?:([a-z]+)-)?([a-z]+)-(\d+)$/.exec(v);
+  if (!m) return fail('Region must look like "us-east-1" or "us-gov-west-1".');
+  const direction = m[3];
+  if (!AWS_DIRECTIONS.has(direction)) {
+    return fail(`Unknown direction "${direction}". Expected east/west/north/south/central/etc.`);
+  }
+  return OK;
+}
+function validateMockPath(value) {
+  const v = value.trim();
+  if (!v) return fail("Path is required.");
+  if (!v.startsWith("/")) return fail('Path must start with "/".');
+  if (/\s/.test(v)) return fail("Path must not contain whitespace.");
+  if (v.includes("?")) return fail("Path must not include a query string.");
+  if (v.includes("#")) return fail("Path must not include a fragment.");
+  return OK;
+}
+function validateEnvVarName(value) {
+  const v = value.trim();
+  if (!v) return fail("Variable name is required.");
+  if (/[\s{}]/.test(v)) return fail("Variable name cannot contain spaces or braces.");
+  if (!/^[A-Za-z_][A-Za-z0-9_-]*$/.test(v)) {
+    return fail("Use letters, digits, underscores, hyphens. Must start with a letter or _.");
+  }
+  return OK;
+}
+function validatePlanName(value) {
+  const v = value.trim();
+  if (!v) return fail("Plan name is required.");
+  if (v.length > 80) return fail("Plan name must be 80 characters or fewer.");
+  return OK;
+}
+function validatePRTitle(value) {
+  const v = value.trim();
+  if (!v) return fail("Title is required.");
+  if (v.length > 256) return fail("Title must be 256 characters or fewer.");
+  return OK;
+}
+function validateJsonString(value, opts = {}) {
+  const v = value.trim();
+  if (!v) {
+    if (opts.allowEmpty) return OK;
+    return fail("JSON cannot be empty.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(v);
+  } catch (e) {
+    return fail(`Invalid JSON: ${e instanceof Error ? e.message : "parse failed"}.`);
+  }
+  const allow = opts.allowRoots ?? "any";
+  if (allow === "object" && (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))) {
+    return fail("JSON root must be an object.");
+  }
+  if (allow === "array" && !Array.isArray(parsed)) {
+    return fail("JSON root must be an array.");
+  }
+  return OK;
+}
+var HEADER_TOKEN_RE = /^[A-Za-z0-9!#$%&'*+\-.^_`|~]+$/;
+function validateHttpHeaderName(value) {
+  const v = value.trim();
+  if (!v) return fail("Header name is required.");
+  if (!HEADER_TOKEN_RE.test(v)) {
+    return fail("Header name must be a valid HTTP token (letters, digits, and -_.!#$%&'*+^`|~).");
+  }
+  return OK;
+}
+function validateRegex(value, flags) {
+  if (value === "") return fail("Regex cannot be empty.");
+  try {
+    new RegExp(value, flags);
+    return OK;
+  } catch (e) {
+    return fail(`Invalid regex: ${e instanceof Error ? e.message : "parse failed"}.`);
+  }
+}
+var JSON_PATH_RE = /^\$(\.\.?[A-Za-z_$][\w$]*|\[(?:\*|\d+|'[^']*')\])*$/;
+function validateJsonPath(value) {
+  const v = value.trim();
+  if (!v) return fail("JSONPath cannot be empty.");
+  if (!v.startsWith("$")) return fail('JSONPath must start with "$".');
+  if (!JSON_PATH_RE.test(v)) {
+    return fail("JSONPath syntax looks malformed \u2014 expected $.foo.bar or $.items[0].name.");
+  }
+  return OK;
+}
+function validatePositiveDuration(value) {
+  const n = typeof value === "string" ? Number(value) : value;
+  if (!Number.isFinite(n)) return fail("Duration must be a number.");
+  if (n < 0) return fail("Duration cannot be negative.");
+  if (!Number.isInteger(n)) return fail("Duration must be a whole number.");
+  return OK;
+}
+function safeExternalHref(value) {
+  if (typeof value !== "string" || value.length === 0) return null;
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+  return parsed.toString();
+}
+
+// src/format.ts
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes < 0) return "\u2014";
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let value = bytes / 1024;
+  let unitIdx = 0;
+  while (value >= 1024 && unitIdx < units.length - 1) {
+    value /= 1024;
+    unitIdx++;
+  }
+  return `${value.toFixed(value >= 100 ? 0 : value >= 10 ? 1 : 2)} ${units[unitIdx]}`;
+}
+function utf8ByteLength(s) {
+  if (typeof TextEncoder === "undefined") return s.length;
+  return new TextEncoder().encode(s).length;
+}
+
+// src/envPriority.ts
+function envPriorityKey(ref) {
+  if (ref.kind === "local") return `local:${ref.name}`;
+  return `linked:${ref.linkedWorkspaceId}:${ref.envName}`;
+}
+function parseEnvPriorityKey(key) {
+  if (key.startsWith("local:")) {
+    return { kind: "local", name: key.slice("local:".length) };
+  }
+  if (key.startsWith("linked:")) {
+    const rest = key.slice("linked:".length);
+    const colonIdx = rest.indexOf(":");
+    if (colonIdx === -1) return null;
+    return {
+      kind: "linked",
+      linkedWorkspaceId: rest.slice(0, colonIdx),
+      envName: rest.slice(colonIdx + 1)
+    };
+  }
+  return null;
+}
+function envPriorityRefEqual(a, b) {
+  if (a.kind !== b.kind) return false;
+  if (a.kind === "local") return b.kind === "local" && a.name === b.name;
+  return b.kind === "linked" && a.linkedWorkspaceId === b.linkedWorkspaceId && a.envName === b.envName;
+}
+function envPriorityDisplayName(ref) {
+  return ref.kind === "local" ? ref.name : ref.envName;
+}
+
+// src/types.ts
+var DEFAULT_WORKSPACE_NAME = "My Workspace";
+var RUN_BODY_PREVIEW_LIMIT = 64 * 1024;
+var FONT_SIZE_PERCENT_MIN = 80;
+var FONT_SIZE_PERCENT_MAX = 150;
+var FONT_SIZE_PERCENT_STEP = 10;
+var FONT_SIZE_PERCENT_DEFAULT = 100;
+
+// src/authDefaults.ts
+var oauth2TokenDefaults = {
+  accessToken: "",
+  tokenType: "Bearer",
+  refreshToken: "",
+  expiresAt: null,
+  obtainedScope: ""
+};
+var FACTORIES = {
+  none: () => ({ type: "none" }),
+  inherit: () => ({ type: "inherit" }),
+  bearer: () => ({ type: "bearer", token: "" }),
+  basic: () => ({ type: "basic", username: "", password: "" }),
+  "api-key": () => ({ type: "api-key", key: "", value: "", addTo: "header" }),
+  "custom-header": () => ({ type: "custom-header", key: "", value: "" }),
+  "oauth2-client-credentials": () => ({
+    type: "oauth2-client-credentials",
+    tokenUrl: "",
+    clientId: "",
+    clientSecret: "",
+    scope: "",
+    clientAuthMethod: "header",
+    ...oauth2TokenDefaults
+  }),
+  "oauth2-auth-code": () => ({
+    type: "oauth2-auth-code",
+    authUrl: "",
+    tokenUrl: "",
+    clientId: "",
+    clientSecret: "",
+    redirectUri: "",
+    scope: "",
+    state: "",
+    ...oauth2TokenDefaults
+  }),
+  "oauth2-pkce": () => ({
+    type: "oauth2-pkce",
+    authUrl: "",
+    tokenUrl: "",
+    clientId: "",
+    clientSecret: "",
+    redirectUri: "",
+    scope: "",
+    state: "",
+    codeVerifier: "",
+    codeChallengeMethod: "S256",
+    ...oauth2TokenDefaults
+  }),
+  "oauth2-password": () => ({
+    type: "oauth2-password",
+    tokenUrl: "",
+    clientId: "",
+    clientSecret: "",
+    username: "",
+    password: "",
+    scope: "",
+    ...oauth2TokenDefaults
+  }),
+  "oauth2-implicit": () => ({
+    type: "oauth2-implicit",
+    authUrl: "",
+    clientId: "",
+    redirectUri: "",
+    scope: "",
+    accessToken: "",
+    tokenType: "Bearer",
+    expiresAt: null,
+    obtainedScope: ""
+  }),
+  "oauth2-device": () => ({
+    type: "oauth2-device",
+    deviceAuthUrl: "",
+    tokenUrl: "",
+    clientId: "",
+    scope: "",
+    deviceCode: "",
+    userCode: "",
+    verificationUri: "",
+    ...oauth2TokenDefaults
+  }),
+  "aws-sigv4": () => ({
+    type: "aws-sigv4",
+    accessKeyId: "",
+    secretAccessKey: "",
+    sessionToken: "",
+    region: "us-east-1",
+    service: "",
+    addTo: "header"
+  }),
+  digest: () => ({ type: "digest", username: "", password: "" }),
+  ntlm: () => ({
+    type: "ntlm",
+    username: "",
+    password: "",
+    domain: "",
+    workstation: ""
+  }),
+  hawk: () => ({
+    type: "hawk",
+    hawkId: "",
+    hawkKey: "",
+    algorithm: "sha256",
+    ext: ""
+  }),
+  "jwt-bearer": () => ({
+    type: "jwt-bearer",
+    algorithm: "HS256",
+    secretOrKey: "",
+    payload: '{\n  "sub": "user-id",\n  "iat": 1700000000\n}',
+    jwtHeaders: '{\n  "typ": "JWT"\n}',
+    token: ""
+  })
+};
+function defaultAuthFor(type) {
+  return FACTORIES[type]();
+}
+function normalizeAuth(input) {
+  if (input && typeof input === "object" && "type" in input && typeof input.type === "string" && input.type in FACTORIES) {
+    return input;
+  }
+  return { type: "none" };
+}
+var REQUEST_AUTH_TYPES = Object.keys(
+  FACTORIES
+);
+
+// src/mcp.ts
+var MCP_TOOL_NAMES = [
+  "import.curl",
+  "import.openapi",
+  "import.postman",
+  "import.insomnia",
+  "import.har",
+  "generate.code",
+  "workspace.read",
+  "workspace.write",
+  "request.create",
+  "request.read",
+  "request.update",
+  "request.delete",
+  "folder.create",
+  "folder.read",
+  "folder.update",
+  "folder.delete",
+  "environment.create",
+  "environment.read",
+  "environment.update",
+  "environment.delete",
+  "environment.set_active",
+  "environment.set_priority",
+  "environment.export",
+  "environment.import",
+  "plan.create",
+  "plan.run",
+  "plan.read",
+  "plan.update",
+  "plan.delete",
+  "plan.add_step",
+  "plan.remove_step",
+  "plan.reorder_steps",
+  "plan.set_variables",
+  "assertion.create",
+  "assertion.read",
+  "assertion.update",
+  "assertion.delete",
+  "history.list_runs",
+  "history.get_run",
+  "history.delete_run",
+  "history.purge_by_age",
+  "codebase.extract_collection",
+  "prompt.create_environment",
+  "prompt.create_assertion",
+  "prompt.create_plan",
+  "prompt.create_request",
+  "prompt.update_request",
+  "prompt.create_folder_tree",
+  "prompt.add_plan_steps",
+  "prompt.set_plan_variables",
+  "prompt.create_mock_server",
+  "prompt.add_mock_endpoint",
+  "prompt.set_endpoint_validation_rules",
+  "prompt.set_endpoint_response_rules",
+  "prompt.set_endpoint_multipliers",
+  "mock.create_from_openapi",
+  "mock.create_from_postman",
+  "mock.create_from_insomnia",
+  "mock.create_manual",
+  "mock.list",
+  "mock.list_endpoints",
+  "mock.start",
+  "mock.stop",
+  "mock.delete",
+  "mock.add_endpoint",
+  "mock.update_endpoint",
+  "mock.delete_endpoint",
+  "mock.set_validation_rules",
+  "mock.set_response_rules",
+  "mock.set_multipliers",
+  "mock.import_postman_mock_collection"
+];
+
+// src/mock.ts
+var NO_BODY_STATUSES = /* @__PURE__ */ new Set([100, 101, 102, 103, 204, 205, 304]);
+function getAllowedMockResponseBodyTypes(status) {
+  if (NO_BODY_STATUSES.has(status)) return ["none"];
+  if (status === 200) {
+    return ["none", "json", "text", "xml", "urlencoded", "form-data", "binary"];
+  }
+  return ["none", "json", "text", "xml", "urlencoded", "form-data"];
+}
+function coerceMockResponseBodyTypeForStatus(currentBodyType, status) {
+  const allowed = getAllowedMockResponseBodyTypes(status);
+  if (allowed.includes(currentBodyType)) return null;
+  if (allowed.includes("json")) return "json";
+  return "none";
+}
+function makeDefaultMockResponseBody(type) {
+  switch (type) {
+    case "none":
+      return { type: "none", content: "" };
+    case "form-data":
+      return { type: "form-data", content: "", formRows: [] };
+    case "binary":
+      return { type: "binary", content: "" };
+    default:
+      return { type, content: "" };
+  }
+}
+function makeDefaultMockResponse() {
+  return {
+    status: 200,
+    headers: [{ key: "Content-Type", value: "application/json", enabled: true }],
+    body: { type: "json", content: '{\n  "ok": true\n}' }
+  };
+}
+function makeDefaultRequestSchema() {
+  return { pathParams: [], queryParams: [], headers: [], cookies: [] };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_WORKSPACE_NAME,
+  FONT_SIZE_PERCENT_DEFAULT,
+  FONT_SIZE_PERCENT_MAX,
+  FONT_SIZE_PERCENT_MIN,
+  FONT_SIZE_PERCENT_STEP,
+  MCP_TOOL_NAMES,
+  REQUEST_AUTH_TYPES,
+  RUN_BODY_PREVIEW_LIMIT,
+  coerceMockResponseBodyTypeForStatus,
+  defaultAuthFor,
+  envPriorityDisplayName,
+  envPriorityKey,
+  envPriorityRefEqual,
+  formatBytes,
+  generateId,
+  getAllowedMockResponseBodyTypes,
+  makeDefaultMockResponse,
+  makeDefaultMockResponseBody,
+  makeDefaultRequestSchema,
+  normalizeAuth,
+  parseEnvPriorityKey,
+  safeExternalHref,
+  utf8ByteLength,
+  validateAwsRegion,
+  validateEnvVarName,
+  validateHttpHeaderName,
+  validateJsonPath,
+  validateJsonString,
+  validateMockPath,
+  validatePRTitle,
+  validatePlanName,
+  validatePositiveDuration,
+  validateRegex,
+  validateUrl
+});
+//# sourceMappingURL=index.cjs.map