@opengeni/contracts 5.5.0 → 5.5.2-canary.40656248492001

package/dist/chunk-VLUKBV6Y.js

@@ -0,0 +1,1170 @@
+import {
+  collectSecretShapes,
+  mapSecretMaskableStrings,
+  maskSecretShapes,
+  maskSecretShapesInText,
+  secretShapeMaskLabel
+} from "./chunk-BMUTAZX5.js";
+import {
+  VAULT_LIMITS,
+  isValidSecretName
+} from "./chunk-G4RKARXZ.js";
+
+// src/secret-references.ts
+var SECRET_REFERENCE_MARKER = "{{secret";
+var SecretReferenceSyntaxError = class extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message ?? `invalid secret reference: ${reason}`);
+    this.name = "SecretReferenceSyntaxError";
+    this.reason = reason;
+  }
+};
+var PREFIXES = [
+  // Longest first: "{{secretfile:" must win over "{{secret".
+  { prefix: "{{secretfile:", kind: "secretfile" },
+  { prefix: "{{secret:", kind: "secret" }
+];
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var PREVIOUS_SUFFIX = "#previous";
+var ID_PREFIX = "id:";
+function containsSecretReference(text) {
+  return text.includes(SECRET_REFERENCE_MARKER);
+}
+function prefixAt(text, index) {
+  for (const candidate of PREFIXES) {
+    if (text.startsWith(candidate.prefix, index)) return candidate;
+  }
+  return null;
+}
+function isControl(code) {
+  return code <= 31 || code >= 127 && code <= 159;
+}
+function parseBody(body) {
+  if (body.length === 0)
+    throw new SecretReferenceSyntaxError("empty_body", "secret reference is empty");
+  let rest = body;
+  let previous = false;
+  if (rest.endsWith(PREVIOUS_SUFFIX)) {
+    previous = true;
+    rest = rest.slice(0, -PREVIOUS_SUFFIX.length);
+  }
+  if (rest.includes("#")) {
+    throw new SecretReferenceSyntaxError(
+      "unsupported_version_suffix",
+      "only #previous is supported, and it must be last"
+    );
+  }
+  const parts = rest.split("/");
+  let otp = false;
+  if (parts.length >= 2 && parts[parts.length - 1].toLowerCase() === "otp") {
+    otp = true;
+    parts.pop();
+  }
+  if (parts[0].toLowerCase().startsWith(ID_PREFIX)) {
+    const itemId = parts[0].slice(ID_PREFIX.length);
+    if (!UUID_PATTERN.test(itemId)) {
+      throw new SecretReferenceSyntaxError("invalid_id", "id: must be followed by an item UUID");
+    }
+    if (parts.length > 2) {
+      throw new SecretReferenceSyntaxError("too_many_segments", "id form takes at most one field");
+    }
+    const field = parts[1] ?? null;
+    if (field !== null) assertSegment(field);
+    return { target: { form: "id", itemId: itemId.toLowerCase(), field }, otp, previous };
+  }
+  if (parts.length > 3) {
+    throw new SecretReferenceSyntaxError(
+      "too_many_segments",
+      "a reference has at most Vault/Item/field"
+    );
+  }
+  for (const segment of parts) assertSegment(segment);
+  return {
+    target: {
+      form: "path",
+      segments: parts
+    },
+    otp,
+    previous
+  };
+}
+function assertSegment(segment) {
+  if (segment.length === 0) {
+    throw new SecretReferenceSyntaxError("empty_segment", "a reference has an empty name");
+  }
+  if (!isValidSecretName(segment)) {
+    throw new SecretReferenceSyntaxError(
+      "invalid_segment",
+      `"${segment.slice(0, 40)}" is not a valid vault, item or field name`
+    );
+  }
+}
+function scanCandidate(text, index, prefix) {
+  const bodyStart = index + prefix.prefix.length;
+  const limit = Math.min(text.length, index + VAULT_LIMITS.referenceMaxChars);
+  let cursor = bodyStart;
+  while (cursor < text.length) {
+    const code = text.charCodeAt(cursor);
+    const character = text[cursor];
+    if (character === "}" && text[cursor + 1] === "}") {
+      const end = cursor + 2;
+      if (end - index > VAULT_LIMITS.referenceMaxChars) {
+        return { ok: false, end, reason: "too_long" };
+      }
+      const raw = text.slice(index, end);
+      try {
+        const parsed = parseBody(text.slice(bodyStart, cursor));
+        return {
+          ok: true,
+          end,
+          reference: { kind: prefix.kind, raw, start: index, end, ...parsed }
+        };
+      } catch (error) {
+        return {
+          ok: false,
+          end,
+          reason: error instanceof SecretReferenceSyntaxError ? error.reason : "invalid"
+        };
+      }
+    }
+    if (character === "{" || character === "}" || isControl(code) || cursor >= limit) {
+      const end = Math.max(cursor, bodyStart);
+      return { ok: false, end, reason: cursor >= limit ? "too_long" : "unterminated" };
+    }
+    cursor += 1;
+  }
+  return { ok: false, end: text.length, reason: "unterminated" };
+}
+function tokenizeSecretText(text) {
+  if (!containsSecretReference(text)) return text.length > 0 ? [{ type: "text", value: text }] : [];
+  const tokens = [];
+  let buffer = "";
+  let cursor = 0;
+  const flush = () => {
+    if (buffer.length > 0) tokens.push({ type: "text", value: buffer });
+    buffer = "";
+  };
+  while (cursor < text.length) {
+    const next = text.indexOf(SECRET_REFERENCE_MARKER, cursor);
+    if (next < 0) {
+      buffer += text.slice(cursor);
+      break;
+    }
+    const prefix = prefixAt(text, next);
+    if (prefix === null) {
+      buffer += text.slice(cursor, next + SECRET_REFERENCE_MARKER.length);
+      cursor = next + SECRET_REFERENCE_MARKER.length;
+      continue;
+    }
+    const escaped = next - 1 >= cursor && text[next - 1] === "\\";
+    const scanned = scanCandidate(text, next, prefix);
+    if (escaped) {
+      buffer += text.slice(cursor, next - 1) + text.slice(next, scanned.end);
+      cursor = scanned.end;
+      continue;
+    }
+    buffer += text.slice(cursor, next);
+    flush();
+    if (scanned.ok) {
+      tokens.push({ type: "reference", reference: scanned.reference });
+    } else {
+      tokens.push({
+        type: "invalid",
+        raw: text.slice(next, scanned.end),
+        start: next,
+        end: scanned.end,
+        reason: scanned.reason
+      });
+    }
+    cursor = scanned.end;
+  }
+  flush();
+  return tokens;
+}
+function findSecretReferences(text) {
+  if (!containsSecretReference(text)) return [];
+  return tokenizeSecretText(text).flatMap(
+    (token) => token.type === "reference" ? [token.reference] : []
+  );
+}
+function findInvalidSecretReferences(text) {
+  if (!containsSecretReference(text)) return [];
+  return tokenizeSecretText(text).filter(
+    (token) => token.type === "invalid"
+  );
+}
+function parseSecretReference(raw) {
+  const prefix = prefixAt(raw, 0);
+  if (prefix === null) {
+    throw new SecretReferenceSyntaxError(
+      "missing_prefix",
+      "a secret reference starts with {{secret: or {{secretfile:"
+    );
+  }
+  const scanned = scanCandidate(raw, 0, prefix);
+  if (!scanned.ok) throw new SecretReferenceSyntaxError(scanned.reason);
+  if (scanned.end !== raw.length) {
+    throw new SecretReferenceSyntaxError("trailing_text", "unexpected text after the reference");
+  }
+  return scanned.reference;
+}
+function formatSecretReference(input) {
+  const kind = input.kind ?? "secret";
+  const parts = [];
+  if ("itemId" in input) {
+    if (!UUID_PATTERN.test(input.itemId)) throw new SecretReferenceSyntaxError("invalid_id");
+    parts.push(`${ID_PREFIX}${input.itemId.toLowerCase()}`);
+  } else {
+    if (input.vault !== void 0) parts.push(input.vault);
+    parts.push(input.item);
+  }
+  if (input.field !== void 0) parts.push(input.field);
+  for (const part of "itemId" in input ? parts.slice(1) : parts) assertSegment(part);
+  const body = `${parts.join("/")}${input.otp ? "/otp" : ""}${input.previous ? PREVIOUS_SUFFIX : ""}`;
+  const raw = `{{${kind}:${body}}}`;
+  if (raw.length > VAULT_LIMITS.referenceMaxChars) throw new SecretReferenceSyntaxError("too_long");
+  return raw;
+}
+function secretNameKey(name) {
+  return name.normalize("NFC").trim().toLowerCase();
+}
+function referenceKey(ref) {
+  const target = ref.target.form === "id" ? `id:${ref.target.itemId.toLowerCase()}/${ref.target.field === null ? "" : secretNameKey(ref.target.field)}` : `path:${ref.target.segments.map(secretNameKey).join("/")}`;
+  return `${ref.kind}|${target}|${ref.otp ? "otp" : ""}|${ref.previous ? "previous" : ""}`;
+}
+function unescapeSecretText(text) {
+  if (!containsSecretReference(text)) return text;
+  return tokenizeSecretText(text).map(
+    (token) => token.type === "text" ? token.value : token.type === "reference" ? token.reference.raw : token.raw
+  ).join("");
+}
+function walkStrings(value, visit, seen) {
+  if (typeof value === "string") {
+    visit(value);
+    return;
+  }
+  if (value === null || typeof value !== "object") return;
+  if (seen.has(value)) return;
+  seen.add(value);
+  if (Array.isArray(value)) {
+    for (const entry of value) walkStrings(entry, visit, seen);
+    return;
+  }
+  for (const entry of Object.values(value))
+    walkStrings(entry, visit, seen);
+}
+function collectReferencesDeep(value) {
+  const out = [];
+  walkStrings(value, (text) => out.push(...findSecretReferences(text)), /* @__PURE__ */ new Set());
+  return out;
+}
+function collectInvalidReferencesDeep(value) {
+  const out = [];
+  walkStrings(value, (text) => out.push(...findInvalidSecretReferences(text)), /* @__PURE__ */ new Set());
+  return out;
+}
+function replaceReferencesDeep(value, replace) {
+  const replaceText = (text) => {
+    if (!containsSecretReference(text)) return text;
+    return tokenizeSecretText(text).map(
+      (token) => token.type === "text" ? token.value : token.type === "reference" ? replace(token.reference) : token.raw
+    ).join("");
+  };
+  const copy = (input) => {
+    if (typeof input === "string") return replaceText(input);
+    if (input === null || typeof input !== "object") return input;
+    if (Array.isArray(input)) return input.map(copy);
+    if (input instanceof Uint8Array || input instanceof Date) return input;
+    const out = {};
+    for (const [key, entry] of Object.entries(input)) {
+      out[key] = copy(entry);
+    }
+    return out;
+  };
+  return copy(value);
+}
+
+// src/secret-value-masking.ts
+var SECRET_VALUE_MASK_MIN_CHARS = 8;
+var SECRET_VALUE_CLIPPED_MIN_CHARS = 16;
+var SECRET_VALUE_CLIPPED_MIN_SHARE = 0.5;
+var SECRET_VALUE_MEMORY_MAX_ENTRIES = 512;
+var CREDENTIAL_LABEL_OPEN = "[opengeni credential: ";
+var SHAPE_MARKER_OPEN = "[masked ";
+function secretCredentialMaskLabel(kind) {
+  const safe = kind.replace(/[^A-Za-z0-9 ._-]/gu, "").slice(0, 60) || "credential";
+  return `${CREDENTIAL_LABEL_OPEN}${safe}]`;
+}
+var SECRET_VALUE_GENERIC_MASK_LABEL = "[secret]";
+var REFERENCE_OPEN = "{{secret:";
+var FILE_REFERENCE_OPEN = "{{secretfile:";
+var JSON_UNSAFE = /["\\\u0000-\u001f\u007f-\u009f\u2028\u2029]/u;
+function secretReferenceMaskLabel(input) {
+  let raw = input.raw;
+  if (raw.startsWith(FILE_REFERENCE_OPEN)) {
+    raw = REFERENCE_OPEN + raw.slice(FILE_REFERENCE_OPEN.length);
+  }
+  if (raw.startsWith(REFERENCE_OPEN) && !JSON_UNSAFE.test(raw)) return raw;
+  if (input.itemId) {
+    try {
+      let previous = false;
+      try {
+        previous = parseSecretReference(raw).previous;
+      } catch {
+        previous = false;
+      }
+      const id = formatSecretReference({
+        itemId: input.itemId,
+        ...input.fieldName ? { field: input.fieldName } : {},
+        ...previous ? { previous: true } : {}
+      });
+      if (!JSON_UNSAFE.test(id)) return id;
+    } catch {
+    }
+  }
+  return SECRET_VALUE_GENERIC_MASK_LABEL;
+}
+function isSecretReferenceMaskLabel(label) {
+  return label.startsWith(REFERENCE_OPEN);
+}
+var BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function utf8Bytes(value) {
+  try {
+    return new TextEncoder().encode(value);
+  } catch {
+    return null;
+  }
+}
+function base64(bytes) {
+  let out = "";
+  for (let index = 0; index < bytes.length; index += 3) {
+    const a = bytes[index];
+    const b = index + 1 < bytes.length ? bytes[index + 1] : 0;
+    const c = index + 2 < bytes.length ? bytes[index + 2] : 0;
+    const triple = a << 16 | b << 8 | c;
+    out += BASE64_ALPHABET[triple >> 18 & 63];
+    out += BASE64_ALPHABET[triple >> 12 & 63];
+    out += index + 1 < bytes.length ? BASE64_ALPHABET[triple >> 6 & 63] : "=";
+    out += index + 2 < bytes.length ? BASE64_ALPHABET[triple & 63] : "=";
+  }
+  return out;
+}
+function base64Forms(value) {
+  const bytes = utf8Bytes(value);
+  if (bytes === null || bytes.length === 0) return [];
+  const forms = [];
+  const whole = base64(bytes);
+  forms.push(whole, whole.replace(/=+$/u, ""));
+  for (let offset = 0; offset < 3; offset += 1) {
+    const padded = new Uint8Array(offset + bytes.length);
+    padded.set(bytes, offset);
+    const encoded = base64(padded);
+    const start = Math.ceil(offset * 8 / 6);
+    const end = Math.floor((offset + bytes.length) * 8 / 6);
+    if (end > start) forms.push(encoded.slice(start, end));
+  }
+  const withUrlSafe = [];
+  for (const form of forms) {
+    withUrlSafe.push(form, form.replaceAll("+", "-").replaceAll("/", "_"));
+  }
+  return withUrlSafe;
+}
+var PEM_BOUNDARY = /^-----(BEGIN|END) [A-Z0-9 ]+-----$/u;
+var KEY_MATERIAL_LINE = /^(?:[0-9A-Fa-f]+|(?=[^\n]*[A-Z])(?=[^\n]*[a-z])(?=[^\n]*[0-9])[A-Za-z0-9+/_-]+={0,2})$/u;
+function secretValueForms(value, options = {}) {
+  const minChars = options.minChars ?? SECRET_VALUE_MASK_MIN_CHARS;
+  if (typeof value !== "string" || value.length < minChars) return [];
+  const forms = /* @__PURE__ */ new Set();
+  const add = (form) => {
+    if (form && form.length >= minChars) forms.add(form);
+  };
+  add(value);
+  add(value.trim());
+  const lines = value.split(/\r?\n|\r/u);
+  if (lines.length > 1) {
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (PEM_BOUNDARY.test(trimmed)) continue;
+      if (options.lines === "all" || trimmed.length >= 16 && KEY_MATERIAL_LINE.test(trimmed)) {
+        add(trimmed);
+      }
+    }
+  }
+  const escaped = JSON.stringify(value).slice(1, -1);
+  add(escaped);
+  add(JSON.stringify(escaped).slice(1, -1));
+  try {
+    const uri = encodeURIComponent(value);
+    add(uri);
+    add(uri.replaceAll("%20", "+"));
+    add(uri.replace(/%[0-9A-F]{2}/gu, (match) => match.toLowerCase()));
+  } catch {
+  }
+  try {
+    add(new URLSearchParams({ v: value }).toString().slice(2));
+  } catch {
+  }
+  if (options.base64 !== false) for (const form of base64Forms(value)) add(form);
+  return [...forms].sort((left, right) => right.length - left.length);
+}
+var PROTECTED_PATTERNS = [
+  "\\[opengeni credential: [A-Za-z0-9 ._-]{1,60}\\]",
+  "\\[masked [a-z0-9 _-]{1,40}\\]",
+  "\\[secret\\]"
+];
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+var TRUNCATION_MARK = /\.\.\.|\u2026/gu;
+var CLIPPED_INDEX_MAX_FORM_CHARS = 8192;
+var CLIPPED_INDEX_MAX_ENTRIES = 2e5;
+var CLIPPED_MAX_CUTS = 256;
+var CLIPPED_MAX_CANDIDATES = 32;
+var SECRET_VALUE_CLIPPED_TEXT_END_MIN_CHARS = 1024;
+function compileSecretValueMasks(entries, options = {}) {
+  const minChars = Math.max(2, options.minChars ?? SECRET_VALUE_MASK_MIN_CHARS);
+  const clippedMinChars = Math.max(
+    minChars,
+    options.clippedMinChars ?? SECRET_VALUE_CLIPPED_MIN_CHARS
+  );
+  const clippedMinShare = Math.min(
+    1,
+    Math.max(0, options.clippedMinShare ?? SECRET_VALUE_CLIPPED_MIN_SHARE)
+  );
+  const labels = /* @__PURE__ */ new Map();
+  const labelTexts = /* @__PURE__ */ new Set();
+  const clippable = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (typeof entry?.value !== "string" || typeof entry.label !== "string") continue;
+    const forms2 = secretValueForms(entry.value, { ...options, minChars });
+    if (forms2.length === 0) continue;
+    labelTexts.add(entry.label);
+    for (const form of forms2) if (!labels.has(form)) labels.set(form, entry.label);
+    clippable.add(entry.value);
+    clippable.add(entry.value.trim());
+    clippable.add(JSON.stringify(entry.value).slice(1, -1));
+  }
+  const forms = [...labels.keys()].sort((left, right) => right.length - left.length);
+  const byPrefix = /* @__PURE__ */ new Map();
+  const byClippedEnd = /* @__PURE__ */ new Map();
+  const firstPairs = /* @__PURE__ */ new Set();
+  for (const form of forms) {
+    const prefix = form.slice(0, minChars);
+    const bucket = byPrefix.get(prefix);
+    if (bucket) bucket.push(form);
+    else byPrefix.set(prefix, [form]);
+    firstPairs.add(form.charCodeAt(0) * 65536 + form.charCodeAt(1));
+  }
+  let indexed = 0;
+  for (let index = forms.length - 1; index >= 0; index -= 1) {
+    const form = forms[index];
+    if (options.clippedForms !== "all" && !clippable.has(form)) continue;
+    if (form.length <= clippedMinChars || form.length > CLIPPED_INDEX_MAX_FORM_CHARS) continue;
+    const shortest = Math.max(clippedMinChars, Math.ceil(form.length * clippedMinShare));
+    if (indexed + (form.length - shortest) > CLIPPED_INDEX_MAX_ENTRIES) break;
+    for (let length = shortest; length < form.length; length += 1) {
+      const key = form.slice(length - clippedMinChars, length);
+      const starts = byClippedEnd.get(key);
+      if (starts) starts.push({ form, length });
+      else byClippedEnd.set(key, [{ form, length }]);
+    }
+    indexed += form.length - shortest;
+  }
+  for (const starts of byClippedEnd.values()) {
+    starts.sort((left, right) => right.length - left.length);
+  }
+  const pattern = forms.length === 0 ? null : new RegExp(
+    [
+      ...[...labelTexts].sort((left, right) => right.length - left.length).map(escapeRegExp),
+      ...PROTECTED_PATTERNS
+    ].map((source) => `(?:${source})`).join("|"),
+    "gu"
+  );
+  return {
+    empty: forms.length === 0,
+    minChars,
+    skipKey: options.skipKey,
+    pattern,
+    labels,
+    forms,
+    byPrefix,
+    firstPairs,
+    clippedMinChars,
+    clippedMinShare,
+    clippedTextEndMinChars: Math.max(
+      0,
+      options.clippedTextEndMinChars ?? SECRET_VALUE_CLIPPED_TEXT_END_MIN_CHARS
+    ),
+    byClippedEnd,
+    longestForm: forms[0]?.length ?? 0
+  };
+}
+function clippedSecretTail(text, cut, masks) {
+  const probe = masks.clippedMinChars;
+  if (cut < probe || masks.byClippedEnd.size === 0) return null;
+  const candidates = masks.byClippedEnd.get(text.slice(cut - probe, cut));
+  if (!candidates) return null;
+  let checked = 0;
+  for (const { form, length } of candidates) {
+    if (length > cut) continue;
+    if (checked++ >= CLIPPED_MAX_CANDIDATES) break;
+    if (!text.startsWith(form.slice(0, length), cut - length)) continue;
+    const label = masks.labels.get(form);
+    if (label !== void 0) return { length, label };
+  }
+  return null;
+}
+function overlapsKept(start, end, kept) {
+  for (const [from, to] of kept) if (start < to && from < end) return true;
+  return false;
+}
+function keptRanges(text, pattern) {
+  const kept = [];
+  pattern.lastIndex = 0;
+  for (const match of text.matchAll(pattern)) {
+    if (match[0].length > 0) kept.push([match.index, match.index + match[0].length]);
+  }
+  return kept;
+}
+function maskSecretValuesInText(text, masks) {
+  if (masks.empty || masks.pattern === null || text.length < masks.minChars) return text;
+  const size = masks.minChars;
+  const kept = keptRanges(text, masks.pattern);
+  let out = "";
+  let copied = 0;
+  let next = 0;
+  for (let at = 0; at <= text.length - size; ) {
+    while (next < kept.length && kept[next][1] <= at) next += 1;
+    if (next < kept.length && kept[next][0] <= at) {
+      at = kept[next][1];
+      next += 1;
+      continue;
+    }
+    if (!masks.firstPairs.has(text.charCodeAt(at) * 65536 + text.charCodeAt(at + 1))) {
+      at += 1;
+      continue;
+    }
+    const candidates = masks.byPrefix.get(text.slice(at, at + size));
+    const limit = next < kept.length ? kept[next][0] : text.length;
+    const form = candidates?.find(
+      (candidate) => at + candidate.length <= limit && text.startsWith(candidate, at)
+    );
+    if (form === void 0) {
+      at += 1;
+      continue;
+    }
+    out += text.slice(copied, at) + masks.labels.get(form);
+    at += form.length;
+    copied = at;
+  }
+  out += text.slice(copied);
+  if (masks.byClippedEnd.size === 0) return out;
+  const cuts = out.length >= masks.clippedTextEndMinChars ? [out.length] : [];
+  const marks = [...out.matchAll(TRUNCATION_MARK)];
+  for (let index = marks.length - 1; index >= 0; index -= 1) {
+    if (cuts.length >= CLIPPED_MAX_CUTS) break;
+    const mark = marks[index];
+    const previous = marks[index - 1];
+    if (previous && previous.index + previous[0].length === mark.index) continue;
+    cuts.push(mark.index);
+  }
+  if (cuts.length === 0) return out;
+  const keptBefore = keptRanges(out, masks.pattern);
+  let changedFrom = out.length + 1;
+  for (const cut of cuts) {
+    if (cut > changedFrom) continue;
+    const tail = clippedSecretTail(out, cut, masks);
+    if (!tail) continue;
+    const start = cut - tail.length;
+    if (overlapsKept(start, cut, keptBefore)) continue;
+    out = out.slice(0, start) + tail.label + out.slice(cut);
+    changedFrom = start;
+  }
+  return out;
+}
+function maskSecretValues(value, entries, options = {}) {
+  const masks = Array.isArray(entries) ? compileSecretValueMasks(entries, options) : entries;
+  if (masks.empty) return value;
+  return mapSecretMaskableStrings(
+    value,
+    (text) => maskSecretValuesInText(text, masks),
+    masks.skipKey
+  );
+}
+var FIRST_PARTY_SECRET_VALUES_META_KEY = "opengeniSecretValues";
+function firstPartySecretValuesFromMeta(meta) {
+  if (meta === null || typeof meta !== "object") return [];
+  const entries = meta[FIRST_PARTY_SECRET_VALUES_META_KEY];
+  if (!Array.isArray(entries)) return [];
+  return entries.filter(
+    (entry) => entry !== null && typeof entry === "object" && typeof entry.value === "string" && typeof entry.label === "string"
+  );
+}
+function isDistinctiveSecret(value, username) {
+  if (username !== void 0 && value === username) return false;
+  const kinds = Number(/[a-z]/.test(value)) + Number(/[A-Z]/.test(value)) + Number(/[0-9]/.test(value)) + Number(/[^A-Za-z0-9]/.test(value));
+  return value.length >= 16 && kinds >= 3 || value.length >= 24 && kinds >= 2;
+}
+function revealedForms(value) {
+  if (value.length === 0) return [];
+  const escaped = JSON.stringify(value).slice(1, -1);
+  return escaped === value ? [value] : [value, escaped];
+}
+var SECRET_SHAPE_CAPTURES_PER_RESULT = 16;
+var SecretValueMemory = class {
+  values = /* @__PURE__ */ new Map();
+  operations = /* @__PURE__ */ new Map();
+  compiled = null;
+  /** Masks without values that only have a `[masked <kind>]` marker, by version. */
+  compiledReferenced = null;
+  changes = 0;
+  options;
+  maxEntries;
+  onDiagnostic;
+  refresher;
+  /** Values an explicit, audited reveal (`secret_get`) handed to the agent. */
+  revealed = /* @__PURE__ */ new Set();
+  disposed = false;
+  /** Secret-shaped values seen in tool output, with what replaces them (any length). */
+  shapes = /* @__PURE__ */ new Map();
+  shapeCapturer;
+  constructor(options = {}) {
+    const { maxEntries, onDiagnostic, ...maskOptions } = options;
+    this.options = maskOptions;
+    this.maxEntries = maxEntries ?? SECRET_VALUE_MEMORY_MAX_ENTRIES;
+    this.onDiagnostic = onDiagnostic;
+  }
+  /** Replace the diagnostic sink (for example once observability is ready). */
+  setDiagnosticSink(sink) {
+    this.onDiagnostic = sink;
+  }
+  /**
+   * Attach a loader that may remember more values (for example uses recorded
+   * by another process). It owns its own throttling.
+   */
+  setRefresher(refresher) {
+    this.refresher = refresher;
+  }
+  /** Run the refresher, waiting at most `maxWaitMs`; never throws. */
+  async refresh(maxWaitMs = 2e3) {
+    const refresher = this.refresher;
+    if (!refresher) return;
+    let timer;
+    try {
+      await Promise.race([
+        refresher(),
+        new Promise((resolve) => {
+          timer = setTimeout(resolve, maxWaitMs);
+        })
+      ]);
+    } catch (error) {
+      this.report("refresh", error);
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  }
+  get minChars() {
+    return this.options.minChars ?? SECRET_VALUE_MASK_MIN_CHARS;
+  }
+  get size() {
+    return this.values.size;
+  }
+  /** Increases whenever the searched values change (for memoized masking). */
+  get version() {
+    return this.changes;
+  }
+  /**
+   * Remember a value. Returns whether it is searched for (false when shorter
+   * than the minimum). A value keeps its first reference label; a reference
+   * label replaces a credential marker, because it is the more useful name.
+   */
+  remember(value, label) {
+    try {
+      if (typeof value !== "string" || typeof label !== "string") return false;
+      if (this.disposed || value.length < this.minChars || this.isRevealed(value)) return false;
+      const existing = this.values.get(value);
+      const keep = existing !== void 0 && (existing === label || isSecretReferenceMaskLabel(existing) || !isSecretReferenceMaskLabel(label));
+      this.values.delete(value);
+      this.values.set(value, keep ? existing : label);
+      this.evict();
+      if (!keep) {
+        this.compiled = null;
+        this.changes += 1;
+      }
+      return true;
+    } catch (error) {
+      this.report("remember", error);
+      return false;
+    }
+  }
+  /**
+   * Over the limit, the oldest values go first, but Opengeni's own
+   * credentials (`[opengeni credential: …]`) stay while others can go.
+   */
+  evict() {
+    if (this.values.size <= this.maxEntries) return;
+    for (const [value, label] of this.values) {
+      if (this.values.size <= this.maxEntries) break;
+      if (label.startsWith(CREDENTIAL_LABEL_OPEN)) continue;
+      this.values.delete(value);
+    }
+    while (this.values.size > this.maxEntries) {
+      const oldest = this.values.keys().next().value;
+      if (oldest === void 0) break;
+      this.values.delete(oldest);
+    }
+    this.compiled = null;
+    this.changes += 1;
+  }
+  /**
+   * An explicit, audited plaintext read (`secret_get`) handed this value to
+   * the agent on purpose: it is not masked for the rest of this memory's
+   * life. Never throws.
+   */
+  reveal(value) {
+    try {
+      if (typeof value !== "string" || value.length === 0) return;
+      this.revealed.add(value);
+      let changed = false;
+      for (const [known, label] of this.values) {
+        if (label.startsWith(CREDENTIAL_LABEL_OPEN) || !value.includes(known)) continue;
+        this.values.delete(known);
+        changed = true;
+      }
+      for (const known of this.shapes.keys()) {
+        if (value.includes(known)) this.shapes.delete(known);
+      }
+      if (changed) {
+        this.compiled = null;
+        this.changes += 1;
+      }
+    } catch (error) {
+      this.report("reveal", error);
+    }
+  }
+  /**
+   * Whether `value` is, or lies within, a value `secret_get` revealed. Only a
+   * value of at least the minimum length counts as lying within one, so a
+   * short value is not released by a chance match.
+   */
+  isRevealed(value) {
+    if (this.revealed.size === 0) return false;
+    if (this.revealed.has(value)) return true;
+    if (value.length < this.minChars) return false;
+    for (const revealed of this.revealed) if (revealed.includes(value)) return true;
+    return false;
+  }
+  /**
+   * Forget every value at the end of the owner's life (an attempt), so work
+   * that outlives it neither keeps the plaintext nor masks with it.
+   */
+  dispose() {
+    this.disposed = true;
+    this.values.clear();
+    this.operations.clear();
+    this.revealed.clear();
+    this.shapes.clear();
+    this.shapeCapturer = void 0;
+    this.refresher = void 0;
+    this.compiled = null;
+    this.compiledReferenced = null;
+    this.changes += 1;
+  }
+  /**
+   * Remember a value and note that one tool call (its operation ID) used it,
+   * so the receiver of that call can mask its own stored text with exactly
+   * the values it was given.
+   */
+  rememberForOperation(operationId, value, label) {
+    const searched = this.remember(value, label);
+    if (!searched || !operationId) return searched;
+    try {
+      const entries = this.operations.get(operationId) ?? [];
+      if (!entries.some((entry) => entry.value === value)) entries.push({ value, label });
+      this.operations.delete(operationId);
+      this.operations.set(operationId, entries);
+      while (this.operations.size > 256) {
+        const oldest = this.operations.keys().next().value;
+        if (oldest === void 0) break;
+        this.operations.delete(oldest);
+      }
+    } catch (error) {
+      this.report("remember", error);
+    }
+    return searched;
+  }
+  /** The values one tool call used (see `rememberForOperation`). */
+  operationEntries(operationId) {
+    return [...this.operations.get(operationId) ?? []];
+  }
+  /** Whether a value is remembered (for tests and dedupe; never exposes values). */
+  has(value) {
+    return this.values.has(value);
+  }
+  entries() {
+    return [...this.values].map(([value, label]) => ({ value, label }));
+  }
+  masks() {
+    this.compiled ??= compileSecretValueMasks(this.entries(), this.options);
+    return this.compiled;
+  }
+  /** Deep copy with every remembered value replaced; never throws. */
+  mask(value, stage = "mask") {
+    if (this.values.size === 0) return value;
+    try {
+      return maskSecretValues(value, this.masks());
+    } catch (error) {
+      this.report(stage, error);
+      return value;
+    }
+  }
+  /** `mask` without the values whose label is only a `[masked <kind>]` marker. */
+  maskReferenced(value, stage) {
+    if (this.values.size === 0) return value;
+    let markers = false;
+    for (const label of this.values.values()) {
+      if (label.startsWith(SHAPE_MARKER_OPEN)) {
+        markers = true;
+        break;
+      }
+    }
+    if (!markers) return this.mask(value, stage);
+    try {
+      if (this.compiledReferenced?.version !== this.changes) {
+        this.compiledReferenced = {
+          version: this.changes,
+          masks: compileSecretValueMasks(
+            this.entries().filter((entry) => !entry.label.startsWith(SHAPE_MARKER_OPEN)),
+            this.options
+          )
+        };
+      }
+      return maskSecretValues(value, this.compiledReferenced.masks);
+    } catch (error) {
+      this.report(stage, error);
+      return value;
+    }
+  }
+  /** Mask one text; never throws. */
+  maskText(text, stage = "mask") {
+    if (this.values.size === 0 || typeof text !== "string") return text;
+    try {
+      return maskSecretValuesInText(text, this.masks());
+    } catch (error) {
+      this.report(stage, error);
+      return text;
+    }
+  }
+  /** Mask with the remembered values plus, for this call only, extra ones. */
+  maskWith(value, extra, stage = "mask") {
+    if (extra.length === 0) return this.mask(value, stage);
+    try {
+      return maskSecretValues(value, [...this.entries(), ...extra], this.options);
+    } catch (error) {
+      this.report(stage, error);
+      return value;
+    }
+  }
+  /**
+   * Attach the capturer that saves secret-shaped values found in tool output
+   * (normally into the task vault). Without one they are masked with a marker.
+   */
+  setShapeCapturer(capturer) {
+    this.shapeCapturer = capturer;
+  }
+  /**
+   * Remember a secret-shaped value from tool output: it is replaced wherever
+   * a shape detector finds it, and (when long enough) searched for as a known
+   * value everywhere else. A reference replaces an earlier marker.
+   */
+  rememberShape(value, label, username) {
+    try {
+      if (typeof value !== "string" || typeof label !== "string" || value.length === 0) return;
+      if (this.disposed || this.isRevealed(value)) return;
+      const existing = this.shapes.get(value);
+      if (existing === void 0 || !isSecretReferenceMaskLabel(existing) && isSecretReferenceMaskLabel(label)) {
+        this.shapes.set(value, label);
+        while (this.shapes.size > this.maxEntries) {
+          const oldest = this.shapes.keys().next().value;
+          if (oldest === void 0) break;
+          this.shapes.delete(oldest);
+        }
+      }
+      if (isDistinctiveSecret(value, username)) {
+        this.remember(value, this.shapes.get(value) ?? label);
+      }
+    } catch (error) {
+      this.report("remember_shape", error);
+    }
+  }
+  /**
+   * Find secret-shaped values in tool output that are not known yet and
+   * capture them, waiting at most `maxWaitMs`. Values the capturer does not
+   * return a reference for (or all of them, without a capturer or on any
+   * failure) are remembered with a `[masked <kind>]` marker. Never throws.
+   */
+  async captureShapes(value, stage = "tool_result", maxWaitMs = 5e3) {
+    let pending;
+    try {
+      const known = this.maskReferenced(value, stage);
+      pending = collectSecretShapes(known, 256, {
+        ...this.options.skipKey ? { skipKey: this.options.skipKey } : {},
+        keep: (match, text) => !this.insideRevealed(match, text) && !this.isRevealed(match.value)
+      }).filter((match) => !isSecretReferenceMaskLabel(this.shapes.get(match.value) ?? ""));
+    } catch (error) {
+      this.report(stage, error);
+      return;
+    }
+    if (pending.length === 0) return;
+    const capturable = pending.slice(0, SECRET_SHAPE_CAPTURES_PER_RESULT);
+    const usernames = new Map(pending.map((match) => [match.value, match.username]));
+    let captured = /* @__PURE__ */ new Map();
+    const capturer = this.shapeCapturer;
+    if (capturer) {
+      let timer;
+      try {
+        const late = capturer(capturable);
+        late.then(
+          (references) => {
+            for (const [secret, reference] of references) {
+              if (!isSecretReferenceMaskLabel(reference)) continue;
+              this.rememberShape(secret, reference, usernames.get(secret));
+            }
+          },
+          () => {
+          }
+        );
+        captured = await Promise.race([
+          late,
+          new Promise((resolve) => {
+            timer = setTimeout(() => resolve(null), maxWaitMs);
+          })
+        ]) ?? /* @__PURE__ */ new Map();
+      } catch (error) {
+        this.report("shape_capture", error);
+      } finally {
+        if (timer !== void 0) clearTimeout(timer);
+      }
+    }
+    for (const match of pending) {
+      const reference = captured.get(match.value);
+      this.rememberShape(
+        match.value,
+        reference && isSecretReferenceMaskLabel(reference) ? reference : secretShapeMaskLabel(match.kind),
+        match.username
+      );
+    }
+  }
+  /**
+   * Whether a detected part lies within a value `secret_get` revealed (as
+   * written or JSON-escaped), for example the password of a revealed URL.
+   */
+  insideRevealed(match, text) {
+    if (this.revealed.size === 0) return false;
+    for (const value of this.revealed) {
+      for (const form of revealedForms(value)) {
+        const at = text.indexOf(form, Math.max(0, match.start - form.length + 1));
+        if (at >= 0 && at < match.end) return true;
+      }
+    }
+    return false;
+  }
+  /** What replaces a detected shape: its capture, a known label, a marker, or nothing when revealed. */
+  shapeLabel = (match, text) => this.insideRevealed(match, text) || this.isRevealed(match.value) ? null : this.shapes.get(match.value) ?? this.values.get(match.value) ?? secretShapeMaskLabel(match.kind);
+  /**
+   * Mask tool output: known values first, then every secret-shaped part
+   * (with its captured reference, or a marker). Never throws.
+   */
+  maskToolOutput(value, stage = "tool_result") {
+    const known = this.mask(value, stage);
+    try {
+      return maskSecretShapes(known, this.shapeLabel, this.options.skipKey);
+    } catch (error) {
+      this.report(stage, error);
+      return known;
+    }
+  }
+  /** `maskToolOutput` for one text. */
+  maskToolOutputText(text, stage = "tool_result") {
+    const known = this.maskText(text, stage);
+    if (typeof known !== "string") return known;
+    try {
+      return maskSecretShapesInText(known, this.shapeLabel);
+    } catch (error) {
+      this.report(stage, error);
+      return known;
+    }
+  }
+  report(stage, error) {
+    try {
+      this.onDiagnostic?.({ stage, error: error instanceof Error ? error.name : typeof error });
+    } catch {
+    }
+  }
+};
+function maskSecretValuesInError(error, memory, mode = "known", depth = 0) {
+  if (!memory || !(error instanceof Error) || depth > 4) return error;
+  if (mode === "known" && memory.size === 0) return error;
+  const field = (name) => {
+    try {
+      const text = error[name];
+      if (typeof text !== "string") return;
+      const masked = mode === "tool_output" ? memory.maskToolOutputText(text, "tool_error") : memory.maskText(text, "tool_error");
+      if (masked !== text) error[name] = masked;
+    } catch {
+    }
+  };
+  field("message");
+  field("stack");
+  try {
+    if (error.cause !== void 0) maskSecretValuesInError(error.cause, memory, mode, depth + 1);
+  } catch {
+  }
+  try {
+    const inner = error.errors;
+    if (Array.isArray(inner)) {
+      for (const item of inner.slice(0, 32)) {
+        maskSecretValuesInError(item, memory, mode, depth + 1);
+      }
+    }
+  } catch {
+  }
+  return error;
+}
+function isSecretRevealToolName(name) {
+  return name === "secret_get" || name === "opengeni__secret_get";
+}
+function decodedBase64Text(value) {
+  try {
+    const binary = atob(value.replace(/\s+/gu, ""));
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return null;
+  }
+}
+function secretGetRevealedValues(result, depth = 0) {
+  if (depth > 6) return [];
+  if (typeof result === "string") {
+    const trimmed = result.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return [];
+    try {
+      return secretGetRevealedValues(JSON.parse(trimmed), depth + 1);
+    } catch {
+      return [];
+    }
+  }
+  if (result === null || typeof result !== "object") return [];
+  if (Array.isArray(result)) {
+    return result.flatMap((item) => secretGetRevealedValues(item, depth + 1));
+  }
+  const record = result;
+  if (typeof record.value === "string" && record.encoding === "utf8") return [record.value];
+  if (typeof record.value === "string" && record.encoding === "base64") {
+    const decoded = decodedBase64Text(record.value);
+    return decoded === null ? [record.value] : [record.value, decoded];
+  }
+  return Object.values(record).flatMap((value) => secretGetRevealedValues(value, depth + 1));
+}
+function revealSecretGetResult(memory, toolName, result) {
+  if (!memory) return;
+  try {
+    if (!isSecretRevealToolName(toolName)) return;
+    for (const value of secretGetRevealedValues(result)) memory.reveal(value);
+  } catch {
+  }
+}
+function textMaterial(value) {
+  const material = value.material;
+  if (material.type === "text") return material.value;
+  if (material.type === "bytes") {
+    try {
+      return new TextDecoder("utf-8", { fatal: true }).decode(material.value);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function rememberResolvedSecretValues(memory, resolved, operationId) {
+  if (!memory) return;
+  for (const value of resolved.values()) {
+    try {
+      if (value.fieldKind === "text") continue;
+      const text = textMaterial(value);
+      if (text === null) continue;
+      const label = secretReferenceMaskLabel({
+        raw: value.reference.raw,
+        itemId: value.itemId,
+        fieldName: value.fieldName
+      });
+      if (operationId) memory.rememberForOperation(operationId, text, label);
+      else memory.remember(text, label);
+    } catch {
+    }
+  }
+}
+function rememberingSecretResolver(resolver, target) {
+  return {
+    get principal() {
+      return resolver.principal;
+    },
+    get enabled() {
+      return resolver.enabled;
+    },
+    async resolve(refs, use) {
+      const resolved = await resolver.resolve(refs, use);
+      let memory;
+      try {
+        memory = typeof target === "function" ? target() : target;
+      } catch {
+        memory = null;
+      }
+      rememberResolvedSecretValues(memory, resolved, use.operationId);
+      return resolved;
+    }
+  };
+}
+
+export {
+  SECRET_REFERENCE_MARKER,
+  SecretReferenceSyntaxError,
+  containsSecretReference,
+  tokenizeSecretText,
+  findSecretReferences,
+  findInvalidSecretReferences,
+  parseSecretReference,
+  formatSecretReference,
+  secretNameKey,
+  referenceKey,
+  unescapeSecretText,
+  collectReferencesDeep,
+  collectInvalidReferencesDeep,
+  replaceReferencesDeep,
+  SECRET_VALUE_MASK_MIN_CHARS,
+  SECRET_VALUE_CLIPPED_MIN_CHARS,
+  SECRET_VALUE_CLIPPED_MIN_SHARE,
+  SECRET_VALUE_MEMORY_MAX_ENTRIES,
+  secretCredentialMaskLabel,
+  SECRET_VALUE_GENERIC_MASK_LABEL,
+  secretReferenceMaskLabel,
+  isSecretReferenceMaskLabel,
+  secretValueForms,
+  SECRET_VALUE_CLIPPED_TEXT_END_MIN_CHARS,
+  compileSecretValueMasks,
+  maskSecretValuesInText,
+  maskSecretValues,
+  FIRST_PARTY_SECRET_VALUES_META_KEY,
+  firstPartySecretValuesFromMeta,
+  SECRET_SHAPE_CAPTURES_PER_RESULT,
+  SecretValueMemory,
+  maskSecretValuesInError,
+  isSecretRevealToolName,
+  secretGetRevealedValues,
+  revealSecretGetResult,
+  rememberResolvedSecretValues,
+  rememberingSecretResolver
+};
+//# sourceMappingURL=chunk-VLUKBV6Y.js.map