@verentis/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1104 @@
+// src/auth/api-key.auth.ts
+var ApiKeyAuth = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+    if (!apiKey.startsWith("vrt_")) {
+      throw new Error('Invalid API key format: must start with "vrt_"');
+    }
+  }
+  apiKey;
+  async getAuthHeader() {
+    return `Bearer ${this.apiKey}`;
+  }
+};
+
+// src/auth/bridge.auth.ts
+var SKEW_MS = 3e4;
+var BridgeAuth = class {
+  constructor(hostOrigin) {
+    this.hostOrigin = hostOrigin;
+    this._messageHandler = this.handleMessage.bind(this);
+    if (typeof window !== "undefined") {
+      window.addEventListener("message", this._messageHandler);
+    }
+  }
+  hostOrigin;
+  _token = null;
+  _expiresAt = 0;
+  _refreshTimer = null;
+  _pendingRefresh = null;
+  _messageHandler;
+  /** Set the initial token received from the host's `verentis:init` message */
+  setToken(info) {
+    this._token = info.accessToken;
+    this._expiresAt = new Date(info.expiresAt).getTime();
+    this.scheduleRefresh();
+  }
+  async getAuthHeader() {
+    if (!this._token) return null;
+    if (this.isExpired()) {
+      await this.requestRefresh();
+    }
+    return `Bearer ${this._token}`;
+  }
+  destroy() {
+    if (this._refreshTimer) clearTimeout(this._refreshTimer);
+    if (typeof window !== "undefined") {
+      window.removeEventListener("message", this._messageHandler);
+    }
+  }
+  isExpired() {
+    return Date.now() >= this._expiresAt - SKEW_MS;
+  }
+  _refreshResolve = null;
+  requestRefresh() {
+    if (this._pendingRefresh) return this._pendingRefresh;
+    const requestId = crypto.randomUUID();
+    this._pendingRefresh = new Promise((resolve) => {
+      this._refreshResolve = resolve;
+    });
+    const message = {
+      type: "verentis:token:refresh",
+      version: 1,
+      requestId
+    };
+    window.parent.postMessage(message, this.hostOrigin);
+    return this._pendingRefresh;
+  }
+  handleMessage(event) {
+    if (event.origin !== this.hostOrigin) return;
+    const data = event.data;
+    if (data?.type !== "verentis:token:refreshed") return;
+    this._token = data.token.accessToken;
+    this._expiresAt = new Date(data.token.expiresAt).getTime();
+    this._pendingRefresh = null;
+    this._refreshResolve?.();
+    this._refreshResolve = null;
+    this.scheduleRefresh();
+  }
+  scheduleRefresh() {
+    if (this._refreshTimer) clearTimeout(this._refreshTimer);
+    if (this._expiresAt === 0) return;
+    const delay2 = Math.max(0, this._expiresAt - Date.now() - SKEW_MS);
+    this._refreshTimer = setTimeout(() => void this.requestRefresh(), delay2);
+  }
+};
+
+// src/auth/token.auth.ts
+var SKEW_MS2 = 3e4;
+var TokenAuth = class {
+  _token;
+  _expiresAt;
+  _refreshTimer = null;
+  _refreshFn;
+  constructor(token, expiresAt, refreshFn) {
+    this._token = token;
+    this._expiresAt = expiresAt ? new Date(expiresAt).getTime() : Infinity;
+    this._refreshFn = refreshFn;
+    this.scheduleRefresh();
+  }
+  async getAuthHeader() {
+    if (this.isExpired() && this._refreshFn) {
+      await this.refresh();
+    }
+    return `Bearer ${this._token}`;
+  }
+  /** Update the token (e.g. after a refresh) */
+  update(info) {
+    this._token = info.accessToken;
+    this._expiresAt = new Date(info.expiresAt).getTime();
+    this.scheduleRefresh();
+  }
+  destroy() {
+    if (this._refreshTimer) {
+      clearTimeout(this._refreshTimer);
+      this._refreshTimer = null;
+    }
+  }
+  isExpired() {
+    return Date.now() >= this._expiresAt - SKEW_MS2;
+  }
+  async refresh() {
+    if (!this._refreshFn) return;
+    const info = await this._refreshFn();
+    this.update(info);
+  }
+  scheduleRefresh() {
+    if (this._refreshTimer) clearTimeout(this._refreshTimer);
+    if (!this._refreshFn || this._expiresAt === Infinity) return;
+    const delay2 = Math.max(0, this._expiresAt - Date.now() - SKEW_MS2);
+    this._refreshTimer = setTimeout(() => void this.refresh(), delay2);
+  }
+};
+
+// src/modules/context.ts
+var ContextModule = class {
+  _workspace = null;
+  _surface = null;
+  _file = null;
+  _entryPoint = null;
+  _apiUrl = null;
+  /** The current workspace */
+  get workspace() {
+    if (!this._workspace) {
+      throw new Error("Workspace context not available. Ensure the client is initialized.");
+    }
+    return this._workspace;
+  }
+  /** The host surface that launched the app */
+  get surface() {
+    if (!this._surface) {
+      throw new Error("Launch surface not available. Ensure the client is initialized.");
+    }
+    return this._surface;
+  }
+  /** The file that triggered the app to open on a file surface */
+  get file() {
+    if (!this._file) {
+      throw new Error("File context not available. The app may be running on a workspace surface.");
+    }
+    return this._file;
+  }
+  /** The API URL */
+  get apiUrl() {
+    if (!this._apiUrl) {
+      throw new Error("API URL not available. Ensure the client is initialized.");
+    }
+    return this._apiUrl;
+  }
+  /** Whether a file context is available */
+  get hasFile() {
+    return this._file !== null;
+  }
+  /** The application entry point that matched the opened file */
+  get entryPoint() {
+    return this._entryPoint;
+  }
+  /** Whether an entry point context is available */
+  get hasEntryPoint() {
+    return this._entryPoint !== null;
+  }
+  /** Update context from the host's init message */
+  setFromAppContext(ctx) {
+    this._workspace = ctx.workspace;
+    this._surface = ctx.surface ?? "file";
+    this._file = ctx.file ?? null;
+    this._entryPoint = ctx.entryPoint ?? null;
+    this._apiUrl = ctx.apiUrl;
+  }
+  /** Set workspace info directly (standalone mode) */
+  setWorkspace(workspace) {
+    this._workspace = {
+      id: workspace.id,
+      slug: workspace.slug ?? "",
+      name: workspace.name ?? ""
+    };
+  }
+  /** Set API URL directly */
+  setApiUrl(url) {
+    this._apiUrl = url;
+  }
+};
+
+// src/modules/executions.ts
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "Completed",
+  "Failed",
+  "Cancelled",
+  "TimedOut"
+]);
+function isTerminalStatus(status) {
+  return TERMINAL_STATUSES.has(status);
+}
+var ExecutionsModule = class {
+  constructor(http, workspaceId) {
+    this.http = http;
+    this.workspaceId = workspaceId;
+  }
+  http;
+  workspaceId;
+  /**
+   * Run a file in the virtual file system. The platform resolves the appropriate engine from the
+   * file's type (e.g. a `.py` file runs on the Python engine).
+   */
+  async run(filePath, options) {
+    const workspaceId = this.requireWorkspaceId(options?.workspaceId);
+    return this.http.request("POST", "/executions", {
+      body: JSON.stringify({
+        workspaceId,
+        filePath,
+        branch: options?.branch,
+        tool: options?.tool,
+        mode: options?.mode,
+        arguments: options?.arguments ?? [],
+        parameters: serializeParameters(options?.parameters)
+      }),
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  /**
+   * Execute a specific engine by id, optionally against a file and/or with structured parameters
+   * (e.g. invoking an engine tool without a script).
+   */
+  async execute(engineId, options) {
+    const workspaceId = this.requireWorkspaceId(options?.workspaceId);
+    return this.http.request("POST", "/executions", {
+      body: JSON.stringify({
+        workspaceId,
+        engineId,
+        filePath: options?.filePath,
+        branch: options?.branch,
+        tool: options?.tool,
+        mode: options?.mode,
+        arguments: options?.arguments ?? [],
+        parameters: serializeParameters(options?.parameters)
+      }),
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  /** Get an execution by id. */
+  async get(id, options) {
+    const workspaceId = this.requireWorkspaceId(options?.workspaceId);
+    return this.http.request("GET", `/executions/${encodeURIComponent(id)}`, {
+      params: { workspaceId }
+    });
+  }
+  /** List workspace executions with optional engine, file, lifecycle, and time filters. */
+  async list(options) {
+    const workspaceId = this.requireWorkspaceId(options?.workspaceId);
+    return this.http.request("GET", "/executions", {
+      params: {
+        workspaceId,
+        filePath: options?.filePath,
+        engineIds: options?.engineIds,
+        filePaths: options?.filePaths,
+        status: options?.status,
+        trigger: options?.trigger,
+        activeOnly: options?.activeOnly,
+        requestedAfter: options?.requestedAfter,
+        requestedBefore: options?.requestedBefore,
+        pageNo: options?.pageNo ?? 1,
+        pageSize: options?.pageSize ?? 20,
+        orderBy: options?.orderBy
+      }
+    });
+  }
+  /** Get the captured stdout/stderr of an execution. */
+  async logs(id, options) {
+    const workspaceId = this.requireWorkspaceId(options?.workspaceId);
+    return this.http.request("GET", `/executions/${encodeURIComponent(id)}/logs`, {
+      params: { workspaceId }
+    });
+  }
+  /** Cancel a pending or running execution. */
+  async cancel(id, options) {
+    const workspaceId = this.requireWorkspaceId(options?.workspaceId);
+    return this.http.request("POST", `/executions/${encodeURIComponent(id)}/cancel`, {
+      body: JSON.stringify({ id, workspaceId }),
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  /**
+   * Poll an execution until it reaches a terminal status. Returns immediately if it is already
+   * terminal. Throws if `timeoutMs` elapses or the supplied signal aborts.
+   */
+  async wait(id, options) {
+    const interval = options?.intervalMs ?? 1e3;
+    const deadline = options?.timeoutMs ? Date.now() + options.timeoutMs : void 0;
+    for (; ; ) {
+      const execution = await this.get(id, { workspaceId: options?.workspaceId });
+      if (isTerminalStatus(execution.status)) {
+        return execution;
+      }
+      if (deadline !== void 0 && Date.now() >= deadline) {
+        throw new Error(`Timed out waiting for execution '${id}' to complete`);
+      }
+      await delay(interval, options?.signal);
+    }
+  }
+  /**
+   * Run a file and resolve once it has completed. For synchronous (request-response) executions the
+   * initial response is already terminal; otherwise it polls via {@link wait}.
+   */
+  async runAndWait(filePath, options) {
+    const execution = await this.run(filePath, options);
+    if (isTerminalStatus(execution.status)) {
+      return execution;
+    }
+    return this.wait(execution.id, options);
+  }
+  requireWorkspaceId(override) {
+    const id = override ?? this.workspaceId;
+    if (!id) {
+      throw new Error("workspaceId is required: provide it in options or when creating the client");
+    }
+    return id;
+  }
+};
+function serializeParameters(parameters) {
+  return parameters === void 0 ? void 0 : JSON.stringify(parameters);
+}
+function delay(ms, signal) {
+  if (signal?.aborted) {
+    return Promise.reject(new DOMException("Aborted", "AbortError"));
+  }
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(new DOMException("Aborted", "AbortError"));
+      },
+      { once: true }
+    );
+  });
+}
+
+// src/modules/engines.ts
+var EnginesModule = class {
+  constructor(http, workspaceId) {
+    this.http = http;
+    this.workspaceId = workspaceId;
+  }
+  http;
+  workspaceId;
+  async list(options) {
+    return this.http.request("GET", "/engines", {
+      params: {
+        workspaceId: this.requireWorkspaceId(options?.workspaceId),
+        pageNo: options?.pageNo ?? 1,
+        pageSize: options?.pageSize ?? 20,
+        orderBy: options?.orderBy
+      }
+    });
+  }
+  async get(id, options) {
+    return this.http.request("GET", `/engines/${encodeURIComponent(id)}`, {
+      params: { workspaceId: this.requireWorkspaceId(options?.workspaceId) }
+    });
+  }
+  requireWorkspaceId(override) {
+    const workspaceId = override ?? this.workspaceId;
+    if (!workspaceId) {
+      throw new Error("workspaceId is required: provide it in options or when creating the client");
+    }
+    return workspaceId;
+  }
+};
+
+// src/modules/files.ts
+var FilesModule = class {
+  constructor(http, workspaceId) {
+    this.http = http;
+    this.workspaceId = workspaceId;
+  }
+  http;
+  workspaceId;
+  /**
+   * Get file metadata or directory listing.
+   * For files: returns metadata (path, name, mimeType, size, etc.).
+   * For directories: returns metadata with children array populated.
+   */
+  async get(path, options) {
+    const normalizedPath = normalizePath(path);
+    return this.http.request("GET", `/files/${normalizedPath}`, {
+      params: {
+        branch: options?.branch ?? "main",
+        pageNo: options?.pageNo ?? 1,
+        pageSize: options?.pageSize ?? 20,
+        orderBy: options?.orderBy
+      },
+      headers: this.workspaceHeaders()
+    });
+  }
+  /**
+   * Read the raw content of a file as a Blob.
+   */
+  async readContent(path, branch) {
+    const normalizedPath = normalizePath(path);
+    const response = await this.http.requestRaw("GET", `/files/raw/${normalizedPath}`, {
+      params: { branch: branch ?? "main" },
+      headers: {
+        ...this.workspaceHeaders(),
+        Accept: "*/*"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to read file content: ${response.status} ${response.statusText}`);
+    }
+    return response.blob();
+  }
+  /** Read UTF-8 text content from a workspace file. */
+  async readText(path, branch) {
+    return (await this.readContent(path, branch)).text();
+  }
+  /** Inspect an extracted or sealed package node without exposing sealed payload content. */
+  async getPackageDescriptor(path, branch = "main") {
+    return this.http.request("GET", "/files/package-descriptor", {
+      params: { branch, path },
+      headers: this.workspaceHeaders()
+    });
+  }
+  /**
+   * Download a file or directory as an archive (zip or tgz).
+   * Only applicable when the target has children or you want a packaged download.
+   */
+  async readArchive(path, options) {
+    const normalizedPath = normalizePath(path);
+    const format = options?.format ?? "zip";
+    const response = await this.http.requestRaw("GET", `/files/raw/${normalizedPath}`, {
+      params: {
+        branch: options?.branch ?? "main",
+        format
+      },
+      headers: {
+        ...this.workspaceHeaders(),
+        Accept: format === "tgz" ? "application/gzip" : "application/zip"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to download archive: ${response.status} ${response.statusText}`);
+    }
+    return response.blob();
+  }
+  /**
+   * Upload an archive (zip or tgz) and auto-extract its contents as individual nodes.
+   * If the archive contains a `.verentis-manifest.json`, the original metadata
+   * (display names, mime types, parent-content relationships) will be honoured.
+   */
+  async extractUpload(path, file, options) {
+    const normalizedPath = normalizePath(path);
+    const formData = new FormData();
+    const filename = options?.filename ?? "archive.zip";
+    formData.append("file", file, filename);
+    const metadata = {};
+    if (options?.branch) metadata.branch = options.branch;
+    formData.append("metadata", JSON.stringify(metadata));
+    await this.http.request("POST", `/files/${normalizedPath}`, {
+      body: formData,
+      headers: {
+        ...this.workspaceHeaders(),
+        "X-Auto-Extract": "true"
+      }
+    });
+  }
+  /**
+   * Upload or create a file.
+   */
+  async write(path, options) {
+    const normalizedPath = normalizePath(path);
+    const formData = new FormData();
+    let blob;
+    if (typeof options.content === "string") {
+      blob = new Blob([options.content], { type: options.contentType ?? "text/plain" });
+    } else if (options.content instanceof ArrayBuffer) {
+      blob = new Blob([options.content], { type: options.contentType ?? "application/octet-stream" });
+    } else {
+      blob = options.content;
+    }
+    const filename = options.filename ?? extractFilename(path);
+    formData.append("file", blob, filename);
+    const metadata = {};
+    if (options.contentType) metadata.contentType = options.contentType;
+    if (options.branch) metadata.branch = options.branch;
+    formData.append("metadata", JSON.stringify(metadata));
+    await this.http.request("POST", `/files/${normalizedPath}`, {
+      body: formData,
+      headers: this.workspaceHeaders()
+    });
+  }
+  /**
+   * Move or rename a file.
+   */
+  async move(options) {
+    await this.http.request("PUT", "/files", {
+      body: JSON.stringify({
+        from: normalizePath(options.from),
+        to: normalizePath(options.to),
+        branch: options.branch
+      }),
+      headers: {
+        ...this.workspaceHeaders(),
+        "Content-Type": "application/json"
+      }
+    });
+  }
+  /**
+   * Delete a file.
+   */
+  async remove(options) {
+    await this.http.request("DELETE", "/files", {
+      body: JSON.stringify({
+        path: normalizePath(options.path),
+        branch: options.branch
+      }),
+      headers: {
+        ...this.workspaceHeaders(),
+        "Content-Type": "application/json"
+      }
+    });
+  }
+  workspaceHeaders() {
+    const headers = {};
+    if (this.workspaceId) {
+      headers["X-Workspace-Id"] = this.workspaceId;
+    }
+    return headers;
+  }
+};
+function normalizePath(path) {
+  return path.replace(/\/+/g, "/").replace(/^\//, "").replace(/\/$/, "");
+}
+function extractFilename(path) {
+  const segments = path.split("/");
+  return segments[segments.length - 1] || "file";
+}
+
+// src/modules/installations.ts
+var InstallationsModule = class {
+  constructor(http, workspaceId) {
+    this.http = http;
+    this.workspaceId = workspaceId;
+  }
+  http;
+  workspaceId;
+  async list(options) {
+    return this.http.request("GET", "/installations", {
+      params: {
+        workspaceId: this.requireWorkspaceId(options?.workspaceId),
+        pageNo: options?.pageNo ?? 1,
+        pageSize: options?.pageSize ?? 20,
+        orderBy: options?.orderBy,
+        packageId: options?.packageId,
+        branch: options?.branch,
+        installPath: options?.installPath,
+        status: options?.status,
+        isSystem: options?.isSystem
+      }
+    });
+  }
+  async resolve(installPath, options) {
+    return this.http.request("GET", "/installations/resolve", {
+      params: {
+        workspaceId: this.requireWorkspaceId(options?.workspaceId),
+        branch: options?.branch ?? "main",
+        installPath
+      }
+    });
+  }
+  async update(id, options) {
+    const workspaceId = this.requireWorkspaceId(options?.workspaceId);
+    return this.http.request(
+      "PUT",
+      `/installations/${encodeURIComponent(id)}`,
+      {
+        body: JSON.stringify({
+          id,
+          workspaceId,
+          packageVersion: options?.packageVersion,
+          installMode: options?.installMode
+        }),
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  }
+  async uninstall(id, options) {
+    await this.http.request("DELETE", `/installations/${encodeURIComponent(id)}`, {
+      params: { workspaceId: this.requireWorkspaceId(options?.workspaceId) }
+    });
+  }
+  requireWorkspaceId(override) {
+    const workspaceId = override ?? this.workspaceId;
+    if (!workspaceId) {
+      throw new Error("workspaceId is required: provide it in options or when creating the client");
+    }
+    return workspaceId;
+  }
+};
+
+// src/modules/resources.ts
+var ResourcesModule = class {
+  constructor(http, workspaceId) {
+    this.http = http;
+    this.workspaceId = workspaceId;
+  }
+  http;
+  workspaceId;
+  async list(options) {
+    return this.http.request("GET", "/resources", {
+      params: { workspaceId: this.requireWorkspaceId(options?.workspaceId) }
+    });
+  }
+  async get(id, options) {
+    return this.http.request(
+      "GET",
+      `/resources/${encodeURIComponent(id)}`,
+      { params: { workspaceId: this.requireWorkspaceId(options?.workspaceId) } }
+    );
+  }
+  requireWorkspaceId(override) {
+    const workspaceId = override ?? this.workspaceId;
+    if (!workspaceId) {
+      throw new Error("workspaceId is required: provide it in options or when creating the client");
+    }
+    return workspaceId;
+  }
+};
+
+// src/modules/settings.ts
+var SettingsModule = class {
+  constructor(http, workspaceId) {
+    this.http = http;
+    this.workspaceId = workspaceId;
+  }
+  http;
+  workspaceId;
+  /** List every setting group visible to the workspace (definitions merged with values). */
+  async list(options) {
+    return this.http.request("GET", "/settings", {
+      params: this.scopeParams(options)
+    });
+  }
+  /** Get a single setting by its full key (e.g. `graphite.api-key`). */
+  async get(key, options) {
+    return this.http.request("GET", `/settings/${encodeURIComponent(key)}`, {
+      params: this.scopeParams(options)
+    });
+  }
+  /** Get a setting's value by its full key, or `defaultValue` when unset. */
+  async getValue(key, defaultValue, options) {
+    const item = await this.get(key, options);
+    return item.value ?? item.defaultValue ?? defaultValue;
+  }
+  /**
+   * Check exact setting keys for retained stored values and effective defaults.
+   * This never returns value content and also finds values retained after a definition is removed.
+   */
+  async presence(keys, options) {
+    if (keys.length === 0) return [];
+    return this.http.request("GET", "/settings/presence", {
+      params: {
+        scopeKind: "Workspace",
+        parentId: this.requireWorkspaceId(options?.workspaceId),
+        keys
+      }
+    });
+  }
+  /** Upsert a setting value by its full key. Requires the `fabric.setting.update` scope. */
+  async set(key, value, options) {
+    await this.http.request("PUT", `/settings/${encodeURIComponent(key)}`, {
+      params: {
+        scopeKind: "Workspace",
+        parentId: this.requireWorkspaceId(options?.workspaceId)
+      },
+      body: JSON.stringify(value ?? null),
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  /** Delete a stored value (reverting to the definition default). Requires `fabric.setting.delete`. */
+  async reset(key, options) {
+    await this.http.request("DELETE", `/settings/${encodeURIComponent(key)}`, {
+      params: {
+        scopeKind: "Workspace",
+        parentId: this.requireWorkspaceId(options?.workspaceId)
+      }
+    });
+  }
+  /**
+   * A view of this module where every key is auto-prefixed with `{namespace}.` — the platform's
+   * manifest namespacing convention. An app named `graphite` declaring `key: api-key` reads it as:
+   *
+   * ```ts
+   * const settings = client.settings.namespaced('graphite')
+   * const apiKey = await settings.getValue<string>('api-key')
+   * ```
+   */
+  namespaced(namespace) {
+    const prefix = namespace.endsWith(".") ? namespace : `${namespace}.`;
+    return {
+      get: (key, options) => this.get(prefix + key, options),
+      getValue: (key, defaultValue, options) => this.getValue(prefix + key, defaultValue, options),
+      set: (key, value, options) => this.set(prefix + key, value, options),
+      reset: (key, options) => this.reset(prefix + key, options)
+    };
+  }
+  scopeParams(options) {
+    return {
+      scopeKind: "Workspace",
+      parentId: this.requireWorkspaceId(options?.workspaceId),
+      // Secret values never reach browser callers; the platform rejects `true` for
+      // anything but trusted service-to-service identities.
+      includeSecretValues: "false"
+    };
+  }
+  requireWorkspaceId(override) {
+    const workspaceId = override ?? this.workspaceId;
+    if (!workspaceId) {
+      throw new Error(
+        "workspaceId is required: pass it in options or configure the client with one"
+      );
+    }
+    return workspaceId;
+  }
+};
+
+// src/transport/bridge.transport.ts
+var Bridge = class {
+  listeners = /* @__PURE__ */ new Map();
+  _initResolve;
+  _initPromise;
+  _hostOrigin = null;
+  _messageHandler;
+  _destroyed = false;
+  constructor() {
+    this._initPromise = new Promise((resolve) => {
+      this._initResolve = resolve;
+    });
+    this._messageHandler = this.handleMessage.bind(this);
+    if (typeof window !== "undefined") {
+      window.addEventListener("message", this._messageHandler);
+    }
+  }
+  /** Post `verentis:ready` to the host to start the handshake */
+  sendReady(capabilities) {
+    console.info("[Verentis SDK] Sending verentis:ready to host");
+    const message = {
+      type: "verentis:ready",
+      version: 1,
+      capabilities
+    };
+    window.parent.postMessage(message, "*");
+  }
+  /** Wait for the host to send `verentis:init` with context and token */
+  waitForInit() {
+    return this._initPromise;
+  }
+  /** Get the host origin (available after init) */
+  get hostOrigin() {
+    return this._hostOrigin;
+  }
+  /** Send a message to the host */
+  postToHost(message) {
+    if (!this._hostOrigin) {
+      throw new Error("Bridge not initialized: host origin unknown. Wait for init first.");
+    }
+    window.parent.postMessage(message, this._hostOrigin);
+  }
+  /**
+   * Navigate to another location in the workspace.
+   *
+   * @param path A workspace file path (e.g. `/reports/q1.json`) or an absolute
+   *   http(s) URL. External URLs require the app to declare the
+   *   `navigation:external` capability in its manifest.
+   * @param options Navigation options. Set `newTab: true` to open the target in
+   *   a new browser tab instead of the current one.
+   */
+  navigate(path, options) {
+    this.postToHost({
+      type: "verentis:navigate",
+      version: 1,
+      path,
+      ...options?.newTab ? { newTab: true } : {}
+    });
+  }
+  /** Request iframe resize */
+  resize(height) {
+    this.postToHost({ type: "verentis:resize", version: 1, height });
+  }
+  /** Update the title displayed by the host */
+  setTitle(title) {
+    this.postToHost({ type: "verentis:title", version: 1, title });
+  }
+  /** Signal unsaved changes to the host */
+  setDirty(isDirty) {
+    this.postToHost({ type: "verentis:dirty", version: 1, isDirty });
+  }
+  /** Subscribe to a specific message type from the host */
+  on(type, listener) {
+    if (!this.listeners.has(type)) {
+      this.listeners.set(type, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(type).add(listener);
+    return () => {
+      this.listeners.get(type)?.delete(listener);
+    };
+  }
+  /** Clean up event listeners */
+  destroy() {
+    this._destroyed = true;
+    this.listeners.clear();
+    if (typeof window !== "undefined") {
+      window.removeEventListener("message", this._messageHandler);
+    }
+  }
+  handleMessage(event) {
+    if (this._destroyed) return;
+    const data = event.data;
+    if (!data?.type?.startsWith("verentis:")) return;
+    if (data.type === "verentis:init") {
+      this._hostOrigin = event.origin;
+      console.info("[Verentis SDK] Received verentis:init from host", {
+        origin: event.origin,
+        workspaceId: data.context.workspace.id,
+        filePath: data.context.file?.path ?? null
+      });
+      const initData = data;
+      this._initResolve({ context: initData.context, token: initData.token });
+    }
+    const typeListeners = this.listeners.get(data.type);
+    if (typeListeners) {
+      for (const listener of typeListeners) {
+        listener(data);
+      }
+    }
+  }
+};
+
+// src/types.ts
+var ApiError = class extends Error {
+  constructor(status, detail, title) {
+    super(title ?? `API error ${status}: ${detail}`);
+    this.status = status;
+    this.detail = detail;
+    this.title = title;
+    this.name = "ApiError";
+  }
+  status;
+  detail;
+  title;
+};
+
+// src/transport/http.transport.ts
+var HttpTransport = class {
+  constructor(baseUrl, auth, apiVersion = "v1") {
+    this.baseUrl = baseUrl;
+    this.auth = auth;
+    this.apiVersion = apiVersion;
+  }
+  baseUrl;
+  auth;
+  apiVersion;
+  async request(method, path, options) {
+    const url = this.buildUrl(path, options?.params);
+    console.info("[Verentis SDK] Request started", { method, path, url });
+    const headers = {};
+    const authHeader = await this.auth.getAuthHeader();
+    if (authHeader) {
+      headers["Authorization"] = authHeader;
+    }
+    if (options?.headers) {
+      Object.assign(headers, options.headers);
+    }
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: options?.body
+    });
+    if (!response.ok) {
+      let detail = "";
+      let title;
+      try {
+        const body = await response.json();
+        detail = body.detail ?? body.message ?? JSON.stringify(body);
+        title = body.title;
+      } catch {
+        detail = await response.text().catch(() => response.statusText);
+      }
+      console.error("[Verentis SDK] Request failed", {
+        method,
+        path,
+        status: response.status,
+        detail
+      });
+      throw new ApiError(response.status, detail, title);
+    }
+    console.info("[Verentis SDK] Request succeeded", {
+      method,
+      path,
+      status: response.status,
+      contentType: response.headers.get("content-type") ?? ""
+    });
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      return response.json();
+    }
+    return response.blob();
+  }
+  async requestRaw(method, path, options) {
+    const url = this.buildUrl(path, options?.params);
+    console.info("[Verentis SDK] Raw request started", { method, path, url });
+    const headers = {};
+    const authHeader = await this.auth.getAuthHeader();
+    if (authHeader) {
+      headers["Authorization"] = authHeader;
+    }
+    if (options?.headers) {
+      Object.assign(headers, options.headers);
+    }
+    const response = await fetch(url, { method, headers, body: options?.body });
+    console.info("[Verentis SDK] Raw request completed", {
+      method,
+      path,
+      status: response.status,
+      ok: response.ok,
+      contentType: response.headers.get("content-type") ?? ""
+    });
+    return response;
+  }
+  buildUrl(path, params) {
+    const base = `${this.baseUrl}/${this.apiVersion}${path}`;
+    if (!params) return base;
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (value === void 0) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          searchParams.append(key, String(item));
+        }
+      } else {
+        searchParams.set(key, String(value));
+      }
+    }
+    const qs = searchParams.toString();
+    return qs ? `${base}?${qs}` : base;
+  }
+};
+
+// src/client.ts
+var VerentisClient = class {
+  files;
+  executions;
+  engines;
+  installations;
+  resources;
+  settings;
+  context;
+  bridge;
+  _auth;
+  _http;
+  _ready;
+  constructor(options) {
+    this.context = new ContextModule();
+    const environment = detectEnvironment();
+    if (environment === "iframe" && !options?.auth) {
+      this.bridge = new Bridge();
+      const bridgeAuth = new BridgeAuth("*");
+      this._auth = bridgeAuth;
+      this._ready = this.initFromBridge(bridgeAuth);
+    } else {
+      this.bridge = null;
+      this._auth = createAuthStrategy(options);
+      const apiUrl = options?.apiUrl;
+      if (!apiUrl) {
+        throw new Error("apiUrl is required in standalone mode");
+      }
+      this.context.setApiUrl(apiUrl);
+      if (options?.workspaceId) {
+        this.context.setWorkspace({ id: options.workspaceId });
+      }
+      this._http = new HttpTransport(apiUrl, this._auth, options?.apiVersion ?? "v1");
+      this.files = new FilesModule(this._http, options?.workspaceId);
+      this.executions = new ExecutionsModule(this._http, options?.workspaceId);
+      this.engines = new EnginesModule(this._http, options?.workspaceId);
+      this.installations = new InstallationsModule(this._http, options?.workspaceId);
+      this.resources = new ResourcesModule(this._http, options?.workspaceId);
+      this.settings = new SettingsModule(this._http, options?.workspaceId);
+      this._ready = Promise.resolve();
+      return;
+    }
+  }
+  /**
+   * Returns a promise that resolves when the client is fully initialized.
+   * In standalone mode this resolves immediately.
+   * In iframe mode this resolves after the host sends `verentis:init`.
+   */
+  whenReady() {
+    return this._ready;
+  }
+  /** Clean up resources (timers, event listeners) */
+  destroy() {
+    this._auth.destroy?.();
+    this.bridge?.destroy();
+  }
+  async initFromBridge(bridgeAuth) {
+    this.bridge.sendReady();
+    const { context, token } = await this.bridge.waitForInit();
+    const hostOrigin = this.bridge.hostOrigin;
+    Object.assign(bridgeAuth, new BridgeAuth(hostOrigin));
+    bridgeAuth.setToken(token);
+    this.context.setFromAppContext(context);
+    const http = new HttpTransport(
+      context.apiUrl,
+      bridgeAuth,
+      "v1"
+    );
+    this._http = http;
+    this.files = new FilesModule(http, context.workspace.id);
+    this.executions = new ExecutionsModule(http, context.workspace.id);
+    this.engines = new EnginesModule(http, context.workspace.id);
+    this.installations = new InstallationsModule(http, context.workspace.id);
+    this.resources = new ResourcesModule(http, context.workspace.id);
+    this.settings = new SettingsModule(http, context.workspace.id);
+  }
+};
+function detectEnvironment() {
+  if (typeof window !== "undefined" && window.parent !== window) {
+    return "iframe";
+  }
+  return "standalone";
+}
+function createAuthStrategy(options) {
+  if (!options?.auth) {
+    throw new Error("auth is required in standalone mode: provide { apiKey } or { token }");
+  }
+  if ("apiKey" in options.auth) {
+    return new ApiKeyAuth(options.auth.apiKey);
+  }
+  if ("token" in options.auth) {
+    return new TokenAuth(
+      options.auth.token,
+      options.auth.expiresAt,
+      options.auth.refreshToken
+    );
+  }
+  throw new Error("Invalid auth options: provide { apiKey } or { token }");
+}
+
+// src/utils/mime.ts
+function matchMimeType(pattern, mimeType) {
+  const normalizedPattern = stripParams(pattern).toLowerCase();
+  const normalizedMime = stripParams(mimeType).toLowerCase();
+  if (normalizedPattern === "*/*") return true;
+  const [patternType, patternSubtype] = normalizedPattern.split("/");
+  const [mimeTypeType, mimeSubtype] = normalizedMime.split("/");
+  if (!patternType || !mimeTypeType) return false;
+  if (patternType === "*") return true;
+  if (patternType !== mimeTypeType) return false;
+  if (!patternSubtype || patternSubtype === "*") return true;
+  return patternSubtype === mimeSubtype;
+}
+function findBestMatch(mimeType, bindings) {
+  const matches = bindings.filter((b) => matchMimeType(b.pattern, mimeType)).sort((a, b) => {
+    const aExact = !a.pattern.includes("*");
+    const bExact = !b.pattern.includes("*");
+    if (aExact !== bExact) return aExact ? -1 : 1;
+    return b.priority - a.priority;
+  });
+  return matches[0] ?? null;
+}
+function stripParams(mime) {
+  const idx = mime.indexOf(";");
+  return idx === -1 ? mime.trim() : mime.slice(0, idx).trim();
+}
+
+// src/index.ts
+function createVerentisClient(options) {
+  return new VerentisClient(options);
+}
+
+export { ApiKeyAuth, Bridge, BridgeAuth, ContextModule, EnginesModule, ExecutionsModule, FilesModule, HttpTransport, InstallationsModule, ResourcesModule, SettingsModule, TokenAuth, VerentisClient, createVerentisClient, findBestMatch, isTerminalStatus, matchMimeType };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map