privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-CG47HBKU.mjs

@@ -0,0 +1,435 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/pi-background-tasks/src/core/host-protocol.ts?ext=pi-background-tasks
+var HOST_REQUEST_CHANNEL = "pi-background-tasks:host:request:v1";
+var HOST_RESPONSE_CHANNEL = "pi-background-tasks:host:response:v1";
+var HOST_CHANGED_CHANNEL = "pi-background-tasks:host:changed:v1";
+var HOST_REQUEST_SCHEMA = "pi-background-tasks.host-request.v1";
+var HOST_RESPONSE_SCHEMA = "pi-background-tasks.host-response.v1";
+var HOST_CHANGED_SCHEMA = "pi-background-tasks.host-changed.v1";
+var HOST_API_VERSION = 1;
+var HOST_MAX_PAGE_SIZE = 50;
+var HOST_DEFAULT_PAGE_SIZE = 50;
+var HOST_MAX_LOG_BYTES = 65536;
+var HOST_DEFAULT_LOG_BYTES = 32768;
+var HOST_MAX_INLINE_RESULT_BYTES = 49152;
+var HOST_MAX_FRAME_BYTES = 256 * 1024;
+var HOST_MAX_ERROR_CHARS = 512;
+var HOST_MAX_REQUEST_ID_CHARS = 200;
+var HOST_MAX_CLIENT_ID_CHARS = 128;
+var HOST_MAX_TASK_ID_CHARS = 128;
+var HOST_MAX_CURSOR_CHARS = 512;
+var HOST_MAX_TASK_IDS = 1e3;
+var HOST_MAX_LEASES = 8;
+var HOST_REPLAY_CACHE_SIZE = 64;
+var HOST_MAX_IN_FLIGHT = 16;
+var HOST_CHANGE_COALESCE_MS = 100;
+var HOST_LIST_PREVIEW_CHARS = 512;
+var HOST_OPERATIONS = [
+  "capabilities",
+  "subscribe",
+  "unsubscribe",
+  "list",
+  "detail",
+  "logs",
+  "stop",
+  "stop_all",
+  "rerun",
+  "result",
+  "mark_seen"
+];
+var HOST_CAPABILITIES = Object.freeze({
+  api_version: 1,
+  operations: HOST_OPERATIONS,
+  max_page_size: HOST_MAX_PAGE_SIZE,
+  max_log_bytes: HOST_MAX_LOG_BYTES,
+  max_inline_result_bytes: HOST_MAX_INLINE_RESULT_BYTES
+});
+function hostCapabilities() {
+  return {
+    api_version: HOST_API_VERSION,
+    operations: [...HOST_OPERATIONS],
+    max_page_size: HOST_MAX_PAGE_SIZE,
+    max_log_bytes: HOST_MAX_LOG_BYTES,
+    max_inline_result_bytes: HOST_MAX_INLINE_RESULT_BYTES
+  };
+}
+__name(hostCapabilities, "hostCapabilities");
+var HostApiError = class extends Error {
+  static {
+    __name(this, "HostApiError");
+  }
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "HostApiError";
+    this.code = code;
+  }
+};
+function boundedHostErrorMessage(value) {
+  const raw = value instanceof Error ? value.message : String(value);
+  const text = raw.replace(/\s+/gu, " ").trim();
+  const nonEmpty = text.length > 0 ? text : "unspecified host error";
+  if (nonEmpty.length <= HOST_MAX_ERROR_CHARS) return nonEmpty;
+  return `${nonEmpty.slice(0, HOST_MAX_ERROR_CHARS - 1)}\u2026`;
+}
+__name(boundedHostErrorMessage, "boundedHostErrorMessage");
+function hostErrorBody(error, fallback = "OPERATION_FAILED") {
+  if (error instanceof HostApiError) {
+    return { code: error.code, message: boundedHostErrorMessage(error.message) };
+  }
+  return { code: fallback, message: boundedHostErrorMessage(error) };
+}
+__name(hostErrorBody, "hostErrorBody");
+function hostSuccessFrame(requestId, operation, result) {
+  return {
+    schema_version: HOST_RESPONSE_SCHEMA,
+    request_id: requestId,
+    operation,
+    ok: true,
+    result
+  };
+}
+__name(hostSuccessFrame, "hostSuccessFrame");
+function hostErrorFrame(requestId, operation, error) {
+  return {
+    schema_version: HOST_RESPONSE_SCHEMA,
+    request_id: requestId,
+    operation,
+    ok: false,
+    error: { code: error.code, message: boundedHostErrorMessage(error.message) }
+  };
+}
+__name(hostErrorFrame, "hostErrorFrame");
+function serializeHostResponse(frame) {
+  const text = JSON.stringify(frame);
+  if (Buffer.byteLength(text, "utf8") <= HOST_MAX_FRAME_BYTES) return text;
+  return JSON.stringify(
+    hostErrorFrame(frame.request_id, frame.operation, {
+      code: "TOO_LARGE",
+      message: `${frame.operation} response exceeds the ${String(HOST_MAX_FRAME_BYTES)}-byte frame bound; request a smaller page, window or the artifact reference`
+    })
+  );
+}
+__name(serializeHostResponse, "serializeHostResponse");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function invalid(message) {
+  throw new HostApiError("INVALID_REQUEST", message);
+}
+__name(invalid, "invalid");
+function own(record, key) {
+  return Object.prototype.hasOwnProperty.call(record, key);
+}
+__name(own, "own");
+function assertClosed(record, allowed, label) {
+  const permitted = new Set(allowed);
+  for (const key of Object.keys(record)) {
+    if (!permitted.has(key)) invalid(`${label} contains unknown key ${key}`);
+  }
+}
+__name(assertClosed, "assertClosed");
+function requireRecord(value, label) {
+  if (!isRecord(value)) invalid(`${label} must be an object`);
+  return value;
+}
+__name(requireRecord, "requireRecord");
+function requireBoundedString(value, label, maximum) {
+  if (typeof value !== "string" || value.length === 0) {
+    invalid(`${label} must be a non-empty string`);
+  }
+  if (value.length > maximum) invalid(`${label} must be at most ${String(maximum)} characters`);
+  return value;
+}
+__name(requireBoundedString, "requireBoundedString");
+function requireTaskId(value, label) {
+  const taskId = requireBoundedString(value, label, HOST_MAX_TASK_ID_CHARS);
+  if (taskId.trim() !== taskId) invalid(`${label} must be an exact task id without whitespace`);
+  return taskId;
+}
+__name(requireTaskId, "requireTaskId");
+function requireIntegerInRange(value, label, min, max) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < min || value > max) {
+    invalid(`${label} must be an integer from ${String(min)} to ${String(max)}`);
+  }
+  return value;
+}
+__name(requireIntegerInRange, "requireIntegerInRange");
+function requireBoolean(value, label) {
+  if (typeof value !== "boolean") invalid(`${label} must be boolean`);
+  return value;
+}
+__name(requireBoolean, "requireBoolean");
+function parseLeaseFields(payload, label) {
+  const leaseId = requireBoundedString(payload["leaseId"], `${label}.leaseId`, 128);
+  const activationId = requireBoundedString(payload["activationId"], `${label}.activationId`, 128);
+  const sequence = requireIntegerInRange(
+    payload["sequence"],
+    `${label}.sequence`,
+    1,
+    Number.MAX_SAFE_INTEGER
+  );
+  return { leaseId, activationId, sequence };
+}
+__name(parseLeaseFields, "parseLeaseFields");
+function parseTaskIds(value, label) {
+  if (!Array.isArray(value)) invalid(`${label} must be an array of exact task ids`);
+  if (value.length < 1 || value.length > HOST_MAX_TASK_IDS) {
+    invalid(`${label} must contain 1 to ${String(HOST_MAX_TASK_IDS)} task ids`);
+  }
+  const ids = [];
+  const unique = /* @__PURE__ */ new Set();
+  value.forEach((entry, index) => {
+    const id = requireTaskId(entry, `${label}[${String(index)}]`);
+    if (unique.has(id)) invalid(`${label} contains duplicate task id ${id}`);
+    unique.add(id);
+    ids.push(id);
+  });
+  return ids;
+}
+__name(parseTaskIds, "parseTaskIds");
+var LEASE_KEYS = ["leaseId", "activationId", "sequence"];
+function parseBody(operation, rawPayload) {
+  const label = `${operation}.payload`;
+  const payload = requireRecord(rawPayload, label);
+  switch (operation) {
+    case "capabilities":
+      assertClosed(payload, [], label);
+      return { operation, payload: {} };
+    case "subscribe":
+      assertClosed(payload, ["clientId"], label);
+      return {
+        operation,
+        payload: {
+          clientId: requireBoundedString(
+            payload["clientId"],
+            `${label}.clientId`,
+            HOST_MAX_CLIENT_ID_CHARS
+          )
+        }
+      };
+    case "unsubscribe":
+      assertClosed(payload, LEASE_KEYS, label);
+      return { operation, payload: parseLeaseFields(payload, label) };
+    case "list": {
+      assertClosed(payload, [...LEASE_KEYS, "cursor", "limit"], label);
+      const parsed = parseLeaseFields(payload, label);
+      if (own(payload, "cursor")) {
+        parsed.cursor = requireBoundedString(
+          payload["cursor"],
+          `${label}.cursor`,
+          HOST_MAX_CURSOR_CHARS
+        );
+      }
+      if (own(payload, "limit")) {
+        parsed.limit = requireIntegerInRange(
+          payload["limit"],
+          `${label}.limit`,
+          1,
+          HOST_MAX_PAGE_SIZE
+        );
+      }
+      return { operation, payload: parsed };
+    }
+    case "detail":
+    case "stop":
+    case "rerun":
+    case "result":
+      assertClosed(payload, [...LEASE_KEYS, "taskId"], label);
+      return {
+        operation,
+        payload: {
+          ...parseLeaseFields(payload, label),
+          taskId: requireTaskId(payload["taskId"], `${label}.taskId`)
+        }
+      };
+    case "logs": {
+      assertClosed(payload, [...LEASE_KEYS, "taskId", "maxBytes", "tail"], label);
+      const parsed = {
+        ...parseLeaseFields(payload, label),
+        taskId: requireTaskId(payload["taskId"], `${label}.taskId`)
+      };
+      if (own(payload, "maxBytes")) {
+        parsed.maxBytes = requireIntegerInRange(
+          payload["maxBytes"],
+          `${label}.maxBytes`,
+          1,
+          HOST_MAX_LOG_BYTES
+        );
+      }
+      if (own(payload, "tail")) parsed.tail = requireBoolean(payload["tail"], `${label}.tail`);
+      return { operation, payload: parsed };
+    }
+    case "stop_all":
+    case "mark_seen":
+      assertClosed(payload, [...LEASE_KEYS, "taskIds"], label);
+      return {
+        operation,
+        payload: {
+          ...parseLeaseFields(payload, label),
+          taskIds: parseTaskIds(payload["taskIds"], `${label}.taskIds`)
+        }
+      };
+  }
+}
+__name(parseBody, "parseBody");
+function isHostOperation(value) {
+  return typeof value === "string" && HOST_OPERATIONS.some((operation) => operation === value);
+}
+__name(isHostOperation, "isHostOperation");
+function echo(value, maximum) {
+  if (typeof value !== "string" || value.length === 0) return "malformed";
+  return value.length <= maximum ? value : "malformed";
+}
+__name(echo, "echo");
+function canonicalHostJson(value) {
+  if (Array.isArray(value)) return `[${value.map((entry) => canonicalHostJson(entry)).join(",")}]`;
+  if (isRecord(value)) {
+    const keys = Object.keys(value).sort();
+    return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalHostJson(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+__name(canonicalHostJson, "canonicalHostJson");
+function serializedInputBytes(data) {
+  try {
+    const text = JSON.stringify(data);
+    return typeof text === "string" ? Buffer.byteLength(text, "utf8") : void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(serializedInputBytes, "serializedInputBytes");
+function parseHostRequest(data) {
+  if (!isRecord(data)) {
+    return {
+      ok: false,
+      requestId: "malformed",
+      operation: "malformed",
+      error: { code: "INVALID_REQUEST", message: "request frame must be an object" }
+    };
+  }
+  const requestId = echo(data["request_id"], HOST_MAX_REQUEST_ID_CHARS);
+  const operationEcho = echo(data["operation"], 64);
+  const fail = /* @__PURE__ */ __name((code, message) => ({
+    ok: false,
+    requestId,
+    operation: operationEcho,
+    error: { code, message: boundedHostErrorMessage(message) }
+  }), "fail");
+  const bytes = serializedInputBytes(data);
+  if (bytes === void 0) return fail("INVALID_REQUEST", "request frame must be plain JSON data");
+  if (bytes > HOST_MAX_FRAME_BYTES) {
+    return fail(
+      "TOO_LARGE",
+      `request frame exceeds the ${String(HOST_MAX_FRAME_BYTES)}-byte frame bound`
+    );
+  }
+  try {
+    assertClosed(data, ["schema_version", "request_id", "operation", "payload"], "request");
+    if (data["schema_version"] !== HOST_REQUEST_SCHEMA) {
+      invalid(`request.schema_version must be ${HOST_REQUEST_SCHEMA}`);
+    }
+    const parsedRequestId = requireBoundedString(
+      data["request_id"],
+      "request.request_id",
+      HOST_MAX_REQUEST_ID_CHARS
+    );
+    const operation = data["operation"];
+    if (!isHostOperation(operation)) {
+      return fail(
+        "UNKNOWN_OPERATION",
+        `request.operation must be one of ${HOST_OPERATIONS.join(", ")}`
+      );
+    }
+    if (!own(data, "payload")) invalid("request.payload is required");
+    const body = parseBody(operation, data["payload"]);
+    return {
+      ok: true,
+      request: {
+        requestId: parsedRequestId,
+        body,
+        fingerprint: canonicalHostJson({
+          request_id: parsedRequestId,
+          operation,
+          payload: body.payload
+        })
+      }
+    };
+  } catch (error) {
+    if (error instanceof HostApiError) return fail(error.code, error.message);
+    return fail("INVALID_REQUEST", boundedHostErrorMessage(error));
+  }
+}
+__name(parseHostRequest, "parseHostRequest");
+var CURSOR_PREFIX = "c1.";
+function encodeHostCursor(activationId, position) {
+  const body = Buffer.from(
+    JSON.stringify([activationId, position.startTime, position.id]),
+    "utf8"
+  ).toString("base64url");
+  return `${CURSOR_PREFIX}${body}`;
+}
+__name(encodeHostCursor, "encodeHostCursor");
+function decodeHostCursor(activationId, cursor) {
+  const reject = /* @__PURE__ */ __name(() => {
+    throw new HostApiError(
+      "INVALID_CURSOR",
+      "cursor is not a valid list cursor for this activation; restart paging from the first page"
+    );
+  }, "reject");
+  if (!cursor.startsWith(CURSOR_PREFIX)) reject();
+  let parsed;
+  try {
+    parsed = JSON.parse(
+      Buffer.from(cursor.slice(CURSOR_PREFIX.length), "base64url").toString("utf8")
+    );
+  } catch {
+    reject();
+  }
+  if (!Array.isArray(parsed) || parsed.length !== 3) reject();
+  const tuple = Array.isArray(parsed) ? parsed : [];
+  const [cursorActivation, startTime, id] = tuple;
+  if (cursorActivation !== activationId || typeof startTime !== "number" || !Number.isFinite(startTime) || typeof id !== "string" || id.length === 0) {
+    reject();
+  }
+  return { startTime: Number(startTime), id: String(id) };
+}
+__name(decodeHostCursor, "decodeHostCursor");
+function compareNewestFirst(left, right) {
+  if (left.startTime !== right.startTime) return right.startTime - left.startTime;
+  if (left.id === right.id) return 0;
+  return left.id < right.id ? 1 : -1;
+}
+__name(compareNewestFirst, "compareNewestFirst");
+
+export {
+  HOST_REQUEST_CHANNEL,
+  HOST_RESPONSE_CHANNEL,
+  HOST_CHANGED_CHANNEL,
+  HOST_CHANGED_SCHEMA,
+  HOST_DEFAULT_PAGE_SIZE,
+  HOST_DEFAULT_LOG_BYTES,
+  HOST_MAX_INLINE_RESULT_BYTES,
+  HOST_MAX_LEASES,
+  HOST_REPLAY_CACHE_SIZE,
+  HOST_MAX_IN_FLIGHT,
+  HOST_CHANGE_COALESCE_MS,
+  HOST_LIST_PREVIEW_CHARS,
+  hostCapabilities,
+  HostApiError,
+  boundedHostErrorMessage,
+  hostErrorBody,
+  hostSuccessFrame,
+  hostErrorFrame,
+  serializeHostResponse,
+  parseHostRequest,
+  encodeHostCursor,
+  decodeHostCursor,
+  compareNewestFirst
+};

package/dist-boot/c-CKCTWCT5.mjs

@@ -0,0 +1,51 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  adjudicateDelegateTerminal,
+  decideDelegateDelivery,
+  evaluateDelegateTerminal,
+  inlineTooLarge,
+  prepareDelegateLaunch
+} from "./c-KFIO6LUW.mjs";
+import "./c-C5NK6UYV.mjs";
+import "./c-IFSP3R4D.mjs";
+import "./c-I2MCJ34O.mjs";
+import "./c-US2PUNZL.mjs";
+import "./c-KIVXWBYD.mjs";
+import "./c-BFW6CDVL.mjs";
+import "./c-DR7XQI32.mjs";
+import "./c-I3C6LBW4.mjs";
+import "./c-B2Y7VNHU.mjs";
+import "./c-SKMK3PEE.mjs";
+import "./c-I54OKQHW.mjs";
+import "./c-UPBH5AXY.mjs";
+import "./c-7UOG7POX.mjs";
+import "./c-E4Z3Y5B5.mjs";
+import "./c-6ZO2SADQ.mjs";
+import "./c-JKTFXTGF.mjs";
+import "./c-CRBXNKFO.mjs";
+import "./c-KP6CRIP4.mjs";
+import "./c-RSKCUPJF.mjs";
+import "./c-PTN4S6G2.mjs";
+import "./c-P6N5DQGZ.mjs";
+import "./c-6LOBR4I6.mjs";
+import "./c-3STKRSVO.mjs";
+import "./c-YRDO2WEF.mjs";
+import "./c-BHNIF2AR.mjs";
+import "./c-ABXULAFL.mjs";
+import "./c-2G3BBHRJ.mjs";
+import "./c-O5PP6CTX.mjs";
+import "./c-CDBEJSBF.mjs";
+import "./c-DEE67DJO.mjs";
+import "./c-WO3QSZUU.mjs";
+import "./c-S2RVHR3M.mjs";
+import "./c-EQBKXWNX.mjs";
+import "./c-RQJJ26T4.mjs";
+import "./c-L5GHWG5G.mjs";
+import "./c-CN77DCGF.mjs";
+export {
+  adjudicateDelegateTerminal,
+  decideDelegateDelivery,
+  evaluateDelegateTerminal,
+  inlineTooLarge,
+  prepareDelegateLaunch
+};

package/dist-boot/c-CN77DCGF.mjs

@@ -0,0 +1,60 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __name,
+  __require,
+  __esm,
+  __commonJS,
+  __export,
+  __toESM,
+  __toCommonJS
+};