incus-ts 0.1.0

package/dist/index.js

@@ -0,0 +1,1885 @@
+// src/incus.ts
+import { request as nodeHttpRequest } from "node:http";
+import { createHash, randomBytes } from "node:crypto";
+import { EventEmitter } from "node:events";
+import { connect as nodeNetConnect } from "node:net";
+
+class IncusApiError extends Error {
+  status;
+  statusCode;
+  errorCode;
+  details;
+  constructor(message, status, options = {}) {
+    super(message);
+    this.name = "IncusApiError";
+    this.status = status;
+    this.statusCode = options.statusCode;
+    this.errorCode = options.errorCode;
+    this.details = options.details;
+  }
+}
+var WEBSOCKET_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+var WS_CONNECTING = 0;
+var WS_OPEN = 1;
+var WS_CLOSING = 2;
+var WS_CLOSED = 3;
+
+class UnixSocketWebSocket {
+  socket;
+  CONNECTING = WS_CONNECTING;
+  OPEN = WS_OPEN;
+  CLOSING = WS_CLOSING;
+  CLOSED = WS_CLOSED;
+  binaryType = "arraybuffer";
+  extensions = "";
+  protocol = "";
+  readyState = WS_CONNECTING;
+  bufferedAmount = 0;
+  events = new EventEmitter;
+  readBuffer = Buffer.alloc(0);
+  fragments = [];
+  fragmentOpcode = null;
+  closeInfo = null;
+  closeEmitted = false;
+  constructor(socket, initialData) {
+    this.socket = socket;
+    this.socket.on("data", (chunk) => {
+      this.ingestData(chunk);
+    });
+    this.socket.on("error", (error) => {
+      this.events.emit("error", error);
+    });
+    this.socket.on("close", () => {
+      this.readyState = WS_CLOSED;
+      if (!this.closeEmitted) {
+        this.closeEmitted = true;
+        const info = this.closeInfo ?? { code: 1006, reason: "" };
+        this.events.emit("close", info.code, info.reason);
+      }
+    });
+    this.readyState = WS_OPEN;
+    if (initialData && initialData.byteLength > 0) {
+      this.ingestData(Buffer.from(initialData));
+    }
+  }
+  addEventListener(type, listener) {
+    this.events.on(type, listener);
+  }
+  removeEventListener(type, listener) {
+    this.events.off(type, listener);
+  }
+  on(type, listener) {
+    this.events.on(type, listener);
+  }
+  off(type, listener) {
+    this.events.off(type, listener);
+  }
+  once(type, listener) {
+    this.events.once(type, listener);
+  }
+  send(data) {
+    if (this.readyState !== WS_OPEN) {
+      throw new Error("[Incus.ts] Cannot send on a closed websocket");
+    }
+    const payload = typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(toBytes(data));
+    const opcode = typeof data === "string" ? 1 : 2;
+    this.writeFrame(opcode, payload, true);
+  }
+  close(code = 1000, reason = "") {
+    if (this.readyState === WS_CLOSED) {
+      return;
+    }
+    if (this.readyState === WS_OPEN) {
+      this.readyState = WS_CLOSING;
+      const reasonBytes = Buffer.from(reason, "utf8");
+      const payload = Buffer.alloc(2 + reasonBytes.length);
+      payload.writeUInt16BE(code, 0);
+      reasonBytes.copy(payload, 2);
+      this.writeFrame(8, payload, true);
+    }
+    this.socket.end();
+  }
+  ingestData(chunk) {
+    const bytes = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
+    if (bytes.byteLength === 0) {
+      return;
+    }
+    this.readBuffer = this.readBuffer.byteLength === 0 ? Buffer.from(bytes) : Buffer.concat([this.readBuffer, bytes]);
+    this.parseFrames();
+  }
+  parseFrames() {
+    while (this.readBuffer.byteLength >= 2) {
+      const first = this.readBuffer[0];
+      const second = this.readBuffer[1];
+      if (first === undefined || second === undefined) {
+        return;
+      }
+      const fin = (first & 128) !== 0;
+      let opcode = first & 15;
+      const masked = (second & 128) !== 0;
+      let offset = 2;
+      let payloadLength = second & 127;
+      if (payloadLength === 126) {
+        if (this.readBuffer.byteLength < offset + 2) {
+          return;
+        }
+        payloadLength = this.readBuffer.readUInt16BE(offset);
+        offset += 2;
+      } else if (payloadLength === 127) {
+        if (this.readBuffer.byteLength < offset + 8) {
+          return;
+        }
+        const extended = this.readBuffer.readBigUInt64BE(offset);
+        if (extended > BigInt(Number.MAX_SAFE_INTEGER)) {
+          this.events.emit("error", new Error("[Incus.ts] Websocket frame too large"));
+          this.close(1009, "Frame too large");
+          return;
+        }
+        payloadLength = Number(extended);
+        offset += 8;
+      }
+      let maskKey;
+      if (masked) {
+        if (this.readBuffer.byteLength < offset + 4) {
+          return;
+        }
+        maskKey = this.readBuffer.subarray(offset, offset + 4);
+        offset += 4;
+      }
+      if (this.readBuffer.byteLength < offset + payloadLength) {
+        return;
+      }
+      let payload = this.readBuffer.subarray(offset, offset + payloadLength);
+      this.readBuffer = this.readBuffer.subarray(offset + payloadLength);
+      if (maskKey) {
+        const decoded = Buffer.alloc(payload.byteLength);
+        for (let i = 0;i < payload.byteLength; i += 1) {
+          decoded[i] = payload[i] ^ maskKey[i % 4];
+        }
+        payload = decoded;
+      }
+      if (!fin) {
+        if (opcode !== 0) {
+          this.fragmentOpcode = opcode;
+        }
+        this.fragments.push(Buffer.from(payload));
+        continue;
+      }
+      if (opcode === 0 && this.fragmentOpcode !== null) {
+        this.fragments.push(Buffer.from(payload));
+        payload = Buffer.concat(this.fragments);
+        opcode = this.fragmentOpcode;
+        this.fragments = [];
+        this.fragmentOpcode = null;
+      }
+      this.handleFrame(opcode, payload);
+    }
+  }
+  handleFrame(opcode, payload) {
+    switch (opcode) {
+      case 1:
+        this.events.emit("message", payload.toString("utf8"));
+        break;
+      case 2:
+        this.events.emit("message", new Uint8Array(payload));
+        break;
+      case 8: {
+        let code = 1000;
+        let reason = "";
+        if (payload.byteLength >= 2) {
+          code = payload.readUInt16BE(0);
+          reason = payload.subarray(2).toString("utf8");
+        }
+        this.closeInfo = { code, reason };
+        if (this.readyState === WS_OPEN) {
+          this.readyState = WS_CLOSING;
+          this.writeFrame(8, payload, true);
+        }
+        this.socket.end();
+        break;
+      }
+      case 9:
+        this.writeFrame(10, payload, true);
+        break;
+      case 10:
+        break;
+      default:
+        this.events.emit("error", new Error(`[Incus.ts] Unsupported websocket opcode: ${opcode}`));
+    }
+  }
+  writeFrame(opcode, payload, mask) {
+    const parts = [];
+    const firstByte = 128 | opcode & 15;
+    const payloadLength = payload.byteLength;
+    if (payloadLength < 126) {
+      parts.push(Buffer.from([firstByte, (mask ? 128 : 0) | payloadLength]));
+    } else if (payloadLength <= 65535) {
+      const header = Buffer.alloc(4);
+      header[0] = firstByte;
+      header[1] = (mask ? 128 : 0) | 126;
+      header.writeUInt16BE(payloadLength, 2);
+      parts.push(header);
+    } else {
+      const header = Buffer.alloc(10);
+      header[0] = firstByte;
+      header[1] = (mask ? 128 : 0) | 127;
+      header.writeBigUInt64BE(BigInt(payloadLength), 2);
+      parts.push(header);
+    }
+    if (mask) {
+      const maskKey = randomBytes(4);
+      const maskedPayload = Buffer.from(payload);
+      for (let i = 0;i < maskedPayload.byteLength; i += 1) {
+        maskedPayload[i] = maskedPayload[i] ^ maskKey[i % 4];
+      }
+      parts.push(maskKey, maskedPayload);
+    } else {
+      parts.push(payload);
+    }
+    this.socket.write(Buffer.concat(parts));
+  }
+}
+
+class FetchTransport {
+  descriptor;
+  defaults;
+  constructor(descriptor, defaults) {
+    this.descriptor = descriptor;
+    this.defaults = defaults;
+  }
+  async request(method, path, options = {}) {
+    const url = this.makeRequestUrl(path, options.query);
+    const headers = this.makeHeaders(options);
+    const bodyInfo = prepareBody(options.body);
+    if (bodyInfo.contentType && !headers.has("Content-Type")) {
+      headers.set("Content-Type", bodyInfo.contentType);
+    }
+    const fetchImpl = this.defaults.fetch ?? fetch;
+    const response = await fetchImpl(url, {
+      method: method.toUpperCase(),
+      headers,
+      body: bodyInfo.body,
+      signal: options.signal ?? this.defaults.signal,
+      redirect: "follow"
+    });
+    return {
+      status: response.status,
+      etag: response.headers.get("etag") ?? undefined,
+      headers: response.headers,
+      data: await parseResponseBody(response)
+    };
+  }
+  async websocket(path, protocols) {
+    const baseUrl = toWsBaseURL(this.descriptor.endpoint);
+    const target = path.startsWith("ws://") || path.startsWith("wss://") ? path : new URL(normalizePath(path), baseUrl).toString();
+    return new WebSocket(target, protocols);
+  }
+  makeRequestUrl(path, query) {
+    const isAbsolute = /^https?:\/\//.test(path);
+    const url = isAbsolute ? new URL(path) : new URL(normalizePath(path), `${this.descriptor.endpoint}/`);
+    if (query) {
+      for (const [key, rawValue] of Object.entries(query)) {
+        if (rawValue === undefined) {
+          continue;
+        }
+        url.searchParams.set(key, String(rawValue));
+      }
+    }
+    return url.toString();
+  }
+  makeHeaders(options) {
+    const headers = new Headers(this.defaults.headers);
+    applyHeaders(headers, options.headers);
+    if (this.defaults.userAgent && !headers.has("User-Agent")) {
+      headers.set("User-Agent", this.defaults.userAgent);
+    }
+    if (options.etag) {
+      headers.set("If-Match", options.etag);
+    }
+    if (options.context?.requireAuthenticated) {
+      headers.set("X-Incus-authenticated", "true");
+    }
+    if (this.defaults.oidcTokens?.accessToken && !headers.has("Authorization")) {
+      headers.set("Authorization", `Bearer ${this.defaults.oidcTokens.accessToken}`);
+    }
+    return headers;
+  }
+}
+
+class UnixSocketTransport {
+  descriptor;
+  defaults;
+  constructor(descriptor, defaults) {
+    this.descriptor = descriptor;
+    this.defaults = defaults;
+  }
+  async request(method, path, options = {}) {
+    const socketPath = this.descriptor.socketPath;
+    if (!socketPath) {
+      throw new Error("[Incus.ts] Missing Unix socket path");
+    }
+    const requestPath = this.makeRequestPath(path, options.query);
+    const headers = this.makeHeaders(options);
+    const bodyInfo = await prepareUnixBody(options.body);
+    if (bodyInfo.contentType && !headers.has("Content-Type")) {
+      headers.set("Content-Type", bodyInfo.contentType);
+    }
+    if (bodyInfo.bodyBytes) {
+      headers.set("Content-Length", String(bodyInfo.bodyBytes.byteLength));
+    }
+    return new Promise((resolve, reject) => {
+      const req = nodeHttpRequest({
+        socketPath,
+        path: requestPath,
+        method: method.toUpperCase(),
+        headers: headersToObject(headers)
+      }, (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => {
+          if (typeof chunk === "string") {
+            chunks.push(Buffer.from(chunk));
+          } else {
+            chunks.push(chunk);
+          }
+        });
+        res.on("end", () => {
+          const bytes = Buffer.concat(chunks);
+          const responseHeaders = nodeHeadersToWebHeaders(res.headers);
+          const contentType = responseHeaders.get("content-type") ?? undefined;
+          const parsed = parseRawBody(contentType, bytes);
+          resolve({
+            status: res.statusCode ?? 0,
+            etag: responseHeaders.get("etag") ?? undefined,
+            headers: responseHeaders,
+            data: parsed
+          });
+        });
+      });
+      req.on("error", reject);
+      if (options.signal) {
+        options.signal.addEventListener("abort", () => {
+          req.destroy(new Error("Request aborted"));
+        }, { once: true });
+      }
+      if (bodyInfo.bodyBytes) {
+        req.write(bodyInfo.bodyBytes);
+      }
+      req.end();
+    });
+  }
+  async websocket(path, protocols) {
+    const socketPath = this.descriptor.socketPath;
+    if (!socketPath) {
+      throw new Error("[Incus.ts] Missing Unix socket path");
+    }
+    const requestPath = path.startsWith("ws://") || path.startsWith("wss://") ? (() => {
+      const url = new URL(path);
+      return `${url.pathname}${url.search}`;
+    })() : normalizePath(path);
+    const headers = this.makeWebsocketHeaders();
+    if (!headers.has("Host")) {
+      headers.set("Host", "incus.local");
+    }
+    const websocketKey = randomBytes(16).toString("base64");
+    headers.set("Connection", "Upgrade");
+    headers.set("Upgrade", "websocket");
+    headers.set("Sec-WebSocket-Version", "13");
+    headers.set("Sec-WebSocket-Key", websocketKey);
+    if (protocols) {
+      const selected = Array.isArray(protocols) ? protocols.join(", ") : protocols;
+      if (selected.length > 0) {
+        headers.set("Sec-WebSocket-Protocol", selected);
+      }
+    }
+    const requestLines = [`GET ${requestPath} HTTP/1.1`];
+    for (const [key, value] of headers.entries()) {
+      requestLines.push(`${key}: ${value}`);
+    }
+    requestLines.push("", "");
+    return new Promise((resolve, reject) => {
+      const socket = nodeNetConnect(socketPath);
+      let handshakeBuffer = Buffer.alloc(0);
+      let settled = false;
+      const finish = (handler, tail) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        handler(socket, tail);
+      };
+      const fail = (error) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        socket.destroy();
+        reject(error);
+      };
+      const timeout = setTimeout(() => {
+        fail(new Error("[Incus.ts] WebSocket opening handshake timed out"));
+      }, 1e4);
+      const cleanup = () => {
+        clearTimeout(timeout);
+        socket.off("connect", onConnect);
+        socket.off("data", onData);
+        socket.off("error", onError);
+        socket.off("close", onClose);
+      };
+      const onConnect = () => {
+        socket.write(requestLines.join(`\r
+`));
+      };
+      const onData = (chunk) => {
+        const bytes = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
+        handshakeBuffer = handshakeBuffer.byteLength === 0 ? Buffer.from(bytes) : Buffer.concat([handshakeBuffer, bytes]);
+        const delimiterIndex = handshakeBuffer.indexOf(`\r
+\r
+`);
+        if (delimiterIndex < 0) {
+          return;
+        }
+        const responseHeaders = handshakeBuffer.subarray(0, delimiterIndex + 4);
+        const leftover = handshakeBuffer.subarray(delimiterIndex + 4);
+        const responseText = responseHeaders.toString("utf8");
+        const lines = responseText.split(`\r
+`);
+        const statusLine = lines.shift() ?? "";
+        const statusMatch = /^HTTP\/1\.[01]\s+(\d+)/.exec(statusLine);
+        const status = statusMatch ? Number.parseInt(statusMatch[1], 10) : 0;
+        if (status !== 101) {
+          fail(new Error(`[Incus.ts] WebSocket upgrade failed with status ${status || "unknown"}`));
+          return;
+        }
+        const parsedHeaders = new Map;
+        for (const line of lines) {
+          if (line.length === 0) {
+            continue;
+          }
+          const separator = line.indexOf(":");
+          if (separator < 0) {
+            continue;
+          }
+          const key = line.slice(0, separator).trim().toLowerCase();
+          const value = line.slice(separator + 1).trim();
+          parsedHeaders.set(key, value);
+        }
+        const upgradeHeader = parsedHeaders.get("upgrade")?.toLowerCase();
+        if (upgradeHeader !== "websocket") {
+          fail(new Error("[Incus.ts] Invalid websocket upgrade response"));
+          return;
+        }
+        const accept = parsedHeaders.get("sec-websocket-accept");
+        const expectedAccept = createHash("sha1").update(`${websocketKey}${WEBSOCKET_GUID}`).digest("base64");
+        if (accept !== expectedAccept) {
+          fail(new Error("[Incus.ts] Invalid websocket accept token"));
+          return;
+        }
+        finish((upgradedSocket, tail) => {
+          const websocket = new UnixSocketWebSocket(upgradedSocket, tail.byteLength > 0 ? tail : undefined);
+          resolve(websocket);
+        }, new Uint8Array(leftover));
+      };
+      const onError = (error) => {
+        fail(error);
+      };
+      const onClose = () => {
+        fail(new Error("[Incus.ts] WebSocket connection closed before upgrade completed"));
+      };
+      socket.on("connect", onConnect);
+      socket.on("data", onData);
+      socket.on("error", onError);
+      socket.on("close", onClose);
+    });
+  }
+  makeRequestPath(path, query) {
+    const url = new URL(normalizePath(path), "http://incus.local");
+    if (query) {
+      for (const [key, rawValue] of Object.entries(query)) {
+        if (rawValue === undefined) {
+          continue;
+        }
+        url.searchParams.set(key, String(rawValue));
+      }
+    }
+    return `${url.pathname}${url.search}`;
+  }
+  makeHeaders(options) {
+    const headers = new Headers(this.defaults.headers);
+    applyHeaders(headers, options.headers);
+    if (this.defaults.userAgent && !headers.has("User-Agent")) {
+      headers.set("User-Agent", this.defaults.userAgent);
+    }
+    if (options.etag) {
+      headers.set("If-Match", options.etag);
+    }
+    if (options.context?.requireAuthenticated) {
+      headers.set("X-Incus-authenticated", "true");
+    }
+    if (this.defaults.oidcTokens?.accessToken && !headers.has("Authorization")) {
+      headers.set("Authorization", `Bearer ${this.defaults.oidcTokens.accessToken}`);
+    }
+    return headers;
+  }
+  makeWebsocketHeaders() {
+    const headers = new Headers(this.defaults.headers);
+    if (this.defaults.userAgent && !headers.has("User-Agent")) {
+      headers.set("User-Agent", this.defaults.userAgent);
+    }
+    if (this.defaults.oidcTokens?.accessToken && !headers.has("Authorization")) {
+      headers.set("Authorization", `Bearer ${this.defaults.oidcTokens.accessToken}`);
+    }
+    return headers;
+  }
+}
+function normalizeEndpoint(endpoint) {
+  if (endpoint.length <= 1) {
+    return endpoint;
+  }
+  return endpoint.endsWith("/") ? endpoint.slice(0, -1) : endpoint;
+}
+function normalizePath(path) {
+  if (path.startsWith("http://") || path.startsWith("https://")) {
+    return path;
+  }
+  return path.startsWith("/") ? path : `/${path}`;
+}
+function toWsBaseURL(endpoint) {
+  const url = new URL(endpoint);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  if (!url.pathname.endsWith("/")) {
+    url.pathname = `${url.pathname}/`;
+  }
+  return url.toString();
+}
+function applyHeaders(target, source) {
+  if (!source) {
+    return;
+  }
+  const toApply = new Headers(source);
+  for (const [key, value] of toApply.entries()) {
+    target.set(key, value);
+  }
+}
+function headersToObject(headers) {
+  const result = {};
+  for (const [key, value] of headers.entries()) {
+    result[key] = value;
+  }
+  return result;
+}
+function nodeHeadersToWebHeaders(headers) {
+  const result = new Headers;
+  for (const [key, value] of Object.entries(headers)) {
+    if (value === undefined) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      result.set(key, value.join(", "));
+    } else {
+      result.set(key, value);
+    }
+  }
+  return result;
+}
+function isIncusEnvelope(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const asRecord = value;
+  return "type" in asRecord && "metadata" in asRecord;
+}
+async function parseResponseBody(response) {
+  if (response.status === 204) {
+    return null;
+  }
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    return response.json();
+  }
+  if (contentType.startsWith("text/") || contentType.includes("application/openmetrics-text")) {
+    return response.text();
+  }
+  return new Uint8Array(await response.arrayBuffer());
+}
+function parseRawBody(contentType, bytes) {
+  if (bytes.byteLength === 0) {
+    return null;
+  }
+  const type = contentType ?? "";
+  if (type.includes("application/json")) {
+    try {
+      return JSON.parse(new TextDecoder().decode(bytes));
+    } catch {
+      return new TextDecoder().decode(bytes);
+    }
+  }
+  if (type.startsWith("text/") || type.includes("application/openmetrics-text")) {
+    return new TextDecoder().decode(bytes);
+  }
+  return bytes;
+}
+function parseFilters(filters) {
+  const translated = [];
+  for (const filter of filters) {
+    if (!filter.includes("=")) {
+      continue;
+    }
+    const [left, right] = filter.split("=", 2);
+    translated.push(`${left} eq ${right}`);
+  }
+  return translated.join(" and ");
+}
+function urlsToResourceNames(matchPathPrefix, urls) {
+  const normalizedPrefix = `${matchPathPrefix.replace(/\/$/, "")}/`;
+  return urls.map((rawUrl) => {
+    const parsed = new URL(rawUrl, "http://incus.local");
+    const index = parsed.pathname.indexOf(normalizedPrefix);
+    if (index < 0) {
+      throw new Error(`[Incus.ts] Unexpected resource URL: ${rawUrl}`);
+    }
+    return decodeURIComponent(parsed.pathname.slice(index + normalizedPrefix.length));
+  });
+}
+function toStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((entry) => typeof entry === "string");
+}
+function toRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return value;
+}
+function toRecordArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((entry) => !!entry && typeof entry === "object").map((entry) => entry);
+}
+function flattenOperationMap(value) {
+  if (Array.isArray(value)) {
+    return toRecordArray(value);
+  }
+  if (!value || typeof value !== "object") {
+    return [];
+  }
+  const out = [];
+  for (const entry of Object.values(value)) {
+    if (Array.isArray(entry)) {
+      out.push(...toRecordArray(entry));
+    }
+  }
+  return out;
+}
+function decodeOperationId(operationValue) {
+  const cleaned = operationValue.split("?")[0] ?? operationValue;
+  const parts = cleaned.split("/").filter(Boolean);
+  return decodeURIComponent(parts[parts.length - 1] ?? operationValue);
+}
+function operationPath(id) {
+  return `/1.0/operations/${encodeURIComponent(id)}`;
+}
+function toReadableStream(data) {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(data);
+      controller.close();
+    }
+  });
+}
+function toBytes(data) {
+  if (data instanceof Uint8Array) {
+    return data;
+  }
+  if (typeof data === "string") {
+    return new TextEncoder().encode(data);
+  }
+  if (data === null || data === undefined) {
+    return new Uint8Array;
+  }
+  return new TextEncoder().encode(JSON.stringify(data));
+}
+function toStringRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === "string") {
+      out[key] = entry;
+    }
+  }
+  return out;
+}
+function parseOperationIdFromEnvelope(result) {
+  if (typeof result.operation === "string" && result.operation.length > 0) {
+    return decodeOperationId(result.operation);
+  }
+  if (result.value && typeof result.value === "object") {
+    const asRecord = result.value;
+    if (typeof asRecord.id === "string" && asRecord.id.length > 0) {
+      return decodeOperationId(asRecord.id);
+    }
+    if (typeof asRecord.operation === "string" && asRecord.operation.length > 0) {
+      return decodeOperationId(asRecord.operation);
+    }
+  }
+  return;
+}
+function assertOperationSuccess(operation, source) {
+  const err = operation.err;
+  if (typeof err === "string" && err.trim().length > 0) {
+    throw new Error(`[Incus.ts] Operation ${source} failed: ${err}`);
+  }
+  const statusCode = operation.status_code;
+  if (typeof statusCode === "number" && statusCode >= 400) {
+    const status = typeof operation.status === "string" ? ` (${operation.status})` : "";
+    throw new Error(`[Incus.ts] Operation ${source} failed with status code ${statusCode}${status}`);
+  }
+}
+function extractExecFds(operationValue) {
+  const record = toRecord(operationValue);
+  const candidates = [
+    record.fds,
+    toRecord(record.metadata).fds,
+    toRecord(toRecord(record.operation).metadata).fds,
+    toRecord(toRecord(record.metadata).operation).fds
+  ];
+  for (const candidate of candidates) {
+    const fds = toStringRecord(candidate);
+    if (Object.keys(fds).length > 0) {
+      return fds;
+    }
+  }
+  return {};
+}
+function getBooleanValue(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "boolean") {
+      return value;
+    }
+  }
+  return;
+}
+function isInteractiveExecRequest(request) {
+  return getBooleanValue(request, ["interactive", "Interactive"]) ?? false;
+}
+function hasWaitForWebsocketFlag(request) {
+  return getBooleanValue(request, [
+    "wait-for-websocket",
+    "wait_for_websocket",
+    "waitForWebsocket",
+    "waitForWS",
+    "WaitForWS"
+  ]) !== undefined;
+}
+function isNodeWebSocket(socket) {
+  return typeof socket.on === "function";
+}
+function addWebSocketMessageListener(socket, listener) {
+  if (isNodeWebSocket(socket) && socket.on && socket.off) {
+    const nodeListener = (data) => {
+      listener(data);
+    };
+    socket.on("message", nodeListener);
+    return () => {
+      socket.off?.("message", nodeListener);
+    };
+  }
+  const domListener = (event) => {
+    const data = event && typeof event === "object" && "data" in event ? event.data : event;
+    listener(data);
+  };
+  socket.addEventListener?.("message", domListener);
+  return () => {
+    socket.removeEventListener?.("message", domListener);
+  };
+}
+function addWebSocketCloseListener(socket, listener) {
+  if (isNodeWebSocket(socket) && socket.on && socket.off) {
+    const nodeListener = () => {
+      listener();
+    };
+    socket.on("close", nodeListener);
+    return () => {
+      socket.off?.("close", nodeListener);
+    };
+  }
+  const domListener = () => {
+    listener();
+  };
+  socket.addEventListener?.("close", domListener);
+  return () => {
+    socket.removeEventListener?.("close", domListener);
+  };
+}
+function addWebSocketErrorListener(socket, listener) {
+  if (isNodeWebSocket(socket) && socket.on && socket.off) {
+    const nodeListener = (error) => {
+      listener(error);
+    };
+    socket.on("error", nodeListener);
+    return () => {
+      socket.off?.("error", nodeListener);
+    };
+  }
+  const domListener = (event) => {
+    listener(event);
+  };
+  socket.addEventListener?.("error", domListener);
+  return () => {
+    socket.removeEventListener?.("error", domListener);
+  };
+}
+function closeWebSocketSafely(socket) {
+  try {
+    socket.close();
+  } catch {}
+}
+async function webSocketDataToBytes(data) {
+  if (data instanceof Uint8Array) {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data);
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  }
+  if (data instanceof Blob) {
+    return new Uint8Array(await data.arrayBuffer());
+  }
+  if (typeof data === "string") {
+    return new TextEncoder().encode(data);
+  }
+  return toBytes(data);
+}
+function streamWebSocketToWritable(socket, output) {
+  const writer = output?.getWriter();
+  let writeChain = Promise.resolve();
+  let finished = false;
+  const detachments = [];
+  const finish = () => {
+    if (finished) {
+      return;
+    }
+    finished = true;
+    for (const detach of detachments) {
+      detach();
+    }
+    if (writer) {
+      writeChain.finally(async () => {
+        try {
+          await writer.close();
+        } catch {}
+        writer.releaseLock();
+      });
+    }
+  };
+  detachments.push(addWebSocketMessageListener(socket, (data) => {
+    if (!writer) {
+      return;
+    }
+    writeChain = writeChain.then(async () => {
+      await writer.write(await webSocketDataToBytes(data));
+    }).catch(() => {});
+  }));
+  detachments.push(addWebSocketCloseListener(socket, finish));
+  detachments.push(addWebSocketErrorListener(socket, finish));
+}
+async function sendToWebSocket(socket, data) {
+  if (isNodeWebSocket(socket)) {
+    await new Promise((resolve, reject) => {
+      socket.send(data, (error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+    return;
+  }
+  socket.send(data);
+}
+async function* toInputChunks(input) {
+  if (input instanceof Uint8Array) {
+    yield input;
+    return;
+  }
+  if (input instanceof ArrayBuffer) {
+    yield new Uint8Array(input);
+    return;
+  }
+  if (ArrayBuffer.isView(input)) {
+    yield new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+    return;
+  }
+  if (input instanceof Blob) {
+    yield new Uint8Array(await input.arrayBuffer());
+    return;
+  }
+  const reader = input.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      if (value) {
+        yield value;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function writeInputToWebSocket(socket, input) {
+  if (!input) {
+    closeWebSocketSafely(socket);
+    return;
+  }
+  try {
+    for await (const chunk of toInputChunks(input)) {
+      await sendToWebSocket(socket, chunk);
+    }
+  } finally {
+    closeWebSocketSafely(socket);
+  }
+}
+function parseFileHeaders(headers) {
+  if (!headers) {
+    return {};
+  }
+  const uidRaw = headers.get("x-incus-uid");
+  const gidRaw = headers.get("x-incus-gid");
+  const modeRaw = headers.get("x-incus-mode");
+  const typeRaw = headers.get("x-incus-type");
+  return {
+    uid: uidRaw ? Number.parseInt(uidRaw, 10) : undefined,
+    gid: gidRaw ? Number.parseInt(gidRaw, 10) : undefined,
+    mode: modeRaw ? Number.parseInt(modeRaw, 8) : undefined,
+    type: typeRaw ?? undefined
+  };
+}
+function createNotImplementedProxy(path) {
+  const fn = (..._args) => Promise.reject(new Error(`[Incus.ts] ${path.join(".")}() is not implemented yet`));
+  return new Proxy(fn, {
+    get(_target, property) {
+      if (property === "then") {
+        return;
+      }
+      if (typeof property === "symbol") {
+        return;
+      }
+      return createNotImplementedProxy([...path, String(property)]);
+    },
+    apply() {
+      return Promise.reject(new Error(`[Incus.ts] ${path.join(".")}() is not implemented yet`));
+    }
+  });
+}
+function createApiWithFallback(root, implemented) {
+  return new Proxy(implemented, {
+    get(target, property, receiver) {
+      if (typeof property === "symbol") {
+        return Reflect.get(target, property, receiver);
+      }
+      if (Reflect.has(target, property)) {
+        return Reflect.get(target, property, receiver);
+      }
+      return createNotImplementedProxy([root, String(property)]);
+    }
+  });
+}
+function createRemoteOperationFromTarget(targetOperation) {
+  return {
+    wait: async () => {
+      if (targetOperation) {
+        await targetOperation.wait();
+      }
+    },
+    cancelTarget: async () => {
+      if (targetOperation) {
+        await targetOperation.cancel();
+      }
+    },
+    target: async () => {
+      if (!targetOperation) {
+        return null;
+      }
+      return targetOperation.refresh();
+    },
+    onUpdate: async (handler) => {
+      if (!targetOperation) {
+        return async () => {};
+      }
+      return targetOperation.onUpdate(handler);
+    }
+  };
+}
+function prepareBody(body) {
+  if (body === undefined || body === null) {
+    return { body: undefined };
+  }
+  if (body instanceof Blob || body instanceof ArrayBuffer || ArrayBuffer.isView(body) || body instanceof ReadableStream || typeof body === "string" || body instanceof URLSearchParams || body instanceof FormData) {
+    return { body };
+  }
+  return {
+    body: JSON.stringify(body),
+    contentType: "application/json"
+  };
+}
+async function prepareUnixBody(body) {
+  if (body === undefined || body === null) {
+    return {};
+  }
+  if (typeof body === "string") {
+    return { bodyBytes: new TextEncoder().encode(body), contentType: "text/plain" };
+  }
+  if (body instanceof Uint8Array) {
+    return { bodyBytes: body };
+  }
+  if (body instanceof ArrayBuffer) {
+    return { bodyBytes: new Uint8Array(body) };
+  }
+  if (ArrayBuffer.isView(body)) {
+    return { bodyBytes: new Uint8Array(body.buffer, body.byteOffset, body.byteLength) };
+  }
+  if (body instanceof Blob) {
+    return { bodyBytes: new Uint8Array(await body.arrayBuffer()) };
+  }
+  if (body instanceof ReadableStream) {
+    throw new Error("[Incus.ts] ReadableStream body over Unix socket is not implemented yet");
+  }
+  return {
+    bodyBytes: new TextEncoder().encode(JSON.stringify(body)),
+    contentType: "application/json"
+  };
+}
+
+class IncusImageClient {
+  transport;
+  endpoint;
+  options;
+  connection;
+  images;
+  raw;
+  contextState;
+  kind;
+  serverSnapshot;
+  constructor(transport, endpoint, options = {}, context = {}, kind = "incus") {
+    this.transport = transport;
+    this.endpoint = endpoint;
+    this.options = options;
+    this.contextState = context;
+    this.kind = kind;
+    this.connection = this.createConnectionApi();
+    this.raw = this.createRawApi();
+    this.images = this.createImagesApi();
+  }
+  get context() {
+    return this.contextState;
+  }
+  disconnect() {
+    this.transport.close?.();
+  }
+  async requestTransport(method, path, options = {}) {
+    const { applyContext = true, ...rest } = options;
+    return this.transport.request(method, path, {
+      ...rest,
+      context: applyContext ? this.contextState : undefined
+    });
+  }
+  async requestEnvelope(method, path, options = {}) {
+    const response = await this.requestTransport(method, path, options);
+    const payload = response.data;
+    if (isIncusEnvelope(payload)) {
+      if (payload.type === "error" || response.status >= 400) {
+        throw new IncusApiError(payload.error ?? `Incus request failed (${response.status})`, response.status, {
+          statusCode: payload.status_code,
+          errorCode: payload.error_code,
+          details: payload.metadata
+        });
+      }
+      return {
+        value: payload.metadata,
+        etag: response.etag,
+        operation: payload.operation,
+        status: response.status,
+        headers: response.headers
+      };
+    }
+    if (response.status >= 400) {
+      throw new IncusApiError(typeof payload === "string" ? payload : `Incus request failed (${response.status})`, response.status, { details: payload });
+    }
+    return {
+      value: payload,
+      etag: response.etag,
+      status: response.status,
+      headers: response.headers
+    };
+  }
+  async requestBinary(method, path, options = {}) {
+    const response = await this.requestTransport(method, path, options);
+    const payload = response.data;
+    if (isIncusEnvelope(payload)) {
+      if (payload.type === "error" || response.status >= 400) {
+        throw new IncusApiError(payload.error ?? `Incus request failed (${response.status})`, response.status, {
+          statusCode: payload.status_code,
+          errorCode: payload.error_code,
+          details: payload.metadata
+        });
+      }
+      return {
+        value: toBytes(payload.metadata),
+        etag: response.etag,
+        operation: payload.operation,
+        status: response.status,
+        headers: response.headers
+      };
+    }
+    if (response.status >= 400) {
+      throw new IncusApiError(typeof payload === "string" ? payload : `Incus request failed (${response.status})`, response.status, { details: payload });
+    }
+    return {
+      value: toBytes(payload),
+      etag: response.etag,
+      status: response.status,
+      headers: response.headers
+    };
+  }
+  async createOperationFromRequest(method, path, options = {}) {
+    const result = await this.requestEnvelope(method, path, options);
+    return this.createOperationFromEnvelopeResult(method, path, result);
+  }
+  createOperationFromEnvelopeResult(method, path, result) {
+    const operationId = parseOperationIdFromEnvelope(result);
+    if (!operationId) {
+      throw new Error(`[Incus.ts] Missing operation id in response for ${method.toUpperCase()} ${path}`);
+    }
+    return this.createOperation(operationId);
+  }
+  createOperation(id) {
+    return {
+      id,
+      wait: async (options = {}) => {
+        const result = await this.requestEnvelope("GET", `${operationPath(id)}/wait`, {
+          query: {
+            timeout: options.timeoutSeconds ?? -1
+          },
+          signal: options.signal
+        });
+        const operation = toRecord(result.value);
+        assertOperationSuccess(operation, id);
+        return operation;
+      },
+      cancel: async () => {
+        await this.requestEnvelope("DELETE", operationPath(id));
+      },
+      refresh: async () => {
+        const result = await this.requestEnvelope("GET", operationPath(id));
+        return toRecord(result.value);
+      },
+      websocket: async (secret) => {
+        return this.openWebsocket(`${operationPath(id)}/websocket?secret=${encodeURIComponent(secret)}`);
+      },
+      onUpdate: async (handler) => {
+        const timer = setInterval(async () => {
+          try {
+            const operation = await this.requestEnvelope("GET", operationPath(id));
+            handler(toRecord(operation.value));
+          } catch {}
+        }, 1000);
+        return async () => {
+          clearInterval(timer);
+        };
+      }
+    };
+  }
+  async openWebsocket(path, options = {}) {
+    if (!this.transport.websocket) {
+      throw new Error("[Incus.ts] Transport does not support websocket connections");
+    }
+    let finalPath = path;
+    if (options.applyContext !== false) {
+      const url = new URL(normalizePath(path), "http://incus.local");
+      if (this.context.target && !url.searchParams.has("target")) {
+        url.searchParams.set("target", this.context.target);
+      }
+      if (this.context.project && !url.searchParams.has("project") && !url.searchParams.has("all-projects")) {
+        url.searchParams.set("project", this.context.project);
+      }
+      finalPath = `${url.pathname}${url.search}`;
+    }
+    return this.transport.websocket(finalPath);
+  }
+  async getServerSnapshot() {
+    if (this.serverSnapshot) {
+      return this.serverSnapshot;
+    }
+    if (this.kind === "simple-streams" || this.kind === "incus-public") {
+      return;
+    }
+    try {
+      const server = await this.requestEnvelope("GET", "/1.0");
+      this.serverSnapshot = toRecord(server.value);
+      return this.serverSnapshot;
+    } catch {
+      return;
+    }
+  }
+  createConnectionApi() {
+    return createApiWithFallback("connection", {
+      info: async () => {
+        const server = await this.getServerSnapshot();
+        const env = toRecord(server?.environment);
+        const addresses = Array.isArray(env.addresses) ? env.addresses.filter((entry) => typeof entry === "string") : [];
+        const httpsAddresses = addresses.filter((entry) => !entry.startsWith(":")).map((entry) => `https://${entry}`);
+        const socketPath = this.endpoint.startsWith("unix://") ? this.endpoint.replace(/^unix:\/\//, "") : undefined;
+        return {
+          addresses: httpsAddresses,
+          certificate: typeof env.certificate === "string" ? env.certificate : undefined,
+          protocol: this.kind === "simple-streams" ? "simplestreams" : "incus",
+          url: this.endpoint.startsWith("unix://") ? undefined : this.endpoint,
+          socketPath,
+          project: this.context.project ?? "default",
+          target: this.context.target ?? (typeof env.server_name === "string" ? env.server_name : undefined)
+        };
+      },
+      httpClient: async () => this.options.fetch ?? fetch,
+      doHttp: async (request) => {
+        const fetchImpl = this.options.fetch ?? fetch;
+        return fetchImpl(request);
+      },
+      disconnect: () => this.disconnect()
+    });
+  }
+  createRawApi() {
+    return createApiWithFallback("raw", {
+      query: async (method, path, body, options = {}) => {
+        const result = await this.requestEnvelope(method, path, {
+          body,
+          etag: options.etag,
+          applyContext: false
+        });
+        return { value: result.value, etag: result.etag };
+      },
+      websocket: async (path) => this.openWebsocket(path, { applyContext: false }),
+      operation: async (method, path, body, options = {}) => {
+        return this.createOperationFromRequest(method, path, {
+          body,
+          etag: options.etag,
+          applyContext: false
+        });
+      }
+    });
+  }
+  createImageAliasesApi() {
+    return createApiWithFallback("images.aliases", {
+      list: async () => {
+        const result = await this.requestEnvelope("GET", "/1.0/images/aliases", { query: { recursion: 1 } });
+        return toRecordArray(result.value);
+      },
+      names: async () => {
+        const result = await this.requestEnvelope("GET", "/1.0/images/aliases");
+        return urlsToResourceNames("/images/aliases", toStringArray(result.value));
+      },
+      get: async (name) => {
+        const result = await this.requestEnvelope("GET", `/1.0/images/aliases/${encodeURIComponent(name)}`);
+        return { value: toRecord(result.value), etag: result.etag };
+      },
+      getArchitectures: async (name) => {
+        const alias = await this.requestEnvelope("GET", `/1.0/images/aliases/${encodeURIComponent(name)}`);
+        const target = toRecord(alias.value).target;
+        if (typeof target !== "string") {
+          return {};
+        }
+        const image = await this.requestEnvelope("GET", `/1.0/images/${encodeURIComponent(target)}`);
+        const architecture = toRecord(image.value).architecture;
+        if (typeof architecture !== "string") {
+          return {};
+        }
+        return { [architecture]: toRecord(alias.value) };
+      },
+      create: async (alias) => {
+        await this.requestEnvelope("POST", "/1.0/images/aliases", { body: alias });
+      },
+      update: async (name, alias, options = {}) => {
+        await this.requestEnvelope("PUT", `/1.0/images/aliases/${encodeURIComponent(name)}`, { body: alias, etag: options.etag });
+      },
+      rename: async (name, alias) => {
+        await this.requestEnvelope("POST", `/1.0/images/aliases/${encodeURIComponent(name)}`, { body: alias });
+      },
+      remove: async (name) => {
+        await this.requestEnvelope("DELETE", `/1.0/images/aliases/${encodeURIComponent(name)}`);
+      }
+    });
+  }
+  createImagesApi() {
+    if (this.kind === "simple-streams") {
+      return createApiWithFallback("images", {
+        aliases: createNotImplementedProxy(["images", "aliases"])
+      });
+    }
+    return createApiWithFallback("images", {
+      list: async (options = {}) => {
+        const query = {
+          recursion: 1
+        };
+        if (options.allProjects) {
+          query["all-projects"] = true;
+        }
+        if (options.filter && options.filter.length > 0) {
+          query.filter = parseFilters(options.filter);
+        }
+        const result = await this.requestEnvelope("GET", "/1.0/images", {
+          query
+        });
+        return toRecordArray(result.value);
+      },
+      fingerprints: async (options = {}) => {
+        if (options.filter?.length || options.allProjects) {
+          const images = await this.images.list(options);
+          return images.map((image) => image.fingerprint).filter((entry) => typeof entry === "string");
+        }
+        const result = await this.requestEnvelope("GET", "/1.0/images");
+        return urlsToResourceNames("/images", toStringArray(result.value));
+      },
+      get: async (fingerprint, options = {}) => {
+        const result = await this.requestEnvelope("GET", `/1.0/images/${encodeURIComponent(fingerprint)}`, {
+          query: options.secret ? { secret: options.secret } : undefined
+        });
+        return { value: toRecord(result.value), etag: result.etag };
+      },
+      create: async (image, upload) => {
+        const body = upload ? { ...image, upload } : image;
+        return this.createOperationFromRequest("POST", "/1.0/images", { body });
+      },
+      copyFrom: async (_source, _image, _options) => createRemoteOperationFromTarget(null),
+      update: async (fingerprint, image, options = {}) => {
+        await this.requestEnvelope("PUT", `/1.0/images/${encodeURIComponent(fingerprint)}`, {
+          body: image,
+          etag: options.etag
+        });
+      },
+      remove: async (fingerprint) => {
+        return this.createOperationFromRequest("DELETE", `/1.0/images/${encodeURIComponent(fingerprint)}`);
+      },
+      refresh: async (fingerprint) => {
+        return this.createOperationFromRequest("POST", `/1.0/images/${encodeURIComponent(fingerprint)}/refresh`);
+      },
+      createSecret: async (fingerprint) => {
+        return this.createOperationFromRequest("POST", `/1.0/images/${encodeURIComponent(fingerprint)}/secret`);
+      },
+      export: async (fingerprint, request) => {
+        return this.createOperationFromRequest("POST", `/1.0/images/${encodeURIComponent(fingerprint)}/export`, { body: request ?? {} });
+      },
+      aliases: this.createImageAliasesApi()
+    });
+  }
+}
+
+class IncusClient extends IncusImageClient {
+  server;
+  certificates;
+  instances;
+  events;
+  metadata;
+  networks;
+  operations;
+  profiles;
+  projects;
+  storage;
+  cluster;
+  warnings;
+  oidc;
+  constructor(transport, endpoint, options = {}, context = {}, kind = "incus") {
+    super(transport, endpoint, options, context, kind);
+    this.server = this.createServerApi();
+    this.certificates = createNotImplementedProxy(["certificates"]);
+    this.instances = this.createInstancesApi();
+    this.events = createNotImplementedProxy(["events"]);
+    this.metadata = createApiWithFallback("metadata", {
+      configuration: async () => {
+        const result = await this.requestEnvelope("GET", "/1.0/metadata/configuration");
+        return toRecord(result.value);
+      }
+    });
+    this.networks = createNotImplementedProxy(["networks"]);
+    this.operations = this.createOperationsApi();
+    this.profiles = createNotImplementedProxy(["profiles"]);
+    this.projects = createNotImplementedProxy(["projects"]);
+    this.storage = createNotImplementedProxy(["storage"]);
+    this.cluster = createNotImplementedProxy(["cluster"]);
+    this.warnings = createNotImplementedProxy(["warnings"]);
+    this.oidc = createApiWithFallback("oidc", {
+      tokens: async () => {
+        if (!this.options.oidcTokens) {
+          return null;
+        }
+        return { ...this.options.oidcTokens };
+      }
+    });
+  }
+  withContext(contextPatch) {
+    return new IncusClient(this.transport, this.endpoint, this.options, {
+      ...this.context,
+      ...contextPatch
+    }, this.kind);
+  }
+  project(name) {
+    return this.withContext({ project: name });
+  }
+  target(name) {
+    return this.withContext({ target: name });
+  }
+  requireAuthenticated(authenticated = true) {
+    return this.withContext({ requireAuthenticated: authenticated });
+  }
+  createServerApi() {
+    return createApiWithFallback("server", {
+      metrics: async () => {
+        const result = await this.requestEnvelope("GET", "/1.0/metrics");
+        return typeof result.value === "string" ? result.value : new TextDecoder().decode(toBytes(result.value));
+      },
+      get: async () => {
+        const result = await this.requestEnvelope("GET", "/1.0");
+        return { value: toRecord(result.value), etag: result.etag };
+      },
+      resources: async () => {
+        const result = await this.requestEnvelope("GET", "/1.0/resources");
+        return toRecord(result.value);
+      },
+      update: async (server, options = {}) => {
+        await this.requestEnvelope("PUT", "/1.0", {
+          body: server,
+          etag: options.etag
+        });
+      },
+      applyPreseed: async (config) => {
+        await this.requestEnvelope("PUT", "/1.0", { body: config });
+      },
+      hasExtension: async (extension) => {
+        const result = await this.requestEnvelope("GET", "/1.0");
+        const server = toRecord(result.value);
+        const apiExtensions = server.api_extensions;
+        if (!Array.isArray(apiExtensions)) {
+          return false;
+        }
+        return apiExtensions.some((entry) => entry === extension);
+      },
+      isClustered: async () => {
+        const result = await this.requestEnvelope("GET", "/1.0");
+        const env = toRecord(toRecord(result.value).environment);
+        return env.server_clustered === true;
+      }
+    });
+  }
+  createOperationsApi() {
+    return createApiWithFallback("operations", {
+      uuids: async () => {
+        const result = await this.requestEnvelope("GET", "/1.0/operations");
+        return urlsToResourceNames("/operations", toStringArray(result.value));
+      },
+      list: async (options = {}) => {
+        const result = await this.requestEnvelope("GET", "/1.0/operations", {
+          query: {
+            recursion: 1,
+            "all-projects": options.allProjects ? "true" : undefined
+          }
+        });
+        return flattenOperationMap(result.value);
+      },
+      get: async (uuid) => {
+        const result = await this.requestEnvelope("GET", `/1.0/operations/${encodeURIComponent(uuid)}`);
+        return { value: toRecord(result.value), etag: result.etag };
+      },
+      wait: async (uuid, timeoutSeconds = -1) => {
+        const result = await this.requestEnvelope("GET", `/1.0/operations/${encodeURIComponent(uuid)}/wait`, {
+          query: { timeout: timeoutSeconds }
+        });
+        const operation = toRecord(result.value);
+        assertOperationSuccess(operation, uuid);
+        return { value: operation, etag: result.etag };
+      },
+      waitWithSecret: async (uuid, secret, timeoutSeconds = -1) => {
+        const result = await this.requestEnvelope("GET", `/1.0/operations/${encodeURIComponent(uuid)}/wait`, {
+          query: {
+            secret,
+            timeout: timeoutSeconds
+          }
+        });
+        const operation = toRecord(result.value);
+        assertOperationSuccess(operation, uuid);
+        return { value: operation, etag: result.etag };
+      },
+      websocket: async (uuid, secret) => {
+        const query = secret ? `?secret=${encodeURIComponent(secret)}` : "";
+        return this.openWebsocket(`/1.0/operations/${encodeURIComponent(uuid)}/websocket${query}`);
+      },
+      remove: async (uuid) => {
+        await this.requestEnvelope("DELETE", `/1.0/operations/${encodeURIComponent(uuid)}`);
+      }
+    });
+  }
+  shouldAttachExecIO(options) {
+    return Boolean(options?.stdin || options?.stdout || options?.stderr || options?.onControl);
+  }
+  async getExecFds(operation, initialOperationValue) {
+    const initial = extractExecFds(initialOperationValue);
+    if (Object.keys(initial).length > 0) {
+      return initial;
+    }
+    const refreshed = await operation.refresh();
+    return extractExecFds(refreshed);
+  }
+  async attachExecWebsockets(operation, request, options, initialOperationValue) {
+    const fds = await this.getExecFds(operation, initialOperationValue ?? {});
+    if (Object.keys(fds).length === 0) {
+      return;
+    }
+    const openChannel = async (name) => {
+      const secret = fds[name];
+      if (!secret) {
+        return null;
+      }
+      const socket = await operation.websocket(secret);
+      if (options?.signal) {
+        options.signal.addEventListener("abort", () => {
+          closeWebSocketSafely(socket);
+        }, { once: true });
+      }
+      return socket;
+    };
+    const controlSocket = await openChannel("control");
+    if (controlSocket) {
+      streamWebSocketToWritable(controlSocket);
+      options?.onControl?.(controlSocket);
+    }
+    if (isInteractiveExecRequest(request)) {
+      const interactiveSocket = await openChannel("0");
+      if (!interactiveSocket) {
+        return;
+      }
+      streamWebSocketToWritable(interactiveSocket, options?.stdout);
+      writeInputToWebSocket(interactiveSocket, options?.stdin);
+      return;
+    }
+    const stdinSocket = await openChannel("0");
+    if (stdinSocket) {
+      writeInputToWebSocket(stdinSocket, options?.stdin);
+    }
+    const stdoutSocket = await openChannel("1");
+    if (stdoutSocket) {
+      streamWebSocketToWritable(stdoutSocket, options?.stdout);
+    }
+    const stderrSocket = await openChannel("2");
+    if (stderrSocket) {
+      streamWebSocketToWritable(stderrSocket, options?.stderr);
+    }
+  }
+  createInstancesApi() {
+    const logs = createApiWithFallback("instances.logs", {
+      list: async (instanceName) => {
+        const result = await this.requestEnvelope("GET", `/1.0/instances/${encodeURIComponent(instanceName)}/logs`);
+        return urlsToResourceNames(`/instances/${encodeURIComponent(instanceName)}/logs`, toStringArray(result.value));
+      },
+      get: async (instanceName, filename) => {
+        const result = await this.requestBinary("GET", `/1.0/instances/${encodeURIComponent(instanceName)}/logs/${encodeURIComponent(filename)}`);
+        return toReadableStream(result.value);
+      },
+      remove: async (instanceName, filename) => {
+        await this.requestEnvelope("DELETE", `/1.0/instances/${encodeURIComponent(instanceName)}/logs/${encodeURIComponent(filename)}`);
+      },
+      getConsole: async (instanceName) => {
+        const result = await this.requestBinary("GET", `/1.0/instances/${encodeURIComponent(instanceName)}/console`);
+        return toReadableStream(result.value);
+      },
+      removeConsole: async (instanceName) => {
+        await this.requestEnvelope("DELETE", `/1.0/instances/${encodeURIComponent(instanceName)}/console`);
+      }
+    });
+    const files = createApiWithFallback("instances.files", {
+      get: async (instanceName, path) => {
+        const response = await this.requestTransport("GET", `/1.0/instances/${encodeURIComponent(instanceName)}/files`, {
+          query: { path }
+        });
+        const headers = parseFileHeaders(response.headers);
+        if ((headers.type ?? "").toLowerCase() === "directory") {
+          const decoded = isIncusEnvelope(response.data) ? toStringArray(response.data.metadata) : [];
+          return {
+            stream: toReadableStream(new Uint8Array),
+            uid: headers.uid,
+            gid: headers.gid,
+            mode: headers.mode,
+            type: headers.type,
+            entries: decoded
+          };
+        }
+        if (response.status >= 400) {
+          if (isIncusEnvelope(response.data)) {
+            throw new IncusApiError(response.data.error ?? `Incus request failed (${response.status})`, response.status, {
+              statusCode: response.data.status_code,
+              errorCode: response.data.error_code,
+              details: response.data.metadata
+            });
+          }
+          throw new IncusApiError(`Incus request failed (${response.status})`, response.status, {
+            details: response.data
+          });
+        }
+        return {
+          stream: toReadableStream(toBytes(response.data)),
+          uid: headers.uid,
+          gid: headers.gid,
+          mode: headers.mode,
+          type: headers.type
+        };
+      },
+      put: async (instanceName, path, options) => {
+        const headers = new Headers;
+        if (options.uid !== undefined) {
+          headers.set("X-Incus-uid", String(options.uid));
+        }
+        if (options.gid !== undefined) {
+          headers.set("X-Incus-gid", String(options.gid));
+        }
+        if (options.mode !== undefined) {
+          headers.set("X-Incus-mode", options.mode.toString(8).padStart(4, "0"));
+        }
+        if (options.type) {
+          headers.set("X-Incus-type", options.type);
+        }
+        if (options.writeMode) {
+          headers.set("X-Incus-write", options.writeMode);
+        }
+        await this.requestEnvelope("POST", `/1.0/instances/${encodeURIComponent(instanceName)}/files`, {
+          query: { path },
+          body: options.content,
+          headers
+        });
+      },
+      remove: async (instanceName, path) => {
+        await this.requestEnvelope("DELETE", `/1.0/instances/${encodeURIComponent(instanceName)}/files`, {
+          query: { path }
+        });
+      },
+      sftp: async () => {
+        throw new Error("[Incus.ts] Instance SFTP helper is not implemented yet");
+      }
+    });
+    return createApiWithFallback("instances", {
+      names: async (options = {}) => {
+        if (options.allProjects) {
+          const query2 = {
+            recursion: 1,
+            "all-projects": "true"
+          };
+          if (options.type) {
+            query2["instance-type"] = options.type;
+          }
+          const result2 = await this.requestEnvelope("GET", "/1.0/instances", { query: query2 });
+          const records = toRecordArray(result2.value);
+          const grouped = {};
+          for (const record of records) {
+            const project = typeof record.project === "string" ? record.project : "default";
+            const name = typeof record.name === "string" ? record.name : undefined;
+            if (!name) {
+              continue;
+            }
+            grouped[project] ??= [];
+            grouped[project].push(name);
+          }
+          return grouped;
+        }
+        const query = {};
+        if (options.type) {
+          query["instance-type"] = options.type;
+        }
+        const result = await this.requestEnvelope("GET", "/1.0/instances", {
+          query
+        });
+        return urlsToResourceNames("/instances", toStringArray(result.value));
+      },
+      list: async (options = {}) => {
+        const query = {
+          recursion: options.full ? 2 : 1
+        };
+        if (options.type) {
+          query["instance-type"] = options.type;
+        }
+        if (options.allProjects) {
+          query["all-projects"] = "true";
+        }
+        if (options.filter && options.filter.length > 0) {
+          query.filter = parseFilters(options.filter);
+        }
+        const result = await this.requestEnvelope("GET", "/1.0/instances", { query });
+        return toRecordArray(result.value);
+      },
+      get: async (name, options = {}) => {
+        const result = await this.requestEnvelope("GET", `/1.0/instances/${encodeURIComponent(name)}`, {
+          query: options.full ? { recursion: 1 } : undefined
+        });
+        return { value: toRecord(result.value), etag: result.etag };
+      },
+      create: async (instance) => {
+        return this.createOperationFromRequest("POST", "/1.0/instances", { body: instance });
+      },
+      createFromImage: async (_source, _image, _request) => createRemoteOperationFromTarget(null),
+      createFromBackup: async (args) => {
+        return this.createOperationFromRequest("POST", "/1.0/instances", { body: args });
+      },
+      copyFrom: async (_source, _instance, _options) => createRemoteOperationFromTarget(null),
+      update: async (name, instance, options = {}) => {
+        return this.createOperationFromRequest("PUT", `/1.0/instances/${encodeURIComponent(name)}`, {
+          body: instance,
+          etag: options.etag
+        });
+      },
+      rename: async (name, request) => {
+        return this.createOperationFromRequest("POST", `/1.0/instances/${encodeURIComponent(name)}`, { body: request });
+      },
+      migrate: async (name, request) => {
+        return this.createOperationFromRequest("POST", `/1.0/instances/${encodeURIComponent(name)}`, { body: request });
+      },
+      remove: async (name) => {
+        return this.createOperationFromRequest("DELETE", `/1.0/instances/${encodeURIComponent(name)}`);
+      },
+      updateMany: async (state, options = {}) => {
+        return this.createOperationFromRequest("PUT", "/1.0/instances", {
+          body: state,
+          etag: options.etag
+        });
+      },
+      rebuild: async (name, request) => {
+        return this.createOperationFromRequest("POST", `/1.0/instances/${encodeURIComponent(name)}/rebuild`, { body: request });
+      },
+      rebuildFromImage: async (_source, _image, _name, _request) => createRemoteOperationFromTarget(null),
+      state: async (name) => {
+        const result = await this.requestEnvelope("GET", `/1.0/instances/${encodeURIComponent(name)}/state`);
+        return { value: toRecord(result.value), etag: result.etag };
+      },
+      setState: async (name, state, options = {}) => {
+        return this.createOperationFromRequest("PUT", `/1.0/instances/${encodeURIComponent(name)}/state`, {
+          body: state,
+          etag: options.etag
+        });
+      },
+      access: async (name) => {
+        const result = await this.requestEnvelope("GET", `/1.0/instances/${encodeURIComponent(name)}/access`);
+        return toRecord(result.value);
+      },
+      exec: async (name, request, options) => {
+        const path = `/1.0/instances/${encodeURIComponent(name)}/exec`;
+        const body = { ...request };
+        const shouldAttachIO = this.shouldAttachExecIO(options);
+        if (shouldAttachIO && !hasWaitForWebsocketFlag(body)) {
+          body["wait-for-websocket"] = true;
+        }
+        const result = await this.requestEnvelope("POST", path, {
+          body,
+          signal: options?.signal
+        });
+        const operation = this.createOperationFromEnvelopeResult("POST", path, result);
+        if (shouldAttachIO) {
+          await this.attachExecWebsockets(operation, body, options, result.value);
+        }
+        return operation;
+      },
+      console: async (name, request, options) => {
+        return this.createOperationFromRequest("POST", `/1.0/instances/${encodeURIComponent(name)}/console`, {
+          body: request,
+          signal: options?.signal
+        });
+      },
+      consoleDynamic: async () => {
+        throw new Error("[Incus.ts] Dynamic console attach is not implemented yet");
+      },
+      metadata: async (name) => {
+        const result = await this.requestEnvelope("GET", `/1.0/instances/${encodeURIComponent(name)}/metadata`);
+        return { value: toRecord(result.value), etag: result.etag };
+      },
+      updateMetadata: async (name, metadata, options = {}) => {
+        await this.requestEnvelope("PUT", `/1.0/instances/${encodeURIComponent(name)}/metadata`, {
+          body: metadata,
+          etag: options.etag
+        });
+      },
+      debugMemory: async (name, format = "elf") => {
+        const result = await this.requestBinary("GET", `/1.0/instances/${encodeURIComponent(name)}/debug/memory`, {
+          query: {
+            format,
+            "instance-type": "virtual-machine"
+          }
+        });
+        return toReadableStream(result.value);
+      },
+      logs,
+      files,
+      templates: createNotImplementedProxy(["instances", "templates"]),
+      snapshots: createNotImplementedProxy(["instances", "snapshots"]),
+      backups: createNotImplementedProxy(["instances", "backups"])
+    });
+  }
+}
+
+class Incus {
+  static async connect(endpoint, options = {}) {
+    const normalized = normalizeEndpoint(endpoint);
+    const descriptor = { kind: "incus", endpoint: normalized };
+    return new IncusClient(new FetchTransport(descriptor, options), normalized, options, {}, "incus");
+  }
+  static async connectHttp(options = {}) {
+    const endpoint = normalizeEndpoint(options.endpoint ?? "https://custom.socket");
+    const descriptor = { kind: "incus-http", endpoint };
+    return new IncusClient(new FetchTransport(descriptor, options), endpoint, options, {}, "incus-http");
+  }
+  static async connectUnix(options = {}) {
+    const socketPath = options.socketPath ?? "/var/lib/incus/unix.socket";
+    const endpoint = `unix://${socketPath}`;
+    const descriptor = {
+      kind: "incus-unix",
+      endpoint,
+      socketPath
+    };
+    return new IncusClient(new UnixSocketTransport(descriptor, options), endpoint, options, {}, "incus-unix");
+  }
+  static async connectPublic(endpoint, options = {}) {
+    const normalized = normalizeEndpoint(endpoint);
+    const descriptor = {
+      kind: "incus-public",
+      endpoint: normalized
+    };
+    return new IncusImageClient(new FetchTransport(descriptor, options), normalized, options, {}, "incus-public");
+  }
+  static async connectSimpleStreams(endpoint, options = {}) {
+    const normalized = normalizeEndpoint(endpoint);
+    const descriptor = {
+      kind: "simple-streams",
+      endpoint: normalized
+    };
+    return new IncusImageClient(new FetchTransport(descriptor, options), normalized, options, {}, "simple-streams");
+  }
+  static fromTransport(endpoint, transport, options = {}) {
+    return new IncusClient(transport, normalizeEndpoint(endpoint), options);
+  }
+  static fromImageTransport(endpoint, transport, options = {}) {
+    return new IncusImageClient(transport, normalizeEndpoint(endpoint), options);
+  }
+}
+export {
+  IncusImageClient,
+  IncusClient,
+  IncusApiError,
+  Incus
+};
+
+//# debugId=841E8449BC239A1264756E2164756E21
+//# sourceMappingURL=index.js.map