apixa 0.0.0-stage → 0.1.0

package/dist/chunk-GWZTJ7LM.js

@@ -0,0 +1,2410 @@
+// packages/core/src/errors/api-error.ts
+var ApiError = class extends Error {
+  status;
+  code;
+  data;
+  request;
+  response;
+  retryable;
+  attempt;
+  cause;
+  constructor(message, options) {
+    super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = "ApiError";
+    this.status = options?.status;
+    this.code = options?.code ?? "NETWORK";
+    this.data = options?.data;
+    this.request = options?.request;
+    this.response = options?.response;
+    this.retryable = options?.retryable ?? false;
+    this.attempt = options?.attempt;
+    this.cause = options?.cause;
+  }
+};
+
+// packages/core/src/errors/network-error.ts
+var NetworkError = class extends ApiError {
+  constructor(message = "Network request failed", options) {
+    super(message, { code: "NETWORK", retryable: true, ...options });
+    this.name = "NetworkError";
+  }
+};
+
+// packages/core/src/errors/http-error.ts
+var HttpError = class extends ApiError {
+  constructor(message, options) {
+    super(message, { code: "HTTP", retryable: false, ...options });
+    this.name = "HttpError";
+  }
+};
+
+// packages/core/src/errors/parse-error.ts
+var ParseError = class extends ApiError {
+  constructor(message = "Failed to parse response", options) {
+    super(message, { code: "PARSE", retryable: false, ...options });
+    this.name = "ParseError";
+  }
+};
+
+// packages/core/src/errors/validation-error.ts
+var ValidationError = class extends ApiError {
+  constructor(message = "Response validation failed", options) {
+    super(message, { code: "VALIDATION", retryable: false, ...options });
+    this.name = "ValidationError";
+  }
+};
+
+// packages/core/src/errors/timeout-error.ts
+var TimeoutError = class extends ApiError {
+  constructor(message = "Request timed out", options) {
+    super(message, { code: "TIMEOUT", retryable: true, ...options });
+    this.name = "TimeoutError";
+  }
+};
+
+// packages/core/src/errors/abort-error.ts
+var AbortError = class extends ApiError {
+  constructor(message = "Request was aborted", options) {
+    super(message, { code: "ABORT", retryable: false, ...options });
+    this.name = "AbortError";
+  }
+};
+
+// packages/core/src/errors/config-error.ts
+var ConfigError = class extends ApiError {
+  constructor(message, options) {
+    super(message, { code: "CONFIG", retryable: false, ...options });
+    this.name = "ConfigError";
+  }
+};
+
+// packages/core/src/errors/security-error.ts
+var SecurityError = class extends ApiError {
+  constructor(message, options) {
+    super(message, { code: "SECURITY", retryable: false, ...options });
+    this.name = "SecurityError";
+  }
+};
+
+// packages/core/src/errors/transform-error.ts
+var TransformError = class extends ApiError {
+  /** Dotted location of the object that failed, e.g. `$.items[0].profile`. */
+  path;
+  keys;
+  constructor(message, details, options) {
+    super(message, { code: "TRANSFORM", retryable: false, ...options });
+    this.name = "TransformError";
+    this.path = details.path;
+    this.keys = details.keys;
+  }
+};
+
+// packages/core/src/errors/mock-error.ts
+var STATUS = {
+  MOCK_NOT_FOUND: 404,
+  MOCK_DUPLICATE_ID: 409,
+  MOCK_INVALID_INPUT: 400,
+  MOCK_UNSUPPORTED: 501,
+  MOCK_LOAD: void 0
+};
+var MockError = class extends ApiError {
+  constructor(code, message, options) {
+    super(message, { code, status: STATUS[code], retryable: false, cause: options?.cause });
+    this.name = "MockError";
+  }
+};
+
+// packages/core/src/errors/guards.ts
+function isApiError(error) {
+  return error instanceof ApiError;
+}
+function isHttpError(error) {
+  return error instanceof HttpError;
+}
+function isTimeoutError(error) {
+  return error instanceof TimeoutError;
+}
+function isMockError(error) {
+  return error instanceof MockError;
+}
+
+// packages/core/src/http/url.ts
+var ABSOLUTE = /^https?:\/\//i;
+function isAbsoluteUrl(value) {
+  return ABSOLUTE.test(value);
+}
+function parseBaseURL(value) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new ConfigError(
+      `baseURL must be a non-empty string (got ${value === "" ? '""' : typeof value}).`
+    );
+  }
+  if (isAbsoluteUrl(value)) {
+    let url;
+    try {
+      url = new URL(value);
+    } catch (cause) {
+      throw new ConfigError(`baseURL "${value}" is not a valid URL.`, { cause });
+    }
+    if (url.search || url.hash) {
+      throw new ConfigError(`baseURL "${value}" must not contain a query string or fragment.`);
+    }
+    return { raw: value, origin: url.origin, path: url.pathname.replace(/\/+$/, "") };
+  }
+  if (value.startsWith("/") && !value.startsWith("//")) {
+    if (/[?#]/.test(value)) {
+      throw new ConfigError(`baseURL "${value}" must not contain a query string or fragment.`);
+    }
+    return { raw: value, origin: null, path: value.replace(/\/+$/, "") };
+  }
+  throw new ConfigError(
+    `baseURL "${value}" must be an absolute http(s) URL (e.g. "https://api.example.com") or a browser-relative path starting with "/" (e.g. "/api").`
+  );
+}
+function requestOrigin(base) {
+  if (base.origin) return base.origin;
+  const origin = globalThis.location?.origin;
+  if (typeof origin === "string" && origin !== "null" && origin !== "") return origin;
+  throw new ConfigError(
+    `baseURL "${base.raw}" is relative, but this environment has no browser origin to resolve it against. Use an absolute URL (e.g. "http://localhost:3000${base.raw}") outside the browser.`
+  );
+}
+function buildUrl(base, path, queryString, origin) {
+  if (isAbsoluteUrl(path)) return `${path}${queryString}`;
+  const normalized = path === "" || path === "/" ? "" : path.startsWith("/") ? path : `/${path}`;
+  return `${origin ?? ""}${base.path}${normalized}${queryString}`;
+}
+function assertSameOrigin(url, origin) {
+  let parsed;
+  try {
+    parsed = new URL(url, origin);
+  } catch (cause) {
+    throw new SecurityError(`Request URL "${url}" is not a valid URL.`, { cause });
+  }
+  if (parsed.origin !== origin || parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new SecurityError(
+      `Request URL ${parsed.href} resolves outside the API origin ${origin}; it was not sent so credentials cannot leak. Use a separate client (or defineApis) for another origin.`
+    );
+  }
+  return parsed;
+}
+
+// packages/core/src/http/body.ts
+function isJsonContentType(headers) {
+  const contentType = headers.get("content-type") ?? "";
+  return contentType.includes("application/json") || contentType.includes("+json");
+}
+function serializeBody(body, headers) {
+  if (body === void 0 || body === null) {
+    return body;
+  }
+  if (typeof body === "string" || body instanceof FormData || body instanceof URLSearchParams || body instanceof Blob || body instanceof ArrayBuffer || ArrayBuffer.isView(body) || typeof ReadableStream !== "undefined" && body instanceof ReadableStream) {
+    return body;
+  }
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "application/json");
+  }
+  return JSON.stringify(body);
+}
+
+// packages/core/src/transport/read-body.ts
+var RAW_TEXT_PREVIEW_LENGTH = 200;
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch (cause) {
+    const preview = text.length > RAW_TEXT_PREVIEW_LENGTH ? `${text.slice(0, RAW_TEXT_PREVIEW_LENGTH)}\u2026` : text;
+    throw new ParseError(`Failed to parse response body as JSON: ${preview}`, { cause });
+  }
+}
+async function readBody(response, responseType = "json") {
+  if (response.status === 204 || response.status === 205) {
+    return null;
+  }
+  if (responseType === "stream") {
+    return response.body;
+  }
+  if (responseType === "blob") {
+    return response.blob();
+  }
+  if (responseType === "arrayBuffer") {
+    return response.arrayBuffer();
+  }
+  if (responseType === "text") {
+    return response.text();
+  }
+  const contentType = response.headers.get("content-type") ?? "";
+  if (isJsonContentType(response.headers)) {
+    const text2 = await response.text();
+    if (!text2) return null;
+    return parseJson(text2);
+  }
+  if (contentType.startsWith("text/")) {
+    return response.text();
+  }
+  const text = await response.text();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+// packages/core/src/transport/fetch.ts
+function createFetchTransport(fetchImpl = fetch) {
+  return {
+    async request(input) {
+      let response;
+      try {
+        response = await fetchImpl(input.url, {
+          method: input.method,
+          headers: input.headers,
+          body: input.body,
+          signal: input.signal
+        });
+      } catch (error) {
+        if (error instanceof DOMException && error.name === "AbortError") {
+          throw new AbortError("Request was aborted", { cause: error });
+        }
+        if (error instanceof DOMException && (error.name === "TimeoutError" || error.message.includes("timed out"))) {
+          throw new TimeoutError("Request timed out", { cause: error });
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          const reason = error.cause;
+          if (reason instanceof DOMException && (reason.name === "TimeoutError" || reason.message.includes("timed out"))) {
+            throw new TimeoutError("Request timed out", { cause: error });
+          }
+          throw new AbortError("Request was aborted", { cause: error });
+        }
+        throw new NetworkError(error instanceof Error ? error.message : "Network request failed", {
+          cause: error
+        });
+      }
+      const body = await readBody(response, input.responseType ?? "json");
+      return {
+        status: response.status,
+        headers: response.headers,
+        raw: response,
+        body
+      };
+    }
+  };
+}
+
+// packages/core/src/http/path.ts
+var PARAM = /:([A-Za-z0-9_]+)/g;
+function interpolatePath(path, params) {
+  const absolute = /^(https?:\/\/[^/]+)(.*)$/i.exec(path);
+  const head = absolute ? absolute[1] : "";
+  const tail = absolute ? absolute[2] : path;
+  return head + tail.replace(PARAM, (_, key) => {
+    const value = params?.[key];
+    if (value === void 0 || value === null || value === "") {
+      throw new ValidationError(`Missing path parameter "${key}" for ${path}`);
+    }
+    return encodeURIComponent(String(value));
+  });
+}
+function joinPath(base, relative) {
+  if (!relative || relative === "/") {
+    return base.replace(/\/+$/, "") || "/";
+  }
+  if (/^https?:\/\//i.test(relative)) {
+    return relative;
+  }
+  const normalizedBase = base.replace(/\/+$/, "");
+  const normalizedRelative = relative.startsWith("/") ? relative : `/${relative}`;
+  return `${normalizedBase}${normalizedRelative}`;
+}
+function extractPathParamNames(path) {
+  if (/^https?:\/\//i.test(path)) path = new URL(path).pathname;
+  const names = [];
+  const re = /:([A-Za-z0-9_]+)/g;
+  let match;
+  while ((match = re.exec(path)) !== null) {
+    names.push(match[1]);
+  }
+  return names;
+}
+
+// packages/core/src/mock/datasets.ts
+var MOCK_DATASETS = {
+  "users-mock": "id",
+  "products-mock": "id",
+  "companies-mock": "id",
+  "orders-mock": "id",
+  "posts-mock": "id",
+  "comments-mock": "id",
+  "countries-csc": "id",
+  "countries-mledoze": "id",
+  "countries-parseapi": "country",
+  "country-codes-iso": "id",
+  "cities-capitals": "id",
+  "currencies-parseapi": "currency",
+  "languages-parseapi": "language",
+  "timezones-parseapi": "timezone",
+  "area-codes-parseapi": "area_code"
+};
+function isMockDatasetId(value) {
+  return typeof value === "string" && Object.prototype.hasOwnProperty.call(MOCK_DATASETS, value);
+}
+function listMockDatasetIds() {
+  return Object.keys(MOCK_DATASETS);
+}
+var LOADER_SLOT = /* @__PURE__ */ Symbol.for("@apixa/core.mockDatasetLoader");
+function registerMockDatasetLoader(loader) {
+  globalThis[LOADER_SLOT] = loader;
+}
+async function loadNamedDataset(id) {
+  const datasetLoader = globalThis[LOADER_SLOT];
+  if (!datasetLoader) {
+    throw new MockError(
+      "MOCK_LOAD",
+      `mock: "${id}" needs the optional "@apixa/mocking" integration. Install it and import "@apixa/mocking/register" once (before the first call), or pass inline records / a provider instead.`
+    );
+  }
+  return datasetLoader(id);
+}
+
+// packages/core/src/mock/source.ts
+var MOCK_OBJECT_KEYS = /* @__PURE__ */ new Set(["data", "idKey", "seed"]);
+var SEED_KEYS = /* @__PURE__ */ new Set(["limit", "offset"]);
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function describe(value) {
+  return Array.isArray(value) ? "array" : value === null ? "null" : typeof value;
+}
+function normalizeMockSource(resource, value) {
+  const label = `resources.${resource}.mock`;
+  let data = value;
+  let idKey;
+  let seed;
+  if (isPlainObject(value)) {
+    for (const key of Object.keys(value)) {
+      if (!MOCK_OBJECT_KEYS.has(key)) {
+        throw new ConfigError(
+          `${label} has unknown option "${key}". Supported: data, idKey, seed. Operation behavior belongs in resources.${resource}.operations, not in mock.`
+        );
+      }
+    }
+    if (!("data" in value)) throw new ConfigError(`${label} object needs a "data" source.`);
+    data = value.data;
+    if (value.idKey !== void 0) {
+      if (typeof value.idKey !== "string" || value.idKey === "") {
+        throw new ConfigError(`${label}.idKey must be a non-empty string.`);
+      }
+      idKey = value.idKey;
+    }
+    if (value.seed !== void 0) seed = normalizeSeed(label, value.seed);
+  }
+  if (typeof data === "string") {
+    if (!isMockDatasetId(data)) {
+      throw new ConfigError(
+        `${label}: unknown dataset "${data}". Available: ${listMockDatasetIds().join(", ")}.`
+      );
+    }
+    const id = data;
+    const datasetIdKey = MOCK_DATASETS[id];
+    if (idKey !== void 0 && idKey !== datasetIdKey) {
+      throw new ConfigError(
+        `${label}.idKey "${idKey}" does not match dataset "${id}" (uses "${datasetIdKey}").`
+      );
+    }
+    return { label, idKey: datasetIdKey, load: () => loadNamedDataset(id), seed, immutable: true };
+  }
+  if (Array.isArray(data)) {
+    const records = data;
+    const key = idKey ?? "id";
+    validateRecords(label, records, key);
+    return { label, idKey: key, load: () => records, seed };
+  }
+  if (typeof data === "function") {
+    const provider = data;
+    return {
+      label,
+      idKey: idKey ?? "id",
+      seed,
+      load: () => {
+        const result = provider();
+        return typeof result?.then === "function" ? Promise.resolve(result).then((records) => assertArray(label, records)) : assertArray(label, result);
+      }
+    };
+  }
+  if (typeof value === "boolean") {
+    throw new ConfigError(
+      `${label} must be a dataset id, an array of records, a provider function, or { data, idKey?, seed? } (got ${String(value)}). mock: true was removed \u2014 use mock: "<dataset-id>".`
+    );
+  }
+  throw new ConfigError(
+    `${label} must be a dataset id, an array of records, a provider function, or { data, idKey?, seed? } (got ${describe(data)}).`
+  );
+}
+function normalizeSeed(label, value) {
+  if (!isPlainObject(value)) throw new ConfigError(`${label}.seed must be { limit?, offset? }.`);
+  for (const key of Object.keys(value)) {
+    if (!SEED_KEYS.has(key))
+      throw new ConfigError(`${label}.seed has unknown option "${key}". Supported: limit, offset.`);
+  }
+  const seed = {};
+  for (const key of ["limit", "offset"]) {
+    const n = value[key];
+    if (n === void 0) continue;
+    if (typeof n !== "number" || !Number.isInteger(n) || n < 0) {
+      throw new ConfigError(
+        `${label}.seed.${key} must be a non-negative integer (got ${String(n)}).`
+      );
+    }
+    seed[key] = n;
+  }
+  return seed;
+}
+function assertArray(label, records) {
+  if (!Array.isArray(records)) {
+    throw new ConfigError(
+      `${label} provider must return an array of records (got ${describe(records)}).`
+    );
+  }
+  return records;
+}
+function validateRecords(label, records, idKey) {
+  const seen = /* @__PURE__ */ new Set();
+  records.forEach((record, i) => {
+    if (!isPlainObject(record)) {
+      throw new ConfigError(`${label}[${i}] must be a plain object (got ${describe(record)}).`);
+    }
+    const id = record[idKey];
+    if (typeof id !== "string" && typeof id !== "number" || id === "") {
+      throw new ConfigError(
+        `${label}[${i}] is missing identity field "${idKey}" (string or number).`
+      );
+    }
+    const key = String(id);
+    if (seen.has(key)) throw new ConfigError(`${label}: duplicate ${idKey} "${key}".`);
+    seen.add(key);
+  });
+}
+
+// packages/core/src/mock/store.ts
+var clone = (value) => structuredClone(value);
+var own = (row, key) => Object.hasOwn(row, key) ? row[key] : void 0;
+var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function findUnsafeKey(root) {
+  const stack = [root];
+  const seen = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    const value = stack.pop();
+    if (value === null || typeof value !== "object" || seen.has(value)) continue;
+    seen.add(value);
+    for (const key of Object.keys(value)) {
+      if (UNSAFE_KEYS.has(key)) return key;
+      stack.push(value[key]);
+    }
+  }
+  return void 0;
+}
+var RESERVED_QUERY_KEYS = /* @__PURE__ */ new Set(["page", "pageSize", "cursor", "id", "id[]"]);
+function filterEntries(query) {
+  if (!query) return [];
+  return Object.entries(query).filter(([k, v]) => !RESERVED_QUERY_KEYS.has(k) && v !== void 0);
+}
+function matchesExact(row, entries) {
+  return entries.every(
+    ([key, value]) => Array.isArray(value) ? value.map(String).includes(String(own(row, key))) : String(own(row, key)) === String(value)
+  );
+}
+function matchesContains(row, entries) {
+  return entries.every(
+    ([key, value]) => String(own(row, key) ?? "").toLowerCase().includes(String(value).toLowerCase())
+  );
+}
+var MockStore = class {
+  idKey;
+  source;
+  initial;
+  /**
+   * Working rows. They share row objects with `initial` until a row is replaced: every write
+   * builds a new row object, and nothing hands out a reference (reads clone). `liveRows()` is the
+   * one exception, so it first makes the working rows private (`shared = false`).
+   */
+  rows = [];
+  shared = true;
+  index = /* @__PURE__ */ new Map();
+  loading;
+  numericIds = true;
+  numberTyped = true;
+  /** Monotonic id counter: generated ids are never reused, even after deletes. */
+  counter = 0;
+  constructor(source) {
+    this.source = source;
+    this.idKey = source.idKey;
+  }
+  fail(code, message) {
+    return new MockError(code, `${this.source.label}: ${message}`);
+  }
+  /** Load + validate + seed once. Concurrent first calls share one load; a failure is retried next call. */
+  ready() {
+    if (this.initial) return Promise.resolve();
+    this.loading ??= (async () => {
+      let records;
+      try {
+        records = await this.source.load();
+        validateRecords(this.source.label, records, this.idKey);
+      } catch (cause) {
+        if (cause instanceof MockError) throw cause;
+        const detail = cause instanceof Error ? cause.message : String(cause);
+        throw new MockError(
+          "MOCK_LOAD",
+          `${this.source.label}: failed to load mock data \u2014 ${detail}`,
+          { cause }
+        );
+      }
+      const { limit, offset = 0 } = this.source.seed ?? {};
+      const seeded = records.slice(
+        offset,
+        limit === void 0 ? void 0 : offset + limit
+      );
+      this.initial = this.source.immutable ? seeded : seeded.map(clone);
+      this.applyInitial();
+    })().finally(() => {
+      this.loading = void 0;
+    });
+    return this.loading;
+  }
+  applyInitial() {
+    this.rows = this.initial.slice();
+    this.shared = true;
+    this.index = new Map(this.rows.map((row) => [String(row[this.idKey]), row]));
+    this.numericIds = this.rows.every((row) => /^\d+$/.test(String(row[this.idKey])));
+    this.numberTyped = this.rows.length === 0 || typeof this.rows[0][this.idKey] === "number";
+    this.counter = this.numericIds ? Math.max(0, ...this.rows.map((row) => Number(row[this.idKey]))) : 0;
+  }
+  /**
+   * Live rows for custom `defineMockApi` operations that edit records in place. Call
+   * `reindex()` afterwards if ids were added, removed, or changed.
+   */
+  liveRows() {
+    if (this.shared) {
+      this.rows = this.rows.map(clone);
+      this.shared = false;
+      this.reindex();
+    }
+    return this.rows;
+  }
+  reindex() {
+    this.index = new Map(this.rows.map((row) => [String(row[this.idKey]), row]));
+  }
+  /** Back to the seeded state. A store that never loaded stays unloaded (next call seeds it). */
+  reset() {
+    if (this.initial) this.applyInitial();
+  }
+  key(id) {
+    if (typeof id !== "string" && typeof id !== "number" || id === "") {
+      throw this.fail(
+        "MOCK_INVALID_INPUT",
+        `invalid ${this.idKey} ${JSON.stringify(id) ?? String(id)} (expected a non-empty string or number)`
+      );
+    }
+    return String(id);
+  }
+  find(id) {
+    const key = this.key(id);
+    const row = this.index.get(key);
+    if (!row) throw this.fail("MOCK_NOT_FOUND", `no record with ${this.idKey} "${key}"`);
+    return row;
+  }
+  input(value, what) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+      throw this.fail("MOCK_INVALID_INPUT", `${what} must be a plain object`);
+    }
+    let copy;
+    try {
+      copy = clone(value);
+    } catch (cause) {
+      throw new MockError(
+        "MOCK_INVALID_INPUT",
+        `${this.source.label}: ${what} must be structured-cloneable`,
+        { cause }
+      );
+    }
+    const unsafe = findUnsafeKey(copy);
+    if (unsafe !== void 0) {
+      throw this.fail("MOCK_INVALID_INPUT", `${what} must not contain the key "${unsafe}"`);
+    }
+    return copy;
+  }
+  nextId() {
+    if (!this.numericIds) {
+      throw this.fail(
+        "MOCK_INVALID_INPUT",
+        `create() needs "${this.idKey}": this data has non-numeric ids`
+      );
+    }
+    do
+      this.counter++;
+    while (this.index.has(String(this.counter)));
+    return this.numberTyped ? this.counter : String(this.counter);
+  }
+  assertSameId(input, current) {
+    if (input[this.idKey] !== void 0 && String(input[this.idKey]) !== String(current[this.idKey])) {
+      throw this.fail(
+        "MOCK_INVALID_INPUT",
+        `cannot change ${this.idKey} from "${String(current[this.idKey])}"`
+      );
+    }
+  }
+  insert(row) {
+    if (row[this.idKey] === void 0) row[this.idKey] = this.nextId();
+    const key = this.key(row[this.idKey]);
+    if (this.index.has(key))
+      throw this.fail("MOCK_DUPLICATE_ID", `a record with ${this.idKey} "${key}" already exists`);
+    this.rows.push(row);
+    this.index.set(key, row);
+    return row;
+  }
+  replaceRow(current, next) {
+    const i = this.rows.indexOf(current);
+    this.rows[i] = next;
+    this.index.set(String(current[this.idKey]), next);
+    return next;
+  }
+  // ---- reads (each independent; none calls another public operation) ----
+  /**
+   * Matching rows by reference, for the engine only: callers must clone (`cloneRows`) whatever
+   * they return. Lets a paginated read copy one page instead of the whole dataset.
+   */
+  select(query) {
+    const entries = filterEntries(query);
+    const ids = query?.id ?? query?.["id[]"];
+    let rows = this.rows;
+    if (ids !== void 0) {
+      const wanted = new Set((Array.isArray(ids) ? ids : [ids]).map(String));
+      rows = rows.filter((row) => wanted.has(String(own(row, this.idKey))));
+    }
+    return entries.length ? rows.filter((row) => matchesExact(row, entries)) : rows;
+  }
+  cloneRows(rows) {
+    return rows.map(clone);
+  }
+  /** Exact-match filter over non-paging query keys; `id` values select those ids. */
+  list(query) {
+    return this.cloneRows(this.select(query));
+  }
+  get(id) {
+    return clone(this.find(id));
+  }
+  /** Requested order, missing ids omitted, duplicates collapsed. */
+  getMany(ids) {
+    if (!Array.isArray(ids))
+      throw this.fail("MOCK_INVALID_INPUT", "getMany expects an array of ids");
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const id of ids) {
+      const key = this.key(id);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const row = this.index.get(key);
+      if (row) out.push(clone(row));
+    }
+    return out;
+  }
+  exists(id) {
+    return this.index.has(this.key(id));
+  }
+  getBy(name, value) {
+    const row = this.rows.find((r) => String(own(r, name)) === String(value));
+    if (!row) throw this.fail("MOCK_NOT_FOUND", `no record with ${name} "${String(value)}"`);
+    return clone(row);
+  }
+  findFirst(query) {
+    const entries = filterEntries(query);
+    const row = this.rows.find((r) => matchesExact(r, entries));
+    return row ? clone(row) : null;
+  }
+  /** Case-insensitive substring match on every given key. */
+  search(query) {
+    return this.cloneRows(this.selectContaining(query));
+  }
+  /** Substring matches by reference (see `select`). */
+  selectContaining(query) {
+    const entries = filterEntries(query);
+    return entries.length ? this.rows.filter((row) => matchesContains(row, entries)) : this.rows;
+  }
+  count(query) {
+    const entries = filterEntries(query);
+    return entries.length ? this.rows.filter((row) => matchesExact(row, entries)).length : this.rows.length;
+  }
+  // ---- writes ----
+  create(body) {
+    return clone(this.insert(this.input(body, "create() input")));
+  }
+  /** Validates every item first, then inserts all (no partial writes on duplicate ids). */
+  createMany(bodies) {
+    if (!Array.isArray(bodies))
+      throw this.fail("MOCK_INVALID_INPUT", "createMany expects an array");
+    const rows = bodies.map((body, i) => this.input(body, `createMany[${i}]`));
+    const keys = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      if (row[this.idKey] === void 0) continue;
+      const key = this.key(row[this.idKey]);
+      if (this.index.has(key) || keys.has(key)) {
+        throw this.fail("MOCK_DUPLICATE_ID", `a record with ${this.idKey} "${key}" already exists`);
+      }
+      keys.add(key);
+    }
+    return rows.map((row) => clone(this.insert(row)));
+  }
+  update(id, body) {
+    const changes = this.input(body, "update() input");
+    const current = this.find(id);
+    this.assertSameId(changes, current);
+    const { [this.idKey]: _ignored, ...fields } = changes;
+    return clone(this.replaceRow(current, { [this.idKey]: current[this.idKey], ...fields }));
+  }
+  patch(id, body) {
+    const changes = this.input(body, "patch() input");
+    const current = this.find(id);
+    this.assertSameId(changes, current);
+    const next = { ...current };
+    for (const [key, value] of Object.entries(changes)) {
+      if (value !== void 0 && key !== this.idKey) next[key] = value;
+    }
+    return clone(this.replaceRow(current, next));
+  }
+  /** Replace when the id exists, otherwise insert with that id. */
+  upsert(id, body) {
+    const key = this.key(id);
+    const changes = this.input(body, "upsert() input");
+    const current = this.index.get(key);
+    if (current) {
+      this.assertSameId(changes, current);
+      const { [this.idKey]: _ignored, ...fields } = changes;
+      return clone(this.replaceRow(current, { [this.idKey]: current[this.idKey], ...fields }));
+    }
+    if (changes[this.idKey] !== void 0 && String(changes[this.idKey]) !== key) {
+      throw this.fail("MOCK_INVALID_INPUT", `body ${this.idKey} does not match "${key}"`);
+    }
+    return clone(this.insert({ ...changes, [this.idKey]: id }));
+  }
+  delete(id) {
+    const row = this.find(id);
+    this.rows.splice(this.rows.indexOf(row), 1);
+    this.index.delete(String(row[this.idKey]));
+  }
+  /** Removes the listed ids that exist; missing ids are ignored (idempotent bulk delete). */
+  deleteMany(ids) {
+    if (!Array.isArray(ids))
+      throw this.fail("MOCK_INVALID_INPUT", "deleteMany expects an array of ids");
+    const keys = new Set(ids.map((id) => this.key(id)));
+    this.rows = this.rows.filter((row) => !keys.has(String(row[this.idKey])));
+    for (const key of keys) this.index.delete(key);
+  }
+};
+
+// packages/core/src/mock/execute.ts
+var DEFAULT_PAGE_SIZE = 20;
+function positiveInt(store, name, raw, fallback, min) {
+  if (raw === void 0 || raw === null || raw === "") return fallback;
+  const n = typeof raw === "number" ? raw : Number(raw);
+  if (!Number.isInteger(n) || n < min) {
+    throw new MockError(
+      "MOCK_INVALID_INPUT",
+      `${store}: ${name} must be an integer >= ${min} (got ${String(raw)})`
+    );
+  }
+  return n;
+}
+function paginate(store, label, rows, mode, query = {}) {
+  if (!mode) return store.cloneRows(rows);
+  const pageSize = positiveInt(label, "pageSize", query.pageSize, DEFAULT_PAGE_SIZE, 1);
+  if (mode === "page") {
+    const page = positiveInt(label, "page", query.page, 1, 1);
+    const start2 = (page - 1) * pageSize;
+    return {
+      data: store.cloneRows(rows.slice(start2, start2 + pageSize)),
+      total: rows.length,
+      page,
+      pageSize
+    };
+  }
+  const start = positiveInt(label, "cursor", query.cursor, 0, 0);
+  const end = start + pageSize;
+  return {
+    data: store.cloneRows(rows.slice(start, end)),
+    nextCursor: end < rows.length ? String(end) : null
+  };
+}
+async function runBuiltin(store, source, intent, pagination) {
+  await store.ready();
+  const q = intent.query;
+  switch (intent.op) {
+    case "getAll":
+      return { status: 200, data: paginate(store, source.label, store.select(q), pagination, q) };
+    case "getById":
+      return { status: 200, data: store.get(intent.id) };
+    case "getBySlug":
+      return { status: 200, data: store.getBy("slug", intent.slug) };
+    case "getMany":
+      return { status: 200, data: store.getMany(intent.ids) };
+    case "getBy":
+      return { status: 200, data: store.getBy(intent.field, intent.value) };
+    case "findFirst":
+      return { status: 200, data: store.findFirst(q) };
+    case "search":
+      return { status: 200, data: store.search(q) };
+    case "exists":
+      return { status: 200, data: store.exists(intent.id) };
+    case "count":
+      return { status: 200, data: store.count(q) };
+    case "create":
+      return { status: 201, data: store.create(intent.body) };
+    case "update":
+      return { status: 200, data: store.update(intent.id, intent.body) };
+    case "patch":
+      return { status: 200, data: store.patch(intent.id, intent.body) };
+    case "upsert":
+      return { status: 200, data: store.upsert(intent.id, intent.body) };
+    case "delete":
+      store.delete(intent.id);
+      return { status: 204, data: null };
+    case "createMany":
+      return { status: 201, data: store.createMany(intent.body) };
+    case "deleteMany":
+      store.deleteMany(intent.body);
+      return { status: 204, data: null };
+  }
+}
+function routeToIntent(method, relativePath, query, body, label) {
+  if (/^[a-z][a-z0-9+.-]*:/i.test(relativePath)) {
+    throw new MockError(
+      "MOCK_UNSUPPORTED",
+      `${label}: cannot simulate absolute URL "${relativePath}" on a mocked resource`
+    );
+  }
+  const path = relativePath.split("?")[0].replace(/\/+$/, "");
+  const segments = path.split("/").filter(Boolean).map(decodeURIComponent);
+  const m = method.toUpperCase();
+  if (segments.length === 0) {
+    if (m === "GET") return { op: "getAll", query };
+    if (m === "POST") return { op: "create", body };
+  } else if (segments.length === 1) {
+    const [seg] = segments;
+    if (seg === "count" && m === "GET") return { op: "count", query };
+    if (seg === "search" && m === "GET") return { op: "search", query };
+    if (seg === "bulk" && m === "POST") return { op: "createMany", body };
+    if (seg === "bulk" && m === "DELETE") return { op: "deleteMany", body };
+    if (m === "GET") return { op: "getById", id: seg };
+    if (m === "PUT") return { op: "update", id: seg, body };
+    if (m === "PATCH") return { op: "patch", id: seg, body };
+    if (m === "DELETE") return { op: "delete", id: seg };
+  } else if (segments.length === 2 && segments[0] === "slug" && m === "GET") {
+    return { op: "getBySlug", slug: segments[1] };
+  }
+  throw new MockError(
+    "MOCK_UNSUPPORTED",
+    `${label}: cannot simulate ${m} "${relativePath || "/"}" against in-memory records. Supported: GET/POST "", GET/PUT/PATCH/DELETE "/:id", GET "/count", GET "/search", GET "/slug/:slug", POST/DELETE "/bulk".`
+  );
+}
+
+// packages/core/src/mock/handler.ts
+function createStoreHandle(store) {
+  const handle = {
+    get: (id) => store.get(id),
+    exists: (id) => store.exists(id),
+    list: (query) => store.list(query),
+    create: (input) => store.create(input),
+    update: (id, input) => store.update(id, input),
+    patch: (id, input) => store.patch(id, input),
+    delete: (id) => store.delete(id)
+  };
+  return Object.freeze(handle);
+}
+async function runMockHandler(handler, store, call) {
+  await store.ready();
+  if (call.signal.aborted) throw call.signal.reason ?? new AbortError();
+  const handle = createStoreHandle(store);
+  const context = {
+    get records() {
+      return store.list();
+    },
+    store: handle,
+    params: { ...call.params },
+    query: { ...call.query ?? {} },
+    body: call.body,
+    signal: call.signal,
+    resource: call.resource,
+    operation: call.operation
+  };
+  const pending = Promise.resolve().then(() => handler(context));
+  const data = await raceAbort(pending, call.signal);
+  const noContent = call.method === "DELETE" && (data === void 0 || data === null);
+  return { status: noContent ? 204 : 200, data: noContent ? null : data };
+}
+function raceAbort(work, signal) {
+  if (signal.aborted) {
+    work.catch(() => void 0);
+    return Promise.reject(signal.reason ?? new AbortError());
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(signal.reason ?? new AbortError());
+    signal.addEventListener("abort", onAbort, { once: true });
+    work.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+
+// packages/core/src/operation/conventions.ts
+var BUILTIN_CONVENTIONS = {
+  getAll: { method: "GET", path: "", access: "read", extended: false, many: false },
+  getById: { method: "GET", path: "/:id", access: "read", extended: false, many: false },
+  create: { method: "POST", path: "", access: "write", extended: false, many: false },
+  update: { method: "PUT", path: "/:id", access: "write", extended: false, many: false },
+  delete: { method: "DELETE", path: "/:id", access: "write", extended: false, many: false },
+  getBySlug: { method: "GET", path: "/slug/:slug", access: "read", extended: true, many: false },
+  patch: { method: "PATCH", path: "/:id", access: "write", extended: true, many: false },
+  upsert: { method: "PUT", path: "/:id", access: "write", extended: true, many: false },
+  count: { method: "GET", path: "/count", access: "read", extended: true, many: false },
+  search: { method: "GET", path: "/search", access: "read", extended: true, many: false },
+  createMany: { method: "POST", path: "/bulk", access: "write", extended: true, many: true },
+  deleteMany: {
+    method: "DELETE",
+    path: "/bulk",
+    hasBody: true,
+    access: "write",
+    extended: true,
+    many: true
+  },
+  getMany: {
+    method: "GET",
+    path: "",
+    access: "read",
+    extended: true,
+    many: true,
+    strategy: "getMany"
+  },
+  exists: {
+    method: "GET",
+    path: "/:id",
+    access: "read",
+    extended: true,
+    many: false,
+    strategy: "exists"
+  },
+  findFirst: {
+    method: "GET",
+    path: "",
+    access: "read",
+    extended: true,
+    many: false,
+    strategy: "findFirst"
+  },
+  getBy: {
+    method: "GET",
+    path: "",
+    access: "read",
+    extended: true,
+    many: false,
+    strategy: "getBy"
+  }
+};
+function isBuiltinName(name) {
+  return Object.prototype.hasOwnProperty.call(BUILTIN_CONVENTIONS, name);
+}
+
+// packages/core/src/operation/expand.ts
+var GROUP_ORDER = ["extended", "read", "write", "many"];
+function expandOperations(operations, options = {}) {
+  const enabled = /* @__PURE__ */ new Map();
+  for (const [name, convention] of Object.entries(BUILTIN_CONVENTIONS)) {
+    let on = options.defaultOperations !== false;
+    if (options.readOnly && convention.access === "write") on = false;
+    if (options.writeOnly && convention.access === "read") on = false;
+    for (const group of GROUP_ORDER) {
+      const choice = options.operationGroups?.[group];
+      if (choice === void 0) continue;
+      if (group === "extended" && convention.extended || group === "many" && convention.many || group === convention.access) {
+        on = choice;
+      }
+    }
+    enabled.set(name, on);
+  }
+  const expanded = {};
+  for (const name of Object.keys(BUILTIN_CONVENTIONS)) {
+    const override = operations?.[name];
+    if (override === false || override === void 0 && !enabled.get(name)) continue;
+    expanded[name] = typeof override === "function" ? override : override === true || override === void 0 ? {} : override;
+  }
+  for (const [name, definition] of Object.entries(operations ?? {})) {
+    if (isBuiltinName(name) || definition === false || definition === void 0 || definition === true)
+      continue;
+    expanded[name] = definition;
+  }
+  return expanded;
+}
+
+// packages/core/src/operation/args.ts
+function parseOperationArgs(pathParamNames, hasBody, args) {
+  let index = 0;
+  let params;
+  if (pathParamNames.length === 1) {
+    const name = pathParamNames[0];
+    params = { [name]: args[index++] };
+  } else if (pathParamNames.length > 1) {
+    params = args[index++];
+  }
+  const body = hasBody ? args[index++] : void 0;
+  const options = args[index];
+  return { params, body, options };
+}
+
+// packages/core/src/http/headers.ts
+function apply(target, source) {
+  if (!source) return;
+  if (source instanceof Headers) {
+    source.forEach((value, key) => target.set(key, value));
+    return;
+  }
+  if (Array.isArray(source)) {
+    for (const [key, value] of source) target.set(key, value);
+    return;
+  }
+  for (const [key, value] of Object.entries(source)) {
+    if (value === void 0 || value === null) target.delete(key);
+    else target.set(key, String(value));
+  }
+}
+async function resolveHeaders(sources, request) {
+  const headers = new Headers();
+  for (const source of sources) {
+    if (typeof source === "function") {
+      let value;
+      try {
+        value = await source();
+      } catch (cause) {
+        const detail = cause instanceof Error ? cause.message : String(cause);
+        throw new ApiError(`Header provider failed: ${detail}`, { code: "HEADERS", cause });
+      }
+      apply(headers, value);
+    } else {
+      apply(headers, source);
+    }
+  }
+  apply(headers, request);
+  return headers;
+}
+
+// packages/core/src/http/query.ts
+function buildQueryString(query, format = "repeat") {
+  if (!query) return "";
+  const parts = [];
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      if (format === "comma") {
+        parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value.map(String).join(","))}`);
+      } else if (format === "brackets") {
+        for (const item of value) {
+          parts.push(`${encodeURIComponent(key)}[]=${encodeURIComponent(String(item))}`);
+        }
+      } else {
+        for (const item of value) {
+          parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(item))}`);
+        }
+      }
+    } else {
+      parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+    }
+  }
+  return parts.length ? `?${parts.join("&")}` : "";
+}
+
+// packages/core/src/transform/keys.ts
+var KEY_CASES = [
+  "camelCase",
+  "snake_case",
+  "PascalCase",
+  "kebab-case"
+];
+function isKeyCase(value) {
+  return typeof value === "string" && KEY_CASES.includes(value);
+}
+var isSeparator = (c) => c === "_" || c === "-";
+var isUpper = (c) => c !== c.toLowerCase() && c === c.toUpperCase();
+function toDelimited(key, sep) {
+  let out = "";
+  for (const c of key) {
+    if (isSeparator(c)) {
+      if (out !== "" && !out.endsWith(sep)) out += sep;
+    } else if (isUpper(c)) {
+      out += out === "" || out.endsWith(sep) ? c.toLowerCase() : sep + c.toLowerCase();
+    } else {
+      out += c;
+    }
+  }
+  return out;
+}
+function toCamel(key) {
+  let out = "";
+  let upperNext = false;
+  for (const c of key) {
+    if (isSeparator(c)) {
+      upperNext = out !== "";
+    } else if (out === "") {
+      out += c.toLowerCase();
+      upperNext = false;
+    } else {
+      out += upperNext ? c.toUpperCase() : c;
+      upperNext = false;
+    }
+  }
+  return out;
+}
+function convertKey(key, to) {
+  switch (to) {
+    case "camelCase":
+      return toCamel(key);
+    case "PascalCase": {
+      const camel = toCamel(key);
+      return camel.charAt(0).toUpperCase() + camel.slice(1);
+    }
+    case "snake_case":
+      return toDelimited(key, "_");
+    case "kebab-case":
+      return toDelimited(key, "-");
+  }
+}
+function isPlainObject2(value) {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+var MAX_DEPTH = 64;
+function transformKeys(value, to, cache) {
+  return walk(value, to, cache ?? /* @__PURE__ */ new Map(), "$", 0);
+}
+function walk(value, to, cache, path, depth) {
+  if (depth > MAX_DEPTH) {
+    throw new TransformError(`Key transform exceeded max depth ${MAX_DEPTH} at ${path}`, {
+      path,
+      keys: []
+    });
+  }
+  if (Array.isArray(value)) {
+    return value.map((item, i) => walk(item, to, cache, `${path}[${i}]`, depth + 1));
+  }
+  if (!isPlainObject2(value)) return value;
+  const out = {};
+  const origin = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(value)) {
+    let next = cache.get(key);
+    if (next === void 0) {
+      next = convertKey(key, to);
+      cache.set(key, next);
+    }
+    const previous = origin.get(next);
+    if (previous !== void 0) {
+      throw new TransformError(
+        `Key transform to ${to} collision at ${path}: "${previous}" and "${key}" both become "${next}"`,
+        { path, keys: [previous, key] }
+      );
+    }
+    origin.set(next, key);
+    const converted = walk(value[key], to, cache, `${path}.${key}`, depth + 1);
+    if (next === "__proto__") {
+      Object.defineProperty(out, next, {
+        value: converted,
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
+    } else {
+      out[next] = converted;
+    }
+  }
+  return out;
+}
+
+// packages/core/src/request/retry.ts
+var DEFAULT_METHODS = ["GET", "HEAD", "OPTIONS"];
+var RETRY_KEYS = /* @__PURE__ */ new Set([
+  "retries",
+  "methods",
+  "statusCodes",
+  "baseDelayMs",
+  "maxDelayMs",
+  "jitter",
+  "respectRetryAfter",
+  "shouldRetry",
+  "onRetry"
+]);
+function resolveRetryConfig(value, label = "retry") {
+  if (value === void 0 || value === false) return void 0;
+  const config = typeof value === "number" ? { retries: value } : value;
+  if (config === null || typeof config !== "object" || Array.isArray(config)) {
+    throw new ConfigError(`${label} must be a number, a retry config object, or false.`);
+  }
+  for (const key of Object.keys(config)) {
+    if (!RETRY_KEYS.has(key)) throw new ConfigError(`${label} has unknown option "${key}".`);
+  }
+  if (typeof config.retries !== "number" || !Number.isInteger(config.retries) || config.retries < 0) {
+    throw new ConfigError(
+      `${label}.retries must be a non-negative integer (got ${String(config.retries)}).`
+    );
+  }
+  for (const key of ["baseDelayMs", "maxDelayMs"]) {
+    const n = config[key];
+    if (n !== void 0 && (typeof n !== "number" || !Number.isFinite(n) || n < 0)) {
+      throw new ConfigError(`${label}.${key} must be a non-negative number.`);
+    }
+  }
+  return {
+    retries: config.retries,
+    methods: config.methods ?? DEFAULT_METHODS,
+    statusCodes: config.statusCodes,
+    baseDelayMs: config.baseDelayMs ?? 200,
+    maxDelayMs: config.maxDelayMs ?? 2e3,
+    jitter: config.jitter ?? true,
+    respectRetryAfter: config.respectRetryAfter ?? true,
+    shouldRetry: config.shouldRetry,
+    onRetry: config.onRetry
+  };
+}
+function isRetryableStatus(status, statusCodes) {
+  if (statusCodes) return statusCodes.includes(status);
+  return status === 408 || status === 429 || status >= 500 && status <= 599;
+}
+function defaultShouldRetry(error, method, retry, attempt) {
+  if (attempt >= retry.retries || !retry.methods.includes(method)) return false;
+  if (error instanceof NetworkError) return true;
+  if (error instanceof HttpError) return isRetryableStatus(error.status ?? 0, retry.statusCodes);
+  return false;
+}
+function decideRetry(retry, ctx, error) {
+  if (ctx.attempt >= retry.retries) return false;
+  if (retry.shouldRetry) return retry.shouldRetry({ ...ctx, error });
+  return defaultShouldRetry(error, ctx.method, retry, ctx.attempt);
+}
+function parseRetryAfter(header, now = Date.now()) {
+  if (header === null) return void 0;
+  const trimmed = header.trim();
+  if (/^\d+$/.test(trimmed)) return Number(trimmed) * 1e3;
+  const date = Date.parse(trimmed);
+  if (Number.isNaN(date)) return void 0;
+  return Math.max(0, date - now);
+}
+function computeBackoffMs(attempt, retry, random = Math.random) {
+  const capped = Math.min(retry.baseDelayMs * 2 ** attempt, retry.maxDelayMs);
+  if (!retry.jitter) return capped;
+  return Math.floor(capped / 2 + random() * (capped / 2));
+}
+function delay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// packages/core/src/request/pipeline.ts
+var REQUEST_KEYS = ["method", "url", "headers", "signal", "meta"];
+function transformQuery(query, to) {
+  if (!query || !to) return query;
+  return transformKeys(query, to);
+}
+function createCallSignal(timeout, external) {
+  const controller = new AbortController();
+  let timedOut = false;
+  let timer;
+  const onAbort = () => controller.abort(external.reason);
+  if (external) {
+    if (external.aborted) controller.abort(external.reason);
+    else external.addEventListener("abort", onAbort, { once: true });
+  }
+  if (timeout !== void 0 && timeout > 0 && !controller.signal.aborted) {
+    timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort(new TimeoutError(`Request timed out after ${timeout}ms`));
+    }, timeout);
+  }
+  return {
+    signal: controller.signal,
+    timedOut: () => timedOut,
+    cleanup: () => {
+      if (timer) clearTimeout(timer);
+      external?.removeEventListener("abort", onAbort);
+    }
+  };
+}
+function classify(error, signal, timedOut, request) {
+  if (signal.aborted && !(error instanceof HttpError)) {
+    if (timedOut) {
+      return error instanceof TimeoutError ? attach(error, request) : new TimeoutError(void 0, { request, cause: error });
+    }
+    return error instanceof AbortError ? attach(error, request) : new AbortError(void 0, { request, cause: signal.reason ?? error });
+  }
+  if (error instanceof ApiError) return attach(error, request);
+  return error;
+}
+function attach(error, request) {
+  error.request ??= request;
+  return error;
+}
+function throwIfAborted(signal) {
+  if (signal.aborted) throw signal.reason ?? new AbortError();
+}
+function assertRequest(value, where) {
+  if (!value || typeof value !== "object")
+    throw new ConfigError(`${where} must return a request object (or nothing).`);
+  const req = value;
+  for (const key of REQUEST_KEYS) {
+    if (!(key in req)) throw new ConfigError(`${where} returned a request without "${key}".`);
+  }
+  if (!(req.headers instanceof Headers))
+    throw new ConfigError(`${where} returned a request whose headers is not a Headers instance.`);
+  if (typeof req.url !== "string")
+    throw new ConfigError(`${where} returned a request with a non-string url.`);
+  return req;
+}
+function assertResponse(value, where) {
+  if (!value || typeof value !== "object" || !("data" in value) || typeof value.status !== "number") {
+    throw new ConfigError(
+      `${where} must return a response object { data, status, headers, request } (or nothing).`
+    );
+  }
+  const res = value;
+  if (!(res.headers instanceof Headers))
+    throw new ConfigError(`${where} returned a response whose headers is not a Headers instance.`);
+  return res;
+}
+async function runOperation(client, resource, op, call) {
+  const options = call.options ?? {};
+  const timeout = options.timeout ?? op.timeout;
+  const { signal, timedOut, cleanup } = createCallSignal(timeout, options.signal);
+  const mocked = resource.mock !== void 0;
+  let request;
+  let idempotencyKey = call.idempotencyKey;
+  try {
+    throwIfAborted(signal);
+    const method = call.method ?? op.method;
+    const pathTemplate = call.path ?? op.path;
+    const path = interpolatePath(pathTemplate, call.params);
+    const query = transformQuery(call.query ?? options.query, op.requestKeys);
+    const qs = client.querySerializer ? normalizeQs(client.querySerializer(query ?? {})) : buildQueryString(query, client.queryArrayFormat);
+    const origin = mocked ? client.base.origin : requestOrigin(client.base);
+    const headers = await resolveHeaders(op.headers, options.headers);
+    idempotencyKey = applyIdempotency(op, options, headers, idempotencyKey, resource.name);
+    throwIfAborted(signal);
+    request = {
+      method,
+      url: buildUrl(client.base, path, qs, origin),
+      path,
+      baseURL: client.base.raw,
+      headers,
+      params: call.params,
+      query,
+      body: call.body,
+      signal,
+      timeout,
+      meta: { ...options.meta ?? {} },
+      resource: resource.name,
+      operation: op.name,
+      mocked
+    };
+    for (const hook of op.onRequest) {
+      const next = await hook(request);
+      if (next !== void 0)
+        request = assertRequest(next, `request middleware for ${resource.name}.${op.name}`);
+      throwIfAborted(signal);
+    }
+    const hasBody = call.hasBody ?? op.hasBody;
+    const wireBody = hasBody && op.requestKeys ? transformKeys(request.body, op.requestKeys) : request.body;
+    let status;
+    let responseHeaders;
+    let raw;
+    let data;
+    if (resource.mock) {
+      const { store, source } = resource.mock;
+      const wire = {
+        query: request.query,
+        body: hasBody ? wireBody : void 0
+      };
+      const relative = interpolatePath(call.relativePath ?? op.relativePath, call.params);
+      let result;
+      if (!call.intent && !call.routed) {
+        if (!op.mockHandler) {
+          throw new MockError(
+            "MOCK_UNSUPPORTED",
+            `${source.label}: custom operation "${resource.name}.${op.name}" (${request.method} ${relative || "/"}) has no mock behavior. Add a \`mock\` handler to the operation, or implement it as a function operation ({ kind, run }) that uses ctx.request().`
+          );
+        }
+        result = await runMockHandler(op.mockHandler, store, {
+          resource: resource.name,
+          operation: op.name,
+          method: request.method,
+          params: { ...call.params ?? {} },
+          query: wire.query,
+          body: wire.body,
+          signal
+        });
+      } else {
+        const intent = call.intent ? call.intent(wire) : routeToIntent(request.method, relative, wire.query, wire.body, source.label);
+        result = await runBuiltin(store, source, intent, resource.pagination);
+      }
+      throwIfAborted(signal);
+      status = result.status;
+      responseHeaders = new Headers();
+      data = result.data;
+    } else {
+      assertSameOrigin(request.url, origin);
+      const response2 = await sendWithRetry(
+        client,
+        op,
+        request,
+        hasBody ? wireBody : void 0,
+        options,
+        signal,
+        call.allow404 === true
+      );
+      status = response2.status;
+      responseHeaders = response2.headers;
+      raw = response2.raw;
+      data = response2.body;
+      if (op.responseKeys) data = transformKeys(data, op.responseKeys);
+      if (call.fromHttp) data = call.fromHttp(data, status);
+    }
+    if (resource.mock && op.responseKeys) data = transformKeys(data, op.responseKeys);
+    if (call.shape) data = call.shape(data);
+    let response = { data, status, headers: responseHeaders, request, raw };
+    for (const hook of op.onResponse) {
+      const next = await hook(response);
+      if (next !== void 0)
+        response = assertResponse(next, `response middleware for ${resource.name}.${op.name}`);
+    }
+    return options.full ? response : response.data;
+  } catch (thrown) {
+    let error = classify(thrown, signal, timedOut(), request);
+    const replay = call.replayed ? void 0 : () => runOperation(client, resource, op, { ...call, replayed: true, idempotencyKey });
+    for (const hook of op.onError) {
+      try {
+        const recovered = await hook(error, { request, replay });
+        if (recovered !== void 0) return recovered;
+      } catch (next) {
+        error = next;
+      }
+    }
+    throw error;
+  } finally {
+    cleanup();
+  }
+}
+function applyIdempotency(op, options, headers, current, resourceName) {
+  if (!op.idempotency) {
+    if (options.idempotencyKey !== void 0) {
+      throw new ConfigError(
+        `resources.${resourceName}.operations.${op.name}: idempotencyKey was passed, but the operation has no idempotency option.`
+      );
+    }
+    return void 0;
+  }
+  const { header, generate } = op.idempotency;
+  if (options.idempotencyKey !== void 0) {
+    if (typeof options.idempotencyKey !== "string" || options.idempotencyKey === "") {
+      throw new ConfigError("options.idempotencyKey must be a non-empty string.");
+    }
+    headers.set(header, options.idempotencyKey);
+    return options.idempotencyKey;
+  }
+  if (current !== void 0) {
+    headers.set(header, current);
+    return current;
+  }
+  const existing = headers.get(header);
+  if (existing !== null) return existing;
+  const key = generate();
+  if (typeof key !== "string" || key === "") {
+    throw new ConfigError(
+      `resources.${resourceName}.operations.${op.name}.idempotency.generate must return a non-empty string.`
+    );
+  }
+  headers.set(header, key);
+  return key;
+}
+function normalizeQs(value) {
+  if (!value) return "";
+  return value.startsWith("?") ? value : `?${value}`;
+}
+function isReplayable(body) {
+  return !(typeof ReadableStream !== "undefined" && body instanceof ReadableStream);
+}
+async function sendWithRetry(client, op, request, wireBody, options, signal, allow404) {
+  const retry = options.retry !== void 0 ? resolveRetryConfig(options.retry, "options.retry") : op.retry;
+  const headers = new Headers(request.headers);
+  const body = serializeBody(wireBody, headers);
+  const replayable = isReplayable(body);
+  for (let attempt = 0; ; attempt++) {
+    throwIfAborted(signal);
+    let failure;
+    let failedResponse;
+    try {
+      const response = await client.transport.request({
+        url: request.url,
+        method: request.method,
+        headers,
+        body,
+        signal,
+        responseType: options.responseType
+      });
+      if (response.status >= 200 && response.status < 300 || allow404 && response.status === 404) {
+        return response;
+      }
+      failedResponse = {
+        data: response.body,
+        status: response.status,
+        headers: response.headers,
+        request,
+        raw: response.raw
+      };
+      failure = new HttpError(`Request failed with status ${response.status}`, {
+        status: response.status,
+        data: response.body,
+        request,
+        response: failedResponse,
+        attempt
+      });
+    } catch (error) {
+      if (signal.aborted) throw error;
+      failure = error instanceof ApiError ? error : new NetworkError(error instanceof Error ? error.message : "Network request failed", {
+        cause: error
+      });
+      failure.request ??= request;
+      failure.attempt = attempt;
+    }
+    const ctx = {
+      request,
+      response: failedResponse,
+      attempt,
+      method: request.method,
+      error: failure
+    };
+    const retryAfter = retry?.respectRetryAfter && failedResponse ? parseRetryAfter(failedResponse.headers.get("retry-after")) : void 0;
+    const canRetry = retry !== void 0 && replayable && !signal.aborted && decideRetry(retry, ctx, failure) && (retryAfter === void 0 || retryAfter <= retry.maxDelayMs);
+    failure.retryable = canRetry;
+    if (!canRetry) throw failure;
+    await retry.onRetry?.(ctx);
+    await delay(retryAfter ?? computeBackoffMs(attempt, retry), signal);
+  }
+}
+
+// packages/core/src/utils/slice.ts
+function isPlainSliceRange(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).every((k) => k === "start" || k === "end");
+}
+function assertResourceSlice(slice, label = "slice") {
+  if (typeof slice === "number") {
+    if (!Number.isInteger(slice) || slice < 0) {
+      throw new Error(`${label}: must be a non-negative integer (got ${String(slice)}).`);
+    }
+    return;
+  }
+  if (!isPlainSliceRange(slice)) {
+    throw new Error(`${label}: must be a non-negative integer or { start, end }.`);
+  }
+  const { start, end } = slice;
+  if (typeof start !== "number" || !Number.isInteger(start) || start < 0) {
+    throw new Error(`${label}.start must be a non-negative integer (got ${String(start)}).`);
+  }
+  if (typeof end !== "number" || !Number.isInteger(end) || end < 0) {
+    throw new Error(`${label}.end must be a non-negative integer (got ${String(end)}).`);
+  }
+  if (end < start) {
+    throw new Error(`${label}.end (${end}) must not be before ${label}.start (${start}).`);
+  }
+}
+function applyResourceSlice(records, slice, label = "slice") {
+  if (slice === void 0) return records;
+  assertResourceSlice(slice, label);
+  if (typeof slice === "number") {
+    if (slice >= records.length) return records.slice();
+    return records.slice(0, slice);
+  }
+  if (slice.end > records.length) return records.slice();
+  return records.slice(slice.start, slice.end);
+}
+function applyResourceSliceToListResult(data, slice) {
+  if (slice === void 0 || !Array.isArray(data)) return data;
+  return applyResourceSlice(data, slice);
+}
+
+// packages/core/src/api/validate.ts
+var ROOT_KEYS = /* @__PURE__ */ new Set([
+  "baseURL",
+  "headers",
+  "transport",
+  "timeout",
+  "retry",
+  "middleware",
+  "requestMiddleware",
+  "responseMiddleware",
+  "transforms",
+  "queryArrayFormat",
+  "querySerializer",
+  "resources"
+]);
+var RESOURCE_KEYS = /* @__PURE__ */ new Set([
+  "path",
+  "headers",
+  "timeout",
+  "retry",
+  "middleware",
+  "requestMiddleware",
+  "responseMiddleware",
+  "transforms",
+  "defaultOperations",
+  "readOnly",
+  "writeOnly",
+  "operationGroups",
+  "operations",
+  "mock",
+  "pagination",
+  "slice"
+]);
+var OPERATION_KEYS = /* @__PURE__ */ new Set([
+  "kind",
+  "idempotency",
+  "method",
+  "path",
+  "hasBody",
+  "headers",
+  "timeout",
+  "retry",
+  "middleware",
+  "requestMiddleware",
+  "responseMiddleware",
+  "transforms",
+  "mock"
+]);
+var RUN_KEYS = /* @__PURE__ */ new Set(["kind", "run"]);
+var METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+function requiredKind(method) {
+  return method === "GET" || method === "HEAD" || method === "OPTIONS" ? "read" : "write";
+}
+function validateMethodKind(where, kind, method) {
+  if (!METHODS.has(method)) {
+    throw new ConfigError(
+      `${where}: HTTP method "${String(method)}" is invalid. Use GET, HEAD, OPTIONS, POST, PUT, PATCH, or DELETE.`
+    );
+  }
+  const required = requiredKind(method);
+  if (kind !== required) {
+    throw new ConfigError(
+      `${where}: Operation kind "${kind}" is incompatible with HTTP method "${method}". ${method} requires kind "${required}". Change the method or kind.`
+    );
+  }
+}
+var GROUPS = /* @__PURE__ */ new Set(["read", "write", "many", "extended"]);
+var HOOK_KEYS = /* @__PURE__ */ new Set(["onRequest", "onResponse", "onError"]);
+function isPlainObject3(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function typeName(value) {
+  return Array.isArray(value) ? "array" : value === null ? "null" : typeof value;
+}
+function unknownKey(where, key, allowed) {
+  throw new ConfigError(
+    `${where} has unknown option "${key}". Supported: ${[...allowed].join(", ")}.`
+  );
+}
+function assertKnownKeys(where, value, allowed) {
+  for (const key of Object.keys(value)) if (!allowed.has(key)) unknownKey(where, key, allowed);
+}
+function validateRoot(config) {
+  if (!isPlainObject3(config)) {
+    throw new ConfigError(`defineApi() expects a config object (got ${typeName(config)}).`);
+  }
+  for (const key of Object.keys(config)) {
+    if (ROOT_KEYS.has(key)) continue;
+    const value = config[key];
+    if (isPlainObject3(value) && "path" in value) {
+      throw new ConfigError(
+        `"${key}" looks like a resource at the root of the config. Resources must be nested: defineApi({ baseURL, resources: { ${key}: { path: ${JSON.stringify(value.path)} } } }).`
+      );
+    }
+    unknownKey("defineApi config", key, ROOT_KEYS);
+  }
+  if (!("resources" in config)) {
+    throw new ConfigError(
+      `defineApi config needs a "resources" object, e.g. resources: { users: { path: "/users" } }.`
+    );
+  }
+  if (!isPlainObject3(config.resources)) {
+    throw new ConfigError(
+      `"resources" must be an object of resource definitions (got ${typeName(config.resources)}).`
+    );
+  }
+  if (config.transport !== void 0) {
+    const transport = config.transport;
+    if (!transport || typeof transport !== "object" || typeof transport.request !== "function") {
+      throw new ConfigError(`transport must be an object with a request(input) function.`);
+    }
+  }
+  if (config.queryArrayFormat !== void 0 && !["repeat", "comma", "brackets"].includes(config.queryArrayFormat)) {
+    throw new ConfigError(
+      `queryArrayFormat must be "repeat", "comma", or "brackets" (got ${String(config.queryArrayFormat)}).`
+    );
+  }
+  if (config.querySerializer !== void 0 && typeof config.querySerializer !== "function") {
+    throw new ConfigError(`querySerializer must be a function.`);
+  }
+  validateLayer("defineApi config", config);
+}
+function validateLayer(where, layer) {
+  const { headers, timeout, retry, middleware, requestMiddleware, responseMiddleware, transforms } = layer;
+  resolveRetryConfig(retry, `${where}.retry`);
+  if (headers !== void 0 && typeof headers !== "function" && typeof headers !== "object") {
+    throw new ConfigError(
+      `${where}.headers must be an object, Headers, entries array, or a (sync/async) function.`
+    );
+  }
+  if (headers === null) throw new ConfigError(`${where}.headers must not be null.`);
+  if (timeout !== void 0 && (typeof timeout !== "number" || !Number.isFinite(timeout) || timeout < 0)) {
+    throw new ConfigError(
+      `${where}.timeout must be a non-negative number of milliseconds (got ${String(timeout)}).`
+    );
+  }
+  if (middleware !== void 0) validateHooks(`${where}.middleware`, middleware);
+  if (requestMiddleware !== void 0)
+    validateFnArray(`${where}.requestMiddleware`, requestMiddleware);
+  if (responseMiddleware !== void 0)
+    validateFnArray(`${where}.responseMiddleware`, responseMiddleware);
+  if (transforms !== void 0) validateTransforms(`${where}.transforms`, transforms);
+}
+function validateHooks(where, value) {
+  if (Array.isArray(value)) {
+    throw new ConfigError(
+      `${where} must be an object { onRequest?, onResponse?, onError? }. Around-style middleware arrays were removed; use requestMiddleware / responseMiddleware arrays instead.`
+    );
+  }
+  if (!isPlainObject3(value))
+    throw new ConfigError(`${where} must be an object { onRequest?, onResponse?, onError? }.`);
+  for (const [key, hook] of Object.entries(value)) {
+    if (!HOOK_KEYS.has(key)) unknownKey(where, key, HOOK_KEYS);
+    if (hook !== void 0 && typeof hook !== "function")
+      throw new ConfigError(`${where}.${key} must be a function.`);
+  }
+}
+function validateFnArray(where, value) {
+  if (!Array.isArray(value)) throw new ConfigError(`${where} must be an array of functions.`);
+  value.forEach((fn, i) => {
+    if (typeof fn !== "function")
+      throw new ConfigError(`${where}[${i}] must be a function (got ${typeName(fn)}).`);
+  });
+}
+function validateTransforms(where, value) {
+  if (!isPlainObject3(value))
+    throw new ConfigError(`${where} must be { request?: { keys }, response?: { keys } }.`);
+  for (const [direction, rule] of Object.entries(value)) {
+    if (direction !== "request" && direction !== "response")
+      unknownKey(where, direction, /* @__PURE__ */ new Set(["request", "response"]));
+    if (rule === void 0) continue;
+    if (!isPlainObject3(rule)) throw new ConfigError(`${where}.${direction} must be { keys }.`);
+    assertKnownKeys(`${where}.${direction}`, rule, /* @__PURE__ */ new Set(["keys"]));
+    if (!isKeyCase(rule.keys)) {
+      throw new ConfigError(
+        `${where}.${direction}.keys must be one of ${KEY_CASES.join(", ")} (got ${JSON.stringify(rule.keys)}).`
+      );
+    }
+  }
+}
+function validateResource(name, value) {
+  const where = `resources.${name}`;
+  if (!isPlainObject3(value))
+    throw new ConfigError(`${where} must be a resource object like { path: "/${name}" }.`);
+  assertKnownKeys(where, value, RESOURCE_KEYS);
+  if (typeof value.path !== "string" || !value.path.startsWith("/")) {
+    throw new ConfigError(`${where}.path must be a string starting with "/" (e.g. "/${name}").`);
+  }
+  for (const flag of ["defaultOperations", "readOnly", "writeOnly"]) {
+    if (value[flag] !== void 0 && typeof value[flag] !== "boolean") {
+      throw new ConfigError(`${where}.${flag} must be a boolean.`);
+    }
+  }
+  if (value.readOnly === true && value.writeOnly === true) {
+    throw new ConfigError(`${where} cannot set both readOnly and writeOnly to true.`);
+  }
+  if (value.operationGroups !== void 0) {
+    if (!isPlainObject3(value.operationGroups))
+      throw new ConfigError(`${where}.operationGroups must be an object.`);
+    for (const [group, choice] of Object.entries(value.operationGroups)) {
+      if (!GROUPS.has(group)) unknownKey(`${where}.operationGroups`, group, GROUPS);
+      if (choice !== void 0 && typeof choice !== "boolean") {
+        throw new ConfigError(`${where}.operationGroups.${group} must be a boolean.`);
+      }
+    }
+  }
+  if (value.pagination !== void 0 && value.pagination !== "page" && value.pagination !== "cursor") {
+    throw new ConfigError(
+      `${where}.pagination must be "page" or "cursor" (got ${JSON.stringify(value.pagination)}).` + (typeof value.pagination === "boolean" ? ` The mock pagination boolean was replaced by pagination: "page".` : "")
+    );
+  }
+  if (value.slice !== void 0) {
+    try {
+      assertResourceSlice(value.slice, `${where}.slice`);
+    } catch (cause) {
+      throw new ConfigError(cause.message, { cause });
+    }
+  }
+  validateLayer(where, value);
+  if (value.operations !== void 0) {
+    if (!isPlainObject3(value.operations))
+      throw new ConfigError(`${where}.operations must be an object.`);
+    for (const [op, definition] of Object.entries(value.operations))
+      validateOperation(`${where}.operations.${op}`, op, definition);
+  }
+}
+function validateOperation(where, name, value) {
+  const builtin = isBuiltinName(name);
+  if (value === void 0 || value === false) return;
+  if (typeof value === "function") {
+    if (!builtin)
+      throw new ConfigError(
+        `${where}: custom function operation requires { kind: "read" | "write", run }.`
+      );
+    return;
+  }
+  if (value === true) {
+    if (!builtin) {
+      throw new ConfigError(
+        `${where}: true cannot create custom operation "${name}"; give it { method, path } or a function.`
+      );
+    }
+    return;
+  }
+  if (!isPlainObject3(value)) {
+    throw new ConfigError(
+      `${where} must be true, false, a config object, or a function (got ${typeName(value)}).`
+    );
+  }
+  if (builtin && "kind" in value) {
+    throw new ConfigError(
+      `${where}.kind: builtin "${name}" is always "${BUILTIN_CONVENTIONS[name].access}"; kind is for custom operations.`
+    );
+  }
+  if (!builtin) {
+    if (value.kind !== "read" && value.kind !== "write")
+      throw new ConfigError(
+        `${where}.kind must be explicitly set to "read" or "write" (got ${JSON.stringify(value.kind)}).`
+      );
+  }
+  if ("run" in value) {
+    assertKnownKeys(where, value, RUN_KEYS);
+    if (typeof value.run !== "function")
+      throw new ConfigError(`${where}.run must be a function (got ${typeName(value.run)}).`);
+    return;
+  }
+  assertKnownKeys(where, value, OPERATION_KEYS);
+  if (value.mock !== void 0) {
+    if (builtin) {
+      throw new ConfigError(
+        `${where}.mock: builtin "${name}" is simulated by Core; \`mock\` is for custom operations.`
+      );
+    }
+    if (typeof value.mock !== "function") {
+      throw new ConfigError(
+        `${where}.mock must be a function ({ records, store, params, query, body, signal }) => result (got ${typeName(value.mock)}).`
+      );
+    }
+  }
+  if (value.method !== void 0 && !METHODS.has(value.method)) {
+    throw new ConfigError(
+      `${where}.method must be one of ${[...METHODS].join(", ")} (got ${JSON.stringify(value.method)}).`
+    );
+  }
+  if (!builtin && value.method === void 0) {
+    throw new ConfigError(`${where}: custom operation "${name}" needs a method.`);
+  }
+  const method = value.method ?? (builtin ? BUILTIN_CONVENTIONS[name].method : void 0);
+  validateMethodKind(
+    where,
+    builtin ? BUILTIN_CONVENTIONS[name].access : value.kind,
+    method
+  );
+  if (value.path !== void 0 && typeof value.path !== "string")
+    throw new ConfigError(`${where}.path must be a string.`);
+  if (value.hasBody !== void 0 && typeof value.hasBody !== "boolean")
+    throw new ConfigError(`${where}.hasBody must be a boolean.`);
+  validateIdempotency(
+    where,
+    value.idempotency,
+    builtin ? BUILTIN_CONVENTIONS[name].access : value.kind
+  );
+  validateLayer(where, value);
+}
+var IDEMPOTENCY_KEYS = /* @__PURE__ */ new Set(["header", "generate"]);
+function validateIdempotency(where, value, kind) {
+  if (value === void 0 || value === false) return;
+  if (kind !== "write") {
+    throw new ConfigError(
+      `${where}.idempotency: only write operations send an idempotency key (this operation is a "${kind}").`
+    );
+  }
+  if (value === true) return;
+  if (!isPlainObject3(value)) {
+    throw new ConfigError(
+      `${where}.idempotency must be true, false, or { header?, generate? } (got ${typeName(value)}).`
+    );
+  }
+  assertKnownKeys(`${where}.idempotency`, value, IDEMPOTENCY_KEYS);
+  if (value.header !== void 0 && (typeof value.header !== "string" || !/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(value.header))) {
+    throw new ConfigError(`${where}.idempotency.header must be a valid HTTP header name.`);
+  }
+  if (value.generate !== void 0 && typeof value.generate !== "function") {
+    throw new ConfigError(`${where}.idempotency.generate must be a function.`);
+  }
+}
+
+// packages/core/src/api/metadata.ts
+var OPERATION_METADATA = /* @__PURE__ */ Symbol.for("apixa.operations");
+function getOperationMetadata(resource) {
+  const value = resource[OPERATION_METADATA];
+  return value && typeof value === "object" ? value : void 0;
+}
+var IDEMPOTENCY_GENERATORS = /* @__PURE__ */ new WeakMap();
+function registerIdempotencyGenerators(resource, generators) {
+  IDEMPOTENCY_GENERATORS.set(resource, generators);
+}
+function createIdempotencyKey(resource, operation) {
+  return IDEMPOTENCY_GENERATORS.get(resource)?.[operation]?.();
+}
+
+// packages/core/src/api/resource-client.ts
+var BODY_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
+function pick(...values) {
+  for (let i = values.length - 1; i >= 0; i--) if (values[i] !== void 0) return values[i];
+  return void 0;
+}
+function prepareLayers(where, layers) {
+  const present = layers.filter((l) => l !== void 0);
+  const retry = pick(...present.map((l) => l.retry));
+  return {
+    headers: present.map((l) => l.headers).filter((h) => h !== void 0),
+    timeout: pick(...present.map((l) => l.timeout)),
+    retry: resolveRetryConfig(retry, `${where}.retry`),
+    onRequest: present.flatMap((l) => [
+      ...l.middleware?.onRequest ? [l.middleware.onRequest] : [],
+      ...l.requestMiddleware ?? []
+    ]),
+    onResponse: present.flatMap((l) => [
+      ...l.middleware?.onResponse ? [l.middleware.onResponse] : [],
+      ...l.responseMiddleware ?? []
+    ]),
+    onError: present.flatMap((l) => l.middleware?.onError ? [l.middleware.onError] : []),
+    requestKeys: pick(...present.map((l) => l.transforms?.request?.keys)),
+    responseKeys: pick(...present.map((l) => l.transforms?.response?.keys))
+  };
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function toArray(result) {
+  if (Array.isArray(result)) return result;
+  if (result && typeof result === "object" && Array.isArray(result.data)) {
+    return result.data;
+  }
+  return [];
+}
+function splitTrailing(args, hasResourceParams, fixed) {
+  const params = hasResourceParams ? args[fixed] : void 0;
+  const options = args[hasResourceParams ? fixed + 1 : fixed];
+  return { params, options };
+}
+function createResourceClient(client, input) {
+  const { name, definition: def, root } = input;
+  const resourcePath = def.path;
+  const resourceLayer = def;
+  const runtime = {
+    name,
+    path: resourcePath,
+    pagination: def.pagination
+  };
+  if (def.mock !== void 0) {
+    const source = normalizeMockSource(name, def.mock);
+    runtime.mock = { source, store: new MockStore(source) };
+  }
+  const slice = def.slice;
+  const resourceParamNames = extractPathParamNames(resourcePath);
+  const hasResourceParams = resourceParamNames.length > 0;
+  const operations = expandOperations(
+    def.operations,
+    {
+      defaultOperations: def.defaultOperations,
+      readOnly: def.readOnly,
+      writeOnly: def.writeOnly,
+      operationGroups: def.operationGroups
+    }
+  );
+  const out = {};
+  const metadata = {};
+  const generators = {};
+  for (const [opName, definition] of Object.entries(operations)) {
+    const where = `resources.${name}.operations.${opName}`;
+    const convention = isBuiltinName(opName) ? BUILTIN_CONVENTIONS[opName] : void 0;
+    const fn = typeof definition === "function" ? definition : isRunDefinition(definition) ? definition.run : void 0;
+    if (fn) {
+      out[opName] = functionOperation(
+        client,
+        runtime,
+        opName,
+        fn,
+        convention?.access ?? definition.kind,
+        prepareLayers(where, [root, resourceLayer])
+      );
+      metadata[opName] = Object.freeze({
+        kind: convention?.access ?? definition.kind,
+        builtin: convention !== void 0,
+        implementation: "function",
+        optionsIndex: null,
+        idempotency: false
+      });
+      continue;
+    }
+    const declared = definition;
+    const method = declared.method ?? convention.method;
+    const relativePath = declared.path ?? convention?.path ?? "";
+    const hasBody = declared.hasBody ?? (convention && "hasBody" in convention ? convention.hasBody : void 0) ?? (convention && "strategy" in convention ? false : BODY_METHODS.has(method));
+    const op = {
+      name: opName,
+      method,
+      path: joinPath(resourcePath, relativePath),
+      relativePath,
+      hasBody,
+      ...prepareLayers(where, [root, resourceLayer, declared])
+    };
+    if (declared.mock !== void 0) {
+      op.mockHandler = declared.mock;
+    }
+    if (declared.idempotency !== void 0 && declared.idempotency !== false) {
+      const config = declared.idempotency === true ? {} : declared.idempotency;
+      op.idempotency = {
+        header: config.header ?? "Idempotency-Key",
+        generate: config.generate ?? defaultIdempotencyKey
+      };
+      generators[opName] = op.idempotency.generate;
+    }
+    if (convention && "strategy" in convention && hasBody) {
+      throw new ConfigError(
+        `${where}: hasBody is unsupported on ${opName} (it has no body mapping).`
+      );
+    }
+    metadata[opName] = Object.freeze({
+      kind: convention?.access ?? declared.kind,
+      builtin: convention !== void 0,
+      implementation: "request",
+      optionsIndex: optionsIndexOf(opName, op, hasResourceParams),
+      idempotency: op.idempotency !== void 0
+    });
+    const run = (call) => runOperation(client, runtime, op, call);
+    out[opName] = convention ? builtinOperation(opName, op, run, {
+      resourceParamNames,
+      hasResourceParams,
+      slice
+    }) : declarativeOperation(op, run);
+  }
+  Object.defineProperty(out, OPERATION_METADATA, { value: Object.freeze(metadata) });
+  if (Object.keys(generators).length > 0)
+    registerIdempotencyGenerators(out, Object.freeze(generators));
+  return { client: out, store: runtime.mock?.store };
+}
+function defaultIdempotencyKey() {
+  const webCrypto = globalThis.crypto;
+  if (typeof webCrypto?.randomUUID === "function") return webCrypto.randomUUID();
+  if (typeof webCrypto?.getRandomValues !== "function") {
+    throw new ConfigError("idempotency: no Web Crypto in this runtime; pass idempotency.generate.");
+  }
+  const bytes = webCrypto.getRandomValues(new Uint8Array(16));
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = [...bytes].map((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)}`;
+}
+function isRunDefinition(value) {
+  return isRecord(value) && typeof value.run === "function";
+}
+function optionsIndexOf(name, op, hasResourceParams) {
+  const params = hasResourceParams ? 1 : 0;
+  if (name === "exists" || name === "getMany" || name === "findFirst") return 1 + params;
+  if (name === "getBy") return 2 + params;
+  return (extractPathParamNames(op.path).length > 0 ? 1 : 0) + (op.hasBody ? 1 : 0);
+}
+function declarativeOperation(op, run) {
+  const paramNames = extractPathParamNames(op.path);
+  return (...args) => {
+    const parsed = parseOperationArgs(paramNames, op.hasBody, args);
+    return run({ params: parsed.params, body: parsed.body, options: parsed.options });
+  };
+}
+function builtinOperation(name, op, run, ctx) {
+  const paramNames = extractPathParamNames(op.path);
+  const idParam = paramNames.find((p) => !ctx.resourceParamNames.includes(p));
+  const keyName = (field) => op.requestKeys ? convertKey(field, op.requestKeys) : field;
+  switch (name) {
+    case "exists":
+      return (id, ...rest) => {
+        const { params, options } = splitTrailing(rest, ctx.hasResourceParams, 0);
+        return run({
+          params: { ...params, ...idParam ? { [idParam]: id } : {} },
+          query: idParam ? options?.query : { ...options?.query ?? {}, id },
+          options,
+          allow404: true,
+          fromHttp: (_data, status) => status !== 404,
+          intent: () => ({ op: "exists", id })
+        });
+      };
+    case "getMany":
+      return (ids, ...rest) => {
+        const { params, options } = splitTrailing(rest, ctx.hasResourceParams, 0);
+        return run({
+          params,
+          query: { ...options?.query ?? {}, id: ids },
+          options,
+          fromHttp: toArray,
+          intent: () => ({ op: "getMany", ids })
+        });
+      };
+    case "findFirst":
+      return (query, ...rest) => {
+        const { params, options } = splitTrailing(rest, ctx.hasResourceParams, 0);
+        return run({
+          params,
+          query,
+          options,
+          fromHttp: (data) => toArray(data)[0] ?? null,
+          intent: (wire) => ({ op: "findFirst", query: wire.query })
+        });
+      };
+    case "getBy":
+      return (fieldOrPath, value, ...rest) => {
+        const { params, options } = splitTrailing(rest, ctx.hasResourceParams, 0);
+        const field = String(fieldOrPath);
+        const encoded = encodeURIComponent(String(value));
+        let path;
+        if (/:field\b|:value\b/.test(op.path)) {
+          path = op.path.replace(/:field\b/g, encodeURIComponent(field)).replace(/:value\b/g, encoded);
+        } else {
+          const dynamic = /:[A-Za-z0-9_]+/.test(field) ? field.replace(/:[A-Za-z0-9_]+/, encoded) : joinPath(field, encoded);
+          path = joinPath(op.path, dynamic);
+        }
+        return run({
+          params,
+          path,
+          options,
+          intent: () => ({ op: "getBy", field: keyName(field), value })
+        });
+      };
+    default:
+      break;
+  }
+  return (...args) => {
+    const parsed = parseOperationArgs(paramNames, op.hasBody, args);
+    const params = parsed.params;
+    const id = idParam ? params?.[idParam] : void 0;
+    const call = { params, body: parsed.body, options: parsed.options };
+    call.intent = (wire) => {
+      switch (name) {
+        case "getAll":
+        case "count":
+        case "search":
+          return { op: name, query: wire.query ?? (isRecord(wire.body) ? wire.body : void 0) };
+        case "getBySlug":
+          return { op: name, slug: id };
+        case "getById":
+        case "delete":
+          return { op: name, id };
+        case "update":
+        case "patch":
+        case "upsert":
+          return { op: name, id, body: wire.body };
+        default:
+          return { op: name, body: wire.body };
+      }
+    };
+    if (name === "getAll" && ctx.slice !== void 0) {
+      const slice = ctx.slice;
+      call.shape = (data) => applyResourceSliceToListResult(data, slice);
+    }
+    return run(call);
+  };
+}
+function functionOperation(client, runtime, opName, fn, kind, layers) {
+  const base = {
+    name: opName,
+    method: "GET",
+    path: runtime.path,
+    relativePath: "",
+    hasBody: false,
+    ...layers
+  };
+  const ctx = {
+    resource: runtime.name,
+    operation: opName,
+    request: (init = {}) => {
+      const method = init.method ?? "GET";
+      validateMethodKind(`resources.${runtime.name}.operations.${opName}`, kind, method);
+      const options = {
+        headers: init.headers,
+        signal: init.signal,
+        timeout: init.timeout,
+        retry: init.retry,
+        responseType: init.responseType,
+        meta: init.meta,
+        full: init.full
+      };
+      return runOperation(client, runtime, base, {
+        method,
+        path: joinPath(runtime.path, init.path ?? ""),
+        relativePath: init.path ?? "",
+        params: init.params,
+        query: init.query,
+        body: init.body,
+        hasBody: init.body !== void 0,
+        routed: true,
+        options
+      });
+    }
+  };
+  return (...args) => Promise.resolve().then(() => fn(ctx, ...args));
+}
+
+// packages/core/src/api/client.ts
+var stores = /* @__PURE__ */ new WeakMap();
+function buildClient(config) {
+  validateRoot(config);
+  const base = parseBaseURL(config.baseURL);
+  const runtime = {
+    base,
+    transport: config.transport ?? createFetchTransport(),
+    queryArrayFormat: config.queryArrayFormat ?? "repeat",
+    querySerializer: config.querySerializer
+  };
+  const root = {
+    headers: config.headers,
+    timeout: config.timeout,
+    retry: config.retry,
+    middleware: config.middleware,
+    requestMiddleware: config.requestMiddleware,
+    responseMiddleware: config.responseMiddleware,
+    transforms: config.transforms
+  };
+  const client = {};
+  const all = [];
+  for (const [name, definition] of Object.entries(config.resources)) {
+    validateResource(name, definition);
+    const built = createResourceClient(runtime, { name, definition, root });
+    const resource = Object.freeze(built.client);
+    if (built.store) {
+      stores.set(resource, [built.store]);
+      all.push(built.store);
+    }
+    client[name] = resource;
+  }
+  const frozen = Object.freeze(client);
+  stores.set(frozen, all);
+  return frozen;
+}
+function resetMockState(target) {
+  const found = stores.get(target);
+  if (!found || found.length === 0 && !Object.isFrozen(target)) {
+    throw new ConfigError(
+      "resetMock() expects a mocked resource (api.users) or a client created by defineApi()."
+    );
+  }
+  for (const store of found) store.reset();
+}
+
+// packages/core/src/api/define-api.ts
+function defineApi(config) {
+  if (arguments.length === 0) return (curried) => buildClient(curried);
+  return buildClient(config);
+}
+
+// packages/core/src/api/define-apis.ts
+function build(configs) {
+  if (!isPlainObject3(configs)) {
+    throw new ConfigError(
+      `defineApis() expects an object of named client configs (e.g. { backend: { baseURL, resources } }).`
+    );
+  }
+  const out = {};
+  for (const [name, config] of Object.entries(configs)) {
+    try {
+      out[name] = buildClient(config);
+    } catch (error) {
+      if (error instanceof ApiError && error.code === "CONFIG") {
+        throw new ConfigError(`defineApis.${name}: ${error.message}`, { cause: error });
+      }
+      throw error;
+    }
+  }
+  return Object.freeze(out);
+}
+function defineApis(configs) {
+  if (arguments.length === 0) return (curried) => build(curried);
+  return build(configs);
+}
+
+// packages/core/src/api/reset.ts
+function resetMock(target) {
+  resetMockState(target);
+}
+
+export {
+  ApiError,
+  NetworkError,
+  HttpError,
+  ParseError,
+  ValidationError,
+  TimeoutError,
+  AbortError,
+  ConfigError,
+  SecurityError,
+  TransformError,
+  MockError,
+  isApiError,
+  isHttpError,
+  isTimeoutError,
+  isMockError,
+  createFetchTransport,
+  MOCK_DATASETS,
+  isMockDatasetId,
+  listMockDatasetIds,
+  registerMockDatasetLoader,
+  normalizeMockSource,
+  MockStore,
+  runBuiltin,
+  BUILTIN_CONVENTIONS,
+  expandOperations,
+  KEY_CASES,
+  convertKey,
+  transformKeys,
+  isRetryableStatus,
+  parseRetryAfter,
+  computeBackoffMs,
+  applyResourceSliceToListResult,
+  OPERATION_METADATA,
+  getOperationMetadata,
+  createIdempotencyKey,
+  defineApi,
+  defineApis,
+  resetMock
+};