@phosphorco/bb-cross-references 0.1.1 → 0.4.0

package/dist/bb.js

@@ -365,7 +365,915 @@ function referenceLabelError(value) {
 }
 
 // src/index.ts
+import { z as z4 } from "zod";
+
+// src/recognition.ts
 import { z } from "zod";
+import { canonicalJson, SourceIdentitySchema, SafeHrefSchema } from "@phosphorco/bb-context-recognition";
+var RECOGNITION_CODEC_VERSION = 1;
+var MAX_RECOGNITION_IDENTITY_BYTES = 16384;
+function recognitionIdentity(source, verified) {
+  const parsed = SourceIdentitySchema.parse(source);
+  if (parsed.provider === "bb.thread") {
+    if (!verified || verified.id !== parsed.id || verified.deletedAt != null)
+      throw new Error("A verified existing thread is required.");
+    return threadIdentity(verified.projectId, verified.id);
+  }
+  if (parsed.provider === "bb.file")
+    throw new Error("Use verifiedFileIdentity with verified frame metadata.");
+  if (parsed.provider === "bb.url") {
+    const href = SafeHrefSchema.parse(parsed.id);
+    return { provider: "url", keys: canonicalizeIdentity({ provider: "url", keys: { href: new URL(href).href } }).keys };
+  }
+  return { provider: "recognition", keys: { provider: parsed.provider, identity: sha256Hex(canonicalJson([parsed.provider, parsed.id])) } };
+}
+function recognitionIdentityRecord(source) {
+  const parsed = SourceIdentitySchema.parse(source);
+  const json = canonicalJson({ provider: parsed.provider, id: parsed.id });
+  if (new TextEncoder().encode(json).length > MAX_RECOGNITION_IDENTITY_BYTES)
+    throw new Error("Recognition identity mapping exceeds its bound.");
+  return json;
+}
+var VerifiedFileTargetSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("workspace"), environmentId: fileOwnerId(), path: verifiedFilePath() }),
+  z.strictObject({ kind: z.literal("thread-storage"), threadId: fileOwnerId(), path: verifiedFilePath() })
+]);
+function fileOwnerId() {
+  return z.string().min(1).max(128).regex(/^[A-Za-z0-9_-]+$/);
+}
+function verifiedFilePath() {
+  return z.string().min(1).max(4096).refine((path) => !path.startsWith("/") && !/[\\:%?#\u0000-\u001f\u007f]/u.test(path) && path.split("/").every((part) => part.length > 0 && part !== "." && part !== ".."), "Expected a canonical relative file path.");
+}
+function verifiedFileIdentity(value) {
+  const file = VerifiedFileTargetSchema.parse(value);
+  const owner = file.kind === "workspace" ? file.environmentId : file.threadId;
+  return { provider: "recognition", keys: { provider: "bb.file", identity: sha256Hex(canonicalJson(["bb.file", file.kind, owner, file.path])) } };
+}
+function verifiedFileIdentityRecord(value) {
+  const json = canonicalJson({ provider: "bb.file", verifiedFile: VerifiedFileTargetSchema.parse(value) });
+  if (new TextEncoder().encode(json).length > MAX_RECOGNITION_IDENTITY_BYTES)
+    throw new Error("Verified file mapping exceeds its bound.");
+  return json;
+}
+// src/producer.ts
+import { z as z2 } from "zod";
+import { canonicalJson as canonicalJson2, SafeHrefSchema as SafeHrefSchema2, SourceIdentitySchema as SourceIdentitySchema2 } from "@phosphorco/bb-context-recognition";
+var PRODUCER_METHODS = Object.freeze({ describe: "crossReferencesProducer.describe", getState: "crossReferencesProducerV1GetState", apply: "crossReferencesProducerV1Apply", reportStatus: "crossReferencesProducerV1ReportStatus" });
+var BRIEF_NAVIGATION_METHODS = Object.freeze({ describe: "threadBriefNavigation.describe", resolve: "threadBriefNavigationV1ResolveHeading" });
+var BRIEF_LIMITS = Object.freeze({ inputBytes: 1048576, statusBytes: 16384, responseBytes: 1048576, locations: 512, perTarget: 100, headingBytes: 256, describeMs: 1000, callMs: 5000, readMs: 2000, navigationInputBytes: 8192, navigationOutputBytes: 16384 });
+var DISPLAY_POLICY_LIMITS = Object.freeze({ valueChars: 1048576, valueBytes: 1048576, fields: 8192, distinct: 4096, sourceBytes: 2097152, work: 8388608, views: 4, tokens: 128, tokenChars: 4096, tokenBytes: 16384 });
+var BRIEF_LIMIT_CODES = ["target-count", "projection-bytes", "occurrence-count", "per-target-occurrences", "heading-bytes", "envelope-bytes", "presentation-label-bytes", "presentation-detail-bytes", "presentation-url-bytes", "presentation-bytes"];
+var roles = ["heading", "source-label", "target-label", "detail", "presentation-href", "provenance", "codec", "authored-url", "required-identity"];
+function wellFormed(s) {
+  for (const c of s) {
+    const n = c.codePointAt(0);
+    if (n >= 55296 && n <= 57343)
+      return false;
+  }
+  return true;
+}
+function control(s) {
+  for (const c of s) {
+    const n = c.codePointAt(0);
+    if (n < 32 || n >= 127 && n <= 159)
+      return true;
+  }
+  return false;
+}
+var space = (c) => c.trim() === "";
+
+class PolicyStop {
+  reason;
+  constructor(reason) {
+    this.reason = reason;
+  }
+}
+
+class PolicyHit {
+  reason;
+  constructor(reason) {
+    this.reason = reason;
+  }
+}
+function charge(m, n) {
+  if (n < 0 || m.work + n > DISPLAY_POLICY_LIMITS.work)
+    throw new PolicyStop("source-work-limit");
+  m.work += n;
+}
+var entities = { amp: "&", colon: ":", sol: "/", bsol: "\\", quest: "?", num: "#", percnt: "%", equals: "=", commat: "@", semi: ";", Tab: "\t", NewLine: `
+` };
+function decodeView(s, m) {
+  charge(m, s.length * 2);
+  const out = [];
+  let changed = false;
+  for (let i = 0;i < s.length; ) {
+    const c = s[i];
+    if (c === "%" && /[0-9a-f]/i.test(s[i + 1] ?? "")) {
+      const bytes = [];
+      while (s[i] === "%") {
+        const h = s.slice(i + 1, i + 3);
+        if (h.length !== 2 || !/^[0-9a-f]{2}$/i.test(h))
+          throw new PolicyStop("encoding-ambiguity");
+        bytes.push(parseInt(h, 16));
+        i += 3;
+      }
+      try {
+        out.push(new TextDecoder("utf-8", { fatal: true }).decode(Uint8Array.from(bytes)));
+      } catch {
+        throw new PolicyStop("encoding-ambiguity");
+      }
+      changed = true;
+      continue;
+    }
+    if (c === "\\") {
+      const n = s[i + 1];
+      if (n === "u") {
+        const h = s.slice(i + 2, i + 6);
+        if (!/^[0-9a-f]{4}$/i.test(h))
+          throw new PolicyStop("encoding-ambiguity");
+        let value = String.fromCharCode(parseInt(h, 16));
+        i += 6;
+        if (value.charCodeAt(0) >= 55296 && value.charCodeAt(0) <= 56319) {
+          if (s.slice(i, i + 2) !== "\\u" || !/^[0-9a-f]{4}$/i.test(s.slice(i + 2, i + 6)))
+            throw new PolicyStop("encoding-ambiguity");
+          value += String.fromCharCode(parseInt(s.slice(i + 2, i + 6), 16));
+          i += 6;
+        }
+        if (!wellFormed(value))
+          throw new PolicyStop("encoding-ambiguity");
+        out.push(value);
+        changed = true;
+        continue;
+      }
+      const escape = { "/": "/", "\\": "\\", '"': '"', b: "\b", f: "\f", n: `
+`, r: "\r", t: "\t" };
+      if (n === undefined || escape[n] === undefined)
+        throw new PolicyStop("encoding-ambiguity");
+      out.push(escape[n]);
+      i += 2;
+      changed = true;
+      continue;
+    }
+    if (c === "&" && /[A-Za-z0-9_#]/.test(s[i + 1] ?? "")) {
+      let j = i + 1;
+      while (j < s.length && j - i <= 32 && !space(s[j]) && s[j] !== ";" && s[j] !== "&")
+        j++;
+      if (s[j] === ";") {
+        const name = s.slice(i + 1, j);
+        let decoded;
+        if (name.startsWith("#")) {
+          const hex = name[1]?.toLowerCase() === "x", digits = name.slice(hex ? 2 : 1);
+          if (!(hex ? /^[a-f0-9]+$/i : /^[0-9]+$/).test(digits))
+            throw new PolicyStop("encoding-ambiguity");
+          const cp = parseInt(digits, hex ? 16 : 10);
+          if (cp > 1114111 || cp >= 55296 && cp <= 57343)
+            throw new PolicyStop("encoding-ambiguity");
+          decoded = String.fromCodePoint(cp);
+        } else
+          decoded = Object.hasOwn(entities, name) ? entities[name] : undefined;
+        if (decoded === undefined)
+          throw new PolicyStop("encoding-ambiguity");
+        out.push(decoded);
+        i = j + 1;
+        changed = true;
+        continue;
+      }
+      const partial = s.slice(i + 1, j);
+      if (s[i + 1] === "#" || j - i > 32 || !partial.includes("=") && Object.keys(entities).some((name) => name.startsWith(partial) || partial.startsWith(name)))
+        throw new PolicyStop("encoding-ambiguity");
+    }
+    out.push(c);
+    i++;
+  }
+  return { text: out.join(""), changed };
+}
+function scanPolicy(s, m, tokens) {
+  charge(m, s.length * 4);
+  const token = (value) => {
+    if (++tokens.count > DISPLAY_POLICY_LIMITS.tokens)
+      throw new PolicyStop("token-limit");
+    if (value.length > DISPLAY_POLICY_LIMITS.tokenChars)
+      throw new PolicyStop("token-limit");
+    charge(m, value.length * 2);
+    if (utf8ByteLength(value) > DISPLAY_POLICY_LIMITS.tokenBytes)
+      throw new PolicyStop("token-limit");
+  };
+  const url = (value) => {
+    token(value);
+    let u;
+    try {
+      u = new URL(value, "https://display-policy.invalid");
+    } catch {
+      throw new PolicyStop("encoding-ambiguity");
+    }
+    if (u.username || u.password)
+      throw new PolicyHit("url-credentials");
+    if (hasSensitiveUrlParameter(u))
+      throw new PolicyHit("sensitive-url-parameter");
+    if (!SafeHrefSchema2.safeParse(value).success)
+      throw new PolicyHit("unsafe-url-form");
+  };
+  for (let at = 0;at < s.length; ) {
+    while (at < s.length && space(s[at]))
+      at++;
+    const start = at;
+    while (at < s.length && !space(s[at]))
+      at++;
+    const run = s.slice(start, at);
+    if (!run)
+      continue;
+    let hasScheme = false;
+    for (let i = 0;i < run.length; i++) {
+      const tail = run.slice(i, i + 8).toLowerCase();
+      if (tail.startsWith("http://") || tail.startsWith("https://")) {
+        hasScheme = true;
+        if (run.length - i > DISPLAY_POLICY_LIMITS.tokenChars)
+          throw new PolicyStop("token-limit");
+        url(run.slice(i));
+      } else if (run[i] === ":" && run.slice(i + 1, i + 3) === "//" && i > 0 && !run.slice(Math.max(0, i - 5), i).toLowerCase().endsWith("http") && !run.slice(Math.max(0, i - 5), i).toLowerCase().endsWith("https"))
+        throw new PolicyHit("unsafe-url-form");
+    }
+    if (!hasScheme) {
+      const slash = run.indexOf("/");
+      if (slash >= 0) {
+        if (run.length - slash > DISPLAY_POLICY_LIMITS.tokenChars)
+          throw new PolicyStop("token-limit");
+        url(run.slice(slash));
+      }
+    }
+    for (let i = 0;i < run.length; i++)
+      if (run[i] === "=") {
+        let begin = i;
+        while (begin > 0 && /[A-Za-z0-9_%.-]/.test(run[begin - 1]))
+          begin--;
+        const name = run.slice(begin, i);
+        if (!name)
+          continue;
+        token(name);
+        const u = new URL("https://display-policy.invalid");
+        u.search = "?" + name + "=value";
+        if (hasSensitiveUrlParameter(u))
+          throw new PolicyHit("credential-shaped-token");
+      }
+  }
+}
+function classify(value, m) {
+  const before = m.work;
+  let views = 0;
+  const tokens = { count: 0 };
+  const result = (extra) => ({ version: 1, workUnits: m.work - before, decodedViews: views, ...extra });
+  try {
+    if (value.length > DISPLAY_POLICY_LIMITS.valueChars)
+      throw new PolicyStop("input-limit");
+    charge(m, value.length * 3);
+    if (!wellFormed(value))
+      throw new PolicyStop("ill-formed-unicode");
+    if (utf8ByteLength(value) > DISPLAY_POLICY_LIMITS.valueBytes)
+      throw new PolicyStop("input-limit");
+    let current = value;
+    for (let i = 0;i < DISPLAY_POLICY_LIMITS.views; i++) {
+      views++;
+      if (control(current))
+        throw new PolicyStop("control-character");
+      scanPolicy(current, m, tokens);
+      const decoded = decodeView(current, m);
+      if (!decoded.changed)
+        return result({ state: "safe", coverage: "complete" });
+      if (i === DISPLAY_POLICY_LIMITS.views - 1)
+        throw new PolicyStop("encoding-limit");
+      current = decoded.text;
+    }
+    throw new PolicyStop("encoding-limit");
+  } catch (e) {
+    if (e instanceof PolicyHit)
+      return result({ state: "unsafe", coverage: "complete-for-hit", reason: e.reason });
+    if (e instanceof PolicyStop)
+      return result({ state: "unclassified", coverage: "incomplete", reason: e.reason });
+    throw e;
+  }
+}
+function classifyBriefDisplayTextV1(value) {
+  if (typeof value !== "string")
+    throw new Error("Invalid display-policy argument.");
+  return classify(value, { work: 0 });
+}
+function classifyBriefDisplayFieldsV1(fields) {
+  if (!Array.isArray(fields) || fields.length > DISPLAY_POLICY_LIMITS.fields)
+    return { version: 1, state: "unclassified", reason: "field-limit", results: [], usage: { distinctValues: 0, originalUtf8Bytes: 0, workUnits: 0 }, complete: false };
+  for (const f of fields)
+    if (!f || !Array.isArray(f.key) || f.key.length > 8 || f.key.some((n) => typeof n !== "number" || !Number.isSafeInteger(n) || n < 0 || n > 8191) || !roles.includes(f.role) || typeof f.value !== "string")
+      throw new Error("Invalid display-policy field.");
+  const ordered = fields.map((f, i) => ({ f, i })).sort((a, b) => Number(b.f.role === "required-identity") - Number(a.f.role === "required-identity") || compareNumbers(a.f.key, b.f.key) || a.i - b.i);
+  const meter = { work: 0 }, cache = new Map, results = { version: 1, state: "classified", results: [], usage: { distinctValues: 0, originalUtf8Bytes: 0, workUnits: 0 }, complete: true };
+  for (const { f, i } of ordered) {
+    let r = cache.get(f.value);
+    if (!r) {
+      const incomplete = (reason) => ({ version: 1, state: "unclassified", coverage: "incomplete", reason, workUnits: 0, decodedViews: 0 });
+      if (cache.size >= DISPLAY_POLICY_LIMITS.distinct)
+        r = incomplete("field-limit");
+      else {
+        try {
+          if (f.value.length > DISPLAY_POLICY_LIMITS.valueChars)
+            r = incomplete("input-limit");
+          else {
+            charge(meter, f.value.length);
+            const bytes = utf8ByteLength(f.value);
+            if (results.usage.originalUtf8Bytes + bytes > DISPLAY_POLICY_LIMITS.sourceBytes)
+              r = incomplete("source-work-limit");
+            else {
+              results.usage.originalUtf8Bytes += bytes;
+              r = classify(f.value, meter);
+            }
+          }
+        } catch (e) {
+          if (e instanceof PolicyStop)
+            r = incomplete(e.reason);
+          else
+            throw e;
+        }
+        cache.set(f.value, r);
+      }
+    }
+    results.results[i] = { key: f.key, result: r };
+    if (r.state !== "safe")
+      results.complete = false;
+  }
+  results.usage.distinctValues = cache.size;
+  results.usage.workUnits = meter.work;
+  return results;
+}
+function compareNumbers(a, b) {
+  for (let i = 0;i < Math.min(a.length, b.length); i++)
+    if (a[i] !== b[i])
+      return a[i] - b[i];
+  return a.length - b.length;
+}
+var integer = z2.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var positive = integer.min(1);
+var digest = z2.string().regex(/^[a-f0-9]{64}$/);
+var bytes = (n) => z2.string().refine(wellFormed, "Malformed Unicode.").refine((v) => utf8ByteLength(v) <= n, "Text byte bound exceeded.");
+var plugin = z2.string().regex(/^[a-z][a-z0-9._-]{0,63}$/);
+var identity = z2.strictObject({ provider: z2.string(), keys: z2.record(z2.string(), z2.string()) }).superRefine((v, c) => {
+  try {
+    canonicalizeIdentity(v);
+  } catch {
+    c.addIssue({ code: "custom", message: "Invalid resource identity." });
+  }
+});
+var briefFileSchema = z2.strictObject({ kind: z2.literal("thread-storage"), threadId: z2.string().regex(/^[A-Za-z0-9_-]{1,128}$/), path: z2.literal("BRIEF.md") });
+var safeHref = SafeHrefSchema2.refine((v) => utf8ByteLength(v) <= 16384 && !hasSensitiveUrlParameter(new URL(v, "https://display-policy.invalid")), "Unsafe URL.");
+var cause = z2.enum(["policy", "unclassified"]);
+var withheld = (display) => z2.strictObject({ state: z2.literal("withheld"), digest, display: z2.literal(display), cause });
+var briefHeadingSchema = z2.union([z2.null(), z2.strictObject({ state: z2.literal("named"), text: bytes(256) }), withheld("Heading withheld")]);
+var labelText = bytes(256).refine((v) => !control(v) && v.trim().length > 0, "Invalid label.");
+var briefSourceLabelSchema = z2.union([z2.strictObject({ state: z2.literal("safe"), text: labelText }), withheld("Brief")]);
+var briefTargetLabelSchema = z2.union([z2.strictObject({ state: z2.literal("safe"), text: labelText }), withheld("Reference")]);
+var detail = z2.union([z2.null(), z2.strictObject({ state: z2.literal("safe"), text: bytes(1024).refine((v) => !control(v) && v.trim().length > 0) }), withheld("Details withheld")]);
+var presentationHref = z2.union([z2.strictObject({ state: z2.literal("absent") }), z2.strictObject({ state: z2.literal("exact"), href: safeHref.refine((v) => utf8ByteLength(v) <= 2048 && !control(v) && v.trim().length > 0) }), withheld("Destination withheld")]);
+var presentation = (label) => z2.strictObject({ label, detail, url: presentationHref });
+var briefSourcePresentationSchema = presentation(briefSourceLabelSchema);
+var briefTargetPresentationSchema = presentation(briefTargetLabelSchema);
+var span = z2.strictObject({ start: integer, end: positive }).refine((v) => v.end > v.start);
+var provenanceValue = z2.strictObject({
+  pluginId: plugin,
+  origin: z2.enum(["builtin", "contributed"]),
+  confidence: z2.enum(["high", "medium", "low"]),
+  recognition: z2.strictObject({ basis: z2.enum(["explicit", "text-url", "existing-link", "git-remote", "context"]), explanation: bytes(1024).min(1), evidence: z2.strictObject({ span: span.optional(), link: integer.optional(), remote: bytes(1024).optional() }).optional() }),
+  source: SourceIdentitySchema2.strict(),
+  authoredHref: safeHref.optional(),
+  verifiedFile: VerifiedFileTargetSchema.optional()
+});
+var provenanceSummary = z2.strictObject({ pluginId: plugin, origin: z2.enum(["builtin", "contributed"]), confidence: z2.enum(["high", "medium", "low"]), basis: z2.enum(["explicit", "text-url", "existing-link", "git-remote", "context"]) });
+var briefProvenanceSchema = z2.union([z2.strictObject({ state: z2.literal("safe"), value: provenanceValue }), withheld("Recognition details withheld").extend({ summary: provenanceSummary })]);
+var codecProof = z2.discriminatedUnion("kind", [
+  z2.strictObject({ kind: z2.literal("recognition"), source: SourceIdentitySchema2.strict() }),
+  z2.strictObject({ kind: z2.literal("thread"), source: SourceIdentitySchema2.strict(), verified: z2.strictObject({ id: z2.string(), projectId: z2.string() }) }),
+  z2.strictObject({ kind: z2.literal("file"), verified: VerifiedFileTargetSchema }),
+  z2.strictObject({ kind: z2.literal("url"), href: safeHref })
+]);
+var codec = z2.union([z2.strictObject({ state: z2.literal("available"), value: codecProof }), withheld("Identity metadata withheld")]);
+var briefAuthoredUrlSchema = z2.union([z2.strictObject({ state: z2.literal("exact"), href: safeHref }), z2.strictObject({ state: z2.literal("not-url") }), z2.strictObject({ state: z2.literal("unknown") }), withheld("Destination withheld")]);
+var briefFrameSchema = z2.strictObject({
+  codec: z2.literal("utf8-fatal-bom-consumed-v1"),
+  rawBytes: integer.max(1048576),
+  bomBytes: z2.union([z2.literal(0), z2.literal(3)]),
+  fileUtf16Length: integer.max(1048576),
+  bodyBase: z2.strictObject({ startUtf16: integer, startLine: positive, utf16Length: integer }),
+  lineMapping: z2.strictObject({ codec: z2.literal("native-file-lines-v1"), fileLineCount: positive })
+}).superRefine((v, c) => {
+  if (v.rawBytes < v.bomBytes || v.bodyBase.startUtf16 + v.bodyBase.utf16Length > v.fileUtf16Length || v.bodyBase.startLine > v.lineMapping.fileLineCount)
+    c.addIssue({ code: "custom", message: "Invalid source frame." });
+});
+var briefLocatorSchema = z2.strictObject({
+  kind: z2.literal("thread-brief"),
+  threadId: z2.string().regex(/^[A-Za-z0-9_-]{1,128}$/),
+  file: briefFileSchema,
+  sourceContentRevision: digest,
+  section: z2.strictObject({ heading: briefHeadingSchema, line: positive }),
+  location: z2.strictObject({ kind: z2.literal("line"), line: positive, column: positive.nullable(), endLine: positive.nullable() }),
+  span: z2.strictObject({ frame: z2.enum(["file-utf16", "body-utf16"]), start: integer, end: positive }).refine((v) => v.end > v.start).optional()
+});
+var briefOccurrenceSchema = z2.strictObject({ occurrenceKey: digest, sourceOccurrenceId: bytes(256).regex(/^ref-(0|[1-9]\d{0,2})$/).refine((v) => Number(v.slice(4)) < 512), target: identity, locator: briefLocatorSchema, provenance: briefProvenanceSchema, authoredUrl: briefAuthoredUrlSchema });
+var briefTargetDescriptorSchema = z2.strictObject({ target: identity, presentation: briefTargetPresentationSchema, codec });
+var briefEvidenceSchema = z2.strictObject({
+  kind: z2.literal("thread-brief"),
+  sourceFile: briefFileSchema,
+  sourceState: z2.enum(["present", "absent", "empty"]),
+  sourceContentRevision: digest.nullable(),
+  completeness: z2.strictObject({ state: z2.literal("complete"), codecVersion: z2.literal(1) }),
+  metadataPolicyVersion: z2.literal(1),
+  frame: briefFrameSchema.nullable(),
+  sourcePresentation: briefSourcePresentationSchema,
+  targetDescriptors: z2.array(briefTargetDescriptorSchema).max(256),
+  occurrences: z2.array(briefOccurrenceSchema).max(512)
+});
+function briefWithheldDigest(role, original) {
+  if (!roles.includes(role))
+    throw new Error("Invalid withheld role.");
+  return sha256Hex(canonicalJson2(["brief-withheld", 1, role, original]));
+}
+function briefOccurrenceKey(rawRevision, target, locator, sourceOccurrenceId) {
+  return sha256Hex(canonicalJson2(["brief-occurrence", 1, rawRevision, identityValue(target), locator, sourceOccurrenceId]));
+}
+function identityValue(v) {
+  const c = canonicalizeIdentity(v);
+  return { provider: c.provider, keys: c.keys };
+}
+function briefEvidenceDigest(input) {
+  const e = briefEvidenceSchema.parse(input);
+  return sha256Hex(canonicalJson2(["brief-evidence", 1, {
+    ...e,
+    targetDescriptors: e.targetDescriptors.map((d) => ({ ...d, target: identityValue(d.target) })).sort((a, b) => canonicalJson2(a.target) < canonicalJson2(b.target) ? -1 : canonicalJson2(a.target) > canonicalJson2(b.target) ? 1 : 0),
+    occurrences: e.occurrences.map((o) => ({ ...o, target: identityValue(o.target) })).sort((a, b) => a.occurrenceKey < b.occurrenceKey ? -1 : a.occurrenceKey > b.occurrenceKey ? 1 : 0)
+  }]));
+}
+function briefPresentation(p) {
+  return { label: p.label.state === "safe" ? p.label.text : p.label.display, ...p.detail?.state === "safe" ? { detail: p.detail.text } : {}, ...p.url.state === "exact" ? { url: p.url.href } : {} };
+}
+function briefApplyLimitCodes(input) {
+  const codes = new Set;
+  const { evidence: e, projection: p } = input;
+  if (utf8ByteLength(JSON.stringify(input)) > BRIEF_LIMITS.inputBytes)
+    codes.add("envelope-bytes");
+  if (p.targets.length > 256)
+    codes.add("target-count");
+  if (e.occurrences.length > 512)
+    codes.add("occurrence-count");
+  const per = new Map;
+  for (const o of e.occurrences) {
+    const k = canonicalJson2(o.target);
+    per.set(k, (per.get(k) ?? 0) + 1);
+    if (o.locator.section.heading?.state === "named" && utf8ByteLength(o.locator.section.heading.text) > 256)
+      codes.add("heading-bytes");
+  }
+  if ([...per.values()].some((n) => n > 100))
+    codes.add("per-target-occurrences");
+  for (const witness of [e.sourcePresentation, ...e.targetDescriptors.map((d) => d.presentation)]) {
+    const v = briefPresentation(witness);
+    if (witness.label.state === "safe" && utf8ByteLength(witness.label.text) > 256)
+      codes.add("presentation-label-bytes");
+    if (witness.detail?.state === "safe" && utf8ByteLength(witness.detail.text) > 1024)
+      codes.add("presentation-detail-bytes");
+    if (witness.url.state === "exact" && utf8ByteLength(witness.url.href) > 2048)
+      codes.add("presentation-url-bytes");
+    if (utf8ByteLength(JSON.stringify(v)) > 4096)
+      codes.add("presentation-bytes");
+  }
+  for (const r of [p.source, ...p.targets]) {
+    const v = r.presentation;
+    if (typeof v.label === "string" && utf8ByteLength(v.label) > 256)
+      codes.add("presentation-label-bytes");
+    if (typeof v.detail === "string" && utf8ByteLength(v.detail) > 1024)
+      codes.add("presentation-detail-bytes");
+    if (typeof v.url === "string" && utf8ByteLength(v.url) > 2048)
+      codes.add("presentation-url-bytes");
+    if (utf8ByteLength(JSON.stringify(v)) > 4096)
+      codes.add("presentation-bytes");
+  }
+  if (utf8ByteLength(JSON.stringify({ protocolVersion: 1, producerPluginId: p.producerPluginId, source: p.source, tombstone: p.tombstone, targets: p.targets })) > 262144)
+    codes.add("projection-bytes");
+  return [...codes].sort();
+}
+
+class BriefAdmissionError extends Error {
+  code;
+  limits;
+  constructor(code, limits = []) {
+    super(code === "over-limit" ? "Brief references exceed admitted limits." : code === "identity-unrepresentable" ? "Brief identity cannot be represented safely." : "Invalid brief evidence.");
+    this.code = code;
+    this.limits = limits;
+    this.name = "BriefAdmissionError";
+  }
+}
+function assertBriefDisplaySafe(e) {
+  const fields = [];
+  let index = 0;
+  const strings = (v, role) => {
+    if (typeof v === "string")
+      fields.push({ key: [index++], role, value: v });
+    else if (Array.isArray(v))
+      for (const x of v)
+        strings(x, role);
+    else if (v && typeof v === "object")
+      for (const x of Object.values(v))
+        strings(x, role);
+  };
+  strings(verifiedFileIdentity(e.sourceFile), "required-identity");
+  for (const d of e.targetDescriptors)
+    strings(identityValue(d.target), "required-identity");
+  const p = (v, source) => {
+    if (v.label.state === "safe")
+      strings(v.label.text, source ? "source-label" : "target-label");
+    if (v.detail?.state === "safe")
+      strings(v.detail.text, "detail");
+    if (v.url.state === "exact")
+      strings(v.url.href, "presentation-href");
+  };
+  p(e.sourcePresentation, true);
+  for (const d of e.targetDescriptors) {
+    p(d.presentation, false);
+    if (d.codec.state === "available")
+      strings(d.codec.value, "codec");
+  }
+  for (const o of e.occurrences) {
+    if (o.locator.section.heading?.state === "named")
+      strings(o.locator.section.heading.text, "heading");
+    if (o.provenance.state === "safe")
+      strings(o.provenance.value, "provenance");
+    if (o.authoredUrl.state === "exact")
+      strings(o.authoredUrl.href, "authored-url");
+  }
+  const result = classifyBriefDisplayFieldsV1(fields);
+  if (result.state !== "classified")
+    throw new BriefAdmissionError("identity-unrepresentable");
+  for (let i = 0;i < result.results.length; i++)
+    if (result.results[i].result.state !== "safe")
+      throw new BriefAdmissionError(fields[i].role === "required-identity" ? "identity-unrepresentable" : "invalid");
+}
+function validateBriefCommand(projection, evidence, evidenceDigest) {
+  const e = briefEvidenceSchema.parse(evidence);
+  if (projection.producerPluginId !== "thread-brief" || canonicalJson2(identityValue({ provider: projection.source.provider, keys: projection.source.keys })) !== canonicalJson2(verifiedFileIdentity(e.sourceFile)))
+    throw new BriefAdmissionError("invalid");
+  if (canonicalJson2(projection.source.presentation) !== canonicalJson2(briefPresentation(e.sourcePresentation)))
+    throw new BriefAdmissionError("invalid");
+  const targets = new Map(projection.targets.map((t) => {
+    const c = canonicalizeResource(t);
+    return [c.identityDigest, c];
+  }));
+  if (targets.size !== projection.targets.length || targets.size !== e.targetDescriptors.length)
+    throw new BriefAdmissionError("invalid");
+  const descriptors = new Set;
+  for (const d of e.targetDescriptors) {
+    const key = canonicalizeIdentity(d.target).identityDigest, t = targets.get(key);
+    if (!t || descriptors.has(key) || canonicalJson2(t.presentation) !== canonicalJson2(briefPresentation(d.presentation)))
+      throw new BriefAdmissionError("invalid");
+    descriptors.add(key);
+    if (d.codec.state === "available") {
+      const p = d.codec.value;
+      const decoded = p.kind === "file" ? verifiedFileIdentity(p.verified) : p.kind === "url" ? { provider: "url", keys: { href: new URL(p.href).href } } : recognitionIdentity(p.source, p.kind === "thread" ? p.verified : undefined);
+      if (canonicalJson2(identityValue(decoded)) !== canonicalJson2(identityValue(d.target)))
+        throw new BriefAdmissionError("invalid");
+    }
+  }
+  const limits = [], keys = new Set, ids = new Set, counts = new Map;
+  if (e.sourceState === "absent") {
+    if (e.sourceContentRevision !== null || e.frame !== null || e.occurrences.length || targets.size || !projection.tombstone)
+      throw new BriefAdmissionError("invalid");
+  } else {
+    if (e.sourceContentRevision === null || e.frame === null || e.sourceState === "empty" && (e.occurrences.length > 0 || targets.size > 0 || !projection.tombstone) || e.sourceState === "present" && projection.tombstone)
+      throw new BriefAdmissionError("invalid");
+  }
+  if (e.sourceState === "empty") {
+    const f = e.frame;
+    if (f.fileUtf16Length !== 0 || f.bodyBase.startUtf16 !== 0 || f.bodyBase.utf16Length !== 0 || f.bodyBase.startLine !== 1 || f.lineMapping.fileLineCount !== 1 || f.rawBytes !== f.bomBytes || e.sourceContentRevision !== sha256Hex(f.bomBytes === 3 ? "\uFEFF" : ""))
+      throw new BriefAdmissionError("invalid");
+  }
+  for (const o of e.occurrences) {
+    const key = canonicalizeIdentity(o.target).identityDigest;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+    if (!targets.has(key) || keys.has(o.occurrenceKey) || ids.has(o.sourceOccurrenceId) || o.locator.threadId !== e.sourceFile.threadId || canonicalJson2(o.locator.file) !== canonicalJson2(e.sourceFile) || o.locator.sourceContentRevision !== e.sourceContentRevision || o.occurrenceKey !== briefOccurrenceKey(e.sourceContentRevision, o.target, o.locator, o.sourceOccurrenceId))
+      throw new BriefAdmissionError("invalid");
+    const f = e.frame;
+    if (o.locator.section.line > f.lineMapping.fileLineCount || o.locator.location.line > f.lineMapping.fileLineCount || o.locator.location.endLine !== null && (o.locator.location.endLine < o.locator.location.line || o.locator.location.endLine > f.lineMapping.fileLineCount) || o.locator.span && o.locator.span.end > (o.locator.span.frame === "file-utf16" ? f.fileUtf16Length : f.bodyBase.utf16Length))
+      throw new BriefAdmissionError("invalid");
+    keys.add(o.occurrenceKey);
+    ids.add(o.sourceOccurrenceId);
+  }
+  if (counts.size !== targets.size)
+    throw new BriefAdmissionError("invalid");
+  if ([...counts.values()].some((n) => n > 100))
+    limits.push("per-target-occurrences");
+  if (limits.length)
+    throw new BriefAdmissionError("over-limit", limits);
+  assertBriefDisplaySafe(e);
+  if (briefEvidenceDigest(e) !== evidenceDigest)
+    throw new BriefAdmissionError("invalid");
+  return e;
+}
+var limitCodes = z2.array(z2.enum(BRIEF_LIMIT_CODES)).max(10).refine((v) => new Set(v).size === v.length && v.every((x, i) => i === 0 || v[i - 1] < x));
+var identityCodes = z2.array(z2.enum(["unsafe-required-identity", "unsupported-required-codec", "required-identity-bound"])).min(1).max(3).refine((v) => new Set(v).size === v.length && v.every((x, i) => i === 0 || v[i - 1] < x));
+var blockedBriefStatusSchema = z2.discriminatedUnion("state", [
+  z2.strictObject({ state: z2.literal("over-limit"), sourceContentRevision: digest, limits: limitCodes.refine((v) => v.length > 0) }),
+  z2.strictObject({ state: z2.literal("identity-unrepresentable"), sourceContentRevision: digest, identityReasons: identityCodes, limits: limitCodes })
+]);
+function briefStatusDigest(producerPluginId, source, sourceFile, status) {
+  const s = blockedBriefStatusSchema.parse(status);
+  return sha256Hex(canonicalJson2(["brief-status", 1, producerPluginId, identityValue(source), briefFileSchema.parse(sourceFile), { ...s, limits: [...s.limits].sort(), ..."identityReasons" in s ? { identityReasons: [...s.identityReasons].sort() } : {} }]));
+}
+var producerGetStateInputSchema = z2.strictObject({ version: z2.literal(1), producerPluginId: z2.literal("thread-brief"), source: identity });
+var producerReportStatusInputSchema = producerGetStateInputSchema.extend({ sourceFile: briefFileSchema, attemptRevision: positive, expectedRevision: integer, statusDigest: digest, status: blockedBriefStatusSchema }).superRefine((v, c) => {
+  if (canonicalJson2(identityValue(v.source)) !== canonicalJson2(verifiedFileIdentity(v.sourceFile)) || briefStatusDigest(v.producerPluginId, v.source, v.sourceFile, v.status) !== v.statusDigest)
+    c.addIssue({ code: "custom", message: "Invalid brief status binding." });
+});
+var presentationOut = z2.object({ label: labelText, detail: bytes(1024).refine((v) => !control(v) && v.trim().length > 0).optional(), url: bytes(2048).optional() }).passthrough();
+var resourceOut = z2.object({ provider: z2.string(), keys: z2.record(z2.string(), z2.string()), presentation: presentationOut }).passthrough();
+var projectionOut = z2.object({ producerPluginId: plugin, source: resourceOut, revision: integer, mutationId: z2.string(), payloadDigest: digest, tombstone: z2.boolean(), targets: z2.array(resourceOut).max(256) }).passthrough();
+var statusOut = z2.union([
+  blockedBriefStatusSchema.options[0].extend({ attemptRevision: positive, statusDigest: digest, sourceFile: briefFileSchema.passthrough(), applicability: z2.enum(["current", "superseded-by-graph"]) }).passthrough(),
+  blockedBriefStatusSchema.options[1].extend({ attemptRevision: positive, statusDigest: digest, sourceFile: briefFileSchema.passthrough(), applicability: z2.enum(["current", "superseded-by-graph"]) }).passthrough()
+]);
+var producerStateSchema = z2.object({ version: z2.literal(1), projection: projectionOut.nullable(), evidence: z2.object({ kind: z2.literal("thread-brief"), graphRevision: positive, graphPayloadDigest: digest, evidenceDigest: digest, sourceContentRevision: digest.nullable(), state: z2.enum(["bound", "unconfirmed"]), sourceState: z2.enum(["present", "absent", "empty"]), occurrenceCount: integer.max(512) }).passthrough().nullable(), status: statusOut.nullable(), revisionHighWater: integer }).passthrough();
+var producerDescribeInputSchema = z2.null();
+var producerDescribeOutputSchema = z2.object({ protocol: z2.literal("cross-references-producer"), versions: z2.array(positive).max(16), sourceKinds: z2.array(z2.literal("thread-brief")).max(1), limits: z2.object({ inputBytes: positive, statusBytes: positive, locations: positive, perTarget: positive, headingBytes: positive, limitCodes: z2.array(z2.string()).max(32) }).passthrough() }).passthrough();
+var producerDescribe = () => ({ protocol: "cross-references-producer", versions: [1], sourceKinds: ["thread-brief"], limits: { inputBytes: BRIEF_LIMITS.inputBytes, statusBytes: BRIEF_LIMITS.statusBytes, locations: 512, perTarget: 100, headingBytes: 256, limitCodes: [...BRIEF_LIMIT_CODES] } });
+function projectionValue(value) {
+  const resource = (r) => ({ provider: r.provider, keys: r.keys, presentation: { label: r.presentation.label, ...r.presentation.detail === undefined ? {} : { detail: r.presentation.detail }, ...r.presentation.url === undefined ? {} : { url: r.presentation.url } } });
+  return { protocolVersion: value.protocolVersion, producerPluginId: value.producerPluginId, mutationId: value.mutationId, source: resource(value.source), revision: value.revision, expectedRevision: value.expectedRevision, payloadDigest: value.payloadDigest, tombstone: value.tombstone, targets: value.targets.map(resource) };
+}
+function createProducerSchemas(projection) {
+  const admittedProjection = projection.transform(projectionValue);
+  return {
+    [PRODUCER_METHODS.describe]: { input: producerDescribeInputSchema, output: producerDescribeOutputSchema },
+    [PRODUCER_METHODS.getState]: { input: producerGetStateInputSchema, output: producerStateSchema },
+    [PRODUCER_METHODS.apply]: { input: z2.strictObject({ version: z2.literal(1), projection: admittedProjection, evidence: briefEvidenceSchema, evidenceDigest: digest }), output: z2.object({ version: z2.literal(1), outcome: z2.enum(["applied", "duplicate", "equal", "stale", "conflict", "cas-mismatch"]), currentRevision: integer, currentDigest: digest.nullable(), evidenceDisposition: z2.enum(["installed", "replayed", "conflict", "not-applied"]), state: producerStateSchema }).passthrough() },
+    [PRODUCER_METHODS.reportStatus]: { input: producerReportStatusInputSchema, output: z2.object({ version: z2.literal(1), outcome: z2.enum(["recorded", "duplicate", "stale", "conflict", "cas-mismatch"]), state: producerStateSchema }).passthrough() }
+  };
+}
+var briefNavigationInputSchema = z2.strictObject({ version: z2.literal(1), sourceFile: briefFileSchema, sourceContentRevision: digest, frame: briefFrameSchema, section: z2.strictObject({ heading: briefHeadingSchema, originalLine: positive }) });
+var briefNavigationOutputSchema = z2.discriminatedUnion("state", [
+  z2.object({ version: z2.literal(1), state: z2.literal("ready"), sourceFile: briefFileSchema.passthrough(), sourceContentRevision: digest, location: z2.object({ kind: z2.literal("line"), line: positive, column: z2.null() }).passthrough(), proof: z2.object({ kind: z2.literal("accepted-revision-revalidated"), acceptedRevision: digest, selection: z2.literal("same-revision"), frame: briefFrameSchema.safeExtend({ bodyBase: briefFrameSchema.shape.bodyBase.passthrough(), lineMapping: briefFrameSchema.shape.lineMapping.passthrough() }).passthrough() }).passthrough() }).passthrough(),
+  z2.object({ version: z2.literal(1), state: z2.literal("fallback"), sourceFile: briefFileSchema.passthrough(), location: z2.null(), reason: z2.enum(["stale", "no-accepted-document", "ambiguous", "heading-unavailable", "source-unavailable", "over-limit"]) }).passthrough()
+]);
+var briefNavigationDescribeOutputSchema = z2.object({ protocol: z2.literal("thread-brief-navigation"), versions: z2.array(positive).max(16) }).passthrough();
+var briefNavigationRpcSchemas = { [BRIEF_NAVIGATION_METHODS.describe]: { input: z2.null(), output: briefNavigationDescribeOutputSchema }, [BRIEF_NAVIGATION_METHODS.resolve]: { input: briefNavigationInputSchema, output: briefNavigationOutputSchema } };
+var outWithheld = (display) => withheld(display).passthrough();
+var briefHeadingOutputSchema = z2.union([z2.null(), z2.object({ state: z2.literal("named"), text: bytes(256) }).passthrough(), outWithheld("Heading withheld")]);
+var briefFileOutputSchema = briefFileSchema.passthrough();
+var briefFrameOutputSchema = briefFrameSchema.safeExtend({ bodyBase: briefFrameSchema.shape.bodyBase.passthrough(), lineMapping: briefFrameSchema.shape.lineMapping.passthrough() }).passthrough();
+var briefLocatorOutputSchema = briefLocatorSchema.extend({ file: briefFileOutputSchema, section: z2.object({ heading: briefHeadingOutputSchema, line: positive }).passthrough(), location: briefLocatorSchema.shape.location.passthrough(), span: briefLocatorSchema.shape.span.unwrap().passthrough().optional() }).passthrough();
+var verifiedFileOutput = z2.union([VerifiedFileTargetSchema.options[0].passthrough(), VerifiedFileTargetSchema.options[1].passthrough()]);
+var provenanceValueOutput = provenanceValue.extend({ source: SourceIdentitySchema2.passthrough(), verifiedFile: verifiedFileOutput.optional(), recognition: provenanceValue.shape.recognition.extend({ evidence: provenanceValue.shape.recognition.shape.evidence.unwrap().extend({ span: span.passthrough().optional() }).passthrough().optional() }).passthrough() }).passthrough();
+var briefProvenanceOutputSchema = z2.union([z2.object({ state: z2.literal("safe"), value: provenanceValueOutput }).passthrough(), outWithheld("Recognition details withheld").extend({ summary: provenanceSummary.passthrough() })]);
+var briefAuthoredUrlOutputSchema = z2.union([z2.object({ state: z2.literal("exact"), href: safeHref }).passthrough(), z2.object({ state: z2.literal("not-url") }).passthrough(), z2.object({ state: z2.literal("unknown") }).passthrough(), outWithheld("Destination withheld")]);
+function validateBriefNavigationResultV1(input, raw) {
+  const value = briefNavigationOutputSchema.parse(raw), file = value.sourceFile;
+  if (file.kind !== input.sourceFile.kind || file.threadId !== input.sourceFile.threadId || file.path !== input.sourceFile.path)
+    throw new Error("Brief navigation target mismatch.");
+  if (value.state === "ready" && (value.sourceContentRevision !== input.sourceContentRevision || value.proof.acceptedRevision !== input.sourceContentRevision || canonicalJson2(knownFrame(value.proof.frame)) !== canonicalJson2(knownFrame(input.frame)) || value.location.line !== input.section.originalLine || value.location.line > input.frame.lineMapping.fileLineCount))
+    throw new Error("Brief navigation proof mismatch.");
+  return value;
+}
+function knownFrame(f) {
+  return { codec: f.codec, rawBytes: f.rawBytes, bomBytes: f.bomBytes, fileUtf16Length: f.fileUtf16Length, bodyBase: { startUtf16: f.bodyBase.startUtf16, startLine: f.bodyBase.startLine, utf16Length: f.bodyBase.utf16Length }, lineMapping: { codec: f.lineMapping.codec, fileLineCount: f.lineMapping.fileLineCount } };
+}
+
+// src/evidence-v2.ts
+import { z as z3 } from "zod";
+import { ContextBundleV1Schema, SafeHrefSchema as SafeHrefSchema3, CandidateV1Schema, SourceIdentitySchema as SourceIdentitySchema3 } from "@phosphorco/bb-context-recognition";
+var MENTION_V2_LIMITS = Object.freeze({
+  responseBytes: 1048576,
+  inputBytes: 65536,
+  pageSize: 100,
+  cursorBytes: 4096,
+  excerptCodePoints: 320,
+  excerptBytes: 1280,
+  rowBytes: 131072,
+  readMs: 2000,
+  callMs: 5000,
+  lookupMs: 1500,
+  lookupCalls: 8
+});
+var MENTION_V2_METHODS = Object.freeze({ list: "crossReferencesV2ListMentions", resolve: "crossReferencesV2ResolveLookup" });
+var integer2 = () => z3.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var time = () => integer2().max(8640000000000000);
+var digest2 = z3.string().regex(/^[a-f0-9]{64}$/);
+var text = (n) => z3.string().max(n).refine((v) => utf8ByteLength(v) <= n, "UTF8 byte bound exceeded.");
+var id = z3.string().min(1).max(256).refine((v) => !/[\p{Cc}]/u.test(v));
+var producer = z3.string().regex(/^[a-z][a-z0-9._-]{0,63}$/);
+var keys = z3.record(z3.string(), z3.string()).refine((v) => Object.keys(v).length <= 16);
+function isUtf16CodePointBoundary(text2, offset) {
+  if (!Number.isSafeInteger(offset) || offset < 0 || offset > text2.length)
+    return false;
+  const before = text2.charCodeAt(offset - 1), after = text2.charCodeAt(offset);
+  return !(before >= 55296 && before <= 56319 && after >= 56320 && after <= 57343);
+}
+function wellFormedUtf16(text2) {
+  for (const point of text2) {
+    const value = point.codePointAt(0);
+    if (value >= 55296 && value <= 57343)
+      return false;
+  }
+  return true;
+}
+var identityShape = { provider: z3.string().min(1).max(64), keys };
+var identityInputV2Schema = z3.strictObject(identityShape).superRefine((v, c) => {
+  try {
+    canonicalizeIdentity(v);
+  } catch {
+    c.addIssue({ code: "custom", message: "Invalid resource identity." });
+  }
+});
+var presentation2 = z3.object({ label: text(256).min(1), url: text(2048).optional(), detail: text(1024).optional() }).passthrough();
+var resourceOutputV2Schema = z3.object({ ...identityShape, presentation: presentation2 }).passthrough().superRefine((v, c) => {
+  try {
+    canonicalizeResource({ provider: v.provider, keys: v.keys, presentation: { label: v.presentation.label, ...v.presentation.url === undefined ? {} : { url: v.presentation.url }, ...v.presentation.detail === undefined ? {} : { detail: v.presentation.detail } } });
+  } catch {
+    c.addIssue({ code: "custom", message: "Invalid resource." });
+  }
+});
+var safeAuthoredHrefSchema = SafeHrefSchema3.refine((v) => utf8ByteLength(v) <= 16384 && !hasSensitiveUrlParameter(new URL(v, "https://local.invalid")), "Unsafe destination.");
+var mentionQueryV2Schema = z3.discriminatedUnion("kind", [
+  z3.strictObject({ kind: z3.literal("resource"), target: identityInputV2Schema, relation: z3.enum(["self", "github-pr-family"]) }).refine((v) => v.relation === "self" || v.target.provider === "recognition" && v.target.keys.provider === "github" && /^[a-f0-9]{64}$/.test(v.target.keys.identity ?? ""), "Expected a GitHub root identity."),
+  z3.strictObject({ kind: z3.literal("authored-url"), href: safeAuthoredHrefSchema })
+]);
+var listMentionsInputV2Schema = z3.strictObject({
+  version: z3.literal(2),
+  query: mentionQueryV2Schema,
+  source: identityInputV2Schema.optional(),
+  producerPluginId: producer.optional(),
+  pageSize: z3.number().int().min(1).max(100).optional(),
+  cursor: text(4096).optional(),
+  ifSnapshot: digest2.optional()
+}).refine((v) => !(v.cursor !== undefined && v.ifSnapshot !== undefined), "Cursor and conditional are exclusive.");
+var spanShape = { start: integer2(), end: integer2() };
+var spanOutputV2Schema = z3.object(spanShape).passthrough().refine((v) => v.end > v.start);
+var readyShape = {
+  state: z3.literal("ready"),
+  text: z3.string().refine(wellFormedUtf16, "Excerpt text must be well-formed UTF16.").refine((v) => [...v].length <= 320 && utf8ByteLength(v) <= 1280),
+  sourceSpan: spanOutputV2Schema,
+  matchSpan: spanOutputV2Schema,
+  clippedBefore: z3.boolean(),
+  clippedAfter: z3.boolean(),
+  matchClippedBefore: z3.boolean(),
+  matchClippedAfter: z3.boolean(),
+  codecVersion: z3.literal(1)
+};
+var readyCoordinates = (v) => v.matchSpan.end <= v.text.length && v.sourceSpan.end - v.sourceSpan.start === v.text.length && isUtf16CodePointBoundary(v.text, v.matchSpan.start) && isUtf16CodePointBoundary(v.text, v.matchSpan.end);
+var excerptV2Schema = z3.discriminatedUnion("state", [
+  z3.object(readyShape).passthrough().refine(readyCoordinates, "Excerpt bounds must be code-point aligned."),
+  z3.object({ state: z3.literal("unavailable"), reason: z3.enum(["not-materialized", "indivisible-word", "no-eligible-context"]), codecVersion: z3.literal(1) }).passthrough()
+]);
+var excerptRecordV2Schema = z3.discriminatedUnion("state", [
+  z3.strictObject({ ...readyShape, sourceSpan: z3.strictObject(spanShape).refine((v) => v.end > v.start), matchSpan: z3.strictObject(spanShape).refine((v) => v.end > v.start) }).refine(readyCoordinates, "Excerpt bounds must be code-point aligned."),
+  z3.strictObject({ state: z3.literal("unavailable"), reason: z3.enum(["indivisible-word", "no-eligible-context"]), codecVersion: z3.literal(1) })
+]);
+var locatorOutputV2Schema = z3.object({ kind: z3.literal("conversation"), threadId: id, messageId: id, messageSeq: integer2(), anchorSeq: integer2().nullable(), role: z3.enum(["user", "assistant"]) }).passthrough();
+var recognitionProvenance = z3.object({
+  pluginId: id,
+  origin: z3.enum(["builtin", "contributed"]),
+  confidence: CandidateV1Schema.shape.confidence,
+  recognition: z3.object({
+    basis: z3.enum(["explicit", "text-url", "existing-link", "git-remote", "context"]),
+    explanation: z3.string().min(1).max(200),
+    evidence: z3.object({ span: spanOutputV2Schema.optional(), link: integer2().optional(), remote: id.optional() }).passthrough().optional()
+  }).passthrough(),
+  source: SourceIdentitySchema3.passthrough(),
+  authoredHref: safeAuthoredHrefSchema.optional(),
+  verifiedFile: VerifiedFileTargetSchema.optional()
+}).passthrough();
+var verifiedFileOutput2 = z3.union([
+  z3.object({ kind: z3.literal("workspace"), environmentId: id, path: z3.string().min(1).max(4096) }).passthrough(),
+  z3.object({ kind: z3.literal("thread-storage"), threadId: id, path: z3.string().min(1).max(4096) }).passthrough()
+]);
+var provenanceOutput = recognitionProvenance.extend({ verifiedFile: verifiedFileOutput2.optional() });
+var claimShape = {
+  source: resourceOutputV2Schema,
+  target: resourceOutputV2Schema,
+  producerPluginId: producer,
+  graphRevision: integer2(),
+  cap: z3.object({ state: z3.enum(["uncapped", "capped", "unknown"]), limit: z3.literal(100).nullable(), sourceHistoryUnknown: z3.boolean().nullable() }).passthrough()
+};
+var knownItem = z3.discriminatedUnion("kind", [
+  z3.object({
+    ...claimShape,
+    kind: z3.literal("brief-occurrence"),
+    evidenceRevision: integer2().min(1),
+    occurrenceKey: digest2,
+    sourceOccurrenceId: text(256),
+    locator: briefLocatorOutputSchema,
+    sourceContentRevision: digest2,
+    frame: briefFrameOutputSchema,
+    excerpt: z3.object({ state: z3.literal("unavailable"), reason: z3.literal("not-materialized"), codecVersion: z3.literal(1) }).passthrough(),
+    provenance: briefProvenanceOutputSchema,
+    authoredUrl: briefAuthoredUrlOutputSchema,
+    authoredUrlState: z3.enum(["exact", "not-url", "unknown", "withheld"]),
+    confirmation: z3.enum(["producer-attested", "retained-unconfirmed"])
+  }).passthrough().refine((v) => v.authoredUrlState === v.authoredUrl.state && v.sourceContentRevision === v.locator.sourceContentRevision && v.locator.threadId === v.locator.file.threadId, "Inconsistent Brief item."),
+  z3.object({
+    ...claimShape,
+    kind: z3.literal("occurrence"),
+    evidenceRevision: integer2().min(1),
+    occurrenceKey: digest2,
+    locator: locatorOutputV2Schema,
+    sourceContentRevision: digest2,
+    span: spanOutputV2Schema,
+    excerpt: excerptV2Schema,
+    messageCreatedAt: time(),
+    observedAt: time(),
+    confirmation: z3.enum(["observed", "retained-unconfirmed"]),
+    provenance: provenanceOutput,
+    authoredUrlState: z3.enum(["exact", "not-url", "unknown"])
+  }).passthrough(),
+  z3.object({ ...claimShape, kind: z3.literal("claim-without-evidence"), reason: z3.enum(["legacy", "producer-no-evidence", "not-yet-collected"]), matchBasis: z3.enum(["primary-resource", "primary-url-identity"]) }).passthrough(),
+  z3.object({ ...claimShape, kind: z3.literal("unsupported"), reason: z3.literal("unsupported-format") }).passthrough()
+]);
+var mentionItemV2Schema = z3.unknown().transform((raw, ctx) => {
+  const r = raw;
+  const unknown = (value, known) => typeof value === "string" && !known.includes(value);
+  const future = !!r && typeof r === "object" && (unknown(r.kind, ["occurrence", "brief-occurrence", "claim-without-evidence", "unsupported"]) || r.kind === "occurrence" && (unknown(r.locator?.kind, ["conversation"]) || unknown(r.excerpt?.state, ["ready", "unavailable"]) || typeof r.excerpt?.codecVersion === "number" && r.excerpt.codecVersion !== 1 || unknown(r.confirmation, ["observed", "retained-unconfirmed"]) || unknown(r.authoredUrlState, ["exact", "not-url", "unknown"]) || unknown(r.locator?.role, ["user", "assistant"]) || unknown(r.provenance?.origin, ["builtin", "contributed"]) || unknown(r.provenance?.confidence, ["high", "medium", "low"]) || unknown(r.provenance?.recognition?.basis, ["explicit", "text-url", "existing-link", "git-remote", "context"]) || r.excerpt?.state === "unavailable" && unknown(r.excerpt.reason, ["not-materialized", "indivisible-word", "no-eligible-context"])) || r.kind === "brief-occurrence" && (unknown(r.locator?.kind, ["thread-brief"]) || unknown(r.confirmation, ["producer-attested", "retained-unconfirmed"]) || unknown(r.authoredUrlState, ["exact", "not-url", "unknown", "withheld"]) || unknown(r.provenance?.state, ["safe", "withheld"]) || unknown(r.locator?.section?.heading?.state, ["named", "withheld"]) || unknown(r.locator?.section?.heading?.cause, ["policy", "unclassified"]) || unknown(r.provenance?.cause, ["policy", "unclassified"]) || unknown(r.authoredUrl?.state, ["exact", "not-url", "unknown", "withheld"]) || unknown(r.authoredUrl?.cause, ["policy", "unclassified"]) || unknown(r.frame?.codec, ["utf8-fatal-bom-consumed-v1"]) || unknown(r.frame?.lineMapping?.codec, ["native-file-lines-v1"]) || unknown(r.locator?.location?.kind, ["line"]) || unknown(r.locator?.span?.frame, ["file-utf16", "body-utf16"]) || unknown(r.excerpt?.state, ["unavailable"]) || unknown(r.excerpt?.reason, ["not-materialized"]) || typeof r.excerpt?.codecVersion === "number" && r.excerpt.codecVersion !== 1) || r.kind === "claim-without-evidence" && (unknown(r.reason, ["legacy", "producer-no-evidence", "not-yet-collected"]) || unknown(r.matchBasis, ["primary-resource", "primary-url-identity"])) || unknown(r.cap?.state, ["uncapped", "capped", "unknown"]));
+  if (future && (!r.cap || !z3.object({ state: z3.string(), limit: z3.literal(100).nullable(), sourceHistoryUnknown: z3.boolean().nullable() }).safeParse(r.cap).success)) {
+    ctx.addIssue({ code: "custom", message: "Invalid required claim cap." });
+    return z3.NEVER;
+  }
+  const candidate = future ? {
+    source: r.source,
+    target: r.target,
+    producerPluginId: r.producerPluginId,
+    graphRevision: r.graphRevision,
+    cap: { state: "unknown", limit: null, sourceHistoryUnknown: null },
+    kind: "unsupported",
+    reason: "unsupported-format"
+  } : raw;
+  const parsed = knownItem.safeParse(candidate);
+  if (parsed.success)
+    return parsed.data;
+  ctx.addIssue({ code: "custom", message: "Invalid mention item." });
+  return z3.NEVER;
+});
+var mentionCountsV2Schema = z3.object({ retainedOccurrences: integer2(), confirmedOccurrences: integer2(), unconfirmedOccurrences: integer2(), producerClaims: integer2(), indexedSources: integer2(), claimsWithoutLocations: integer2(), excerptUnavailable: integer2() }).passthrough().refine((v) => v.confirmedOccurrences + v.unconfirmedOccurrences === v.retainedOccurrences && v.claimsWithoutLocations <= v.producerClaims && v.indexedSources <= v.producerClaims && v.excerptUnavailable <= v.retainedOccurrences);
+var coverageV2Schema = z3.object({
+  scope: z3.literal("known-sources"),
+  collectionIncomplete: z3.boolean(),
+  retentionLimited: z3.boolean(),
+  capHistoryUnknown: z3.boolean(),
+  legacyClaimsPresent: z3.boolean(),
+  evidenceStateUnknown: z3.boolean(),
+  authoredUrlCoverage: z3.object({ state: z3.enum(["complete-for-known-locations", "partial"]), unknownLocations: integer2(), scope: z3.literal("known-locations"), watermark: digest2 }).passthrough(),
+  reasons: z3.array(text(128)).max(32),
+  reasonsClipped: z3.boolean(),
+  checkedAt: time().nullable()
+}).passthrough();
+var listMentionsOutputV2Schema = z3.discriminatedUnion("status", [
+  z3.object({ version: z3.literal(2), status: z3.literal("page"), snapshot: digest2, items: z3.array(mentionItemV2Schema).max(100), counts: mentionCountsV2Schema, coverage: coverageV2Schema, nextCursor: text(4096).nullable() }).passthrough(),
+  z3.object({ version: z3.literal(2), status: z3.literal("not-modified"), snapshot: digest2, coverage: coverageV2Schema }).passthrough(),
+  z3.object({ version: z3.literal(2), status: z3.literal("restart"), reason: z3.literal("snapshot-changed"), snapshot: digest2 }).passthrough(),
+  z3.object({ version: z3.literal(2), status: z3.literal("unavailable"), reason: z3.enum(["index-warming", "read-budget"]), retryable: z3.boolean() }).passthrough()
+]);
+var lookupContextV2Schema = ContextBundleV1Schema.omit({ consumer: true, links: true }).extend({ links: z3.array(z3.strictObject({ href: safeAuthoredHrefSchema })).max(16).optional() });
+var resolveLookupInputV2Schema = z3.strictObject({ version: z3.literal(2), text: z3.string().min(1).max(4096).refine((v) => utf8ByteLength(v) <= 16384), mode: z3.enum(["recognize", "exact-url"]), context: lookupContextV2Schema.optional() });
+var identityOutput = z3.object(identityShape).passthrough().superRefine((v, c) => {
+  try {
+    canonicalizeIdentity({ provider: v.provider, keys: v.keys });
+  } catch {
+    c.addIssue({ code: "custom", message: "Invalid lookup identity." });
+  }
+});
+var queryOutput = z3.discriminatedUnion("kind", [
+  z3.object({ kind: z3.literal("resource"), target: identityOutput, relation: z3.enum(["self", "github-pr-family"]) }).passthrough(),
+  z3.object({ kind: z3.literal("authored-url"), href: safeAuthoredHrefSchema }).passthrough()
+]);
+var resolveLookupOutputV2Schema = z3.object({
+  version: z3.literal(2),
+  state: z3.enum(["ready", "ambiguous", "unrecognized", "incomplete"]),
+  options: z3.array(z3.object({ query: queryOutput, label: text(256), inputSpan: spanOutputV2Schema, basis: z3.enum(["supplier", "native", "stored-codec"]), reasons: z3.array(text(128)).max(16) }).passthrough()).max(8),
+  reasons: z3.array(text(128)).max(16)
+}).passthrough();
+var crossReferencesV2RpcSchemas = {
+  crossReferencesV2ListMentions: { input: listMentionsInputV2Schema, output: listMentionsOutputV2Schema },
+  crossReferencesV2ResolveLookup: { input: resolveLookupInputV2Schema, output: resolveLookupOutputV2Schema }
+};
+var mentionsChangedV2Schema = z3.object({ version: z3.literal(2), producerPluginId: producer, sourceIdentityDigest: digest2, graphRevision: integer2(), evidenceRevision: integer2().nullable(), affectedIdentityDigests: z3.array(digest2).max(512), scopeListClipped: z3.boolean() }).passthrough();
+var MENTIONS_V2_CHANNEL = "cross-references-mentions-v2-changed";
+// src/lookup.ts
+function githubLookup(value) {
+  if (!safeAuthoredHrefSchema.safeParse(value).success)
+    return null;
+  let u;
+  try {
+    u = new URL(value);
+  } catch {
+    return null;
+  }
+  if (u.hostname.toLowerCase() !== "github.com" || u.port || u.username || u.password)
+    return null;
+  const p = u.pathname.replace(/\/$/, "").split("/").slice(1);
+  if (!/^[a-z0-9](?:[a-z0-9-]{0,37}[a-z0-9])?$/i.test(p[0] ?? "") || !/^[a-z0-9_.-]{1,100}$/i.test(p[1] ?? "") || [".", ".."].includes(p[1] ?? "") || !["pull", "issues"].includes(p[2] ?? "") || !/^[1-9]\d*$/.test(p[3] ?? "") || !Number.isSafeInteger(Number(p[3])))
+    return null;
+  const repo = `${p[0]}/${p[1]}`.toLowerCase(), n = String(Number(p[3])), kind = p[2] === "pull" ? "pull-request" : "issue";
+  const source = { provider: "github", id: `github.com/${repo}#${n}`, kind };
+  return { source, query: { kind: "resource", target: recognitionIdentity(source), relation: kind === "pull-request" ? "github-pr-family" : "self" }, label: `${repo}#${n}` };
+}
+// src/index.ts
 var FORWARD_REFERENCE_CHECK_LIMIT = 10;
 function assertInputRecord(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -439,130 +1347,130 @@ var namePattern = /^[a-z][a-z0-9._-]{0,63}$/;
 var uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 var digestPattern = /^[0-9a-f]{64}$/;
 var safeInteger = (schema) => schema.refine(Number.isSafeInteger, { message: "must be a safe integer" });
-var presentationSchema = z.object({
-  label: z.string().max(MAX_PRESENTATION_LABEL_BYTES),
-  detail: z.string().max(MAX_PRESENTATION_DETAIL_BYTES).optional(),
-  url: z.string().max(MAX_PRESENTATION_URL_BYTES).optional()
+var presentationSchema = z4.object({
+  label: z4.string().max(MAX_PRESENTATION_LABEL_BYTES),
+  detail: z4.string().max(MAX_PRESENTATION_DETAIL_BYTES).optional(),
+  url: z4.string().max(MAX_PRESENTATION_URL_BYTES).optional()
 }).strict().superRefine((value, context) => {
   try {
     canonicalizeResource({ provider: "test", keys: { resource: "placeholder" }, presentation: value });
-  } catch (cause) {
-    context.addIssue({ code: "custom", message: cause instanceof Error ? cause.message : String(cause) });
+  } catch (cause2) {
+    context.addIssue({ code: "custom", message: cause2 instanceof Error ? cause2.message : String(cause2) });
   }
 });
-var resourceSchema = z.object({
-  provider: z.string().max(64).regex(namePattern),
-  keys: z.record(z.string().max(64), z.string().max(MAX_KEY_VALUE_BYTES)),
+var resourceSchema = z4.object({
+  provider: z4.string().max(64).regex(namePattern),
+  keys: z4.record(z4.string().max(64), z4.string().max(MAX_KEY_VALUE_BYTES)),
   presentation: presentationSchema
 }).strict().superRefine((value, context) => {
   try {
     canonicalizeResource(value);
-  } catch (cause) {
-    context.addIssue({ code: "custom", message: cause instanceof Error ? cause.message : String(cause) });
+  } catch (cause2) {
+    context.addIssue({ code: "custom", message: cause2 instanceof Error ? cause2.message : String(cause2) });
   }
 });
-var resourceIdentitySchema = z.object({
-  provider: z.string().max(64).regex(namePattern),
-  keys: z.record(z.string().max(64), z.string().max(MAX_KEY_VALUE_BYTES))
+var resourceIdentitySchema = z4.object({
+  provider: z4.string().max(64).regex(namePattern),
+  keys: z4.record(z4.string().max(64), z4.string().max(MAX_KEY_VALUE_BYTES))
 }).strict().superRefine((value, context) => {
   try {
     canonicalizeIdentity(value);
-  } catch (cause) {
-    context.addIssue({ code: "custom", message: cause instanceof Error ? cause.message : String(cause) });
+  } catch (cause2) {
+    context.addIssue({ code: "custom", message: cause2 instanceof Error ? cause2.message : String(cause2) });
   }
 });
-var producerPluginIdSchema = z.string().max(64).regex(namePattern);
-var mutationIdSchema = z.string().max(MAX_MUTATION_ID_BYTES).regex(uuidPattern);
-var revisionSchema = safeInteger(z.number().int());
-var applyProjectionInputSchema = z.object({
-  protocolVersion: z.literal(PROTOCOL_VERSION),
+var producerPluginIdSchema = z4.string().max(64).regex(namePattern);
+var mutationIdSchema = z4.string().max(MAX_MUTATION_ID_BYTES).regex(uuidPattern);
+var revisionSchema = safeInteger(z4.number().int());
+var applyProjectionInputSchema = z4.object({
+  protocolVersion: z4.literal(PROTOCOL_VERSION),
   producerPluginId: producerPluginIdSchema,
   mutationId: mutationIdSchema,
   source: resourceSchema,
   revision: revisionSchema.positive(),
   expectedRevision: revisionSchema.nonnegative(),
-  payloadDigest: z.string().regex(digestPattern),
-  tombstone: z.boolean(),
-  targets: z.array(resourceSchema).max(MAX_TARGETS)
+  payloadDigest: z4.string().regex(digestPattern),
+  tombstone: z4.boolean(),
+  targets: z4.array(resourceSchema).max(MAX_TARGETS)
 }).strict().superRefine((value, context) => {
   try {
     normalizeProjectionCommand(value);
-  } catch (cause) {
-    context.addIssue({ code: "custom", message: cause instanceof Error ? cause.message : String(cause) });
+  } catch (cause2) {
+    context.addIssue({ code: "custom", message: cause2 instanceof Error ? cause2.message : String(cause2) });
   }
 });
-var applyProjectionResponseSchema = z.object({
-  outcome: z.enum(["applied", "duplicate", "equal", "stale", "conflict", "cas-mismatch"]),
+var applyProjectionResponseSchema = z4.object({
+  outcome: z4.enum(["applied", "duplicate", "equal", "stale", "conflict", "cas-mismatch"]),
   currentRevision: revisionSchema.nonnegative(),
-  currentDigest: z.string().regex(digestPattern).nullable()
+  currentDigest: z4.string().regex(digestPattern).nullable()
 }).strict();
-var projectionSchema = z.object({
+var projectionSchema = z4.object({
   producerPluginId: producerPluginIdSchema,
   source: resourceSchema,
   revision: revisionSchema.nonnegative(),
   mutationId: mutationIdSchema,
-  payloadDigest: z.string().regex(digestPattern),
-  tombstone: z.boolean(),
-  targets: z.array(resourceSchema).max(MAX_TARGETS)
+  payloadDigest: z4.string().regex(digestPattern),
+  tombstone: z4.boolean(),
+  targets: z4.array(resourceSchema).max(MAX_TARGETS)
 }).strict();
-var getProjectionInputSchema = z.object({
+var getProjectionInputSchema = z4.object({
   producerPluginId: producerPluginIdSchema,
   source: resourceIdentitySchema
 }).strict();
-var getProjectionOutputSchema = z.object({ projection: projectionSchema.nullable() }).strict();
-var backlinkRowSchema = z.object({
+var getProjectionOutputSchema = z4.object({ projection: projectionSchema.nullable() }).strict();
+var backlinkRowSchema = z4.object({
   source: resourceSchema,
   producerPluginId: producerPluginIdSchema,
   revision: revisionSchema.nonnegative(),
   targetPresentation: presentationSchema,
-  position: z.number().int().min(0).max(MAX_TARGETS - 1).refine(Number.isSafeInteger),
+  position: z4.number().int().min(0).max(MAX_TARGETS - 1).refine(Number.isSafeInteger),
   lastSeenAt: revisionSchema.nonnegative().nullable().optional()
 }).strict();
-var listBacklinksInputSchema = z.object({
+var listBacklinksInputSchema = z4.object({
   target: resourceIdentitySchema,
-  pageSize: z.number().int().min(1).max(100).refine(Number.isSafeInteger).optional(),
-  cursor: z.string().max(4096).optional()
+  pageSize: z4.number().int().min(1).max(100).refine(Number.isSafeInteger).optional(),
+  cursor: z4.string().max(4096).optional()
 }).strict();
-var listBacklinksOutputSchema = z.object({
-  rows: z.array(backlinkRowSchema).max(100),
+var listBacklinksOutputSchema = z4.object({
+  rows: z4.array(backlinkRowSchema).max(100),
   total: revisionSchema.nonnegative(),
-  nextCursor: z.string().max(4096).nullable()
+  nextCursor: z4.string().max(4096).nullable()
 }).strict();
-var forwardReferenceRowSchema = z.object({
+var forwardReferenceRowSchema = z4.object({
   target: resourceSchema,
   producerPluginId: producerPluginIdSchema,
   revision: revisionSchema.nonnegative(),
-  position: z.number().int().min(0).max(MAX_TARGETS - 1).refine(Number.isSafeInteger),
+  position: z4.number().int().min(0).max(MAX_TARGETS - 1).refine(Number.isSafeInteger),
   lastSeenAt: revisionSchema.nonnegative().nullable().optional()
 }).strict();
-var listForwardReferencesInputSchema = z.object({
+var listForwardReferencesInputSchema = z4.object({
   source: resourceIdentitySchema,
   producerPluginId: producerPluginIdSchema.optional(),
-  pageSize: z.number().int().min(1).max(100).refine(Number.isSafeInteger).optional(),
-  cursor: z.string().max(4096).optional()
+  pageSize: z4.number().int().min(1).max(100).refine(Number.isSafeInteger).optional(),
+  cursor: z4.string().max(4096).optional()
 }).strict();
-var listForwardReferencesOutputSchema = z.object({
-  rows: z.array(forwardReferenceRowSchema).max(100),
+var listForwardReferencesOutputSchema = z4.object({
+  rows: z4.array(forwardReferenceRowSchema).max(100),
   total: revisionSchema.nonnegative(),
-  nextCursor: z.string().max(4096).nullable()
+  nextCursor: z4.string().max(4096).nullable()
 }).strict();
-var checkForwardReferencesInputSchema = z.object({
+var checkForwardReferencesInputSchema = z4.object({
   source: resourceIdentitySchema,
   producerPluginId: producerPluginIdSchema.optional()
 }).strict();
-var forwardReferenceStatusSchema = z.object({
-  url: z.string().max(MAX_PRESENTATION_URL_BYTES),
-  status: z.number().int().min(100).max(599).nullable(),
-  label: z.string().min(1).max(128)
+var forwardReferenceStatusSchema = z4.object({
+  url: z4.string().max(MAX_PRESENTATION_URL_BYTES),
+  status: z4.number().int().min(100).max(599).nullable(),
+  label: z4.string().min(1).max(128)
 }).strict();
-var checkForwardReferencesOutputSchema = z.array(forwardReferenceStatusSchema).max(FORWARD_REFERENCE_CHECK_LIMIT);
+var checkForwardReferencesOutputSchema = z4.array(forwardReferenceStatusSchema).max(FORWARD_REFERENCE_CHECK_LIMIT);
 var CROSS_REFERENCES_PLUGIN_ID = "cross-references";
 var CROSS_REFERENCES_PROTOCOL = "cross-references";
 var LIMITS = Object.freeze({ callMs: 5000, describeMs: 1000, responseBytes: 1024 * 1024 });
-var describeInputSchema = z.null();
-var describeOutputSchema = z.object({
-  protocol: z.literal(CROSS_REFERENCES_PROTOCOL),
-  versions: z.array(z.number().int().positive().refine(Number.isSafeInteger)).max(16)
+var describeInputSchema = z4.null();
+var describeOutputSchema = z4.object({
+  protocol: z4.literal(CROSS_REFERENCES_PROTOCOL),
+  versions: z4.array(z4.number().int().positive().refine(Number.isSafeInteger)).max(16)
 });
 var crossReferencesRpcSchemas = {
   "crossReferences.describe": { input: describeInputSchema, output: describeOutputSchema },
@@ -572,14 +1480,16 @@ var crossReferencesRpcSchemas = {
   listForwardReferences: { input: listForwardReferencesInputSchema, output: listForwardReferencesOutputSchema },
   checkForwardReferences: { input: checkForwardReferencesInputSchema, output: checkForwardReferencesOutputSchema }
 };
-var referenceSnapshotSchema = z.object({
+var referenceSnapshotSchema = z4.object({
   revision: revisionSchema.nonnegative(),
-  targets: z.array(resourceSchema).max(MAX_TARGETS),
-  status: z.object({ state: z.enum(["synced", "pending", "degraded", "blocked"]), error: z.string().max(4096).nullable() })
+  targets: z4.array(resourceSchema).max(MAX_TARGETS),
+  status: z4.object({ state: z4.enum(["synced", "pending", "degraded", "blocked"]), error: z4.string().max(4096).nullable() })
 });
+var crossReferencesProducerRpcSchemas = createProducerSchemas(applyProjectionInputSchema);
 
 // src/bb.ts
-import { z as z2 } from "zod";
+import { defineRpcContract } from "@get-bb/plugin-sdk";
+import { z as z5 } from "zod";
 class CrossReferencesProtocolError extends Error {
   code = "incompatible_protocol";
   constructor(message) {
@@ -620,7 +1530,7 @@ function createCrossReferencesClient(sdk, targetPluginId = CROSS_REFERENCES_PLUG
     }, method === "crossReferences.describe" ? describeMs : callMs);
     try {
       const value = await Promise.race([
-        sdk.plugins.callRpc({ pluginId, method, input: JSON.parse(JSON.stringify(parsedInput)), outputSchema: z2.unknown(), signal: controller.signal }),
+        sdk.plugins.callRpc({ pluginId, method, input: JSON.parse(JSON.stringify(parsedInput)), outputSchema: z5.unknown(), signal: controller.signal }),
         cancelled
       ]);
       const json = JSON.stringify(value);
@@ -659,7 +1569,190 @@ function createCrossReferencesClient(sdk, targetPluginId = CROSS_REFERENCES_PLUG
     checkForwardReferences: (input, signal) => operation("checkForwardReferences", input, signal)
   };
 }
+function createCrossReferencesV2Client(sdk, targetPluginId = CROSS_REFERENCES_PLUGIN_ID, options = {}) {
+  const pluginId = validateProducerPluginId(targetPluginId), callMs = budget(options.callMs, LIMITS.callMs), describeMs = budget(options.describeMs, LIMITS.describeMs);
+  async function call(method, input, inputSchema, outputSchema, signal) {
+    const parsed = inputSchema.parse(input), json = JSON.stringify(parsed);
+    if (utf8ByteLength(json) > MENTION_V2_LIMITS.inputBytes)
+      throw new CrossReferencesProtocolError("V2 input exceeds its byte bound.");
+    signal?.throwIfAborted();
+    const controller = new AbortController;
+    let reject;
+    const cancelled = new Promise((_, r) => {
+      reject = r;
+    });
+    const abort = () => {
+      const e = signal?.reason ?? new DOMException("Request aborted", "AbortError");
+      controller.abort(e);
+      reject(e);
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+    const timer = setTimeout(() => {
+      const e = Object.assign(new Error("Cross References V2 timed out."), { name: "TimeoutError", code: "timeout" });
+      controller.abort(e);
+      reject(e);
+    }, method === "crossReferences.describe" ? describeMs : callMs);
+    try {
+      const value = await Promise.race([sdk.plugins.callRpc({ pluginId, method, input: JSON.parse(json), outputSchema: z5.unknown(), signal: controller.signal }), cancelled]);
+      const encoded = JSON.stringify(value);
+      if (encoded === undefined || utf8ByteLength(encoded) > MENTION_V2_LIMITS.responseBytes)
+        throw new CrossReferencesProtocolError("V2 response exceeds its canonical JSON byte bound.");
+      return outputSchema.parse(value);
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+      controller.abort();
+    }
+  }
+  return {
+    pluginId,
+    async describe(signal) {
+      const s = crossReferencesRpcSchemas["crossReferences.describe"];
+      const d = await call("crossReferences.describe", null, s.input, s.output, signal);
+      if (!d.versions.includes(2))
+        throw new CrossReferencesProtocolError("Wire V2 unavailable.");
+      return { protocol: CROSS_REFERENCES_PROTOCOL, version: 2 };
+    },
+    listMentions: (input, signal) => call("crossReferencesV2ListMentions", input, crossReferencesV2RpcSchemas.crossReferencesV2ListMentions.input, crossReferencesV2RpcSchemas.crossReferencesV2ListMentions.output, signal),
+    resolveLookup: (input, signal) => call("crossReferencesV2ResolveLookup", input, crossReferencesV2RpcSchemas.crossReferencesV2ResolveLookup.input, crossReferencesV2RpcSchemas.crossReferencesV2ResolveLookup.output, signal)
+  };
+}
+function sdkSchema(schema) {
+  return { "~standard": {
+    version: 1,
+    vendor: "bb-cross-references",
+    jsonSchema: {
+      input: () => z5.toJSONSchema(schema, { io: "input", unrepresentable: "any" }),
+      output: () => z5.toJSONSchema(schema, { io: "output", unrepresentable: "any" })
+    },
+    validate(value) {
+      const parsed = schema.safeParse(value);
+      return parsed.success ? { value: parsed.data } : { issues: parsed.error.issues.map((issue) => ({ message: issue.message, path: issue.path })) };
+    }
+  } };
+}
+var crossReferencesV2RpcContract = defineRpcContract({
+  crossReferencesV2ListMentions: { input: sdkSchema(crossReferencesV2RpcSchemas.crossReferencesV2ListMentions.input), output: sdkSchema(crossReferencesV2RpcSchemas.crossReferencesV2ListMentions.output) },
+  crossReferencesV2ResolveLookup: { input: sdkSchema(crossReferencesV2RpcSchemas.crossReferencesV2ResolveLookup.input), output: sdkSchema(crossReferencesV2RpcSchemas.crossReferencesV2ResolveLookup.output) }
+});
+function registerCrossReferencesV2(bb, handlers) {
+  bb.rpc.register(crossReferencesV2RpcContract, handlers);
+}
+function byteSdkSchema(schema, bytes2) {
+  const base = sdkSchema(schema);
+  return { "~standard": { ...base["~standard"], validate(value) {
+    try {
+      const json = JSON.stringify(value);
+      if (json === undefined || utf8ByteLength(json) > bytes2)
+        return { issues: [{ message: "Protocol byte bound exceeded." }] };
+    } catch {
+      return { issues: [{ message: "Invalid protocol JSON." }] };
+    }
+    return base["~standard"].validate(value);
+  } } };
+}
+var ps = crossReferencesProducerRpcSchemas;
+var ns = briefNavigationRpcSchemas;
+var crossReferencesProducerRpcContract = defineRpcContract({
+  [PRODUCER_METHODS.describe]: { input: byteSdkSchema(ps[PRODUCER_METHODS.describe].input, BRIEF_LIMITS.statusBytes), output: byteSdkSchema(ps[PRODUCER_METHODS.describe].output, BRIEF_LIMITS.statusBytes) },
+  [PRODUCER_METHODS.getState]: { input: byteSdkSchema(ps[PRODUCER_METHODS.getState].input, BRIEF_LIMITS.statusBytes), output: byteSdkSchema(ps[PRODUCER_METHODS.getState].output, BRIEF_LIMITS.responseBytes) },
+  [PRODUCER_METHODS.apply]: { input: byteSdkSchema(ps[PRODUCER_METHODS.apply].input, BRIEF_LIMITS.inputBytes), output: byteSdkSchema(ps[PRODUCER_METHODS.apply].output, BRIEF_LIMITS.responseBytes) },
+  [PRODUCER_METHODS.reportStatus]: { input: byteSdkSchema(ps[PRODUCER_METHODS.reportStatus].input, BRIEF_LIMITS.statusBytes), output: byteSdkSchema(ps[PRODUCER_METHODS.reportStatus].output, BRIEF_LIMITS.responseBytes) }
+});
+function registerCrossReferencesProducer(bb, handlers) {
+  bb.rpc.register(crossReferencesProducerRpcContract, handlers);
+}
+var briefNavigationRpcContract = defineRpcContract({
+  [BRIEF_NAVIGATION_METHODS.describe]: { input: byteSdkSchema(ns[BRIEF_NAVIGATION_METHODS.describe].input, 8192), output: byteSdkSchema(ns[BRIEF_NAVIGATION_METHODS.describe].output, 16384) },
+  [BRIEF_NAVIGATION_METHODS.resolve]: { input: byteSdkSchema(ns[BRIEF_NAVIGATION_METHODS.resolve].input, 8192), output: byteSdkSchema(ns[BRIEF_NAVIGATION_METHODS.resolve].output, 16384) }
+});
+function registerBriefNavigation(bb, handlers) {
+  bb.rpc.register(briefNavigationRpcContract, handlers);
+}
+function boundedFamilyCall(sdk, pluginId, options = {}) {
+  validateProducerPluginId(pluginId);
+  const callMs = budget(options.callMs, 5000), describeMs = budget(options.describeMs, 1000);
+  return async function call(method, input, inputSchema, outputSchema, inputBytes, outputBytes, signal) {
+    const before = JSON.stringify(input);
+    if (before === undefined || utf8ByteLength(before) > inputBytes)
+      throw new CrossReferencesProtocolError("Protocol input exceeds its byte bound.");
+    const parsed = inputSchema.parse(input);
+    signal?.throwIfAborted();
+    const controller = new AbortController;
+    let reject;
+    const cancelled = new Promise((_, r) => {
+      reject = r;
+    });
+    const abort = () => {
+      const e = signal?.reason ?? new DOMException("Request aborted", "AbortError");
+      controller.abort(e);
+      reject(e);
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+    const timer = setTimeout(() => {
+      const e = Object.assign(new Error("Protocol call timed out."), { name: "TimeoutError", code: "timeout" });
+      controller.abort(e);
+      reject(e);
+    }, method.endsWith(".describe") ? describeMs : callMs);
+    try {
+      const value = await Promise.race([sdk.plugins.callRpc({ pluginId, method, input: JSON.parse(JSON.stringify(parsed)), outputSchema: z5.unknown(), signal: controller.signal }), cancelled]);
+      const json = JSON.stringify(value);
+      if (json === undefined || utf8ByteLength(json) > outputBytes)
+        throw new CrossReferencesProtocolError("Protocol output exceeds its byte bound.");
+      return outputSchema.parse(value);
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+      controller.abort();
+    }
+  };
+}
+function createCrossReferencesProducerClient(sdk, pluginId = CROSS_REFERENCES_PLUGIN_ID, options = {}) {
+  const call = boundedFamilyCall(sdk, pluginId, options);
+  return {
+    pluginId,
+    async describe(signal) {
+      const d = await call(PRODUCER_METHODS.describe, null, ps[PRODUCER_METHODS.describe].input, ps[PRODUCER_METHODS.describe].output, 16384, 16384, signal);
+      if (!d.versions.includes(1))
+        throw new CrossReferencesProtocolError("Producer protocol unavailable.");
+      return d;
+    },
+    getState: (input, signal) => call(PRODUCER_METHODS.getState, input, ps[PRODUCER_METHODS.getState].input, ps[PRODUCER_METHODS.getState].output, 16384, 1048576, signal),
+    apply(input, signal) {
+      const limits = briefApplyLimitCodes(input);
+      if (limits.length)
+        return Promise.reject(new BriefAdmissionError("over-limit", limits));
+      validateBriefCommand(input.projection, input.evidence, input.evidenceDigest);
+      return call(PRODUCER_METHODS.apply, input, ps[PRODUCER_METHODS.apply].input, ps[PRODUCER_METHODS.apply].output, 1048576, 1048576, signal);
+    },
+    reportStatus: (input, signal) => call(PRODUCER_METHODS.reportStatus, input, ps[PRODUCER_METHODS.reportStatus].input, ps[PRODUCER_METHODS.reportStatus].output, 16384, 1048576, signal)
+  };
+}
+function createBriefNavigationClient(sdk, options = {}) {
+  const call = boundedFamilyCall(sdk, "thread-brief", options);
+  return {
+    async describe(signal) {
+      const d = await call(BRIEF_NAVIGATION_METHODS.describe, null, ns[BRIEF_NAVIGATION_METHODS.describe].input, ns[BRIEF_NAVIGATION_METHODS.describe].output, 8192, 16384, signal);
+      if (!d.versions.includes(1))
+        throw new CrossReferencesProtocolError("Brief navigation unavailable.");
+      return d;
+    },
+    async resolve(input, signal) {
+      const value = await call(BRIEF_NAVIGATION_METHODS.resolve, input, ns[BRIEF_NAVIGATION_METHODS.resolve].input, ns[BRIEF_NAVIGATION_METHODS.resolve].output, 8192, 16384, signal);
+      return validateBriefNavigationResultV1(input, value);
+    }
+  };
+}
 export {
+  registerCrossReferencesV2,
+  registerCrossReferencesProducer,
+  registerBriefNavigation,
+  crossReferencesV2RpcContract,
+  crossReferencesProducerRpcContract,
+  createCrossReferencesV2Client,
+  createCrossReferencesProducerClient,
   createCrossReferencesClient,
+  createBriefNavigationClient,
+  briefNavigationRpcContract,
   CrossReferencesProtocolError
 };