lua-cli 3.37.0 → 3.39.0

package/dist/workflow-builder.js

@@ -10,6 +10,39 @@ import { z as z2 } from "zod";
 import { z as z3 } from "zod";
 var __defProp2 = Object.defineProperty;
 var __name2 = /* @__PURE__ */ __name((target, value3) => __defProp2(target, "name", { value: value3, configurable: true }), "__name");
+var PLUMBING_THREAD_CHANNELS = [
+  "trigger",
+  "template-install",
+  "template-uninstall"
+];
+var CHANNEL_CONVERSATION_CHANNELS = [
+  "whatsapp",
+  "slack",
+  "teams",
+  "front",
+  "email",
+  "messagebird",
+  "sms",
+  "mms",
+  "rcs",
+  "instagram",
+  "facebook",
+  "imessage"
+];
+var HIDDEN_THREAD_CHANNELS = [
+  ...PLUMBING_THREAD_CHANNELS,
+  ...CHANNEL_CONVERSATION_CHANNELS
+];
+function isChannelConversationChannel(channel) {
+  return !!channel && CHANNEL_CONVERSATION_CHANNELS.includes(channel);
+}
+__name(isChannelConversationChannel, "isChannelConversationChannel");
+__name2(isChannelConversationChannel, "isChannelConversationChannel");
+function isChannelConversationThread(threadId, channel) {
+  return !!threadId && isChannelConversationChannel(channel);
+}
+__name(isChannelConversationThread, "isChannelConversationThread");
+__name2(isChannelConversationThread, "isChannelConversationThread");
 function isPersonaTextObject(value3) {
   if (value3 === null || typeof value3 !== "object" || Array.isArray(value3)) return false;
   const obj = value3;
@@ -631,6 +664,199 @@ var BROWSER_COMMANDS = [
   }
 ];
 var BROWSER_COMMAND_NAMES = BROWSER_COMMANDS.map((c) => c.name);
+var LOG_FIELDS_MAX_KEYS = 32;
+var LOG_FIELD_MAX_VALUE_BYTES = 1024;
+var LOG_FIELDS_MAX_BYTES = 8192;
+var LOG_FIELD_KEY_PATTERN = /^[a-z][a-z0-9_]{0,63}$/;
+var LOG_FIELD_SECRET_SHAPED_KEY_PATTERNS = Object.freeze([
+  /^api_[0-9a-f]{24,}$/,
+  /^gh[pousr]_[a-z0-9]{36}$/,
+  /^(?:sk|rk|pk)_(?:live|test)_[a-z0-9]{16,}$/,
+  /^lua_hc_[a-z0-9]{20,}/,
+  /^lua_sk_[a-z0-9]{20,}/
+]);
+var LOG_FIELDS_CLAMPED_KEY = "lua_fields_clamped";
+var LOG_FIELD_ARRAY_COUNT_SUFFIX = ".count";
+var LuaLogFieldsError = class _LuaLogFieldsError extends Error {
+  static {
+    __name(this, "_LuaLogFieldsError");
+  }
+  static {
+    __name2(this, "LuaLogFieldsError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "LuaLogFieldsError";
+    Object.setPrototypeOf(this, _LuaLogFieldsError.prototype);
+  }
+};
+function utf8WidthAt(value3, index) {
+  const code = value3.charCodeAt(index);
+  if (code < 128) return {
+    bytes: 1,
+    units: 1
+  };
+  if (code < 2048) return {
+    bytes: 2,
+    units: 1
+  };
+  if (code >= 55296 && code <= 56319) {
+    const next = value3.charCodeAt(index + 1);
+    if (next >= 56320 && next <= 57343) return {
+      bytes: 4,
+      units: 2
+    };
+  }
+  return {
+    bytes: 3,
+    units: 1
+  };
+}
+__name(utf8WidthAt, "utf8WidthAt");
+__name2(utf8WidthAt, "utf8WidthAt");
+function utf8ByteLength(value3) {
+  let bytes = 0;
+  for (let i = 0; i < value3.length; ) {
+    const width = utf8WidthAt(value3, i);
+    bytes += width.bytes;
+    i += width.units;
+  }
+  return bytes;
+}
+__name(utf8ByteLength, "utf8ByteLength");
+__name2(utf8ByteLength, "utf8ByteLength");
+function clampUtf8(value3, maxBytes) {
+  let bytes = 0;
+  for (let i = 0; i < value3.length; ) {
+    const width = utf8WidthAt(value3, i);
+    if (bytes + width.bytes > maxBytes) return value3.slice(0, i);
+    bytes += width.bytes;
+    i += width.units;
+  }
+  return value3;
+}
+__name(clampUtf8, "clampUtf8");
+__name2(clampUtf8, "clampUtf8");
+function mapBytes(fields, withMark) {
+  return utf8ByteLength(JSON.stringify(withMark ? {
+    ...fields,
+    [LOG_FIELDS_CLAMPED_KEY]: true
+  } : fields));
+}
+__name(mapBytes, "mapBytes");
+__name2(mapBytes, "mapBytes");
+function withValueCap(fields, capBytes) {
+  const out = {};
+  for (const [key, value3] of Object.entries(fields)) {
+    out[key] = typeof value3 === "string" ? clampUtf8(value3, capBytes) : value3;
+  }
+  return out;
+}
+__name(withValueCap, "withValueCap");
+__name2(withValueCap, "withValueCap");
+function describeValue(value3) {
+  if (value3 === null) return "null";
+  if (value3 === void 0) return "undefined";
+  if (Array.isArray(value3)) return "an array";
+  return typeof value3 === "object" ? "an object" : `a ${typeof value3}`;
+}
+__name(describeValue, "describeValue");
+__name2(describeValue, "describeValue");
+function assertValidLogFieldKey(key) {
+  if (!LOG_FIELD_KEY_PATTERN.test(key)) {
+    throw new LuaLogFieldsError(`log fields: key \`${key}\` is not allowed \u2014 a key must match ${LOG_FIELD_KEY_PATTERN.source} (lower-case, starts with a letter, then letters/digits/underscore, at most 64 characters)`);
+  }
+  if (LOG_FIELD_SECRET_SHAPED_KEY_PATTERNS.some((pattern) => pattern.test(key))) {
+    throw new LuaLogFieldsError(`log fields: key \`${key}\` is not allowed \u2014 it has the shape of a credential that the log-drain scrubber masks in values; a field KEY is never scrubbed, so it may never carry a secret shape`);
+  }
+  if (key === LOG_FIELDS_CLAMPED_KEY) {
+    throw new LuaLogFieldsError(`log fields: key \`${key}\` is reserved \u2014 the platform sets it to mark a field map it had to clamp`);
+  }
+}
+__name(assertValidLogFieldKey, "assertValidLogFieldKey");
+__name2(assertValidLogFieldKey, "assertValidLogFieldKey");
+function normalizeLogFields(fields) {
+  if (fields === void 0 || fields === null) return void 0;
+  if (typeof fields !== "object" || Array.isArray(fields)) {
+    throw new LuaLogFieldsError(`log fields: expected a plain object of fields, received ${describeValue(fields)}`);
+  }
+  const entries = Object.entries(fields);
+  if (entries.length > LOG_FIELDS_MAX_KEYS) {
+    throw new LuaLogFieldsError(`log fields: ${entries.length} keys exceeds the cap of ${LOG_FIELDS_MAX_KEYS} keys per call`);
+  }
+  const out = {};
+  for (const [key, value3] of entries) {
+    assertValidLogFieldKey(key);
+    if (typeof value3 === "string" || typeof value3 === "boolean") {
+      out[key] = value3;
+      continue;
+    }
+    if (typeof value3 === "number") {
+      if (!Number.isFinite(value3)) {
+        throw new LuaLogFieldsError(`log fields: \`${key}\` must be a finite number \u2014 NaN and Infinity have no JSON form`);
+      }
+      out[key] = value3;
+      continue;
+    }
+    if (Array.isArray(value3)) {
+      const parts = [];
+      for (const element of value3) {
+        if (typeof element !== "string") {
+          throw new LuaLogFieldsError(`log fields: \`${key}\` is an array, so every element must be a string (found ${describeValue(element)})`);
+        }
+        if (element.includes(",")) {
+          throw new LuaLogFieldsError(`log fields: \`${key}\` \u2014 an array element may not contain a comma; elements are comma-joined into one value (with \`${key}${LOG_FIELD_ARRAY_COUNT_SUFFIX}\` beside it), so a comma inside one would be indistinguishable from the separator`);
+        }
+        parts.push(element);
+      }
+      out[key] = parts.join(",");
+      out[`${key}${LOG_FIELD_ARRAY_COUNT_SUFFIX}`] = parts.length;
+      continue;
+    }
+    throw new LuaLogFieldsError(`log fields: \`${key}\` must be a string, number, boolean or string[] \u2014 received ${describeValue(value3)}` + (value3 !== null && typeof value3 === "object" ? " (nested objects are not supported)" : ""));
+  }
+  const keys = Object.keys(out);
+  if (keys.length === 0) return void 0;
+  if (keys.length > LOG_FIELDS_MAX_KEYS) {
+    throw new LuaLogFieldsError(`log fields: ${keys.length} keys exceeds the cap of ${LOG_FIELDS_MAX_KEYS} keys per call \u2014 an array field also contributes its \`${LOG_FIELD_ARRAY_COUNT_SUFFIX.slice(1)}\` sibling`);
+  }
+  if (clampLogFields(out)) out[LOG_FIELDS_CLAMPED_KEY] = true;
+  return out;
+}
+__name(normalizeLogFields, "normalizeLogFields");
+__name2(normalizeLogFields, "normalizeLogFields");
+function clampLogFields(out) {
+  let clamped = false;
+  for (const [key, value3] of Object.entries(out)) {
+    if (typeof value3 !== "string") continue;
+    const capped = clampUtf8(value3, LOG_FIELD_MAX_VALUE_BYTES);
+    if (capped !== value3) {
+      out[key] = capped;
+      clamped = true;
+    }
+  }
+  if (mapBytes(out, clamped) <= LOG_FIELDS_MAX_BYTES) return clamped;
+  const base = {
+    ...out
+  };
+  let low = 0;
+  let high = LOG_FIELD_MAX_VALUE_BYTES;
+  let best = 0;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    if (mapBytes(withValueCap(base, mid), true) <= LOG_FIELDS_MAX_BYTES) {
+      best = mid;
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  const fitted = withValueCap(base, best);
+  for (const key of Object.keys(out)) out[key] = fitted[key];
+  return true;
+}
+__name(clampLogFields, "clampLogFields");
+__name2(clampLogFields, "clampLogFields");
 var DESKTOP_FILE_COMMANDS = [
   "files_roots",
   "files_stat",
@@ -1174,6 +1400,894 @@ function buildPersonalSpaceStartingPersona(agentName) {
 }
 __name(buildPersonalSpaceStartingPersona, "buildPersonalSpaceStartingPersona");
 __name2(buildPersonalSpaceStartingPersona, "buildPersonalSpaceStartingPersona");
+var AGENT_LOG_SOURCES = [
+  "skill",
+  "job",
+  "webhook",
+  "trigger",
+  "preprocessor",
+  "postprocessor",
+  "user_message",
+  "agent_response",
+  "agent_error",
+  "runtime",
+  "mcp",
+  "rag",
+  "device",
+  "device-trigger",
+  "model-resolver",
+  "workflow-step",
+  "workflow-script",
+  "workflow"
+];
+var AGENT_LOG_FIELDS_MAX_WIRE_KEYS = LOG_FIELDS_MAX_KEYS + 1;
+function utf8Bytes(value3) {
+  let bytes = 0;
+  for (let i = 0; i < value3.length; ) {
+    const code = value3.charCodeAt(i);
+    if (code < 128) {
+      bytes += 1;
+      i += 1;
+    } else if (code < 2048) {
+      bytes += 2;
+      i += 1;
+    } else if (code >= 55296 && code <= 56319) {
+      const next = value3.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        bytes += 4;
+        i += 2;
+      } else {
+        bytes += 3;
+        i += 1;
+      }
+    } else {
+      bytes += 3;
+      i += 1;
+    }
+  }
+  return bytes;
+}
+__name(utf8Bytes, "utf8Bytes");
+__name2(utf8Bytes, "utf8Bytes");
+function isPlainFieldKey(key) {
+  if (!LOG_FIELD_KEY_PATTERN.test(key)) return false;
+  return !LOG_FIELD_SECRET_SHAPED_KEY_PATTERNS.some((pattern) => pattern.test(key));
+}
+__name(isPlainFieldKey, "isPlainFieldKey");
+__name2(isPlainFieldKey, "isPlainFieldKey");
+function describeAgentLogFieldsViolation(value3) {
+  if (typeof value3 !== "object" || value3 === null || Array.isArray(value3)) {
+    return "fields must be an object";
+  }
+  const entries = Object.entries(value3);
+  let userKeys = 0;
+  for (const [key, entry] of entries) {
+    if (key === LOG_FIELDS_CLAMPED_KEY) {
+      if (entry !== true) return `fields.${key} must be true`;
+      continue;
+    }
+    userKeys += 1;
+    if (key.endsWith(LOG_FIELD_ARRAY_COUNT_SUFFIX)) {
+      const base = key.slice(0, -LOG_FIELD_ARRAY_COUNT_SUFFIX.length);
+      if (!isPlainFieldKey(base)) return `fields key \`${key}\` is not a legal field key`;
+      if (typeof entry !== "number" || !Number.isFinite(entry)) {
+        return `fields.${key} must be a finite number`;
+      }
+      continue;
+    }
+    if (!isPlainFieldKey(key)) return `fields key \`${key}\` is not a legal field key`;
+    if (typeof entry === "string") {
+      if (utf8Bytes(entry) > LOG_FIELD_MAX_VALUE_BYTES) {
+        return `fields.${key} exceeds ${LOG_FIELD_MAX_VALUE_BYTES} bytes`;
+      }
+      continue;
+    }
+    if (typeof entry === "boolean") continue;
+    if (typeof entry === "number") {
+      if (!Number.isFinite(entry)) return `fields.${key} must be a finite number`;
+      continue;
+    }
+    return `fields.${key} must be a string, number or boolean`;
+  }
+  if (userKeys > LOG_FIELDS_MAX_KEYS) {
+    return `fields has ${userKeys} keys, over the cap of ${LOG_FIELDS_MAX_KEYS}`;
+  }
+  if (utf8Bytes(JSON.stringify(value3)) > LOG_FIELDS_MAX_BYTES) {
+    return `fields exceeds ${LOG_FIELDS_MAX_BYTES} bytes`;
+  }
+  return void 0;
+}
+__name(describeAgentLogFieldsViolation, "describeAgentLogFieldsViolation");
+__name2(describeAgentLogFieldsViolation, "describeAgentLogFieldsViolation");
+function isAgentLogFields(value3) {
+  return describeAgentLogFieldsViolation(value3) === void 0;
+}
+__name(isAgentLogFields, "isAgentLogFields");
+__name2(isAgentLogFields, "isAgentLogFields");
+var LOG_DRAIN_TYPES_PHASE1 = [
+  "http",
+  "otlp",
+  "datadog",
+  "betterstack"
+];
+var LOG_DRAIN_TYPES_PHASE2 = [
+  "splunk",
+  "loki",
+  "axiom",
+  "newrelic",
+  "sumologic"
+];
+var LOG_DRAIN_TYPES_IMPLEMENTED = [
+  ...LOG_DRAIN_TYPES_PHASE1,
+  ...LOG_DRAIN_TYPES_PHASE2,
+  // RECONCILE-4 (W4-4). `s3` is implemented (H4 / PRO-1887) but is NOT in
+  // `LOG_DRAIN_TYPES_PHASE2`, because its own flag opens it and `*` must not. It
+  // belongs here all the same: this list is what a CLIENT may offer, and the server
+  // remains the authority that answers 422 with the live list.
+  "s3"
+];
+var LOG_DRAIN_SOURCES = [
+  ...AGENT_LOG_SOURCES,
+  "execution",
+  // ── phase 2 ──
+  "delivery",
+  "trigger-execution",
+  "job-execution",
+  "workflow-run",
+  "workflow-audit",
+  // PRO-1884 (H2). Appended AFTER 'workflow-audit' so the enum stays additive and
+  // no existing member changes position.
+  "voice-call"
+];
+var LOG_DRAIN_MAX_PER_ORG = 5;
+var LOG_DRAIN_MAX_PER_ORG_ENTERPRISE = 10;
+function maxDrainsForTier(tier) {
+  return tier === "enterprise" ? LOG_DRAIN_MAX_PER_ORG_ENTERPRISE : LOG_DRAIN_MAX_PER_ORG;
+}
+__name(maxDrainsForTier, "maxDrainsForTier");
+__name2(maxDrainsForTier, "maxDrainsForTier");
+var LOG_DRAIN_DATADOG_SITES = [
+  "datadoghq.com",
+  "datadoghq.eu",
+  "us3.datadoghq.com",
+  "us5.datadoghq.com",
+  "ap1.datadoghq.com",
+  "ddog-gov.com"
+];
+var LOG_DRAIN_NEWRELIC_SITES = [
+  "log-api.newrelic.com",
+  "log-api.eu.newrelic.com",
+  "log-api.jp.newrelic.com"
+];
+var LOG_DRAIN_ENDPOINT_TEMPLATES = {
+  datadog: "https://http-intake.logs.{site}/api/v2/logs",
+  newrelic: "https://{site}/log/v1"
+};
+var LOG_DRAIN_PRESET_SITES = {
+  datadog: LOG_DRAIN_DATADOG_SITES,
+  newrelic: LOG_DRAIN_NEWRELIC_SITES
+};
+function resolvePresetEndpoint(type, site) {
+  const template3 = LOG_DRAIN_ENDPOINT_TEMPLATES[type];
+  if (!template3 || !site) return void 0;
+  return template3.replace("{site}", site);
+}
+__name(resolvePresetEndpoint, "resolvePresetEndpoint");
+__name2(resolvePresetEndpoint, "resolvePresetEndpoint");
+var LOG_DRAIN_BUCKET_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/;
+var LOG_DRAIN_BUCKET_HOST_PATTERNS = Object.freeze({
+  aws: [
+    // virtual-host style, regional and legacy global
+    /^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]\.s3(\.dualstack)?(\.[a-z0-9-]+)?\.amazonaws\.com$/,
+    // path style
+    /^s3(\.dualstack)?(\.[a-z0-9-]+)?\.amazonaws\.com$/
+  ],
+  r2: [
+    /^[a-f0-9]{32}\.r2\.cloudflarestorage\.com$/
+  ],
+  gcs: [
+    /^storage\.googleapis\.com$/
+  ]
+});
+function isLogDrainBucketHostAllowed(provider, host) {
+  const normalized = host.trim().toLowerCase().replace(/^\[|\]$/g, "");
+  if (!normalized) return false;
+  return (LOG_DRAIN_BUCKET_HOST_PATTERNS[provider] ?? []).some((pattern) => pattern.test(normalized));
+}
+__name(isLogDrainBucketHostAllowed, "isLogDrainBucketHostAllowed");
+__name2(isLogDrainBucketHostAllowed, "isLogDrainBucketHostAllowed");
+function resolveDrainBucketEndpoint(bucket) {
+  if (!LOG_DRAIN_BUCKET_NAME_PATTERN.test(bucket.bucket)) {
+    throw new Error("log drain bucket name is not a valid S3 bucket label");
+  }
+  if (bucket.provider === "aws") {
+    const region = bucket.region.trim().toLowerCase();
+    if (!/^[a-z0-9-]{1,32}$/.test(region)) throw new Error("log drain bucket region is not an AWS region");
+    return `https://${bucket.bucket}.s3.${region}.amazonaws.com`;
+  }
+  if (!bucket.endpoint) throw new Error(`log drain '${bucket.provider}' bucket requires an endpoint`);
+  let url;
+  try {
+    url = new URL(bucket.endpoint);
+  } catch {
+    throw new Error(`log drain '${bucket.provider}' bucket endpoint is not an absolute URL`);
+  }
+  if (url.protocol !== "https:") throw new Error(`log drain '${bucket.provider}' bucket endpoint must be https`);
+  return `https://${url.host}/${bucket.bucket}`;
+}
+__name(resolveDrainBucketEndpoint, "resolveDrainBucketEndpoint");
+__name2(resolveDrainBucketEndpoint, "resolveDrainBucketEndpoint");
+function drainBucketUsesPathStyle(provider) {
+  return provider !== "aws";
+}
+__name(drainBucketUsesPathStyle, "drainBucketUsesPathStyle");
+__name2(drainBucketUsesPathStyle, "drainBucketUsesPathStyle");
+function presetIntakeHosts(type) {
+  const template3 = LOG_DRAIN_ENDPOINT_TEMPLATES[type];
+  const sites = LOG_DRAIN_PRESET_SITES[type];
+  if (!template3 || !sites) return [];
+  const hosts = [];
+  for (const site of sites) {
+    try {
+      hosts.push(new URL(template3.replace("{site}", site)).hostname.toLowerCase());
+    } catch {
+    }
+  }
+  return hosts;
+}
+__name(presetIntakeHosts, "presetIntakeHosts");
+__name2(presetIntakeHosts, "presetIntakeHosts");
+var LOG_DRAIN_PRESET_HOST_SUFFIXES = {
+  axiom: [
+    ".axiom.co"
+  ],
+  sumologic: [
+    ".sumologic.com"
+  ]
+};
+function presetHostAllowlist(type) {
+  return [
+    ...presetIntakeHosts(type),
+    ...LOG_DRAIN_PRESET_HOST_SUFFIXES[type] ?? []
+  ];
+}
+__name(presetHostAllowlist, "presetHostAllowlist");
+__name2(presetHostAllowlist, "presetHostAllowlist");
+function drainHostAllowlistAllows(allowlist, host) {
+  const needle = host.toLowerCase();
+  return allowlist.some((raw) => {
+    const entry = raw.toLowerCase();
+    if (entry.startsWith(".")) return needle === entry.slice(1) || needle.endsWith(entry);
+    return entry === needle;
+  });
+}
+__name(drainHostAllowlistAllows, "drainHostAllowlistAllows");
+__name2(drainHostAllowlistAllows, "drainHostAllowlistAllows");
+function drainDestinationIsVendorPinned(type) {
+  if (LOG_DRAIN_ENDPOINT_TEMPLATES[type]) return true;
+  return presetHostAllowlist(type).length > 0;
+}
+__name(drainDestinationIsVendorPinned, "drainDestinationIsVendorPinned");
+__name2(drainDestinationIsVendorPinned, "drainDestinationIsVendorPinned");
+function drainVerificationOwnership(input) {
+  if (input.proved === true) return "verified";
+  if (input.mode === "test-post" && drainDestinationIsVendorPinned(input.type)) return "verified";
+  return "reachability-only";
+}
+__name(drainVerificationOwnership, "drainVerificationOwnership");
+__name2(drainVerificationOwnership, "drainVerificationOwnership");
+function drainOwnershipOrDefault(ownership) {
+  return ownership === "verified" ? "verified" : "reachability-only";
+}
+__name(drainOwnershipOrDefault, "drainOwnershipOrDefault");
+__name2(drainOwnershipOrDefault, "drainOwnershipOrDefault");
+var DRAIN_CONTENT_ACK_ERROR_CODE = "DRAIN_CONTENT_ACK_REQUIRED";
+var DRAIN_CONTENT_ACK_FIELD = "includeContentAck";
+var DrainContentAckRequiredError = class extends Error {
+  static {
+    __name(this, "DrainContentAckRequiredError");
+  }
+  static {
+    __name2(this, "DrainContentAckRequiredError");
+  }
+  code = DRAIN_CONTENT_ACK_ERROR_CODE;
+  field = DRAIN_CONTENT_ACK_FIELD;
+  constructor() {
+    super("includeContent ships end-user message content to a third party; set includeContentAck: true to confirm.");
+    this.name = "DrainContentAckRequiredError";
+  }
+};
+function assertDrainContentAck(input) {
+  const turningOn = input.next === true && input.was !== true;
+  if (!turningOn) return void 0;
+  if (input.ack !== true) throw new DrainContentAckRequiredError();
+  return {
+    by: input.actor,
+    source: input.source,
+    at: input.at,
+    ...input.inheritedFrom ? {
+      inheritedFrom: input.inheritedFrom
+    } : {}
+  };
+}
+__name(assertDrainContentAck, "assertDrainContentAck");
+__name2(assertDrainContentAck, "assertDrainContentAck");
+var LOG_DRAIN_PRESET_PATHS = {
+  // https://docs.splunk.com/Documentation/Splunk/latest/Data/HECExamples
+  splunk: {
+    path: "/services/collector/event"
+  },
+  // https://grafana.com/docs/loki/latest/reference/loki-http-api/#ingest-logs
+  loki: {
+    path: "/loki/api/v1/push"
+  },
+  // https://axiom.co/docs/restapi/endpoints/ingestIntoDataset
+  axiom: {
+    path: "/v1/datasets",
+    segment: "dataset",
+    suffix: "/ingest"
+  },
+  // https://help.sumologic.com/docs/send-data/hosted-collectors/http-source/logs-metrics/upload-logs/
+  sumologic: {
+    path: "/receiver/v1/http",
+    segment: "token"
+  }
+};
+var PRESET_SEGMENT_RE = /^[A-Za-z0-9._~%=+-]{1,512}$/;
+function composePresetEndpoint(type, endpoint) {
+  const rule = LOG_DRAIN_PRESET_PATHS[type];
+  if (!rule) return void 0;
+  let url;
+  try {
+    url = new URL(endpoint);
+  } catch {
+    return {
+      ok: false,
+      reason: "invalid_url"
+    };
+  }
+  if (url.protocol !== "https:" || !url.hostname) return {
+    ok: false,
+    reason: "invalid_url"
+  };
+  const origin = url.origin;
+  const path = url.pathname.replace(/\/+$/, "");
+  if (!rule.segment) {
+    const base2 = path.endsWith(rule.path) ? path.slice(0, path.length - rule.path.length) : path;
+    return {
+      ok: true,
+      endpoint: `${origin}${base2}${rule.path}`
+    };
+  }
+  const marker = `${rule.path}/`;
+  const at = path.indexOf(marker);
+  if (at < 0) {
+    return {
+      ok: false,
+      reason: rule.segment === "dataset" ? "missing_dataset" : "missing_token"
+    };
+  }
+  const base = path.slice(0, at);
+  const afterMarker = path.slice(at + marker.length);
+  const rest = rule.suffix && afterMarker.endsWith(rule.suffix) ? afterMarker.slice(0, afterMarker.length - rule.suffix.length) : afterMarker;
+  if (!rest || rest.includes("/")) {
+    return {
+      ok: false,
+      reason: rule.segment === "dataset" ? "missing_dataset" : "missing_token"
+    };
+  }
+  if (!PRESET_SEGMENT_RE.test(rest)) return {
+    ok: false,
+    reason: "bad_segment"
+  };
+  if (rule.segment === "dataset") {
+    return {
+      ok: true,
+      endpoint: `${origin}${base}${rule.path}/${rest}${rule.suffix ?? ""}`,
+      dataset: rest
+    };
+  }
+  return {
+    ok: true,
+    endpoint: `${origin}${base}${rule.path}/`,
+    token: rest
+  };
+}
+__name(composePresetEndpoint, "composePresetEndpoint");
+__name2(composePresetEndpoint, "composePresetEndpoint");
+function joinPresetEndpointToken(endpoint, token) {
+  if (typeof token !== "string" || !PRESET_SEGMENT_RE.test(token)) return endpoint;
+  return endpoint.endsWith("/") ? `${endpoint}${token}` : `${endpoint}/${token}`;
+}
+__name(joinPresetEndpointToken, "joinPresetEndpointToken");
+__name2(joinPresetEndpointToken, "joinPresetEndpointToken");
+var LOG_DRAIN_QUOTAS = {
+  team: {
+    eventsPerDay: 1e6,
+    bytesPerDay: 1 * 1024 ** 3
+  },
+  business: {
+    eventsPerDay: 1e7,
+    bytesPerDay: 10 * 1024 ** 3
+  },
+  enterprise: {
+    eventsPerDay: Number.MAX_SAFE_INTEGER,
+    bytesPerDay: Number.MAX_SAFE_INTEGER
+  }
+};
+var LOG_DRAIN_QUOTA_WARN_RATIO = 0.8;
+var LOG_DRAIN_QUOTA_DROP_DEBUG_RATIO = 1;
+var LOG_DRAIN_QUOTA_DROP_INFO_RATIO = 1.25;
+var LOG_DRAIN_QUOTA_PAUSE_RATIO = 1.5;
+function nextLogDrainQuotaResetAt(now) {
+  return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1)).toISOString();
+}
+__name(nextLogDrainQuotaResetAt, "nextLogDrainQuotaResetAt");
+__name2(nextLogDrainQuotaResetAt, "nextLogDrainQuotaResetAt");
+function logDrainQuotaWindowExpired(usage, now) {
+  const resetsAt = Date.parse(usage?.resetsAt ?? "");
+  if (!Number.isFinite(resetsAt)) return true;
+  return now.getTime() >= resetsAt;
+}
+__name(logDrainQuotaWindowExpired, "logDrainQuotaWindowExpired");
+__name2(logDrainQuotaWindowExpired, "logDrainQuotaWindowExpired");
+function logDrainQuotaRatio(usage, now) {
+  if (!usage) return 0;
+  if (now && logDrainQuotaWindowExpired(usage, now)) return 0;
+  const dimension = /* @__PURE__ */ __name2((used, limit) => {
+    if (!Number.isFinite(limit) || limit <= 0) return 0;
+    if (!Number.isFinite(used) || used <= 0) return 0;
+    return used / limit;
+  }, "dimension");
+  return Math.max(dimension(usage.usedEvents, usage.eventsPerDay), dimension(usage.usedBytes, usage.bytesPerDay));
+}
+__name(logDrainQuotaRatio, "logDrainQuotaRatio");
+__name2(logDrainQuotaRatio, "logDrainQuotaRatio");
+function logDrainQuotaDegradationForRatio(ratio) {
+  if (!Number.isFinite(ratio)) return "none";
+  if (ratio >= LOG_DRAIN_QUOTA_PAUSE_RATIO) return "paused";
+  if (ratio >= LOG_DRAIN_QUOTA_DROP_INFO_RATIO) return "info_dropped";
+  if (ratio >= LOG_DRAIN_QUOTA_DROP_DEBUG_RATIO) return "debug_dropped";
+  return "none";
+}
+__name(logDrainQuotaDegradationForRatio, "logDrainQuotaDegradationForRatio");
+__name2(logDrainQuotaDegradationForRatio, "logDrainQuotaDegradationForRatio");
+function logDrainQuotaDegradation(usage, now) {
+  return logDrainQuotaDegradationForRatio(logDrainQuotaRatio(usage, now));
+}
+__name(logDrainQuotaDegradation, "logDrainQuotaDegradation");
+__name2(logDrainQuotaDegradation, "logDrainQuotaDegradation");
+function logDrainQuotaWarned(usage, now) {
+  return logDrainQuotaRatio(usage, now) >= LOG_DRAIN_QUOTA_WARN_RATIO;
+}
+__name(logDrainQuotaWarned, "logDrainQuotaWarned");
+__name2(logDrainQuotaWarned, "logDrainQuotaWarned");
+function logDrainQuotaDroppedSeverities(degradation) {
+  switch (degradation) {
+    case "debug_dropped":
+      return [
+        5
+      ];
+    case "info_dropped":
+      return [
+        5,
+        9
+      ];
+    default:
+      return [];
+  }
+}
+__name(logDrainQuotaDroppedSeverities, "logDrainQuotaDroppedSeverities");
+__name2(logDrainQuotaDroppedSeverities, "logDrainQuotaDroppedSeverities");
+var LOG_EXPORT_SOURCES = [
+  ...AGENT_LOG_SOURCES,
+  "execution"
+];
+var LOG_EXPORT_MAX_WINDOW_DAYS = 31;
+var LOG_EXPORT_MAX_WINDOW_MS = LOG_EXPORT_MAX_WINDOW_DAYS * 24 * 60 * 60 * 1e3;
+var LOG_EXPORT_URL_TTL_SECONDS = 24 * 60 * 60;
+var LOG_EXPORT_FILE_RETENTION_DAYS = 7;
+var LOG_EXPORT_FILE_RETENTION_MS = LOG_EXPORT_FILE_RETENTION_DAYS * 24 * 60 * 60 * 1e3;
+var LOG_EXPORT_PART_MAX_BYTES = 256 * 1024 * 1024;
+function isLogExportSource(source) {
+  return LOG_EXPORT_SOURCES.includes(source);
+}
+__name(isLogExportSource, "isLogExportSource");
+__name2(isLogExportSource, "isLogExportSource");
+var LOG_DRAIN_NOTICE_RATE_LIMIT_MS = 60 * 6e4;
+var LOG_DRAIN_VERIFICATION_STALE_MS = 24 * 60 * 6e4;
+var LOG_DRAIN_DIGEST_INTERVAL_MS = 24 * 60 * 6e4;
+var LOG_DRAIN_DIGEST_MAX_ENTRIES = 50;
+var LOG_DRAIN_NOTICE_ERROR_MAX_CHARS = 200;
+function clamp(value3, max) {
+  if (typeof value3 !== "string") return void 0;
+  const trimmed = value3.trim();
+  if (!trimmed) return void 0;
+  return trimmed.length <= max ? trimmed : `${trimmed.slice(0, max - 1)}\u2026`;
+}
+__name(clamp, "clamp");
+__name2(clamp, "clamp");
+function numberOr(value3, fallback) {
+  return typeof value3 === "number" && Number.isFinite(value3) ? value3 : fallback;
+}
+__name(numberOr, "numberOr");
+__name2(numberOr, "numberOr");
+function isoOr(value3) {
+  return typeof value3 === "string" && value3.length > 0 ? value3 : void 0;
+}
+__name(isoOr, "isoOr");
+__name2(isoOr, "isoOr");
+function logDrainNoticeView(drain, now) {
+  const health = drain.health ?? {};
+  const quota = drain.quota;
+  const view = {
+    id: String(drain.id ?? ""),
+    name: String(drain.name ?? ""),
+    type: drain.type,
+    state: drain.state,
+    deliveredCount24h: numberOr(health.deliveredCount24h, 0),
+    droppedCount24h: numberOr(health.droppedCount24h, 0),
+    rejectedCount24h: numberOr(health.rejectedCount24h, 0),
+    backlog: numberOr(health.backlog, 0),
+    quotaRatio: quota ? logDrainQuotaRatio(quota, now) : 0
+  };
+  if (health.pauseReason) view.pauseReason = health.pauseReason;
+  const lastError = clamp(health.lastError, LOG_DRAIN_NOTICE_ERROR_MAX_CHARS);
+  if (lastError) view.lastError = lastError;
+  if (typeof health.lastStatusCode === "number") view.lastStatusCode = health.lastStatusCode;
+  const lastSuccessAt = isoOr(health.lastSuccessAt);
+  if (lastSuccessAt) view.lastSuccessAt = lastSuccessAt;
+  const lastFailureAt = isoOr(health.lastFailureAt);
+  if (lastFailureAt) view.lastFailureAt = lastFailureAt;
+  const resetsAt = isoOr(quota?.resetsAt);
+  if (resetsAt) view.quotaResetsAt = resetsAt;
+  return view;
+}
+__name(logDrainNoticeView, "logDrainNoticeView");
+__name2(logDrainNoticeView, "logDrainNoticeView");
+function logDrainHealthCardPath(orgId, drainId) {
+  return `/orgs/${encodeURIComponent(orgId)}/log-drains/${encodeURIComponent(drainId)}`;
+}
+__name(logDrainHealthCardPath, "logDrainHealthCardPath");
+__name2(logDrainHealthCardPath, "logDrainHealthCardPath");
+function percent(ratio) {
+  if (!Number.isFinite(ratio) || ratio <= 0) return "0%";
+  return `${Math.round(ratio * 100)}%`;
+}
+__name(percent, "percent");
+__name2(percent, "percent");
+function becauseClause(view) {
+  const bits = [];
+  if (view.lastStatusCode) bits.push(`HTTP ${view.lastStatusCode}`);
+  if (view.lastError) bits.push(view.lastError);
+  return bits.length ? ` Last error: ${bits.join(" \u2014 ")}.` : "";
+}
+__name(becauseClause, "becauseClause");
+__name2(becauseClause, "becauseClause");
+function logDrainNoticeCopy(payload) {
+  const view = payload.drain;
+  const name = view.name || view.id;
+  const backlog = view.backlog > 0 ? ` ${view.backlog.toLocaleString("en-US")} records are buffered.` : "";
+  switch (payload.kind) {
+    case "failing":
+      return {
+        title: name,
+        subject: `Log drain "${name}" is failing`,
+        previewLine: "Failing \u2014 15 minutes without a successful delivery",
+        summary: `The log drain "${name}" (${view.type}) has gone 15 minutes without a successful delivery and is now failing.${becauseClause(view)}${backlog} Records keep buffering; the drain pauses itself after 24 hours without a success.`,
+        status: "failed",
+        priority: "high"
+      };
+    case "paused_auto":
+      return {
+        title: name,
+        subject: `Log drain "${name}" was paused`,
+        previewLine: "Paused \u2014 24 hours without a successful delivery",
+        summary: `The log drain "${name}" (${view.type}) was paused automatically after 24 hours without a successful delivery.${becauseClause(view)}${backlog} Nothing is being sent while it is paused, and the buffer is delivered on resume. Fix the destination, then resume it from the drain's health card or with \`lua drains resume ${view.id}\`.`,
+        status: "failed",
+        priority: "high"
+      };
+    case "paused_quota":
+      return {
+        title: name,
+        subject: `Log drain "${name}" was paused \u2014 daily quota exhausted`,
+        previewLine: `Paused \u2014 ${percent(view.quotaRatio)} of the daily allowance used`,
+        summary: `The log drain "${name}" (${view.type}) reached ${percent(view.quotaRatio)} of its daily allowance and was paused.${backlog} Records keep buffering. The allowance resets${view.quotaResetsAt ? ` at ${view.quotaResetsAt}` : " at 00:00 UTC"}; narrow the drain's sources or raise the plan's limit to stop it happening again, then resume it with \`lua drains resume ${view.id}\`.`,
+        status: "failed",
+        priority: "high"
+      };
+    case "quota_warning":
+      return {
+        title: name,
+        subject: `Log drain "${name}" has used 80% of its daily allowance`,
+        previewLine: `${percent(view.quotaRatio)} of the daily allowance used`,
+        summary: `The log drain "${name}" (${view.type}) has used ${percent(view.quotaRatio)} of today's allowance. Past 100% debug records are dropped, past 125% info records as well, and at 150% the drain pauses. The allowance resets${view.quotaResetsAt ? ` at ${view.quotaResetsAt}` : " at 00:00 UTC"}.`,
+        status: "failed",
+        priority: "normal"
+      };
+    case "dropped": {
+      const dropped = payload.droppedCount ?? view.droppedCount24h;
+      return {
+        title: name,
+        subject: `Log drain "${name}" is dropping records`,
+        previewLine: `${dropped.toLocaleString("en-US")} records dropped`,
+        summary: `The log drain "${name}" (${view.type}) dropped ${dropped.toLocaleString("en-US")} records because its buffer filled up faster than the destination accepted them.${becauseClause(view)} The gap is reported in band on the next successful batch, so the range is recoverable from the destination itself.`,
+        status: "failed",
+        priority: "high"
+      };
+    }
+    case "verification_pending":
+      return {
+        title: name,
+        subject: `Log drain "${name}" is still unverified`,
+        previewLine: "Unverified after 24 hours \u2014 nothing is being delivered",
+        summary: `The log drain "${name}" (${view.type}) was created more than 24 hours ago and has never completed verification, so nothing is being delivered to it.${becauseClause(view)} Run \`lua drains verify ${view.id}\` once the destination echoes the verification token.`,
+        status: "failed",
+        priority: "normal"
+      };
+    default: {
+      const exhaustive = payload.kind;
+      throw new Error(`unhandled log-drain notice kind: ${String(exhaustive)}`);
+    }
+  }
+}
+__name(logDrainNoticeCopy, "logDrainNoticeCopy");
+__name2(logDrainNoticeCopy, "logDrainNoticeCopy");
+function logDrainNoticeLabel(kind) {
+  switch (kind) {
+    case "failing":
+      return "failing";
+    case "paused_auto":
+      return "paused (no success for 24 h)";
+    case "paused_quota":
+      return "paused (daily allowance exhausted)";
+    case "quota_warning":
+      return "80% of the daily allowance used";
+    case "dropped":
+      return "dropping records";
+    case "verification_pending":
+      return "still unverified";
+    default: {
+      const exhaustive = kind;
+      throw new Error(`unhandled log-drain notice kind: ${String(exhaustive)}`);
+    }
+  }
+}
+__name(logDrainNoticeLabel, "logDrainNoticeLabel");
+__name2(logDrainNoticeLabel, "logDrainNoticeLabel");
+function logDrainNoticeDigestCopy(payload) {
+  const entries = [
+    ...payload.entries ?? []
+  ].sort((a, b) => a.at < b.at ? -1 : a.at > b.at ? 1 : 0).slice(0, LOG_DRAIN_DIGEST_MAX_ENTRIES);
+  const drains = new Set(entries.map((entry) => entry.drainId));
+  const noun = `${entries.length} notice${entries.length === 1 ? "" : "s"}`;
+  const across = `${drains.size} drain${drains.size === 1 ? "" : "s"}`;
+  const lines = entries.map((entry) => `${entry.drainName || entry.drainId} \u2014 ${logDrainNoticeLabel(entry.kind)}`);
+  return {
+    title: "Log drains \u2014 daily summary",
+    subject: `Log drains \u2014 ${noun} in the last day`,
+    previewLine: `${noun} across ${across}`,
+    summary: `${noun} across ${across} in the last day: ${lines.join("; ")}.`,
+    status: "failed",
+    priority: "normal"
+  };
+}
+__name(logDrainNoticeDigestCopy, "logDrainNoticeDigestCopy");
+__name2(logDrainNoticeDigestCopy, "logDrainNoticeDigestCopy");
+var LOG_DRAIN_USAGE_LINE_ITEM = "log_drain_events";
+var LOG_DRAIN_BYTES_PER_GIB = 1024 ** 3;
+var DEFAULT_LOG_DRAIN_PLAN_CONFIG = {
+  version: 1,
+  tiers: {
+    team: {
+      ...LOG_DRAIN_QUOTAS.team
+    },
+    business: {
+      ...LOG_DRAIN_QUOTAS.business
+    },
+    enterprise: {
+      ...LOG_DRAIN_QUOTAS.enterprise
+    }
+  },
+  pricing: {
+    team: {
+      includedEventsPerMonth: 0,
+      includedBytesPerMonth: 0,
+      usdPerMillionEvents: 0,
+      usdPerGiB: 0
+    },
+    business: {
+      includedEventsPerMonth: 0,
+      includedBytesPerMonth: 0,
+      usdPerMillionEvents: 0,
+      usdPerGiB: 0
+    },
+    enterprise: {
+      includedEventsPerMonth: 0,
+      includedBytesPerMonth: 0,
+      usdPerMillionEvents: 0,
+      usdPerGiB: 0
+    }
+  }
+};
+var TIERS = [
+  "team",
+  "business",
+  "enterprise"
+];
+function finiteNonNegative(value3) {
+  return typeof value3 === "number" && Number.isFinite(value3) && value3 >= 0 ? value3 : void 0;
+}
+__name(finiteNonNegative, "finiteNonNegative");
+__name2(finiteNonNegative, "finiteNonNegative");
+function mergeLimits(base, stored) {
+  const patch = stored ?? {};
+  return {
+    eventsPerDay: finiteNonNegative(patch.eventsPerDay) ?? base.eventsPerDay,
+    bytesPerDay: finiteNonNegative(patch.bytesPerDay) ?? base.bytesPerDay
+  };
+}
+__name(mergeLimits, "mergeLimits");
+__name2(mergeLimits, "mergeLimits");
+function mergeCard(base, stored) {
+  const patch = stored ?? {};
+  return {
+    includedEventsPerMonth: finiteNonNegative(patch.includedEventsPerMonth) ?? base.includedEventsPerMonth,
+    includedBytesPerMonth: finiteNonNegative(patch.includedBytesPerMonth) ?? base.includedBytesPerMonth,
+    usdPerMillionEvents: finiteNonNegative(patch.usdPerMillionEvents) ?? base.usdPerMillionEvents,
+    usdPerGiB: finiteNonNegative(patch.usdPerGiB) ?? base.usdPerGiB
+  };
+}
+__name(mergeCard, "mergeCard");
+__name2(mergeCard, "mergeCard");
+function resolveStoredLogDrainPlanConfig(stored) {
+  const values = stored;
+  if (!values || typeof values.version !== "number" || !Number.isFinite(values.version)) {
+    return DEFAULT_LOG_DRAIN_PLAN_CONFIG;
+  }
+  const tiers = {};
+  const pricing = {};
+  for (const tier of TIERS) {
+    tiers[tier] = mergeLimits(DEFAULT_LOG_DRAIN_PLAN_CONFIG.tiers[tier], values.tiers?.[tier]);
+    pricing[tier] = mergeCard(DEFAULT_LOG_DRAIN_PLAN_CONFIG.pricing[tier], values.pricing?.[tier]);
+  }
+  const orgs = {};
+  for (const [orgId, override] of Object.entries(values.orgs ?? {})) {
+    if (!orgId || !override || typeof override !== "object") continue;
+    const row = {};
+    if (override.tier && TIERS.includes(override.tier)) row.tier = override.tier;
+    const events = finiteNonNegative(override.eventsPerDay);
+    const bytes = finiteNonNegative(override.bytesPerDay);
+    if (events !== void 0) row.eventsPerDay = events;
+    if (bytes !== void 0) row.bytesPerDay = bytes;
+    if (override.pricing && typeof override.pricing === "object") row.pricing = {
+      ...override.pricing
+    };
+    if (Object.keys(row).length) orgs[orgId] = row;
+  }
+  return {
+    version: values.version,
+    tiers,
+    pricing,
+    ...Object.keys(orgs).length ? {
+      orgs
+    } : {}
+  };
+}
+__name(resolveStoredLogDrainPlanConfig, "resolveStoredLogDrainPlanConfig");
+__name2(resolveStoredLogDrainPlanConfig, "resolveStoredLogDrainPlanConfig");
+function logDrainPlanTierOverride(config, orgId) {
+  return orgId ? config.orgs?.[orgId]?.tier : void 0;
+}
+__name(logDrainPlanTierOverride, "logDrainPlanTierOverride");
+__name2(logDrainPlanTierOverride, "logDrainPlanTierOverride");
+function logDrainQuotaLimitsFor(config, orgId, tier) {
+  const base = config.tiers[tier] ?? config.tiers.team ?? LOG_DRAIN_QUOTAS.team;
+  const override = orgId ? config.orgs?.[orgId] : void 0;
+  if (!override) return {
+    ...base
+  };
+  return {
+    eventsPerDay: override.eventsPerDay ?? base.eventsPerDay,
+    bytesPerDay: override.bytesPerDay ?? base.bytesPerDay
+  };
+}
+__name(logDrainQuotaLimitsFor, "logDrainQuotaLimitsFor");
+__name2(logDrainQuotaLimitsFor, "logDrainQuotaLimitsFor");
+function logDrainPriceCardFor(config, orgId, tier) {
+  const base = config.pricing[tier] ?? config.pricing.team ?? DEFAULT_LOG_DRAIN_PLAN_CONFIG.pricing.team;
+  const override = orgId ? config.orgs?.[orgId]?.pricing : void 0;
+  return override ? mergeCard(base, override) : {
+    ...base
+  };
+}
+__name(logDrainPriceCardFor, "logDrainPriceCardFor");
+__name2(logDrainPriceCardFor, "logDrainPriceCardFor");
+function priceDrainUsage(totals, card, tier) {
+  const billableRecords = Math.max(0, Math.floor(finiteNonNegative(totals?.billableRecords) ?? 0));
+  const billableBytes = Math.max(0, Math.floor(finiteNonNegative(totals?.billableBytes) ?? 0));
+  const includedEvents = card.includedEventsPerMonth;
+  const includedBytes = card.includedBytesPerMonth;
+  const overageEvents = Math.max(0, billableRecords - includedEvents);
+  const overageBytes = Math.max(0, billableBytes - includedBytes);
+  const eventsUsd = overageEvents / 1e6 * card.usdPerMillionEvents;
+  const bytesUsd = overageBytes / LOG_DRAIN_BYTES_PER_GIB * card.usdPerGiB;
+  const unpriced = card.usdPerMillionEvents === 0 && card.usdPerGiB === 0;
+  const round = /* @__PURE__ */ __name2((usd) => Math.round(usd * 100) / 100, "round");
+  return {
+    lineItem: LOG_DRAIN_USAGE_LINE_ITEM,
+    tier,
+    billableRecords,
+    billableBytes,
+    includedEvents,
+    includedBytes,
+    overageEvents,
+    overageBytes,
+    eventsUsd: round(eventsUsd),
+    bytesUsd: round(bytesUsd),
+    usd: round(Math.max(eventsUsd, bytesUsd)),
+    unpriced
+  };
+}
+__name(priceDrainUsage, "priceDrainUsage");
+__name2(priceDrainUsage, "priceDrainUsage");
+var LOG_CURSOR_MAX_LENGTH = 512;
+var LOG_CURSOR_MAX_ID_LENGTH = 128;
+var LOG_RELATIVE_TIME_PATTERN = /^(\d{1,9})([smhd])$/;
+var LOG_ISO_TIME_PATTERN = /^\d{4}-\d{2}-\d{2}([Tt ]\d{2}:\d{2}(:\d{2}(\.\d{1,9})?)?([Zz]|[+-]\d{2}:?\d{2})?)?$/;
+var RELATIVE_UNIT_MS = {
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+function encodeLogCursor(c) {
+  return Buffer.from(JSON.stringify({
+    t: c.t,
+    id: c.id
+  }), "utf8").toString("base64url");
+}
+__name(encodeLogCursor, "encodeLogCursor");
+__name2(encodeLogCursor, "encodeLogCursor");
+function decodeLogCursor(raw) {
+  if (typeof raw !== "string") return null;
+  const trimmed = raw.trim();
+  if (!trimmed || trimmed.length > LOG_CURSOR_MAX_LENGTH) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.from(trimmed, "base64url").toString("utf8"));
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const { t, id } = parsed;
+  if (typeof t !== "number" || !Number.isSafeInteger(t) || t < 0) return null;
+  if (typeof id !== "string" || !id || id.length > LOG_CURSOR_MAX_ID_LENGTH) return null;
+  return {
+    t,
+    id
+  };
+}
+__name(decodeLogCursor, "decodeLogCursor");
+__name2(decodeLogCursor, "decodeLogCursor");
+function parseLogTimeBound(raw, now = /* @__PURE__ */ new Date()) {
+  if (typeof raw !== "string") return null;
+  const value3 = raw.trim();
+  if (!value3) return null;
+  const relative = LOG_RELATIVE_TIME_PATTERN.exec(value3);
+  if (relative) {
+    const amount = Number(relative[1]);
+    const unitMs = RELATIVE_UNIT_MS[relative[2]];
+    if (!Number.isFinite(amount) || unitMs === void 0) return null;
+    const at2 = now.getTime() - amount * unitMs;
+    return Number.isFinite(at2) ? new Date(at2) : null;
+  }
+  if (!LOG_ISO_TIME_PATTERN.test(value3)) return null;
+  const at = Date.parse(value3);
+  return Number.isNaN(at) ? null : new Date(at);
+}
+__name(parseLogTimeBound, "parseLogTimeBound");
+__name2(parseLogTimeBound, "parseLogTimeBound");
 var CORE_DRAINING_CODE = "CORE_DRAINING";
 var CORE_DRAINING_DEFAULT_RETRY_MS = 1e3;
 var CORE_DRAINING_MAX_RETRY_MS = 5e3;