@frontal-labs/ontology 1.0.0 → 1.0.1

package/dist/index.js

@@ -40,8 +40,1126 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/client.ts
-var import_core2 = require("@frontal-labs/core");
+// ../core/dist/index.js
+var import_zod = require("zod");
+
+// ../../node_modules/.bun/@t3-oss+env-core@0.13.11+dcb9db7a51b27bde/node_modules/@t3-oss/env-core/dist/standard.js
+function ensureSynchronous(value, message) {
+  if (value instanceof Promise) throw new Error(message);
+}
+function parseWithDictionary(dictionary, value) {
+  const result = {};
+  const issues = [];
+  for (const key in dictionary) {
+    const propResult = dictionary[key]["~standard"].validate(value[key]);
+    ensureSynchronous(propResult, `Validation must be synchronous, but ${key} returned a Promise.`);
+    if (propResult.issues) {
+      issues.push(...propResult.issues.map((issue) => ({
+        ...issue,
+        message: issue.message,
+        path: [key, ...issue.path ?? []]
+      })));
+      continue;
+    }
+    result[key] = propResult.value;
+  }
+  if (issues.length) return { issues };
+  return { value: result };
+}
+
+// ../../node_modules/.bun/@t3-oss+env-core@0.13.11+dcb9db7a51b27bde/node_modules/@t3-oss/env-core/dist/index.js
+function createEnv(opts) {
+  const runtimeEnv = opts.runtimeEnvStrict ?? opts.runtimeEnv ?? process.env;
+  if (opts.emptyStringAsUndefined ?? false) {
+    for (const [key, value] of Object.entries(runtimeEnv)) if (value === "") delete runtimeEnv[key];
+  }
+  if (!!opts.skipValidation) {
+    if (opts.extends) for (const preset of opts.extends) preset.skipValidation = true;
+    return runtimeEnv;
+  }
+  const _client = typeof opts.client === "object" ? opts.client : {};
+  const _server = typeof opts.server === "object" ? opts.server : {};
+  const _shared = typeof opts.shared === "object" ? opts.shared : {};
+  const isServer = opts.isServer ?? (typeof window === "undefined" || "Deno" in window);
+  const finalSchemaShape = isServer ? {
+    ..._server,
+    ..._shared,
+    ..._client
+  } : {
+    ..._client,
+    ..._shared
+  };
+  const parsed = opts.createFinalSchema?.(finalSchemaShape, isServer)?.["~standard"].validate(runtimeEnv) ?? parseWithDictionary(finalSchemaShape, runtimeEnv);
+  ensureSynchronous(parsed, "Validation must be synchronous");
+  const onValidationError = opts.onValidationError ?? ((issues) => {
+    console.error("\u274C Invalid environment variables:", issues);
+    throw new Error("Invalid environment variables");
+  });
+  const onInvalidAccess = opts.onInvalidAccess ?? (() => {
+    throw new Error("\u274C Attempted to access a server-side environment variable on the client");
+  });
+  if (parsed.issues) return onValidationError(parsed.issues);
+  const isServerAccess = (prop) => {
+    if (!opts.clientPrefix) return true;
+    return !prop.startsWith(opts.clientPrefix) && !(prop in _shared);
+  };
+  const isValidServerAccess = (prop) => {
+    return isServer || !isServerAccess(prop);
+  };
+  const ignoreProp = (prop) => {
+    return prop === "__esModule" || prop === "$$typeof";
+  };
+  const extendedObj = (opts.extends ?? []).reduce((acc, curr) => {
+    return Object.assign(acc, curr);
+  }, {});
+  const fullObj = Object.assign(extendedObj, parsed.value);
+  return new Proxy(fullObj, { get(target, prop) {
+    if (typeof prop !== "string") return void 0;
+    if (ignoreProp(prop)) return void 0;
+    if (!isValidServerAccess(prop)) return onInvalidAccess(prop);
+    return Reflect.get(target, prop);
+  } });
+}
+
+// ../core/dist/index.js
+var import_zod2 = require("zod");
+var import_zod3 = require("zod");
+var import_zod4 = require("zod");
+var DEFAULT_BASE_URL = "https://api.frontal.dev/v1";
+var API_KEY_PREFIX = "frt_";
+var BACKOFF_STRATEGIES = [
+  "exponential",
+  "linear",
+  "constant"
+];
+var DEFAULT_RETRY_ON = [429, 500, 502, 503, 504];
+var EXPONENTIAL_BASE = 2;
+var JITTER_MAX = 200;
+var SDK_VERSION = "1.0.1";
+var timestampSchema = import_zod.z.date().transform((date) => new Date(date));
+var responseMetaSchema = import_zod.z.object({
+  requestId: import_zod.z.string().min(1),
+  timestamp: timestampSchema,
+  version: import_zod.z.string().optional(),
+  substrate: import_zod.z.string().optional(),
+  latency: import_zod.z.object({
+    total: import_zod.z.number().int().min(0),
+    substrate: import_zod.z.number().int().min(0).optional()
+  }).optional()
+}).strict();
+var paginationMetaSchema = import_zod.z.object({
+  cursor: import_zod.z.string().min(1),
+  hasMore: import_zod.z.boolean(),
+  limit: import_zod.z.number().int().positive().optional(),
+  total: import_zod.z.number().int().min(0).optional(),
+  offset: import_zod.z.number().int().min(0).optional()
+}).strict();
+var errorFieldSchema = import_zod.z.object({
+  field: import_zod.z.string().describe("Field name"),
+  code: import_zod.z.string().describe("Error code"),
+  message: import_zod.z.string().describe("Error message")
+}).strict();
+var docsUrlSchema = import_zod.z.string().url().refine((url) => /^https?:\/\//.test(url), {
+  message: "docs must be an http or https URL"
+});
+var errorResponseSchema = import_zod.z.object({
+  code: import_zod.z.string().min(1).describe("Error code"),
+  message: import_zod.z.string().min(1).describe("Error message"),
+  requestId: import_zod.z.string().min(1).describe("Request ID"),
+  docs: docsUrlSchema.optional().describe("Documentation URL"),
+  fields: import_zod.z.array(errorFieldSchema).optional().describe("Array of error fields")
+}).strict();
+var retryStatusCodeSchema = import_zod.z.number().int().refine((status) => status === 429 || status >= 500 && status <= 599, {
+  message: "Retry status codes must be 429 or 5xx"
+});
+var retryConfigSchema = import_zod.z.object({
+  maxAttempts: import_zod.z.number().int().positive().default(3),
+  baseDelay: import_zod.z.number().int().positive().default(1e3),
+  strategy: import_zod.z.enum(BACKOFF_STRATEGIES).default("exponential"),
+  on: import_zod.z.array(retryStatusCodeSchema).default(DEFAULT_RETRY_ON),
+  jitter: import_zod.z.boolean().default(true)
+}).strict().default({
+  maxAttempts: 3,
+  baseDelay: 1e3,
+  strategy: "exponential",
+  on: DEFAULT_RETRY_ON,
+  jitter: true
+});
+var numericValueSchema = import_zod.z.union([
+  import_zod.z.number(),
+  import_zod.z.literal(Number.POSITIVE_INFINITY),
+  import_zod.z.literal(Number.NEGATIVE_INFINITY)
+]);
+var arrayFilterValueSchema = import_zod.z.union([
+  import_zod.z.array(import_zod.z.string()),
+  import_zod.z.array(numericValueSchema)
+]);
+var scalarFilterValueSchema = import_zod.z.union([
+  import_zod.z.string(),
+  numericValueSchema,
+  import_zod.z.boolean(),
+  import_zod.z.date(),
+  import_zod.z.null(),
+  arrayFilterValueSchema
+]);
+var comparableValueSchema = import_zod.z.union([numericValueSchema, import_zod.z.date()]);
+var filterOperatorSchema = import_zod.z.object({
+  eq: scalarFilterValueSchema.optional(),
+  ne: scalarFilterValueSchema.optional(),
+  gt: comparableValueSchema.optional(),
+  gte: comparableValueSchema.optional(),
+  lt: comparableValueSchema.optional(),
+  lte: comparableValueSchema.optional(),
+  in: arrayFilterValueSchema.optional(),
+  nin: arrayFilterValueSchema.optional(),
+  contains: import_zod.z.string().optional(),
+  startsWith: import_zod.z.string().optional(),
+  endsWith: import_zod.z.string().optional()
+}).strict().refine(
+  (value) => Object.values(value).some((entry) => entry !== void 0),
+  {
+    message: "At least one filter operator is required"
+  }
+);
+var filterValueSchema = import_zod.z.union([
+  scalarFilterValueSchema,
+  filterOperatorSchema
+]);
+var filterConditionsSchema = import_zod.z.record(import_zod.z.string(), filterValueSchema);
+var pageResultSchema = import_zod.z.object({
+  data: import_zod.z.array(import_zod.z.unknown()),
+  meta: responseMetaSchema.optional(),
+  pagination: paginationMetaSchema
+}).strict();
+var FrontalError = class extends Error {
+  code;
+  requestId;
+  statusCode;
+  docs;
+  rateLimit;
+  /**
+   * @param response - The parsed error response from the API.
+   * @param statusCode - The HTTP status code.
+   * @param rateLimit - Optional rate-limit headers from the response.
+   */
+  constructor(response, statusCode, rateLimit) {
+    super(response.message);
+    this.name = "FrontalError";
+    this.code = response.code;
+    this.requestId = response.requestId;
+    this.statusCode = statusCode;
+    this.docs = response.docs;
+    this.rateLimit = rateLimit;
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this);
+    }
+  }
+};
+var NotFoundError = class extends FrontalError {
+  constructor(r, rateLimit) {
+    super(r, 404, rateLimit);
+    this.name = "NotFoundError";
+  }
+};
+var UnauthorizedError = class extends FrontalError {
+  constructor(r, rateLimit) {
+    super(r, 401, rateLimit);
+    this.name = "UnauthorizedError";
+  }
+};
+var ForbiddenError = class extends FrontalError {
+  constructor(r, rateLimit) {
+    super(r, 403, rateLimit);
+    this.name = "ForbiddenError";
+  }
+};
+var ValidationError = class extends FrontalError {
+  /** Per-field validation errors returned by the API. */
+  fields;
+  constructor(r, rateLimit) {
+    super(r, 400, rateLimit);
+    this.name = "ValidationError";
+    this.fields = r.fields ?? [];
+  }
+};
+var ConflictError = class extends FrontalError {
+  constructor(r, rateLimit) {
+    super(r, 409, rateLimit);
+    this.name = "ConflictError";
+  }
+};
+var RateLimitError = class extends FrontalError {
+  /** Recommended delay in seconds before retrying. */
+  retryAfter;
+  constructor(r, retryAfter, rateLimit) {
+    super(r, 429, rateLimit);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var ServiceError = class extends FrontalError {
+  constructor(r, status, rateLimit) {
+    super(r, status, rateLimit);
+    this.name = "ServiceError";
+  }
+};
+var NetworkError = class extends Error {
+  constructor(cause) {
+    super("Network error \u2014 could not reach Frontal API");
+    this.cause = cause;
+    this.name = "NetworkError";
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, new.target);
+    }
+  }
+};
+function normalizeErrorBody(body) {
+  const parsed = errorResponseSchema.safeParse(body);
+  if (parsed.success) return parsed.data;
+  const fallback = typeof body === "object" && body !== null ? body : {};
+  const code = typeof fallback.code === "string" && fallback.code.length > 0 ? fallback.code : "UNKNOWN_ERROR";
+  const hasExplicitCode = typeof fallback.code === "string" && fallback.code.length > 0;
+  const message = hasExplicitCode && typeof fallback.message === "string" && fallback.message.length > 0 ? fallback.message : "An unknown error occurred";
+  return {
+    code,
+    message,
+    requestId: typeof fallback.requestId === "string" && fallback.requestId.length > 0 ? fallback.requestId : "unknown",
+    docs: typeof fallback.docs === "string" ? fallback.docs : void 0,
+    fields: Array.isArray(fallback.fields) ? fallback.fields : void 0
+  };
+}
+function parseFrontalError(body, status, retryAfter, rateLimit) {
+  const normalized = normalizeErrorBody(body);
+  switch (status) {
+    case 400:
+      return new ValidationError(normalized, rateLimit);
+    case 401:
+      return new UnauthorizedError(normalized, rateLimit);
+    case 403:
+      return new ForbiddenError(normalized, rateLimit);
+    case 404:
+      return new NotFoundError(normalized, rateLimit);
+    case 409:
+      return new ConflictError(normalized, rateLimit);
+    case 429: {
+      const parsedRetry = retryAfter ? Number.parseInt(retryAfter, 10) : Number.NaN;
+      return new RateLimitError(
+        normalized,
+        Number.isFinite(parsedRetry) ? parsedRetry : 60,
+        rateLimit
+      );
+    }
+    default:
+      return new ServiceError(normalized, status, rateLimit);
+  }
+}
+var CircuitBreaker = class {
+  failures = 0;
+  lastFailureTime = 0;
+  state = "CLOSED";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /** Returns the current circuit state. */
+  getState() {
+    return this.state;
+  }
+  /** Returns the current consecutive failure count. */
+  getFailures() {
+    return this.failures;
+  }
+  reset() {
+    this.failures = 0;
+    this.state = "CLOSED";
+    this.config.onClose?.();
+  }
+  /**
+   * Executes an async function through the circuit breaker.
+   * Throws CircuitBreakerOpenError immediately if the circuit is OPEN
+   * and the reset timeout has not elapsed. On success in HALF_OPEN state,
+   * resets the circuit to CLOSED.
+   *
+   * @param fn - The async operation to protect.
+   * @throws {CircuitBreakerOpenError} If the circuit is OPEN.
+   */
+  async execute(fn) {
+    if (this.state === "OPEN") {
+      if (Date.now() - this.lastFailureTime > this.config.resetTimeoutMs) {
+        this.state = "HALF_OPEN";
+        this.config.onHalfOpen?.();
+      } else {
+        throw new CircuitBreakerOpenError(
+          this.config.resetTimeoutMs - (Date.now() - this.lastFailureTime)
+        );
+      }
+    }
+    try {
+      const result = await fn();
+      if (this.state === "HALF_OPEN") {
+        this.reset();
+      }
+      return result;
+    } catch (error) {
+      this.failures++;
+      this.lastFailureTime = Date.now();
+      if (this.failures >= this.config.failureThreshold) {
+        this.state = "OPEN";
+        this.config.onOpen?.();
+      }
+      throw error;
+    }
+  }
+  /** Manually forces the circuit into the OPEN state. */
+  forceOpen() {
+    this.state = "OPEN";
+    this.lastFailureTime = Date.now();
+  }
+  /** Manually resets the circuit to the CLOSED state. */
+  forceClose() {
+    this.reset();
+  }
+};
+var CircuitBreakerOpenError = class extends Error {
+  /** Milliseconds remaining until the circuit transitions to HALF_OPEN. */
+  retryAfterMs;
+  constructor(retryAfterMs) {
+    super(
+      `Circuit breaker is open \u2014 retry after ${Math.ceil(retryAfterMs / 1e3)}s`
+    );
+    this.name = "CircuitBreakerOpenError";
+    this.retryAfterMs = retryAfterMs;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+function computeBaseDelay(attempt, strategy, baseDelay) {
+  const normalizedAttempt = Math.floor(attempt);
+  switch (strategy) {
+    case "linear":
+      return Math.max(0, baseDelay * (normalizedAttempt + 1));
+    case "constant":
+      return baseDelay;
+    default:
+      return baseDelay * EXPONENTIAL_BASE ** normalizedAttempt;
+  }
+}
+function calculateDelay(attempt, strategyOrConfig, baseDelay, withJitter = false) {
+  if (typeof strategyOrConfig === "object") {
+    const strategy = "strategy" in strategyOrConfig ? strategyOrConfig.strategy : strategyOrConfig.backoff;
+    const delayBase = "baseDelay" in strategyOrConfig ? strategyOrConfig.baseDelay : strategyOrConfig.retryDelay;
+    const delay2 = computeBaseDelay(attempt, strategy, delayBase);
+    const shouldJitter = "jitter" in strategyOrConfig ? Boolean(strategyOrConfig.jitter) : true;
+    if (!shouldJitter) return delay2;
+    return delay2 + Math.random() * (JITTER_MAX / 2);
+  }
+  const delay = computeBaseDelay(
+    attempt,
+    strategyOrConfig,
+    Math.max(0, baseDelay ?? 0)
+  );
+  if (!withJitter) return delay;
+  return delay + Math.random() * (JITTER_MAX / 2);
+}
+function snakeToCamel(str) {
+  const prefix = str.match(/^_+/)?.[0] ?? "";
+  const body = str.slice(prefix.length);
+  if (!body) return str;
+  return prefix + body.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function camelToSnake(str) {
+  return str.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+var NEVER_TRANSFORM_KEYS = /* @__PURE__ */ new Set(["$ref", "$schema", "$id"]);
+function isStream(obj) {
+  return typeof obj === "object" && obj !== null && (typeof obj.pipe === "function" || typeof obj.getReader === "function");
+}
+function deepTransformKeys(obj, transform, skipKeys) {
+  if (obj === null || obj === void 0) return obj;
+  if (typeof obj !== "object") return obj;
+  if (obj instanceof Date || typeof Buffer !== "undefined" && obj instanceof Buffer || obj instanceof RegExp || obj instanceof FormData || obj instanceof File || obj instanceof Blob)
+    return obj;
+  if (isStream(obj)) return obj;
+  if (Array.isArray(obj)) {
+    return obj.map(
+      (item) => deepTransformKeys(item, transform, skipKeys)
+    );
+  }
+  const proto = Object.getPrototypeOf(obj);
+  if (proto !== Object.prototype && proto !== null) return obj;
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    const shouldSkip = skipKeys?.has(key) || NEVER_TRANSFORM_KEYS.has(key);
+    const newKey = shouldSkip ? key : transform(key);
+    result[newKey] = deepTransformKeys(
+      obj[key],
+      transform,
+      skipKeys
+    );
+  }
+  return result;
+}
+function deepCamelToSnake(obj, skipKeys) {
+  return deepTransformKeys(obj, camelToSnake, skipKeys);
+}
+function deepSnakeToCamel(obj, skipKeys) {
+  return deepTransformKeys(obj, snakeToCamel, skipKeys);
+}
+var HttpClient = class {
+  constructor(config) {
+    this.config = config;
+    if (config.circuitBreaker) {
+      this.breaker = new CircuitBreaker({
+        failureThreshold: config.circuitBreaker.failureThreshold,
+        resetTimeoutMs: config.circuitBreaker.resetTimeoutMs
+      });
+    }
+  }
+  breaker;
+  /**
+   * Sends a GET request.
+   * @param path - API endpoint path.
+   * @param params - Optional query parameters.
+   * @param schema - Optional Zod schema for response validation.
+   */
+  async get(path, params, schema) {
+    return this.request("GET", path, void 0, params, schema);
+  }
+  /**
+   * Sends a POST request with a JSON body.
+   * @param path - API endpoint path.
+   * @param body - Request payload (converted to snake_case automatically).
+   * @param schema - Optional Zod schema for response validation.
+   */
+  async post(path, body, schema) {
+    return this.request("POST", path, body ?? {}, void 0, schema);
+  }
+  /**
+   * Sends a PUT request with a JSON body.
+   * @param path - API endpoint path.
+   * @param body - Request payload (converted to snake_case automatically).
+   * @param schema - Optional Zod schema for response validation.
+   */
+  async put(path, body, schema) {
+    return this.request("PUT", path, body ?? {}, void 0, schema);
+  }
+  /**
+   * Sends a PATCH request with a JSON body.
+   * @param path - API endpoint path.
+   * @param body - Request payload (converted to snake_case automatically).
+   * @param schema - Optional Zod schema for response validation.
+   */
+  async patch(path, body, schema) {
+    return this.request("PATCH", path, body ?? {}, void 0, schema);
+  }
+  /**
+   * Sends a DELETE request.
+   * @param path - API endpoint path.
+   * @param params - Optional query parameters.
+   * @param schema - Optional Zod schema for response validation.
+   */
+  async delete(path, params, schema) {
+    return this.request("DELETE", path, {}, params, schema);
+  }
+  /**
+   * Sends a raw PUT request with a binary/stream body.
+   * @param path - API endpoint path.
+   * @param body - Binary buffer or readable stream.
+   * @param contentType - MIME type of the body.
+   * @param headers - Additional request headers.
+   * @returns The parsed JSON response with keys converted to camelCase.
+   */
+  async putRaw(path, body, contentType, headers = {}) {
+    const url = this.buildUrl(path);
+    const res = await this.fetchWithTimeout(url, {
+      method: "PUT",
+      headers: this.buildHeaders({ "Content-Type": contentType, ...headers }),
+      body
+    });
+    if (!res.ok) await this.throwError(res);
+    if (res.status === 204) return void 0;
+    const json = await res.json();
+    return typeof json === "object" && json !== null ? deepSnakeToCamel(json) : json;
+  }
+  /**
+   * Opens a GET SSE stream, yielding parsed server-sent events.
+   * @param path - API endpoint path.
+   * @param params - Optional query parameters.
+   * @yields SSE event objects with `type`, `data`, and optional `id` fields.
+   */
+  async *stream(path, params) {
+    const url = this.buildUrl(path, params);
+    const res = await this.fetchWithTimeout(url, {
+      method: "GET",
+      headers: this.buildHeaders({ Accept: "text/event-stream" })
+    });
+    if (!res.ok) await this.throwError(res);
+    yield* this.parseSSEResponse(res);
+  }
+  /**
+   * Sends a POST request that returns an SSE stream.
+   * @param path - API endpoint path.
+   * @param body - Request payload (converted to snake_case automatically).
+   * @yields SSE event objects with `type`, `data`, and optional `id` fields.
+   */
+  async *postStream(path, body) {
+    const url = this.buildUrl(path);
+    const res = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: this.buildHeaders({ Accept: "text/event-stream" }),
+      body: JSON.stringify(body ?? {})
+    });
+    if (!res.ok) await this.throwError(res);
+    yield* this.parseSSEResponse(res);
+  }
+  /**
+   * Sends a POST request and returns the raw Response object.
+   * @param path - API endpoint path.
+   * @param body - Request payload.
+   * @param headers - Additional request headers.
+   * @returns The raw fetch Response (caller must handle parsing).
+   */
+  async postRaw(path, body, headers = {}) {
+    const url = this.buildUrl(path);
+    const res = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: new Headers(this.buildHeaders(headers)),
+      body: JSON.stringify(body ?? {})
+    });
+    if (!res.ok) await this.throwError(res);
+    return res;
+  }
+  /**
+   * Sends a POST request with a FormData body (multipart/form-data).
+   * Automatically removes the Content-Type header so the browser sets the
+   * correct multipart boundary.
+   * @param path - API endpoint path.
+   * @param formData - FormData payload.
+   * @param headers - Additional request headers.
+   * @returns The parsed JSON response with keys converted to camelCase.
+   */
+  async postFormData(path, formData, headers = {}) {
+    const url = this.buildUrl(path);
+    const merged = new Headers(this.buildHeaders(headers));
+    merged.delete("Content-Type");
+    const res = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: merged,
+      body: formData
+    });
+    if (!res.ok) await this.throwError(res);
+    const json = await res.json();
+    return deepSnakeToCamel(json);
+  }
+  /**
+   * Sends a raw GET request and returns the Response object directly.
+   * @param path - API endpoint path.
+   * @param params - Optional query parameters.
+   * @param headers - Additional request headers.
+   * @returns The raw fetch Response (caller must handle parsing).
+   */
+  async getRaw(path, params, headers = {}) {
+    const url = this.buildUrl(path, params);
+    const res = await this.fetchWithTimeout(url, {
+      method: "GET",
+      headers: this.buildHeaders(headers)
+    });
+    if (!res.ok) await this.throwError(res);
+    return res;
+  }
+  async *parseSSEResponse(res) {
+    if (!res.body) return;
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      let event = {
+        type: "message",
+        data: null
+      };
+      for (const rawLine of lines) {
+        const line = rawLine.trimEnd();
+        if (line.startsWith("id:")) {
+          event.id = line.slice(3).trim();
+        } else if (line.startsWith("event:")) {
+          event.type = line.slice(6).trim();
+        } else if (line.startsWith("data:")) {
+          const payload = line.slice(5).trim();
+          try {
+            const parsed = JSON.parse(payload);
+            event.data = typeof parsed === "object" && parsed !== null ? deepSnakeToCamel(parsed) : parsed;
+          } catch {
+            event.data = payload;
+          }
+        } else if (line === "") {
+          if (event.data !== null) yield event;
+          event = { type: "message", data: null };
+        }
+      }
+    }
+  }
+  async request(method, path, body, params, schema, attempt = 0) {
+    const url = this.buildUrl(path, params);
+    const requestId = crypto.randomUUID();
+    const transformedBody = body !== void 0 && body !== null ? deepCamelToSnake(body) : body;
+    const reqInit = {
+      method,
+      headers: this.buildHeaders({ "X-Request-Id": requestId }),
+      ...method !== "GET" ? { body: JSON.stringify(transformedBody ?? {}) } : { body: void 0 }
+    };
+    this.config.logger?.request?.(method, url, reqInit);
+    const executeRequest = async () => {
+      try {
+        return await this.fetchWithTimeout(url, reqInit);
+      } catch (error) {
+        this.config.logger?.error?.(error);
+        throw new NetworkError(error);
+      }
+    };
+    let res;
+    try {
+      res = this.breaker ? await this.breaker.execute(executeRequest) : await executeRequest();
+    } catch (error) {
+      if (error instanceof CircuitBreakerOpenError) {
+        throw new Error(
+          `Circuit breaker is open. Retry after ${Math.ceil(error.retryAfterMs / 1e3)}s.`
+        );
+      }
+      throw error;
+    }
+    this.config.logger?.response?.(res);
+    if (!res.ok) {
+      const shouldRetry = [429, 500, 502, 503, 504].includes(res.status) && attempt < this.config.maxRetries;
+      if (shouldRetry) {
+        const retryAfterValue = res.headers.get("Retry-After");
+        const retryAfterSeconds = retryAfterValue ? Number.parseInt(retryAfterValue, 10) : Number.NaN;
+        const delay = Number.isFinite(retryAfterSeconds) ? retryAfterSeconds * 1e3 : calculateDelay(
+          attempt,
+          "exponential",
+          this.config.retryDelay,
+          true
+        );
+        await sleep(delay);
+        return this.request(method, path, body, params, schema, attempt + 1);
+      }
+      await this.throwError(res);
+    }
+    if (res.status === 204) return void 0;
+    const contentType = (res.headers.get("content-type") || "").toLowerCase();
+    const payload = contentType.includes("application/json") ? await res.json() : await res.text();
+    const transformedPayload = typeof payload === "object" && payload !== null ? deepSnakeToCamel(payload) : payload;
+    if (schema) {
+      try {
+        const parsed = schema.safeParse(transformedPayload);
+        if (!parsed.success) {
+          this.config.logger?.error?.(parsed.error);
+          throw parsed.error;
+        }
+        return parsed.data;
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("_zod")) {
+          return transformedPayload;
+        }
+        throw error;
+      }
+    }
+    return transformedPayload;
+  }
+  parseRateLimit(res) {
+    const limit = res.headers.get("X-RateLimit-Limit");
+    const remaining = res.headers.get("X-RateLimit-Remaining");
+    const reset = res.headers.get("X-RateLimit-Reset");
+    if (limit && remaining && reset) {
+      return {
+        limit: Number.parseInt(limit, 10),
+        remaining: Number.parseInt(remaining, 10),
+        reset: Number.parseInt(reset, 10)
+      };
+    }
+    return void 0;
+  }
+  async throwError(res) {
+    let body;
+    try {
+      body = await res.json();
+    } catch {
+      body = {};
+    }
+    const retryAfter = res.headers.get("Retry-After") ?? void 0;
+    const rateLimit = this.parseRateLimit(res);
+    throw parseFrontalError(body, res.status, retryAfter, rateLimit);
+  }
+  buildUrl(path, params) {
+    const base = this.config.baseUrl.replace(/\/$/, "");
+    let normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    if (base.endsWith("/v1") && normalizedPath.startsWith("/v1/")) {
+      if (this.config.debug) {
+        console.warn(
+          `[SDK] Double /v1/ prefix detected and normalized. The base URL already includes "/v1" but the route "${normalizedPath}" also starts with "/v1/". Write routes without a leading "/v1".`
+        );
+      }
+      normalizedPath = normalizedPath.slice("/v1".length);
+    }
+    const url = `${base}${normalizedPath}`;
+    const transformedParams = params ? deepCamelToSnake(params) : params;
+    if (!transformedParams || Object.keys(transformedParams).length === 0) {
+      return url;
+    }
+    const query = Object.entries(transformedParams).filter(([, value]) => value !== void 0 && value !== null).map(
+      ([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`
+    ).join("&");
+    return query ? `${url}?${query}` : url;
+  }
+  buildHeaders(extra = {}) {
+    return {
+      // The opaque API key (`frt_…`) is the sole public credential. The platform
+      // edge validates it and exchanges it for a short-lived JWT before reaching
+      // any service — the SDK never sees or sends a JWT.
+      Authorization: `Bearer ${this.config.apiKey}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "User-Agent": "@frontal-labs/core",
+      "X-Frontal-Core": `typescript@${SDK_VERSION}`,
+      "X-Frontal-Environment": this.config.environment,
+      ...this.config.headers,
+      ...extra
+    };
+  }
+  async fetchWithTimeout(url, init) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      return await (this.config.fetch ?? fetch)(url, {
+        ...init,
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+var sleep = async (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+var apiKeySchema = import_zod2.z.string().min(9, "FRONTAL_API_KEY must be at least 9 characters").max(128, "FRONTAL_API_KEY must be at most 128 characters").refine(
+  (val) => /^frt_[A-Za-z0-9_]+$/.test(val) || /^fr_typed[A-Za-z0-9_]+$/.test(val),
+  "FRONTAL_API_KEY must start with frt_"
+);
+var debugSchema = import_zod2.z.union([
+  import_zod2.z.literal("true"),
+  import_zod2.z.literal("false"),
+  import_zod2.z.literal("1"),
+  import_zod2.z.literal("0")
+]).optional().default("false").transform((val) => val === "true" || val === "1");
+var env = createEnv({
+  server: {
+    FRONTAL_ENV: import_zod2.z.enum(["development", "test", "production"]).default("development"),
+    FRONTAL_API_KEY: apiKeySchema.optional(),
+    FRONTAL_API_URL: import_zod2.z.url("FRONTAL_API_URL must be a valid URL").optional(),
+    FRONTAL_DEBUG: debugSchema
+  },
+  runtimeEnv: {
+    FRONTAL_ENV: process.env.FRONTAL_ENV,
+    FRONTAL_API_KEY: process.env.FRONTAL_API_KEY,
+    FRONTAL_API_URL: process.env.FRONTAL_API_URL,
+    FRONTAL_DEBUG: process.env.FRONTAL_DEBUG
+  },
+  emptyStringAsUndefined: true
+});
+var unwrapClientError = (error) => {
+  if (error instanceof NetworkError) {
+    if (error.cause instanceof Error) {
+      throw error.cause;
+    }
+    throw new Error(String(error.cause));
+  }
+  throw error;
+};
+var FrontalClient = class {
+  config;
+  _http;
+  /**
+   * @param config - Validated client configuration output from clientConfigSchema.
+   */
+  constructor(config) {
+    Object.defineProperty(this, "config", {
+      value: config,
+      writable: false,
+      enumerable: true
+    });
+    const http = new HttpClient(config);
+    Object.defineProperty(this, "_http", {
+      value: http,
+      writable: false,
+      enumerable: true
+    });
+    Object.defineProperty(this, "httpClient", {
+      get() {
+        return http;
+      },
+      enumerable: true
+    });
+  }
+  /** Public accessor for the underlying HttpClient. */
+  get httpClient() {
+    return this._http;
+  }
+  /**
+   * Sends a GET request and optionally validates the response against a schema.
+   * @param path - API endpoint path.
+   * @param schema - Optional Zod schema for response validation.
+   */
+  async get(path, schema) {
+    try {
+      return await this._http.get(path, void 0, schema);
+    } catch (error) {
+      throw unwrapClientError(error);
+    }
+  }
+  /**
+   * Sends a POST request with an optional JSON body and response schema.
+   * @param path - API endpoint path.
+   * @param body - Request payload (converted to snake_case automatically).
+   * @param schema - Optional Zod schema for response validation.
+   */
+  async post(path, body, schema) {
+    try {
+      return await this._http.post(path, body, schema);
+    } catch (error) {
+      throw unwrapClientError(error);
+    }
+  }
+  /**
+   * Sends a PUT request with an optional JSON body and response schema.
+   * @param path - API endpoint path.
+   * @param body - Request payload (converted to snake_case automatically).
+   * @param schema - Optional Zod schema for response validation.
+   */
+  async put(path, body, schema) {
+    try {
+      return await this._http.put(path, body, schema);
+    } catch (error) {
+      throw unwrapClientError(error);
+    }
+  }
+  /**
+   * Sends a PATCH request with an optional JSON body and response schema.
+   * @param path - API endpoint path.
+   * @param body - Request payload (converted to snake_case automatically).
+   * @param schema - Optional Zod schema for response validation.
+   */
+  async patch(path, body, schema) {
+    try {
+      return await this._http.patch(path, body, schema);
+    } catch (error) {
+      throw unwrapClientError(error);
+    }
+  }
+  /**
+   * Sends a DELETE request with optional query parameters and response schema.
+   * @param path - API endpoint path.
+   * @param params - Query parameters (converted to snake_case automatically).
+   * @param schema - Optional Zod schema for response validation.
+   */
+  async delete(path, params, schema) {
+    try {
+      return await this._http.delete(path, params, schema);
+    } catch (error) {
+      throw unwrapClientError(error);
+    }
+  }
+  /**
+   * Opens a GET SSE stream and yields parsed server-sent events.
+   * @param path - API endpoint path.
+   * @param params - Optional query parameters.
+   * @yields Objects with `type`, `data`, and optional `id` fields from SSE events.
+   */
+  async *stream(path, params) {
+    try {
+      yield* this._http.stream(path, params);
+    } catch (error) {
+      throw unwrapClientError(error);
+    }
+  }
+  /**
+   * Sends a raw PUT request with a binary/stream body and custom content type.
+   * @param path - API endpoint path.
+   * @param body - Binary buffer or readable stream to upload.
+   * @param contentType - MIME type of the body.
+   * @param headers - Additional request headers.
+   * @returns The parsed JSON response (keys converted to camelCase).
+   */
+  async putRaw(path, body, contentType, headers = {}) {
+    try {
+      return await this._http.putRaw(path, body, contentType, headers);
+    } catch (error) {
+      throw unwrapClientError(error);
+    }
+  }
+};
+var getDefaultClient = () => {
+  if (!env.FRONTAL_API_KEY) {
+    throw new Error(
+      "FRONTAL_API_KEY environment variable is required. Set it in your environment or pass apiKey explicitly to new FrontalClient()."
+    );
+  }
+  return new FrontalClient({
+    apiKey: env.FRONTAL_API_KEY,
+    baseUrl: env.FRONTAL_API_URL ?? DEFAULT_BASE_URL,
+    timeout: 3e4,
+    maxRetries: 3,
+    retryDelay: 1e3,
+    headers: {},
+    environment: env.FRONTAL_ENV,
+    debug: env.FRONTAL_DEBUG
+  });
+};
+var API_KEY_PATTERN = new RegExp(`^${API_KEY_PREFIX}[A-Za-z0-9_-]+$`);
+var loggerFnSchema = import_zod3.z.custom(
+  (value) => typeof value === "function",
+  "Expected function"
+);
+var headersSchema = import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).superRefine((headers, ctx) => {
+  for (const key of Object.keys(headers)) {
+    if (key.trim().length === 0) {
+      ctx.addIssue({
+        code: import_zod3.z.ZodIssueCode.custom,
+        message: "Header names must be non-empty",
+        path: []
+      });
+      return;
+    }
+  }
+}).default({});
+var clientConfigSchema = import_zod3.z.object({
+  apiKey: import_zod3.z.string().min(9, "apiKey is required").regex(API_KEY_PATTERN, `apiKey must start with "${API_KEY_PREFIX}"`),
+  baseUrl: import_zod3.z.string().url().refine(
+    (value) => value.startsWith("https://") || value.startsWith("http://"),
+    {
+      message: "baseUrl must use http or https"
+    }
+  ).default(DEFAULT_BASE_URL),
+  timeout: import_zod3.z.number().int().positive().default(3e4),
+  maxRetries: import_zod3.z.number().int().min(0).max(10).default(3),
+  retryDelay: import_zod3.z.number().int().positive().default(1e3),
+  headers: headersSchema,
+  environment: import_zod3.z.string().default("production"),
+  debug: import_zod3.z.boolean().default(false),
+  fetch: import_zod3.z.custom((value) => typeof value === "function").optional(),
+  logger: import_zod3.z.object({
+    request: loggerFnSchema.optional(),
+    response: loggerFnSchema.optional(),
+    error: loggerFnSchema.optional()
+  }).optional(),
+  circuitBreaker: import_zod3.z.object({
+    failureThreshold: import_zod3.z.number().int().positive().default(5),
+    resetTimeoutMs: import_zod3.z.number().int().positive().default(3e4)
+  }).optional()
+}).strict();
+function asPagePayload(raw) {
+  return raw;
+}
+var paginationSchema = import_zod4.z.object({
+  cursor: import_zod4.z.string().min(1),
+  hasMore: import_zod4.z.boolean(),
+  total: import_zod4.z.number().int().min(0).optional(),
+  limit: import_zod4.z.number().int().positive().optional(),
+  offset: import_zod4.z.number().int().min(0).optional()
+}).strict();
+function buildPageResult(data, pagination, fetchNext, meta) {
+  let nextPagePromise = null;
+  const page = {
+    data,
+    meta,
+    pagination,
+    _fetchNextPage: fetchNext,
+    async nextPage() {
+      if (!this.pagination.hasMore) return null;
+      if (!nextPagePromise) {
+        nextPagePromise = (async () => {
+          let result = await this._fetchNextPage();
+          if (!result && this._fallbackFetchNextPage) {
+            result = await this._fallbackFetchNextPage();
+          }
+          if (result) {
+            const mutableResult = result;
+            mutableResult._fallbackFetchNextPage = this._fallbackFetchNextPage ?? this._fetchNextPage;
+          }
+          return result;
+        })().finally(() => {
+          nextPagePromise = null;
+        });
+      }
+      return nextPagePromise;
+    },
+    async all() {
+      const items = [...this.data];
+      let current = this;
+      while (current) {
+        if (!current.pagination.hasMore) break;
+        current = await current.nextPage();
+        if (!current) break;
+        items.push(...current.data);
+      }
+      return items;
+    },
+    [Symbol.asyncIterator]() {
+      let current = this;
+      let index = 0;
+      return {
+        async next() {
+          while (current) {
+            if (index < current.data.length) {
+              return { done: false, value: current.data[index++] };
+            }
+            if (!current.pagination.hasMore) {
+              current = null;
+              break;
+            }
+            current = await current.nextPage();
+            index = 0;
+          }
+          return { done: true, value: void 0 };
+        }
+      };
+    }
+  };
+  return page;
+}
+function createPageResult(dataOrRaw, paginationOrFetchNext, fetchNextOrMeta, meta) {
+  if (Array.isArray(dataOrRaw)) {
+    const data = dataOrRaw;
+    const pagination = paginationOrFetchNext;
+    const fetchNextPage2 = fetchNextOrMeta;
+    const fetchNext2 = async () => {
+      if (!fetchNextPage2) return null;
+      return fetchNextPage2.length > 0 ? fetchNextPage2(
+        pagination.cursor
+      ) : fetchNextPage2();
+    };
+    return buildPageResult(data, pagination, fetchNext2, meta);
+  }
+  const raw = dataOrRaw;
+  const fetchNextPage = paginationOrFetchNext;
+  const fetchNext = async () => {
+    if (!fetchNextPage) return null;
+    return fetchNextPage.length > 0 ? fetchNextPage(
+      raw.pagination.cursor
+    ) : fetchNextPage();
+  };
+  return buildPageResult(
+    Array.isArray(raw.data) ? raw.data : [],
+    raw.pagination,
+    fetchNext,
+    raw.meta
+  );
+}
 
 // src/constants.ts
 var DEFAULT_ONTOLOGY_BASE_URL = "https://api.frontal.dev/v1";
@@ -51,7 +1169,6 @@ var DEFAULT_MAX_RETRIES = 3;
 var DEFAULT_RETRY_DELAY = 1e3;
 
 // src/sdk.ts
-var import_core = require("@frontal-labs/core");
 var OntologySdk = class {
   engine;
   objects;
@@ -112,8 +1229,8 @@ var SubdomainBase = class {
    */
   async runs(opts = {}) {
     const raw = await this.http.get(`${this.base}/runs`, opts);
-    return (0, import_core.createPageResult)(
-      (0, import_core.asPagePayload)(raw),
+    return createPageResult(
+      asPagePayload(raw),
       (c) => this.runs({ ...opts, cursor: c })
     );
   }
@@ -202,8 +1319,8 @@ var ObjectsNamespace = class extends SubdomainBase {
    */
   async listObjectTypes(opts = {}) {
     const raw = await this.http.get("/ontology/objects/object-types", opts);
-    return (0, import_core.createPageResult)(
-      (0, import_core.asPagePayload)(raw),
+    return createPageResult(
+      asPagePayload(raw),
       (c) => this.listObjectTypes({ ...opts, cursor: c })
     );
   }
@@ -235,8 +1352,8 @@ var ObjectsNamespace = class extends SubdomainBase {
    */
   async listObjects(opts = {}) {
     const raw = await this.http.get("/ontology/objects/objects", opts);
-    return (0, import_core.createPageResult)(
-      (0, import_core.asPagePayload)(raw),
+    return createPageResult(
+      asPagePayload(raw),
       (c) => this.listObjects({ ...opts, cursor: c })
     );
   }
@@ -276,8 +1393,8 @@ var RelationshipsNamespace = class extends SubdomainBase {
       "/ontology/relationships/relationship-types",
       opts
     );
-    return (0, import_core.createPageResult)(
-      (0, import_core.asPagePayload)(raw),
+    return createPageResult(
+      asPagePayload(raw),
       (c) => this.listTypes({ ...opts, cursor: c })
     );
   }
@@ -297,8 +1414,8 @@ var RelationshipsNamespace = class extends SubdomainBase {
       "/ontology/relationships/relationships",
       opts
     );
-    return (0, import_core.createPageResult)(
-      (0, import_core.asPagePayload)(raw),
+    return createPageResult(
+      asPagePayload(raw),
       (c) => this.list({ ...opts, cursor: c })
     );
   }
@@ -335,8 +1452,8 @@ var SchemasNamespace = class extends SubdomainBase {
    */
   async list(opts = {}) {
     const raw = await this.http.get("/ontology/schemas/schemas", opts);
-    return (0, import_core.createPageResult)(
-      (0, import_core.asPagePayload)(raw),
+    return createPageResult(
+      asPagePayload(raw),
       (c) => this.list({ ...opts, cursor: c })
     );
   }
@@ -414,8 +1531,8 @@ var VersionsNamespace = class extends SubdomainBase {
    */
   async listReleaseBundles(opts = {}) {
     const raw = await this.http.get("/ontology/versions/release-bundles", opts);
-    return (0, import_core.createPageResult)(
-      (0, import_core.asPagePayload)(raw),
+    return createPageResult(
+      asPagePayload(raw),
       (c) => this.listReleaseBundles({ ...opts, cursor: c })
     );
   }
@@ -451,8 +1568,8 @@ var ValidationNamespace = class extends SubdomainBase {
    */
   async listRules(opts = {}) {
     const raw = await this.http.get("/ontology/validation/rules", opts);
-    return (0, import_core.createPageResult)(
-      (0, import_core.asPagePayload)(raw),
+    return createPageResult(
+      asPagePayload(raw),
       (c) => this.listRules({ ...opts, cursor: c })
     );
   }
@@ -535,8 +1652,8 @@ var ReasoningNamespace = class extends SubdomainBase {
    */
   async listRules(opts = {}) {
     const raw = await this.http.get("/ontology/reasoning/rules", opts);
-    return (0, import_core.createPageResult)(
-      (0, import_core.asPagePayload)(raw),
+    return createPageResult(
+      asPagePayload(raw),
       (c) => this.listRules({ ...opts, cursor: c })
     );
   }
@@ -573,8 +1690,8 @@ var RolloutsNamespace = class extends SubdomainBase {
    */
   async list(opts = {}) {
     const raw = await this.http.get("/ontology/rollouts/rollouts", opts);
-    return (0, import_core.createPageResult)(
-      (0, import_core.asPagePayload)(raw),
+    return createPageResult(
+      asPagePayload(raw),
       (c) => this.list({ ...opts, cursor: c })
     );
   }
@@ -657,8 +1774,8 @@ var RollupsNamespace = class extends SubdomainBase {
    */
   async list(opts = {}) {
     const raw = await this.http.get("/ontology/rollups/rollups", opts);
-    return (0, import_core.createPageResult)(
-      (0, import_core.asPagePayload)(raw),
+    return createPageResult(
+      asPagePayload(raw),
       (c) => this.list({ ...opts, cursor: c })
     );
   }
@@ -786,8 +1903,8 @@ var EventsNamespace = class extends SubdomainBase {
    */
   async list(opts = {}) {
     const raw = await this.http.get("/ontology/events/events", opts);
-    return (0, import_core.createPageResult)(
-      (0, import_core.asPagePayload)(raw),
+    return createPageResult(
+      asPagePayload(raw),
       (c) => this.list({ ...opts, cursor: c })
     );
   }
@@ -836,20 +1953,19 @@ var EventsNamespace = class extends SubdomainBase {
 };
 
 // src/client.ts
-var import_core3 = require("@frontal-labs/core");
 function createOntologyClient(clientOrConfig) {
-  if (clientOrConfig instanceof import_core2.FrontalClient) {
+  if (clientOrConfig instanceof FrontalClient) {
     return new OntologySdk(clientOrConfig.httpClient);
   }
-  const http = new import_core2.HttpClient({
+  const http = new HttpClient({
     apiKey: clientOrConfig.apiKey,
-    baseUrl: clientOrConfig.baseUrl ?? import_core3.env.FRONTAL_API_URL ?? DEFAULT_ONTOLOGY_BASE_URL,
+    baseUrl: clientOrConfig.baseUrl ?? env.FRONTAL_API_URL ?? DEFAULT_ONTOLOGY_BASE_URL,
     timeout: clientOrConfig.timeout ?? DEFAULT_TIMEOUT,
     maxRetries: clientOrConfig.maxRetries ?? DEFAULT_MAX_RETRIES,
     retryDelay: DEFAULT_RETRY_DELAY,
     headers: {},
-    environment: import_core3.env.FRONTAL_ENV,
-    debug: import_core3.env.FRONTAL_DEBUG ?? false
+    environment: env.FRONTAL_ENV,
+    debug: env.FRONTAL_DEBUG ?? false
   });
   return new OntologySdk(http);
 }
@@ -857,7 +1973,7 @@ var _ontologyCache;
 var ontology = new Proxy({}, {
   get(_t, prop) {
     if (!_ontologyCache) {
-      _ontologyCache = createOntologyClient((0, import_core2.getDefaultClient)());
+      _ontologyCache = createOntologyClient(getDefaultClient());
     }
     const inst = _ontologyCache;
     const val = inst[prop];
@@ -866,9 +1982,8 @@ var ontology = new Proxy({}, {
 });
 
 // src/schemas.ts
-var import_core4 = require("@frontal-labs/core");
-var import_zod = require("zod");
-var FieldTypeSchema = import_zod.z.enum([
+var import_zod5 = require("zod");
+var FieldTypeSchema = import_zod5.z.enum([
   "string",
   "integer",
   "float",
@@ -882,126 +1997,126 @@ var FieldTypeSchema = import_zod.z.enum([
   "vector",
   "text"
 ]);
-var RelationshipTypeSchema = import_zod.z.enum([
+var RelationshipTypeSchema = import_zod5.z.enum([
   "hasOne",
   "hasMany",
   "belongsTo",
   "manyToMany"
 ]);
-var FieldDefinitionSchema = import_zod.z.object({
+var FieldDefinitionSchema = import_zod5.z.object({
   type: FieldTypeSchema,
-  required: import_zod.z.boolean().default(false),
-  primary: import_zod.z.boolean().default(false),
-  unique: import_zod.z.boolean().default(false),
-  default: import_zod.z.unknown().optional(),
-  substrate: import_zod.z.string().optional(),
-  computed: import_zod.z.boolean().optional(),
-  derivedBy: import_zod.z.string().optional(),
-  cache: import_zod.z.object({
-    ttl: import_zod.z.string()
+  required: import_zod5.z.boolean().default(false),
+  primary: import_zod5.z.boolean().default(false),
+  unique: import_zod5.z.boolean().default(false),
+  default: import_zod5.z.unknown().optional(),
+  substrate: import_zod5.z.string().optional(),
+  computed: import_zod5.z.boolean().optional(),
+  derivedBy: import_zod5.z.string().optional(),
+  cache: import_zod5.z.object({
+    ttl: import_zod5.z.string()
   }).optional(),
-  auto: import_zod.z.boolean().optional(),
-  enum: import_zod.z.array(import_zod.z.string()).optional(),
-  dimensions: import_zod.z.number().int().optional(),
-  items: import_zod.z.string().optional(),
-  description: import_zod.z.string().optional()
+  auto: import_zod5.z.boolean().optional(),
+  enum: import_zod5.z.array(import_zod5.z.string()).optional(),
+  dimensions: import_zod5.z.number().int().optional(),
+  items: import_zod5.z.string().optional(),
+  description: import_zod5.z.string().optional()
 }).loose();
-var RelationshipDefinitionSchema = import_zod.z.object({
-  name: import_zod.z.string().optional(),
+var RelationshipDefinitionSchema = import_zod5.z.object({
+  name: import_zod5.z.string().optional(),
   type: RelationshipTypeSchema,
-  targetEntity: import_zod.z.string(),
-  foreignKey: import_zod.z.string().optional(),
-  substrate: import_zod.z.string().optional(),
-  cascade: import_zod.z.object({
-    delete: import_zod.z.enum(["hard", "soft", "restrict", "nullify"]),
-    update: import_zod.z.enum(["cascade", "restrict"])
+  targetEntity: import_zod5.z.string(),
+  foreignKey: import_zod5.z.string().optional(),
+  substrate: import_zod5.z.string().optional(),
+  cascade: import_zod5.z.object({
+    delete: import_zod5.z.enum(["hard", "soft", "restrict", "nullify"]),
+    update: import_zod5.z.enum(["cascade", "restrict"])
   }).optional(),
-  computed: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
-  description: import_zod.z.string().optional()
+  computed: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()).optional(),
+  description: import_zod5.z.string().optional()
 }).loose();
-var SubstrateRoutingSchema = import_zod.z.object({
-  operational: import_zod.z.string().optional(),
-  analytical: import_zod.z.string().optional(),
-  semantic: import_zod.z.string().optional(),
-  cache: import_zod.z.string().optional()
+var SubstrateRoutingSchema = import_zod5.z.object({
+  operational: import_zod5.z.string().optional(),
+  analytical: import_zod5.z.string().optional(),
+  semantic: import_zod5.z.string().optional(),
+  cache: import_zod5.z.string().optional()
 }).loose();
-var SemanticMetadataSchema = import_zod.z.object({
-  description: import_zod.z.string().optional(),
-  lifecycle: import_zod.z.array(import_zod.z.string()).optional(),
-  criticalFields: import_zod.z.array(import_zod.z.string()).optional(),
-  significantEvents: import_zod.z.array(import_zod.z.string()).optional(),
-  tags: import_zod.z.array(import_zod.z.string()).optional()
+var SemanticMetadataSchema = import_zod5.z.object({
+  description: import_zod5.z.string().optional(),
+  lifecycle: import_zod5.z.array(import_zod5.z.string()).optional(),
+  criticalFields: import_zod5.z.array(import_zod5.z.string()).optional(),
+  significantEvents: import_zod5.z.array(import_zod5.z.string()).optional(),
+  tags: import_zod5.z.array(import_zod5.z.string()).optional()
 }).loose();
-var IndexDefinitionSchema = import_zod.z.object({
-  name: import_zod.z.string().optional(),
-  fields: import_zod.z.array(import_zod.z.string()).min(1),
-  substrate: import_zod.z.string().optional(),
-  unique: import_zod.z.boolean().default(false),
-  type: import_zod.z.enum(["btree", "hash", "gin", "gist", "brin"]).default("btree")
+var IndexDefinitionSchema = import_zod5.z.object({
+  name: import_zod5.z.string().optional(),
+  fields: import_zod5.z.array(import_zod5.z.string()).min(1),
+  substrate: import_zod5.z.string().optional(),
+  unique: import_zod5.z.boolean().default(false),
+  type: import_zod5.z.enum(["btree", "hash", "gin", "gist", "brin"]).default("btree")
 }).loose();
-var ModelDefinitionSchema = import_zod.z.object({
-  name: import_zod.z.string(),
-  displayName: import_zod.z.string().optional(),
-  description: import_zod.z.string().optional(),
-  extends: import_zod.z.string().optional(),
-  mixins: import_zod.z.array(import_zod.z.string()).optional(),
-  fields: import_zod.z.record(import_zod.z.string(), FieldDefinitionSchema),
-  relationships: import_zod.z.record(import_zod.z.string(), RelationshipDefinitionSchema).optional(),
+var ModelDefinitionSchema = import_zod5.z.object({
+  name: import_zod5.z.string(),
+  displayName: import_zod5.z.string().optional(),
+  description: import_zod5.z.string().optional(),
+  extends: import_zod5.z.string().optional(),
+  mixins: import_zod5.z.array(import_zod5.z.string()).optional(),
+  fields: import_zod5.z.record(import_zod5.z.string(), FieldDefinitionSchema),
+  relationships: import_zod5.z.record(import_zod5.z.string(), RelationshipDefinitionSchema).optional(),
   substrates: SubstrateRoutingSchema.optional(),
   semantics: SemanticMetadataSchema.optional(),
-  indexes: import_zod.z.array(IndexDefinitionSchema).optional(),
-  status: import_zod.z.enum(["draft", "active", "deprecated"]).default("draft")
+  indexes: import_zod5.z.array(IndexDefinitionSchema).optional(),
+  status: import_zod5.z.enum(["draft", "active", "deprecated"]).default("draft")
 }).strict();
 var ModelSchema = ModelDefinitionSchema.extend({
-  id: import_zod.z.string(),
-  version: import_zod.z.number().int(),
-  createdAt: import_core4.timestampSchema,
-  updatedAt: import_core4.timestampSchema,
-  entityCount: import_zod.z.number().int().optional()
+  id: import_zod5.z.string(),
+  version: import_zod5.z.number().int(),
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema,
+  entityCount: import_zod5.z.number().int().optional()
 }).loose();
-var MigrationPlanSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  modelId: import_zod.z.string(),
-  fromVersion: import_zod.z.number().int(),
-  toVersion: import_zod.z.number().int(),
-  changes: import_zod.z.array(
-    import_zod.z.object({
-      type: import_zod.z.enum([
+var MigrationPlanSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  modelId: import_zod5.z.string(),
+  fromVersion: import_zod5.z.number().int(),
+  toVersion: import_zod5.z.number().int(),
+  changes: import_zod5.z.array(
+    import_zod5.z.object({
+      type: import_zod5.z.enum([
         "add-field",
         "remove-field",
         "modify-field",
         "add-relationship",
         "remove-relationship"
       ]),
-      description: import_zod.z.string(),
-      impact: import_zod.z.enum(["breaking", "non-breaking", "data-loss"]),
-      sql: import_zod.z.string().optional()
+      description: import_zod5.z.string(),
+      impact: import_zod5.z.enum(["breaking", "non-breaking", "data-loss"]),
+      sql: import_zod5.z.string().optional()
     })
   ),
-  riskLevel: import_zod.z.enum(["low", "medium", "high", "critical"]),
-  estimatedDowntime: import_zod.z.string().optional(),
-  rolloutStrategy: import_zod.z.enum([
+  riskLevel: import_zod5.z.enum(["low", "medium", "high", "critical"]),
+  estimatedDowntime: import_zod5.z.string().optional(),
+  rolloutStrategy: import_zod5.z.enum([
     "zero-downtime",
     "maintenance-window",
     "immediate"
   ]),
-  createdAt: import_core4.timestampSchema
+  createdAt: timestampSchema
 }).loose();
-var RuleDefinitionSchema = import_zod.z.object({
-  name: import_zod.z.string(),
-  description: import_zod.z.string().optional(),
-  entityTypes: import_zod.z.array(import_zod.z.string()).min(1),
-  condition: import_zod.z.string(),
-  action: import_zod.z.enum(["validate", "transform", "notify"]),
-  severity: import_zod.z.enum(["error", "warning", "info"]),
-  enabled: import_zod.z.boolean().default(true)
+var RuleDefinitionSchema = import_zod5.z.object({
+  name: import_zod5.z.string(),
+  description: import_zod5.z.string().optional(),
+  entityTypes: import_zod5.z.array(import_zod5.z.string()).min(1),
+  condition: import_zod5.z.string(),
+  action: import_zod5.z.enum(["validate", "transform", "notify"]),
+  severity: import_zod5.z.enum(["error", "warning", "info"]),
+  enabled: import_zod5.z.boolean().default(true)
 }).strict();
-var MixinDefinitionSchema = import_zod.z.object({
-  name: import_zod.z.string(),
-  description: import_zod.z.string().optional(),
-  fields: import_zod.z.record(import_zod.z.string(), FieldDefinitionSchema),
-  relationships: import_zod.z.record(import_zod.z.string(), RelationshipDefinitionSchema).optional(),
-  appliesTo: import_zod.z.array(import_zod.z.string()).optional()
+var MixinDefinitionSchema = import_zod5.z.object({
+  name: import_zod5.z.string(),
+  description: import_zod5.z.string().optional(),
+  fields: import_zod5.z.record(import_zod5.z.string(), FieldDefinitionSchema),
+  relationships: import_zod5.z.record(import_zod5.z.string(), RelationshipDefinitionSchema).optional(),
+  appliesTo: import_zod5.z.array(import_zod5.z.string()).optional()
 }).strict();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {