@lumibase/sdk 0.10.0

package/dist/index.cjs

@@ -0,0 +1,1326 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ACCESS_EXPORT_SCHEMA: () => ACCESS_EXPORT_SCHEMA,
+  LumiError: () => LumiError,
+  RealtimeClient: () => RealtimeClient,
+  checkCdcPipelineHealth: () => checkCdcPipelineHealth,
+  createAgentArtifact: () => createAgentArtifact,
+  createAgentGoal: () => createAgentGoal,
+  createCdcPipeline: () => createCdcPipeline,
+  createLumiClient: () => createLumiClient,
+  decideAgentApproval: () => decideAgentApproval,
+  deleteCdcPipeline: () => deleteCdcPipeline,
+  deployCdc: () => deployCdc,
+  dryRunAccessImport: () => dryRunAccessImport,
+  evaluateAgentArtifact: () => evaluateAgentArtifact,
+  exportAccessManifest: () => exportAccessManifest,
+  extractSeo: () => extractSeo,
+  generateAgentApp: () => generateAgentApp,
+  generateTypes: () => generateTypes,
+  graphql: () => graphql,
+  importAccessManifest: () => importAccessManifest,
+  jsonLdScript: () => jsonLdScript,
+  legacyRest: () => legacyRest,
+  listAgentApprovals: () => listAgentApprovals,
+  listAgentArtifacts: () => listAgentArtifacts,
+  listAgentGoals: () => listAgentGoals,
+  listAgentRuns: () => listAgentRuns,
+  listAgentTools: () => listAgentTools,
+  listCdcPipelines: () => listCdcPipelines,
+  publishAgentArtifact: () => publishAgentArtifact,
+  readAgentMemoryContext: () => readAgentMemoryContext,
+  readCdcPipeline: () => readCdcPipeline,
+  readCdcPipelineMetricHistory: () => readCdcPipelineMetricHistory,
+  readCdcPipelineMetrics: () => readCdcPipelineMetrics,
+  readItem: () => readItem,
+  readItems: () => readItems,
+  retryAgentRun: () => retryAgentRun,
+  rollbackAgentArtifact: () => rollbackAgentArtifact,
+  rollbackCdcDeployment: () => rollbackCdcDeployment,
+  startCdcPipeline: () => startCdcPipeline,
+  stopCdcPipeline: () => stopCdcPipeline,
+  toNextMetadata: () => toNextMetadata,
+  updateCdcPipeline: () => updateCdcPipeline,
+  validateCdcDeploymentEnv: () => validateCdcDeploymentEnv,
+  writeAgentMemory: () => writeAgentMemory
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var LumiError = class extends Error {
+  constructor(status, body) {
+    super(body?.errors?.[0]?.message ?? `LumiBase ${status}`);
+    this.status = status;
+    this.body = body;
+    this.name = "LumiError";
+  }
+  status;
+  body;
+};
+function parseResponseBody(text) {
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function toErrorBody(status, body) {
+  if (body && typeof body === "object" && Array.isArray(body.errors)) {
+    return body;
+  }
+  const message = typeof body === "string" && body.trim() ? body.trim() : `LumiBase ${status}`;
+  return {
+    errors: [
+      {
+        code: "HTTP_ERROR",
+        message
+      }
+    ]
+  };
+}
+function createLumiClient(opts) {
+  const fetcher = opts.fetcher ?? globalThis.fetch;
+  const base = opts.url.replace(/\/$/, "");
+  async function rawRequest(path, init = {}) {
+    const headers = new Headers(init.headers);
+    for (const [key, value] of Object.entries(opts.headers ?? {})) {
+      headers.set(key, value);
+    }
+    headers.set("authorization", `Bearer ${opts.token}`);
+    headers.set("x-lumi-site", opts.siteId);
+    if (!headers.has("content-type") && init.body) {
+      headers.set("content-type", "application/json");
+    }
+    const res = await fetcher(`${base}${path}`, { ...init, headers });
+    const text = await res.text();
+    const body = parseResponseBody(text);
+    if (!res.ok) {
+      if (res.status === 401 && opts.onUnauthorized) {
+        try {
+          opts.onUnauthorized();
+        } catch {
+        }
+      }
+      throw new LumiError(res.status, toErrorBody(res.status, body));
+    }
+    return body;
+  }
+  const baseClient = {
+    url: opts.url,
+    token: opts.token,
+    siteId: opts.siteId,
+    fetcher,
+    rawRequest,
+    async request(command) {
+      return command(this);
+    },
+    with(plugin) {
+      const ext = plugin(this);
+      return Object.assign(this, ext);
+    }
+  };
+  return baseClient;
+}
+
+// src/types.ts
+var ACCESS_EXPORT_SCHEMA = "lumibase.access@v1";
+
+// src/realtime/index.ts
+var RealtimeClient = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.backoffMs = opts.initialBackoffMs ?? 1e3;
+  }
+  opts;
+  ws = null;
+  subscriptions = /* @__PURE__ */ new Map();
+  presenceListeners = /* @__PURE__ */ new Set();
+  currentPresence = {};
+  sessionId = null;
+  reconnectTimeout = null;
+  backoffMs;
+  stopped = false;
+  // ─── Public API ─────────────────────────────────────────────────────────────
+  /** Open the WebSocket connection. Safe to call multiple times. */
+  connect() {
+    this.stopped = false;
+    this._connect();
+    return this;
+  }
+  /** Close the WebSocket and stop reconnect attempts. */
+  disconnect() {
+    this.stopped = true;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    if (this.ws) {
+      try {
+        this.ws.close(1e3, "client disconnect");
+      } catch {
+      }
+      this.ws = null;
+    }
+  }
+  /**
+   * Subscribe to item mutation events for a specific collection.
+   * Multiple handlers per collection are supported.
+   *
+   * @returns Unsubscribe function.
+   */
+  subscribe(collection, callback) {
+    if (!this.subscriptions.has(collection)) {
+      this.subscriptions.set(collection, /* @__PURE__ */ new Set());
+    }
+    this.subscriptions.get(collection).add(callback);
+    this._send({ type: "subscribe", collection });
+    return () => this.unsubscribe(collection, callback);
+  }
+  /** Remove a specific handler from a collection subscription. */
+  unsubscribe(collection, callback) {
+    const set = this.subscriptions.get(collection);
+    if (!set) return;
+    set.delete(callback);
+    if (set.size === 0) {
+      this.subscriptions.delete(collection);
+      this._send({ type: "unsubscribe", collection });
+    }
+  }
+  /** Update the current user's presence. Sent immediately and on reconnect. */
+  presence(opts) {
+    this.currentPresence = opts;
+    this._send({ type: "presence", ...opts });
+  }
+  /** Register a callback for peer presence updates. */
+  onPresence(callback) {
+    this.presenceListeners.add(callback);
+    return () => this.presenceListeners.delete(callback);
+  }
+  /** Returns the current session ID assigned by the server after connection. */
+  get session() {
+    return this.sessionId;
+  }
+  /** Whether the WebSocket is currently OPEN. */
+  get isConnected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  // ─── Internal ────────────────────────────────────────────────────────────────
+  async _connect() {
+    if (this.ws?.readyState === WebSocket.OPEN || this.ws?.readyState === WebSocket.CONNECTING) return;
+    const { baseUrl, token, siteId, userId } = this.opts;
+    let ticket;
+    try {
+      const res = await fetch(`${baseUrl}/api/v1/realtime/ticket`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${token}`,
+          "X-Lumi-Site": siteId
+        }
+      });
+      if (!res.ok) {
+        throw new Error(`Failed to fetch ticket: ${res.status}`);
+      }
+      const body = await res.json();
+      if (!body.data?.ticket) {
+        throw new Error("Ticket missing from response");
+      }
+      ticket = body.data.ticket;
+    } catch (err) {
+      console.warn("[RealtimeClient] Ticket fetch failed", err);
+      this._scheduleReconnect();
+      return;
+    }
+    if (this.stopped) return;
+    const wsBase = baseUrl.replace(/^http/, "ws");
+    const url = new URL(`${wsBase}/api/v1/realtime`);
+    url.searchParams.set("ticket", ticket);
+    url.searchParams.set("site", siteId);
+    url.searchParams.set("siteId", siteId);
+    let ws;
+    try {
+      ws = new WebSocket(url.toString());
+    } catch {
+      this._scheduleReconnect();
+      return;
+    }
+    this.ws = ws;
+    ws.addEventListener("open", () => {
+      this.backoffMs = this.opts.initialBackoffMs ?? 1e3;
+      for (const collection of this.subscriptions.keys()) {
+        this._sendRaw({ type: "subscribe", collection });
+      }
+      if (Object.keys(this.currentPresence).length > 0) {
+        this._sendRaw({ type: "presence", ...this.currentPresence });
+      }
+    });
+    ws.addEventListener("message", (event) => {
+      try {
+        const msg = JSON.parse(event.data);
+        this._handleMessage(msg);
+      } catch {
+      }
+    });
+    ws.addEventListener("close", () => {
+      this.ws = null;
+      if (!this.stopped) this._scheduleReconnect();
+    });
+    ws.addEventListener("error", () => {
+    });
+  }
+  _handleMessage(msg) {
+    switch (msg.type) {
+      case "welcome":
+        this.sessionId = msg.sessionId;
+        break;
+      case "ping":
+        this._sendRaw({ type: "pong" });
+        break;
+      case "event": {
+        const event = msg;
+        const handlers = this.subscriptions.get(event.collection);
+        if (handlers) {
+          for (const cb of handlers) cb(event);
+        }
+        break;
+      }
+      case "presence": {
+        const users = msg.users ?? [];
+        for (const cb of this.presenceListeners) cb(users);
+        break;
+      }
+    }
+  }
+  _scheduleReconnect() {
+    if (this.stopped || this.reconnectTimeout) return;
+    this.reconnectTimeout = setTimeout(() => {
+      this.reconnectTimeout = null;
+      this._connect();
+      this.backoffMs = Math.min(this.backoffMs * 2, this.opts.maxBackoffMs ?? 3e4);
+    }, this.backoffMs);
+  }
+  _send(data) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this._sendRaw(data);
+    }
+  }
+  _sendRaw(data) {
+    try {
+      this.ws?.send(JSON.stringify(data));
+    } catch {
+    }
+  }
+};
+
+// src/rest/legacy.ts
+function withQuery(path, params = {}) {
+  const qs = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0) continue;
+    qs.set(key, typeof value === "string" ? value : JSON.stringify(value));
+  }
+  const query = qs.toString();
+  return query ? `${path}?${query}` : path;
+}
+function legacyRest() {
+  return function(client) {
+    const collections = {
+      list: () => client.rawRequest("/api/v1/collections"),
+      get: (name) => client.rawRequest(`/api/v1/collections/${name}`),
+      compiled: (name) => client.rawRequest(`/api/v1/collections/${name}/compiled`),
+      create: (input) => client.rawRequest("/api/v1/collections", {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      update: (name, patch) => client.rawRequest(`/api/v1/collections/${name}`, {
+        method: "PATCH",
+        body: JSON.stringify(patch)
+      }),
+      delete: (name) => client.rawRequest(`/api/v1/collections/${name}`, {
+        method: "DELETE"
+      })
+    };
+    const fields = {
+      list: (collectionName) => client.rawRequest(
+        `/api/v1/collections/${collectionName}/fields`
+      ),
+      upsert: (collectionName, fieldName, input) => client.rawRequest(
+        `/api/v1/collections/${collectionName}/fields/${fieldName}`,
+        {
+          method: "PUT",
+          body: JSON.stringify(input)
+        }
+      ),
+      create: (collectionName, input) => fields.upsert(collectionName, input.name, input),
+      update: (collectionName, fieldName, input) => fields.upsert(collectionName, fieldName, input),
+      rename: (collectionName, fromFieldName, toFieldName, input) => fields.upsert(
+        collectionName,
+        toFieldName,
+        {
+          ...input,
+          name: toFieldName,
+          renameFrom: fromFieldName
+        }
+      ),
+      delete: (collectionName, fieldName, options = {}) => client.rawRequest(
+        withQuery(
+          `/api/v1/collections/${collectionName}/fields/${fieldName}`,
+          options
+        ),
+        { method: "DELETE" }
+      )
+    };
+    const relations = {
+      list: () => client.rawRequest("/api/v1/relations"),
+      create: (input) => client.rawRequest("/api/v1/relations", {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      delete: (id) => client.rawRequest(`/api/v1/relations/${id}`, {
+        method: "DELETE"
+      })
+    };
+    const schema = {
+      collections,
+      fields,
+      relations,
+      diff: (name, proposed) => client.rawRequest("/api/v1/collections/diff", {
+        method: "POST",
+        body: JSON.stringify({ name, ...proposed })
+      }),
+      diffInput: (input) => client.rawRequest("/api/v1/collections/diff", {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      apply: (name, proposed) => client.rawRequest(
+        `/api/v1/collections/${name}/schema`,
+        {
+          method: "PUT",
+          body: JSON.stringify(proposed)
+        }
+      ),
+      typegen: (filters) => {
+        const params = new URLSearchParams();
+        if (filters?.include?.length)
+          params.set("include", filters.include.join(","));
+        if (filters?.exclude?.length)
+          params.set("exclude", filters.exclude.join(","));
+        const qs = params.toString();
+        return client.rawRequest(
+          `/api/v1/typegen/schema${qs ? `?${qs}` : ""}`
+        );
+      },
+      listCollections: collections.list,
+      getCollection: collections.get,
+      getCompiled: collections.compiled,
+      createCollection: collections.create,
+      updateCollection: collections.update,
+      deleteCollection: collections.delete,
+      listFields: fields.list,
+      upsertField: fields.upsert,
+      deleteField: fields.delete,
+      listRelations: relations.list,
+      createRelation: relations.create,
+      deleteRelation: relations.delete
+    };
+    function items(name) {
+      function buildQuery(params) {
+        if (!params) return "";
+        const qs = new URLSearchParams();
+        if (params.fields?.length) qs.set("fields", params.fields.join(","));
+        if (params.filter) qs.set("filter", JSON.stringify(params.filter));
+        if (params.sort?.length) qs.set("sort", params.sort.join(","));
+        if (params.limit !== void 0) qs.set("limit", String(params.limit));
+        if (params.offset !== void 0)
+          qs.set("offset", String(params.offset));
+        if (params.status) qs.set("status", params.status);
+        if (params.search) qs.set("search", params.search);
+        const s = qs.toString();
+        return s ? `?${s}` : "";
+      }
+      const base = `/api/v1/items/${name}`;
+      return {
+        list: async (params) => {
+          const res = await client.rawRequest(
+            `${base}${buildQuery(params)}`
+          );
+          return res;
+        },
+        detail: (id, fields2) => client.rawRequest(
+          `${base}/${id}${fields2?.length ? `?fields=${fields2.join(",")}` : ""}`
+        ),
+        create: (input) => client.rawRequest(base, {
+          method: "POST",
+          body: JSON.stringify(input)
+        }),
+        patch: (id, input) => client.rawRequest(`${base}/${id}`, {
+          method: "PATCH",
+          body: JSON.stringify(input)
+        }),
+        replace: (id, input) => client.rawRequest(`${base}/${id}`, {
+          method: "PUT",
+          body: JSON.stringify(input)
+        }),
+        delete: (id) => client.rawRequest(`${base}/${id}`, { method: "DELETE" }),
+        bulk: (op, payload) => client.rawRequest(`${base}/bulk`, {
+          method: "POST",
+          body: JSON.stringify({ op, items: payload })
+        }),
+        listRevisions: (id) => client.rawRequest(`${base}/${id}/revisions`),
+        revertRevision: (id, revisionId) => client.rawRequest(`${base}/${id}/revert/${revisionId}`, {
+          method: "POST"
+        }),
+        // Law Zero pins (content-os Req 8.4/8.5): fields a human edit locked
+        // against agent writes. Release hands the field back to agents.
+        listPins: (id) => client.rawRequest(`${base}/${id}/pins`),
+        releasePin: (id, field) => client.rawRequest(
+          `${base}/${id}/pins/${encodeURIComponent(field)}`,
+          { method: "DELETE" }
+        )
+      };
+    }
+    const roles = {
+      list: () => client.rawRequest("/api/v1/roles"),
+      detail: (id) => client.rawRequest(`/api/v1/roles/${id}`),
+      create: (input) => client.rawRequest("/api/v1/roles", {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      update: (id, patch) => client.rawRequest(`/api/v1/roles/${id}`, {
+        method: "PATCH",
+        body: JSON.stringify(patch)
+      }),
+      delete: (id) => client.rawRequest(`/api/v1/roles/${id}`, { method: "DELETE" }),
+      attachPolicy: (id, input) => client.rawRequest(`/api/v1/roles/${id}/policies`, {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      detachPolicy: (id, policyId) => client.rawRequest(`/api/v1/roles/${id}/policies/${policyId}`, {
+        method: "DELETE"
+      }),
+      assignUser: (id, input) => client.rawRequest(
+        `/api/v1/roles/${id}/users`,
+        { method: "POST", body: JSON.stringify(input) }
+      ),
+      removeUser: (id, userId) => client.rawRequest(`/api/v1/roles/${id}/users/${userId}`, {
+        method: "DELETE"
+      })
+    };
+    const policies = {
+      list: () => client.rawRequest("/api/v1/policies"),
+      detail: (id) => client.rawRequest(`/api/v1/policies/${id}`),
+      create: (input) => client.rawRequest("/api/v1/policies", {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      update: (id, patch) => client.rawRequest(`/api/v1/policies/${id}`, {
+        method: "PATCH",
+        body: JSON.stringify(patch)
+      }),
+      delete: (id) => client.rawRequest(`/api/v1/policies/${id}`, { method: "DELETE" }),
+      addPermission: (id, input) => client.rawRequest(`/api/v1/policies/${id}/permissions`, {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      patchPermission: (id, permId, patch) => client.rawRequest(
+        `/api/v1/policies/${id}/permissions/${permId}`,
+        { method: "PATCH", body: JSON.stringify(patch) }
+      ),
+      removePermission: (id, permId) => client.rawRequest(
+        `/api/v1/policies/${id}/permissions/${permId}`,
+        { method: "DELETE" }
+      ),
+      attachUser: (id, input) => client.rawRequest(`/api/v1/policies/${id}/users`, {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      detachUser: (id, userId) => client.rawRequest(`/api/v1/policies/${id}/users/${userId}`, {
+        method: "DELETE"
+      })
+    };
+    const permissions = {
+      me: () => client.rawRequest("/api/v1/permissions/me"),
+      check: (input) => client.rawRequest("/api/v1/permissions/check", {
+        method: "POST",
+        body: JSON.stringify(input)
+      })
+    };
+    const presets = {
+      list: (collection) => client.rawRequest(`/api/v1/presets${collection ? `?collection=${collection}` : ""}`),
+      get: (id) => client.rawRequest(`/api/v1/presets/${id}`),
+      create: (input) => client.rawRequest("/api/v1/presets", {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      update: (id, patch) => client.rawRequest(`/api/v1/presets/${id}`, {
+        method: "PATCH",
+        body: JSON.stringify(patch)
+      }),
+      delete: (id) => client.rawRequest(`/api/v1/presets/${id}`, { method: "DELETE" })
+    };
+    const translations = {
+      list: (params) => {
+        const qs = new URLSearchParams();
+        if (params?.namespace) qs.set("namespace", params.namespace);
+        if (params?.language) qs.set("language", params.language);
+        const s = qs.toString();
+        return client.rawRequest(`/api/v1/translations${s ? `?${s}` : ""}`);
+      },
+      get: (id) => client.rawRequest(`/api/v1/translations/${id}`),
+      create: (input) => client.rawRequest("/api/v1/translations", {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      update: (id, patch) => client.rawRequest(`/api/v1/translations/${id}`, {
+        method: "PATCH",
+        body: JSON.stringify(patch)
+      }),
+      delete: (id) => client.rawRequest(`/api/v1/translations/${id}`, { method: "DELETE" })
+    };
+    const settings = {
+      list: (scope) => client.rawRequest(`/api/v1/settings${scope ? `?scope=${scope}` : ""}`),
+      get: (key) => client.rawRequest(`/api/v1/settings/${key}`),
+      set: (key, value, scope) => client.rawRequest("/api/v1/settings", {
+        method: "POST",
+        body: JSON.stringify({ key, value, scope })
+      }),
+      delete: (key) => client.rawRequest(`/api/v1/settings/${key}`, { method: "DELETE" })
+    };
+    const site = {
+      get: () => client.rawRequest("/api/v1/site"),
+      update: (patch) => client.rawRequest("/api/v1/site", {
+        method: "PATCH",
+        body: JSON.stringify(patch)
+      })
+    };
+    const users = {
+      list: () => client.rawRequest("/api/v1/users"),
+      get: (id) => client.rawRequest(`/api/v1/users/${id}`),
+      invite: (input) => client.rawRequest("/api/v1/users/invite", {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      update: (id, patch) => client.rawRequest(`/api/v1/users/${id}`, {
+        method: "PATCH",
+        body: JSON.stringify(patch)
+      }),
+      delete: (id) => client.rawRequest(`/api/v1/users/${id}`, { method: "DELETE" }),
+      impersonate: (id) => client.rawRequest(`/api/v1/users/${id}/impersonate`, { method: "POST" })
+    };
+    const teams = {
+      list: () => client.rawRequest("/api/v1/teams"),
+      get: (id) => client.rawRequest(`/api/v1/teams/${id}`),
+      create: (input) => client.rawRequest("/api/v1/teams", {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      update: (id, patch) => client.rawRequest(`/api/v1/teams/${id}`, {
+        method: "PATCH",
+        body: JSON.stringify(patch)
+      }),
+      delete: (id) => client.rawRequest(`/api/v1/teams/${id}`, { method: "DELETE" }),
+      members: {
+        list: (teamId) => client.rawRequest(`/api/v1/teams/${teamId}/members`),
+        add: (teamId, userId) => client.rawRequest(`/api/v1/teams/${teamId}/members`, {
+          method: "POST",
+          body: JSON.stringify({ userId })
+        }),
+        remove: (teamId, userId) => client.rawRequest(`/api/v1/teams/${teamId}/members/${userId}`, { method: "DELETE" })
+      }
+    };
+    const folders = {
+      list: () => client.rawRequest("/api/v1/files/folders"),
+      create: (input) => client.rawRequest("/api/v1/files/folders", {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      update: (id, patch) => client.rawRequest(`/api/v1/files/folders/${id}`, {
+        method: "PATCH",
+        body: JSON.stringify(patch)
+      }),
+      delete: (id) => client.rawRequest(`/api/v1/files/folders/${id}`, { method: "DELETE" })
+    };
+    const files = {
+      list: () => client.rawRequest("/api/v1/files"),
+      create: (input) => client.rawRequest("/api/v1/files", {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      update: (id, patch) => client.rawRequest(`/api/v1/files/${id}`, {
+        method: "PATCH",
+        body: JSON.stringify(patch)
+      }),
+      delete: (id) => client.rawRequest(`/api/v1/files/${id}`, { method: "DELETE" }),
+      getPresignedUrl: (filename) => client.rawRequest("/api/v1/files/presigned-url", {
+        method: "POST",
+        body: JSON.stringify({ filename })
+      })
+    };
+    const webhooks = {
+      list: () => client.rawRequest("/api/v1/webhooks"),
+      create: (input) => client.rawRequest("/api/v1/webhooks", {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      update: (id, patch) => client.rawRequest(`/api/v1/webhooks/${id}`, {
+        method: "PATCH",
+        body: JSON.stringify(patch)
+      }),
+      delete: (id) => client.rawRequest(`/api/v1/webhooks/${id}`, { method: "DELETE" })
+    };
+    const activity = {
+      list: (params) => {
+        const query = new URLSearchParams();
+        if (params?.limit) query.append("limit", params.limit.toString());
+        if (params?.offset) query.append("offset", params.offset.toString());
+        return client.rawRequest(`/api/v1/activity?${query.toString()}`);
+      }
+    };
+    const extensions = {
+      list: () => client.rawRequest("/api/v1/extensions"),
+      create: (input) => client.rawRequest("/api/v1/extensions", {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      update: (id, patch) => client.rawRequest(`/api/v1/extensions/${id}`, {
+        method: "PATCH",
+        body: JSON.stringify(patch)
+      }),
+      delete: (id) => client.rawRequest(`/api/v1/extensions/${id}`, { method: "DELETE" })
+    };
+    const access = {
+      checkConflicts: (input) => client.rawRequest("/api/v1/access/conflicts/check", {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      exportManifest: () => client.rawRequest("/api/v1/access/export"),
+      dryRunImport: (manifest) => client.rawRequest("/api/v1/access/import?dryRun=true", {
+        method: "POST",
+        body: JSON.stringify(manifest)
+      }),
+      importManifest: (manifest, options = {}) => {
+        const query = options.mode ? `?mode=${encodeURIComponent(options.mode)}` : "";
+        return client.rawRequest(`/api/v1/access/import${query}`, {
+          method: "POST",
+          body: JSON.stringify(manifest)
+        });
+      }
+    };
+    const apiKeys = {
+      list: () => client.rawRequest("/api/v1/api-keys"),
+      get: (id) => client.rawRequest(`/api/v1/api-keys/${id}`),
+      create: (input) => client.rawRequest("/api/v1/api-keys", {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      rotate: (id, input = {}) => client.rawRequest(`/api/v1/api-keys/${id}/rotate`, {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      revoke: (id) => client.rawRequest(`/api/v1/api-keys/${id}/revoke`, {
+        method: "POST"
+      }),
+      attachRole: (id, input) => client.rawRequest(`/api/v1/api-keys/${id}/roles`, {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      detachRole: (id, roleId) => client.rawRequest(`/api/v1/api-keys/${id}/roles/${roleId}`, {
+        method: "DELETE"
+      }),
+      attachPolicy: (id, input) => client.rawRequest(`/api/v1/api-keys/${id}/policies`, {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      detachPolicy: (id, policyId) => client.rawRequest(`/api/v1/api-keys/${id}/policies/${policyId}`, {
+        method: "DELETE"
+      }),
+      previewConflicts: (id, input) => access.checkConflicts({
+        ...input,
+        target: { type: "api_key", id }
+      })
+    };
+    const shares = {
+      create: (input) => client.rawRequest("/api/v1/shares", {
+        method: "POST",
+        body: JSON.stringify(input)
+      }),
+      revoke: (id) => client.rawRequest(`/api/v1/shares/${id}/revoke`, {
+        method: "POST"
+      })
+    };
+    return {
+      schema,
+      items,
+      roles,
+      policies,
+      access,
+      apiKeys,
+      shares,
+      permissions,
+      presets,
+      translations,
+      settings,
+      site,
+      users,
+      teams,
+      folders,
+      files,
+      webhooks,
+      activity,
+      extensions,
+      realtime: {
+        /**
+         * Create a RealtimeClient for the current site.
+         *
+         * @param token  Bearer token (or dev token) for the WS handshake.
+         * @param opts   Optional overrides (userId, backoff timing).
+         */
+        create: (token, opts) => {
+          return new RealtimeClient({
+            baseUrl: client.url,
+            token,
+            siteId: client.siteId ?? "",
+            ...opts
+          });
+        },
+        /** @deprecated Use .realtime.create() instead. */
+        connect: async (siteId) => {
+          const res = await client.rawRequest("/api/v1/realtime/ticket", { method: "POST" });
+          const ticket = res.data?.ticket;
+          if (!ticket) {
+            throw new Error("Failed to get realtime ticket");
+          }
+          const wsUrl = client.url.replace(/^http/, "ws") + "/api/v1/realtime?ticket=" + ticket + "&siteId=" + siteId;
+          return new WebSocket(wsUrl);
+        }
+      },
+      auth: {
+        me: () => client.rawRequest("/api/v1/auth/me")
+      },
+      // Phantom type witness
+      _schemaType: void 0,
+      // Backward compat request method
+      request: client.rawRequest
+    };
+  };
+}
+
+// src/rest/index.ts
+function readItems(collection, params) {
+  return async (client) => {
+    const qs = new URLSearchParams();
+    if (params?.fields?.length) qs.set("fields", params.fields.join(","));
+    if (params?.filter) qs.set("filter", JSON.stringify(params.filter));
+    if (params?.sort?.length) qs.set("sort", params.sort.join(","));
+    if (params?.limit !== void 0) qs.set("limit", String(params.limit));
+    if (params?.offset !== void 0) qs.set("offset", String(params.offset));
+    if (params?.status) qs.set("status", params.status);
+    if (params?.search) qs.set("search", params.search);
+    const s = qs.toString();
+    const query = s ? `?${s}` : "";
+    const res = await client.rawRequest(`/api/v1/items/${collection}${query}`);
+    return res;
+  };
+}
+function readItem(collection, id, fields) {
+  return async (client) => {
+    const res = await client.rawRequest(
+      `/api/v1/items/${collection}/${id}${fields?.length ? `?fields=${fields.join(",")}` : ""}`
+    );
+    return res;
+  };
+}
+function exportAccessManifest() {
+  return async (client) => {
+    const res = await client.rawRequest("/api/v1/access/export");
+    return res.data;
+  };
+}
+function dryRunAccessImport(manifest) {
+  return async (client) => {
+    const res = await client.rawRequest("/api/v1/access/import?dryRun=true", {
+      method: "POST",
+      body: JSON.stringify(manifest)
+    });
+    return res.data;
+  };
+}
+function importAccessManifest(manifest, options = {}) {
+  return async (client) => {
+    const query = options.mode ? `?mode=${encodeURIComponent(options.mode)}` : "";
+    const res = await client.rawRequest(`/api/v1/access/import${query}`, {
+      method: "POST",
+      body: JSON.stringify(manifest)
+    });
+    return res.data;
+  };
+}
+function createCdcPipeline(input) {
+  return async (client) => {
+    const res = await client.rawRequest("/api/v1/cdc/pipelines", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+    return res.data;
+  };
+}
+function listCdcPipelines() {
+  return async (client) => {
+    const res = await client.rawRequest("/api/v1/cdc/pipelines");
+    return res.data.pipelines;
+  };
+}
+function readCdcPipeline(id) {
+  return async (client) => {
+    const res = await client.rawRequest(`/api/v1/cdc/pipelines/${id}`);
+    return res.data;
+  };
+}
+function updateCdcPipeline(id, input) {
+  return async (client) => {
+    const res = await client.rawRequest(`/api/v1/cdc/pipelines/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(input)
+    });
+    return res.data;
+  };
+}
+function deleteCdcPipeline(id) {
+  return async (client) => {
+    const res = await client.rawRequest(`/api/v1/cdc/pipelines/${id}`, {
+      method: "DELETE"
+    });
+    return res.data;
+  };
+}
+function startCdcPipeline(id) {
+  return async (client) => {
+    const res = await client.rawRequest(`/api/v1/cdc/pipelines/${id}/start`, {
+      method: "POST"
+    });
+    return res.data;
+  };
+}
+function stopCdcPipeline(id) {
+  return async (client) => {
+    const res = await client.rawRequest(`/api/v1/cdc/pipelines/${id}/stop`, {
+      method: "POST"
+    });
+    return res.data;
+  };
+}
+function checkCdcPipelineHealth(id) {
+  return async (client) => {
+    const res = await client.rawRequest(`/api/v1/cdc/pipelines/${id}/health`);
+    return res.data;
+  };
+}
+function readCdcPipelineMetrics(id) {
+  return async (client) => {
+    const res = await client.rawRequest(`/api/v1/cdc/pipelines/${id}/metrics`);
+    return res.data;
+  };
+}
+function readCdcPipelineMetricHistory(id, since) {
+  return async (client) => {
+    const value = since instanceof Date ? since.toISOString() : since;
+    const query = value ? `?since=${encodeURIComponent(value)}` : "";
+    const res = await client.rawRequest(
+      `/api/v1/cdc/pipelines/${id}/metrics/history${query}`
+    );
+    return res.data;
+  };
+}
+function deployCdc(input) {
+  return async (client) => {
+    const res = await client.rawRequest("/api/v1/cdc/deploy", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+    return res.data;
+  };
+}
+function validateCdcDeploymentEnv(input) {
+  return async (client) => {
+    const res = await client.rawRequest("/api/v1/cdc/deploy/validate-env", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+    return res.data;
+  };
+}
+function rollbackCdcDeployment(id) {
+  return async (client) => {
+    const res = await client.rawRequest(`/api/v1/cdc/deploy/${id}/rollback`, {
+      method: "POST"
+    });
+    return res.data;
+  };
+}
+function listAgentGoals() {
+  return async (client) => {
+    const res = await client.rawRequest("/api/v1/agent/goals");
+    return res.data;
+  };
+}
+function createAgentGoal(input) {
+  return async (client) => {
+    const res = await client.rawRequest("/api/v1/agent/goals", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+    return res.data;
+  };
+}
+function listAgentRuns() {
+  return async (client) => {
+    const res = await client.rawRequest("/api/v1/agent/runs");
+    return res.data;
+  };
+}
+function retryAgentRun(id) {
+  return async (client) => {
+    const res = await client.rawRequest(`/api/v1/agent/runs/${id}/retry`, {
+      method: "POST"
+    });
+    return res.data;
+  };
+}
+function listAgentTools() {
+  return async (client) => {
+    const res = await client.rawRequest("/api/v1/agent/tools");
+    return res.data;
+  };
+}
+function listAgentApprovals() {
+  return async (client) => {
+    const res = await client.rawRequest("/api/v1/agent/approvals");
+    return res.data;
+  };
+}
+function decideAgentApproval(id, decision, reason) {
+  return async (client) => {
+    const res = await client.rawRequest(`/api/v1/agent/approvals/${id}/decide`, {
+      method: "POST",
+      body: JSON.stringify({ decision, reason })
+    });
+    return res.data;
+  };
+}
+function listAgentArtifacts(runId) {
+  return async (client) => {
+    const query = runId ? `?runId=${encodeURIComponent(runId)}` : "";
+    const res = await client.rawRequest(`/api/v1/agent/artifacts${query}`);
+    return res.data;
+  };
+}
+function createAgentArtifact(input) {
+  return async (client) => {
+    const res = await client.rawRequest("/api/v1/agent/artifacts", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+    return res.data;
+  };
+}
+function evaluateAgentArtifact(id, runId) {
+  return async (client) => {
+    const res = await client.rawRequest(`/api/v1/agent/artifacts/${id}/evaluate?runId=${encodeURIComponent(runId)}`, {
+      method: "POST"
+    });
+    return res.data;
+  };
+}
+function publishAgentArtifact(id, overrideReason) {
+  return async (client) => {
+    const res = await client.rawRequest(`/api/v1/agent/artifacts/${id}/publish`, {
+      method: "POST",
+      body: JSON.stringify({ overrideReason })
+    });
+    return res.data;
+  };
+}
+function rollbackAgentArtifact(id, reason) {
+  return async (client) => {
+    const res = await client.rawRequest(`/api/v1/agent/artifacts/${id}/rollback`, {
+      method: "POST",
+      body: JSON.stringify({ reason })
+    });
+    return res.data;
+  };
+}
+function readAgentMemoryContext(scope, scopeId) {
+  return async (client) => {
+    const qs = new URLSearchParams();
+    if (scope) qs.set("scope", scope);
+    if (scopeId) qs.set("scopeId", scopeId);
+    const query = qs.toString() ? `?${qs.toString()}` : "";
+    const res = await client.rawRequest(`/api/v1/agent/memory${query}`);
+    return res.data;
+  };
+}
+function writeAgentMemory(input) {
+  return async (client) => {
+    const res = await client.rawRequest("/api/v1/agent/memory", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+    return res.data;
+  };
+}
+function generateAgentApp(input) {
+  return async (client) => {
+    const res = await client.rawRequest("/api/v1/agent/generate-app", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+    return res.data;
+  };
+}
+
+// src/graphql/index.ts
+function graphql(endpoint = "/api/v1/graphql") {
+  return (client) => {
+    async function execute(document, variables) {
+      const res = await client.rawRequest(endpoint, {
+        method: "POST",
+        body: JSON.stringify({ query: document, variables })
+      });
+      const body = res;
+      if (body.errors?.length) {
+        const errorBody = {
+          errors: body.errors.map((e) => ({
+            code: typeof e.extensions?.code === "string" ? e.extensions.code : "GRAPHQL_ERROR",
+            message: e.message,
+            path: e.path?.map(String),
+            ...e.extensions
+          }))
+        };
+        const status = Number(body.errors[0]?.extensions?.status) || 400;
+        throw new LumiError(status, errorBody);
+      }
+      if (body.data === void 0 || body.data === null) {
+        throw new LumiError(500, {
+          errors: [{ code: "GRAPHQL_EMPTY", message: "GraphQL response contained no data." }]
+        });
+      }
+      return body.data;
+    }
+    return {
+      query: (document, variables) => execute(document, variables),
+      mutate: (document, variables) => execute(document, variables)
+    };
+  };
+}
+
+// src/typegen/index.ts
+function generateTypes(manifest, options = {}) {
+  const { format = "single", branded = true } = options;
+  if (format === "single") {
+    return generateSingleFile(manifest, branded);
+  }
+  return generatePerCollection(manifest, branded);
+}
+function generateSingleFile(manifest, branded) {
+  const imports = [
+    "import type { ID, Locale } from '@lumibase/sdk';",
+    branded ? "import type { Brand } from '@lumibase/sdk';" : ""
+  ].filter(Boolean).join("\n");
+  const collectionInterfaces = manifest.collections.map((coll) => {
+    const base = generateCollectionInterface(coll, branded);
+    const expanded = generateExpandedType(coll);
+    return [base, expanded].filter(Boolean).join("\n\n");
+  }).join("\n\n");
+  const collectionsMap = `export interface LumibaseCollections {
+${manifest.collections.map((c) => `  ${c.name}: ${capitalize(c.name)};`).join("\n")}
+}`;
+  const schemaType = "export type LumibaseSchema = LumibaseCollections;";
+  return `${imports}
+
+${collectionInterfaces}
+
+${collectionsMap}
+
+${schemaType}`;
+}
+function generatePerCollection(manifest, branded) {
+  return generateSingleFile(manifest, branded);
+}
+function generateCollectionInterface(coll, branded) {
+  const fields = coll.fields.map((f) => {
+    const tsType = mapFieldTypeToTs(f, coll, branded);
+    const optional = f.required ? "" : "?";
+    const readonly = f.readonly || f.generated ? "readonly " : "";
+    return `  ${readonly}${f.name}${optional}: ${tsType};`;
+  }).join("\n");
+  return `export interface ${capitalize(coll.name)} {
+${fields}
+}`;
+}
+function generateExpandedType(coll) {
+  const relations = coll.relations ?? [];
+  if (relations.length === 0) {
+    return `export type ${capitalize(coll.name)}Expanded = ${capitalize(coll.name)};`;
+  }
+  const omittedKeys = relations.map((relation) => quoteProperty(relation.field)).join(" | ");
+  const fields = relations.map((relation) => `  ${relation.field}?: ${expandedRelationType(relation)};`).join("\n");
+  return `export type ${capitalize(coll.name)}Expanded = Omit<${capitalize(coll.name)}, ${omittedKeys}> & {
+${fields}
+};`;
+}
+function expandedRelationType(relation) {
+  if (relation.kind === "m2o") {
+    return `${capitalize(relation.target)} | ${capitalize(relation.target)}Expanded | null`;
+  }
+  if (relation.kind === "o2m" || relation.kind === "m2m") {
+    return `Array<${capitalize(relation.target)} | ${capitalize(relation.target)}Expanded>`;
+  }
+  return `Array<{ collection: string; item: unknown }>`;
+}
+function mapFieldTypeToTs(field, coll, branded) {
+  if (field.kind === "m2o") {
+    return nullable(field, mapScalarFieldType(field, branded));
+  }
+  if (field.kind === "o2m" || field.kind === "m2m") {
+    return `${capitalize(field.target || "unknown")}[]`;
+  }
+  if (field.kind === "m2a") {
+    return `Array<{ collection: string; item: unknown }>`;
+  }
+  if (field.enum && field.enum.length > 0) {
+    return nullable(field, field.enum.map((v) => JSON.stringify(v)).join(" | "));
+  }
+  if (field.primaryKey) {
+    return nullable(
+      field,
+      mapPrimaryKeyType(coll.primaryKeyType ?? "nanoid", branded, field.branded)
+    );
+  }
+  const tsType = mapScalarFieldType(field, branded);
+  return nullable(field, field.encrypted ? `${tsType} | '***'` : tsType);
+}
+function mapScalarFieldType(field, branded) {
+  const typeMap = {
+    string: "string",
+    text: "string",
+    hash: "string",
+    csv: "string",
+    integer: "number",
+    bigInteger: "number",
+    decimal: "number",
+    boolean: "boolean",
+    json: "unknown",
+    uuid: mapPrimaryKeyType("uuid", branded, field.branded),
+    date: "string",
+    datetime: "string",
+    time: "string",
+    timestamp: "string",
+    geometry: "GeoJSON.Geometry"
+  };
+  return typeMap[field.type] || "unknown";
+}
+function nullable(field, tsType) {
+  if (!field.required || field.nullable) {
+    return `${tsType} | null`;
+  }
+  return tsType;
+}
+function mapPrimaryKeyType(primaryKeyType, branded, brand) {
+  if (primaryKeyType === "integer" || primaryKeyType === "bigInteger") return "number";
+  if (branded) return `Brand<'${brand || "ID"}', string>`;
+  return "ID";
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function quoteProperty(name) {
+  return JSON.stringify(name);
+}
+
+// src/seo.ts
+function extractSeo(item) {
+  if (!item || typeof item !== "object") return void 0;
+  const seo = item._seo;
+  return seo && typeof seo === "object" ? seo : void 0;
+}
+function toNextMetadata(item) {
+  const seo = extractSeo(item);
+  if (!seo) return {};
+  const metadata = {};
+  if (seo.title) metadata.title = seo.title;
+  if (seo.description) metadata.description = seo.description;
+  if (seo.canonical) metadata.alternates = { canonical: seo.canonical };
+  if (seo.openGraph) metadata.openGraph = seo.openGraph;
+  return metadata;
+}
+function jsonLdScript(item) {
+  const seo = extractSeo(item);
+  if (!seo?.jsonLd) return void 0;
+  return JSON.stringify(seo.jsonLd);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ACCESS_EXPORT_SCHEMA,
+  LumiError,
+  RealtimeClient,
+  checkCdcPipelineHealth,
+  createAgentArtifact,
+  createAgentGoal,
+  createCdcPipeline,
+  createLumiClient,
+  decideAgentApproval,
+  deleteCdcPipeline,
+  deployCdc,
+  dryRunAccessImport,
+  evaluateAgentArtifact,
+  exportAccessManifest,
+  extractSeo,
+  generateAgentApp,
+  generateTypes,
+  graphql,
+  importAccessManifest,
+  jsonLdScript,
+  legacyRest,
+  listAgentApprovals,
+  listAgentArtifacts,
+  listAgentGoals,
+  listAgentRuns,
+  listAgentTools,
+  listCdcPipelines,
+  publishAgentArtifact,
+  readAgentMemoryContext,
+  readCdcPipeline,
+  readCdcPipelineMetricHistory,
+  readCdcPipelineMetrics,
+  readItem,
+  readItems,
+  retryAgentRun,
+  rollbackAgentArtifact,
+  rollbackCdcDeployment,
+  startCdcPipeline,
+  stopCdcPipeline,
+  toNextMetadata,
+  updateCdcPipeline,
+  validateCdcDeploymentEnv,
+  writeAgentMemory
+});