@frontal-labs/ontology 1.0.1 → 1.0.3

package/dist/index.js

@@ -40,1126 +40,8 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// ../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/client.ts
+var import_core2 = require("@frontal-labs/core");
 
 // src/constants.ts
 var DEFAULT_ONTOLOGY_BASE_URL = "https://api.frontal.dev/v1";
@@ -1169,6 +51,7 @@ 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;
@@ -1229,8 +112,8 @@ var SubdomainBase = class {
    */
   async runs(opts = {}) {
     const raw = await this.http.get(`${this.base}/runs`, opts);
-    return createPageResult(
-      asPagePayload(raw),
+    return (0, import_core.createPageResult)(
+      (0, import_core.asPagePayload)(raw),
       (c) => this.runs({ ...opts, cursor: c })
     );
   }
@@ -1319,8 +202,8 @@ var ObjectsNamespace = class extends SubdomainBase {
    */
   async listObjectTypes(opts = {}) {
     const raw = await this.http.get("/ontology/objects/object-types", opts);
-    return createPageResult(
-      asPagePayload(raw),
+    return (0, import_core.createPageResult)(
+      (0, import_core.asPagePayload)(raw),
       (c) => this.listObjectTypes({ ...opts, cursor: c })
     );
   }
@@ -1352,8 +235,8 @@ var ObjectsNamespace = class extends SubdomainBase {
    */
   async listObjects(opts = {}) {
     const raw = await this.http.get("/ontology/objects/objects", opts);
-    return createPageResult(
-      asPagePayload(raw),
+    return (0, import_core.createPageResult)(
+      (0, import_core.asPagePayload)(raw),
       (c) => this.listObjects({ ...opts, cursor: c })
     );
   }
@@ -1393,8 +276,8 @@ var RelationshipsNamespace = class extends SubdomainBase {
       "/ontology/relationships/relationship-types",
       opts
     );
-    return createPageResult(
-      asPagePayload(raw),
+    return (0, import_core.createPageResult)(
+      (0, import_core.asPagePayload)(raw),
       (c) => this.listTypes({ ...opts, cursor: c })
     );
   }
@@ -1414,8 +297,8 @@ var RelationshipsNamespace = class extends SubdomainBase {
       "/ontology/relationships/relationships",
       opts
     );
-    return createPageResult(
-      asPagePayload(raw),
+    return (0, import_core.createPageResult)(
+      (0, import_core.asPagePayload)(raw),
       (c) => this.list({ ...opts, cursor: c })
     );
   }
@@ -1452,8 +335,8 @@ var SchemasNamespace = class extends SubdomainBase {
    */
   async list(opts = {}) {
     const raw = await this.http.get("/ontology/schemas/schemas", opts);
-    return createPageResult(
-      asPagePayload(raw),
+    return (0, import_core.createPageResult)(
+      (0, import_core.asPagePayload)(raw),
       (c) => this.list({ ...opts, cursor: c })
     );
   }
@@ -1531,8 +414,8 @@ var VersionsNamespace = class extends SubdomainBase {
    */
   async listReleaseBundles(opts = {}) {
     const raw = await this.http.get("/ontology/versions/release-bundles", opts);
-    return createPageResult(
-      asPagePayload(raw),
+    return (0, import_core.createPageResult)(
+      (0, import_core.asPagePayload)(raw),
       (c) => this.listReleaseBundles({ ...opts, cursor: c })
     );
   }
@@ -1568,8 +451,8 @@ var ValidationNamespace = class extends SubdomainBase {
    */
   async listRules(opts = {}) {
     const raw = await this.http.get("/ontology/validation/rules", opts);
-    return createPageResult(
-      asPagePayload(raw),
+    return (0, import_core.createPageResult)(
+      (0, import_core.asPagePayload)(raw),
       (c) => this.listRules({ ...opts, cursor: c })
     );
   }
@@ -1652,8 +535,8 @@ var ReasoningNamespace = class extends SubdomainBase {
    */
   async listRules(opts = {}) {
     const raw = await this.http.get("/ontology/reasoning/rules", opts);
-    return createPageResult(
-      asPagePayload(raw),
+    return (0, import_core.createPageResult)(
+      (0, import_core.asPagePayload)(raw),
       (c) => this.listRules({ ...opts, cursor: c })
     );
   }
@@ -1690,8 +573,8 @@ var RolloutsNamespace = class extends SubdomainBase {
    */
   async list(opts = {}) {
     const raw = await this.http.get("/ontology/rollouts/rollouts", opts);
-    return createPageResult(
-      asPagePayload(raw),
+    return (0, import_core.createPageResult)(
+      (0, import_core.asPagePayload)(raw),
       (c) => this.list({ ...opts, cursor: c })
     );
   }
@@ -1774,8 +657,8 @@ var RollupsNamespace = class extends SubdomainBase {
    */
   async list(opts = {}) {
     const raw = await this.http.get("/ontology/rollups/rollups", opts);
-    return createPageResult(
-      asPagePayload(raw),
+    return (0, import_core.createPageResult)(
+      (0, import_core.asPagePayload)(raw),
       (c) => this.list({ ...opts, cursor: c })
     );
   }
@@ -1903,8 +786,8 @@ var EventsNamespace = class extends SubdomainBase {
    */
   async list(opts = {}) {
     const raw = await this.http.get("/ontology/events/events", opts);
-    return createPageResult(
-      asPagePayload(raw),
+    return (0, import_core.createPageResult)(
+      (0, import_core.asPagePayload)(raw),
       (c) => this.list({ ...opts, cursor: c })
     );
   }
@@ -1953,19 +836,20 @@ var EventsNamespace = class extends SubdomainBase {
 };
 
 // src/client.ts
+var import_core3 = require("@frontal-labs/core");
 function createOntologyClient(clientOrConfig) {
-  if (clientOrConfig instanceof FrontalClient) {
+  if (clientOrConfig instanceof import_core2.FrontalClient) {
     return new OntologySdk(clientOrConfig.httpClient);
   }
-  const http = new HttpClient({
+  const http = new import_core2.HttpClient({
     apiKey: clientOrConfig.apiKey,
-    baseUrl: clientOrConfig.baseUrl ?? env.FRONTAL_API_URL ?? DEFAULT_ONTOLOGY_BASE_URL,
+    baseUrl: clientOrConfig.baseUrl ?? import_core3.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: env.FRONTAL_ENV,
-    debug: env.FRONTAL_DEBUG ?? false
+    environment: import_core3.env.FRONTAL_ENV,
+    debug: import_core3.env.FRONTAL_DEBUG ?? false
   });
   return new OntologySdk(http);
 }
@@ -1973,7 +857,7 @@ var _ontologyCache;
 var ontology = new Proxy({}, {
   get(_t, prop) {
     if (!_ontologyCache) {
-      _ontologyCache = createOntologyClient(getDefaultClient());
+      _ontologyCache = createOntologyClient((0, import_core2.getDefaultClient)());
     }
     const inst = _ontologyCache;
     const val = inst[prop];
@@ -1982,8 +866,9 @@ var ontology = new Proxy({}, {
 });
 
 // src/schemas.ts
-var import_zod5 = require("zod");
-var FieldTypeSchema = import_zod5.z.enum([
+var import_core4 = require("@frontal-labs/core");
+var import_zod = require("zod");
+var FieldTypeSchema = import_zod.z.enum([
   "string",
   "integer",
   "float",
@@ -1997,126 +882,126 @@ var FieldTypeSchema = import_zod5.z.enum([
   "vector",
   "text"
 ]);
-var RelationshipTypeSchema = import_zod5.z.enum([
+var RelationshipTypeSchema = import_zod.z.enum([
   "hasOne",
   "hasMany",
   "belongsTo",
   "manyToMany"
 ]);
-var FieldDefinitionSchema = import_zod5.z.object({
+var FieldDefinitionSchema = import_zod.z.object({
   type: FieldTypeSchema,
-  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()
+  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()
   }).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()
+  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()
 }).loose();
-var RelationshipDefinitionSchema = import_zod5.z.object({
-  name: import_zod5.z.string().optional(),
+var RelationshipDefinitionSchema = import_zod.z.object({
+  name: import_zod.z.string().optional(),
   type: RelationshipTypeSchema,
-  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"])
+  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"])
   }).optional(),
-  computed: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()).optional(),
-  description: import_zod5.z.string().optional()
+  computed: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
+  description: import_zod.z.string().optional()
 }).loose();
-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()
+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()
 }).loose();
-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()
+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()
 }).loose();
-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")
+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")
 }).loose();
-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(),
+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(),
   substrates: SubstrateRoutingSchema.optional(),
   semantics: SemanticMetadataSchema.optional(),
-  indexes: import_zod5.z.array(IndexDefinitionSchema).optional(),
-  status: import_zod5.z.enum(["draft", "active", "deprecated"]).default("draft")
+  indexes: import_zod.z.array(IndexDefinitionSchema).optional(),
+  status: import_zod.z.enum(["draft", "active", "deprecated"]).default("draft")
 }).strict();
 var ModelSchema = ModelDefinitionSchema.extend({
-  id: import_zod5.z.string(),
-  version: import_zod5.z.number().int(),
-  createdAt: timestampSchema,
-  updatedAt: timestampSchema,
-  entityCount: import_zod5.z.number().int().optional()
+  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()
 }).loose();
-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([
+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([
         "add-field",
         "remove-field",
         "modify-field",
         "add-relationship",
         "remove-relationship"
       ]),
-      description: import_zod5.z.string(),
-      impact: import_zod5.z.enum(["breaking", "non-breaking", "data-loss"]),
-      sql: import_zod5.z.string().optional()
+      description: import_zod.z.string(),
+      impact: import_zod.z.enum(["breaking", "non-breaking", "data-loss"]),
+      sql: import_zod.z.string().optional()
     })
   ),
-  riskLevel: import_zod5.z.enum(["low", "medium", "high", "critical"]),
-  estimatedDowntime: import_zod5.z.string().optional(),
-  rolloutStrategy: import_zod5.z.enum([
+  riskLevel: import_zod.z.enum(["low", "medium", "high", "critical"]),
+  estimatedDowntime: import_zod.z.string().optional(),
+  rolloutStrategy: import_zod.z.enum([
     "zero-downtime",
     "maintenance-window",
     "immediate"
   ]),
-  createdAt: timestampSchema
+  createdAt: import_core4.timestampSchema
 }).loose();
-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)
+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)
 }).strict();
-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()
+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()
 }).strict();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {