@phosphorco/bb-cross-references 0.0.0-stage → 0.1.1

package/dist/react.js

@@ -0,0 +1,1308 @@
+// src/canonical.ts
+import { sha256 } from "@noble/hashes/sha256";
+import { bytesToHex } from "@noble/hashes/utils";
+var PROTOCOL_VERSION = 1;
+var MAX_RESOURCE_KEYS = 32;
+var MAX_KEY_VALUE_BYTES = 512;
+var MAX_KEY_VALUE_MATERIAL_BYTES = 8192;
+var MAX_CANONICAL_IDENTITY_BYTES = 16 * 1024;
+var MAX_PRESENTATION_BYTES = 4 * 1024;
+var MAX_PRESENTATION_LABEL_BYTES = 256;
+var MAX_PRESENTATION_DETAIL_BYTES = 1024;
+var MAX_PRESENTATION_URL_BYTES = 2048;
+var MAX_TARGETS = 256;
+var MAX_PROJECTION_PAYLOAD_BYTES = 256 * 1024;
+var MAX_MUTATION_ID_BYTES = 128;
+var MACHINE_MONITOR_ROUTE = "/plugins/machine-monitor/machine-monitor";
+var NAME_PATTERN = /^[a-z][a-z0-9._-]{0,63}$/;
+var ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+var CONTROL_PATTERN = /\p{Cc}/u;
+var encoder = new TextEncoder;
+var SENSITIVE_URL_PARAMETER_NAMES = new Set([
+  "access_token",
+  "api_key",
+  "apikey",
+  "authorization",
+  "code",
+  "cookie",
+  "id_token",
+  "password",
+  "passwd",
+  "refresh_token",
+  "secret",
+  "session",
+  "sessionid",
+  "sid",
+  "sig",
+  "signature",
+  "token",
+  "x-amz-credential",
+  "x-amz-security-token",
+  "x-amz-signature",
+  "x-goog-credential",
+  "x-goog-signature",
+  "x-ms-signature"
+]);
+
+class CrossReferenceValidationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CrossReferenceValidationError";
+  }
+}
+function utf8ByteLength(value) {
+  return encoder.encode(value).byteLength;
+}
+function fail(message) {
+  throw new CrossReferenceValidationError(message);
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function assertPlainObject(value, label) {
+  if (!isPlainObject(value))
+    fail(`${label} must be a plain object.`);
+  if (Reflect.ownKeys(value).some((key) => typeof key !== "string")) {
+    fail(`${label} must not contain symbol keys.`);
+  }
+}
+function assertExactObjectKeys(value, allowed, label) {
+  const allowedSet = new Set(allowed);
+  for (const key of Object.keys(value)) {
+    if (!allowedSet.has(key))
+      fail(`${label} contains unknown field ${key}.`);
+  }
+}
+function assertWellFormedUnicode(value, label) {
+  for (let index = 0;index < value.length; index += 1) {
+    const codeUnit = value.charCodeAt(index);
+    if (codeUnit >= 55296 && codeUnit <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (next < 56320 || next > 57343)
+        fail(`${label} contains malformed Unicode.`);
+      index += 1;
+    } else if (codeUnit >= 56320 && codeUnit <= 57343) {
+      fail(`${label} contains malformed Unicode.`);
+    }
+  }
+}
+function assertSafeText(value, label, maxBytes, options = {}) {
+  assertWellFormedUnicode(value, label);
+  if (CONTROL_PATTERN.test(value))
+    fail(`${label} contains a Unicode control character.`);
+  if (options.nonblank === true && value.trim().length === 0)
+    fail(`${label} must not be blank.`);
+  if (utf8ByteLength(value) > maxBytes)
+    fail(`${label} exceeds its ${maxBytes}-byte limit.`);
+  return value;
+}
+function assertName(value, label) {
+  if (typeof value !== "string" || !NAME_PATTERN.test(value)) {
+    fail(`${label} must match ^[a-z][a-z0-9._-]{0,63}$.`);
+  }
+  return value;
+}
+function validateBbId(value, label) {
+  if (typeof value !== "string" || !ID_PATTERN.test(value)) {
+    fail(`${label} must match ^[A-Za-z0-9_-]{1,128}$.`);
+  }
+  return value;
+}
+function validateBbIdentity(provider, keys) {
+  if (provider !== "bb")
+    return;
+  const names = Object.keys(keys);
+  if (names.length === 1 && names[0] === "project") {
+    validateBbId(keys.project, "projectId");
+    return;
+  }
+  if (names.length === 2 && names[0] === "project" && names[1] === "thread") {
+    validateBbId(keys.project, "projectId");
+    validateBbId(keys.thread, "threadId");
+    return;
+  }
+  if (names.length === 2 && names[0] === "page" && names[1] === "plugin" && keys.page === "machine-monitor" && keys.plugin === "machine-monitor") {
+    return;
+  }
+  fail("provider bb must use a v1 project, thread, or Machine Monitor identity.");
+}
+function hasSensitiveParameterName(params) {
+  for (const name of params.keys()) {
+    if (SENSITIVE_URL_PARAMETER_NAMES.has(name.toLowerCase()))
+      return true;
+  }
+  return false;
+}
+function validateUrlIdentity(provider, keys) {
+  if (provider !== "url")
+    return;
+  const names = Object.keys(keys);
+  if (names.length !== 1 || names[0] !== "href")
+    fail("provider url must use exactly the href key.");
+  const href = keys.href;
+  let parsed;
+  try {
+    parsed = new URL(href);
+  } catch {
+    fail("url href must be a valid HTTP(S) URL.");
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+    fail("url href must use HTTP(S).");
+  if (parsed.username !== "" || parsed.password !== "")
+    fail("url href must not contain credentials.");
+  if (hasSensitiveParameterName(parsed.searchParams) || parsed.hash.startsWith("#") && hasSensitiveParameterName(new URLSearchParams(parsed.hash.slice(1)))) {
+    fail("url href must not contain credential-shaped query or fragment parameters.");
+  }
+  if (parsed.href !== href)
+    fail("url href must use canonical URL serialization.");
+}
+function validateProducerPluginId(value) {
+  return assertName(value, "producerPluginId");
+}
+function validateMutationId(value) {
+  if (typeof value !== "string" || utf8ByteLength(value) > MAX_MUTATION_ID_BYTES || !UUID_PATTERN.test(value)) {
+    fail("mutationId must be a lower-case UUID string.");
+  }
+  return value;
+}
+function validateRevision(value, label, minimum) {
+  if (!Number.isSafeInteger(value) || value < minimum) {
+    fail(`${label} must be a safe integer >= ${minimum}.`);
+  }
+  return value;
+}
+function validateDigest(value, label = "payloadDigest") {
+  if (typeof value !== "string" || !/^[0-9a-f]{64}$/.test(value)) {
+    fail(`${label} must be lower-case SHA-256 hex.`);
+  }
+  return value;
+}
+function canonicalizeKeyMap(value) {
+  assertPlainObject(value, "keys");
+  const keyNames = Object.keys(value);
+  if (keyNames.length < 1 || keyNames.length > MAX_RESOURCE_KEYS) {
+    fail(`keys must contain between 1 and ${MAX_RESOURCE_KEYS} entries.`);
+  }
+  let materialBytes = 0;
+  const entries = keyNames.map((key) => {
+    assertName(key, "key name");
+    const rawValue = value[key];
+    if (typeof rawValue !== "string")
+      fail(`key ${key} value must be a string.`);
+    const normalizedValue = rawValue.normalize("NFC");
+    const safeValue = assertSafeText(normalizedValue, `key ${key} value`, MAX_KEY_VALUE_BYTES, { nonblank: true });
+    materialBytes += utf8ByteLength(key) + utf8ByteLength(safeValue);
+    return [key, safeValue];
+  });
+  if (materialBytes > MAX_KEY_VALUE_MATERIAL_BYTES) {
+    fail(`combined key/value material exceeds its ${MAX_KEY_VALUE_MATERIAL_BYTES}-byte limit.`);
+  }
+  entries.sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+  const keys = Object.fromEntries(entries);
+  return { keys, canonicalKeysJson: JSON.stringify(keys) };
+}
+function canonicalizeIdentity(value) {
+  assertPlainObject(value, "resource identity");
+  assertExactObjectKeys(value, ["provider", "keys"], "resource identity");
+  const provider = assertName(value.provider, "provider");
+  const { keys, canonicalKeysJson } = canonicalizeKeyMap(value.keys);
+  validateBbIdentity(provider, keys);
+  validateUrlIdentity(provider, keys);
+  const identityObject = { provider, keys };
+  const canonicalIdentityJson = JSON.stringify(identityObject);
+  if (utf8ByteLength(canonicalIdentityJson) > MAX_CANONICAL_IDENTITY_BYTES) {
+    fail(`canonical identity exceeds its ${MAX_CANONICAL_IDENTITY_BYTES}-byte limit.`);
+  }
+  return {
+    provider,
+    keys,
+    canonicalKeysJson,
+    canonicalIdentityJson,
+    identityDigest: sha256Hex(canonicalIdentityJson)
+  };
+}
+function canonicalizePresentation(value) {
+  assertPlainObject(value, "presentation");
+  assertExactObjectKeys(value, ["label", "detail", "url"], "presentation");
+  if (typeof value.label !== "string")
+    fail("presentation.label must be a string.");
+  const label = assertSafeText(value.label, "presentation.label", MAX_PRESENTATION_LABEL_BYTES, { nonblank: true });
+  const presentation = { label };
+  if (value.detail !== undefined) {
+    if (typeof value.detail !== "string")
+      fail("presentation.detail must be a string when supplied.");
+    presentation.detail = assertSafeText(value.detail, "presentation.detail", MAX_PRESENTATION_DETAIL_BYTES, { nonblank: true });
+  }
+  if (value.url !== undefined) {
+    if (typeof value.url !== "string")
+      fail("presentation.url must be a string when supplied.");
+    const url = assertSafeText(value.url, "presentation.url", MAX_PRESENTATION_URL_BYTES, { nonblank: true });
+    if (url.startsWith("/") && !url.startsWith("//") && !url.includes("\\")) {
+      presentation.url = url;
+    } else if (url.startsWith("http://") || url.startsWith("https://")) {
+      try {
+        const parsed = new URL(url);
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+          fail("presentation.url must use http or https.");
+        presentation.url = url;
+      } catch {
+        fail("presentation.url must be a valid http or https URL.");
+      }
+    } else {
+      fail("presentation.url must be a same-origin route or an http(s) URL.");
+    }
+  }
+  const presentationJson = JSON.stringify(presentation);
+  if (utf8ByteLength(presentationJson) > MAX_PRESENTATION_BYTES) {
+    fail(`presentation exceeds its ${MAX_PRESENTATION_BYTES}-byte limit.`);
+  }
+  return { presentation, presentationJson };
+}
+function canonicalizeResource(value) {
+  assertPlainObject(value, "resource");
+  assertExactObjectKeys(value, ["provider", "keys", "presentation"], "resource");
+  const identity = canonicalizeIdentity({ provider: value.provider, keys: value.keys });
+  const presentation = canonicalizePresentation(value.presentation);
+  if (identity.provider === "url" && presentation.presentation.url !== identity.keys.href) {
+    fail("provider url presentation.url must equal its canonical href identity.");
+  }
+  return { ...identity, ...presentation };
+}
+function resourceIdentityOf(resource) {
+  return { provider: resource.provider, keys: resource.keys };
+}
+function projectIdentity(projectId) {
+  return { provider: "bb", keys: { project: validateBbId(projectId, "projectId") } };
+}
+function threadIdentity(projectId, threadId) {
+  return {
+    provider: "bb",
+    keys: {
+      project: validateBbId(projectId, "projectId"),
+      thread: validateBbId(threadId, "threadId")
+    }
+  };
+}
+function machineMonitorIdentity() {
+  return { provider: "bb", keys: { page: "machine-monitor", plugin: "machine-monitor" } };
+}
+function projectResource(projectId, presentation) {
+  return { ...projectIdentity(projectId), presentation };
+}
+function threadResource(projectId, threadId, presentation) {
+  return { ...threadIdentity(projectId, threadId), presentation };
+}
+function machineMonitorResource(presentation = {
+  label: "Machine Monitor",
+  url: MACHINE_MONITOR_ROUTE
+}) {
+  return { ...machineMonitorIdentity(), presentation };
+}
+function serializeResource(resource) {
+  return {
+    provider: resource.provider,
+    keys: resource.keys,
+    presentation: resource.presentation
+  };
+}
+function sha256Hex(value) {
+  return bytesToHex(sha256(encoder.encode(value)));
+}
+function projectionPayloadJson(producerPluginId, source, tombstone, targets) {
+  const payload = {
+    protocolVersion: PROTOCOL_VERSION,
+    producerPluginId,
+    source: serializeResource(source),
+    tombstone,
+    targets: targets.map(serializeResource)
+  };
+  const json = JSON.stringify(payload);
+  if (utf8ByteLength(json) > MAX_PROJECTION_PAYLOAD_BYTES) {
+    fail(`projection payload exceeds its ${MAX_PROJECTION_PAYLOAD_BYTES}-byte limit.`);
+  }
+  return json;
+}
+function projectionPayloadDigest(producerPluginId, source, tombstone, targets) {
+  return sha256Hex(projectionPayloadJson(producerPluginId, source, tombstone, targets));
+}
+function isExactBbThreadResource(resource) {
+  const keys = Object.keys(resource.keys);
+  return resource.provider === "bb" && keys.length === 2 && keys[0] === "project" && keys[1] === "thread" && ID_PATTERN.test(resource.keys.project) && ID_PATTERN.test(resource.keys.thread);
+}
+function isUrlResource(resource) {
+  return resource.provider === "url" && Object.keys(resource.keys).length === 1 && resource.keys.href != null && resource.presentation.url === resource.keys.href;
+}
+function normalizeThreadOrUrlReference(target) {
+  const resource = canonicalizeResource(target);
+  if (!isExactBbThreadResource(resource) && !isUrlResource(resource)) {
+    throw new CrossReferenceValidationError("References must be exact BB threads or safe HTTP(S) URLs.");
+  }
+  if (isExactBbThreadResource(resource) && resource.presentation.url !== undefined && resource.presentation.url !== `/projects/${resource.keys.project}/threads/${resource.keys.thread}` && resource.presentation.url !== `/threads/${resource.keys.thread}`) {
+    throw new CrossReferenceValidationError("Native thread presentation URL must match its thread identity.");
+  }
+  return resource;
+}
+function urlResource(href, presentation) {
+  const canonicalHref = new URL(href).href;
+  return { provider: "url", keys: { href: canonicalHref }, presentation: { ...presentation, url: canonicalHref } };
+}
+var MAX_REFERENCE_URL_BYTES = 512;
+var MAX_REFERENCE_LABEL_BYTES = 256;
+function hasSensitiveUrlParameter(url) {
+  return hasSensitiveParameterName(url.searchParams) || url.hash.startsWith("#") && hasSensitiveParameterName(new URLSearchParams(url.hash.slice(1)));
+}
+function referenceLabelError(value) {
+  if (value.trim().length === 0)
+    return "Give this external reference a name.";
+  if (utf8ByteLength(value) > MAX_REFERENCE_LABEL_BYTES) {
+    return `Reference names are limited to ${MAX_REFERENCE_LABEL_BYTES} UTF-8 bytes.`;
+  }
+  return null;
+}
+
+// src/index.ts
+import { z } from "zod";
+var FORWARD_REFERENCE_CHECK_LIMIT = 10;
+function assertInputRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new CrossReferenceValidationError("projection input must be an object.");
+  }
+  const fields = Object.keys(value).sort();
+  if (fields.join(",") !== "expectedRevision,mutationId,payloadDigest,producerPluginId,protocolVersion,revision,source,targets,tombstone") {
+    throw new CrossReferenceValidationError("projection input fields are invalid.");
+  }
+}
+function normalizeProjectionCommand(input) {
+  assertInputRecord(input);
+  if (input.protocolVersion !== PROTOCOL_VERSION) {
+    throw new CrossReferenceValidationError(`protocolVersion must be ${PROTOCOL_VERSION}.`);
+  }
+  const producerPluginId = validateProducerPluginId(input.producerPluginId);
+  const mutationId = validateMutationId(input.mutationId);
+  const revision = validateRevision(input.revision, "revision", 1);
+  const expectedRevision = validateRevision(input.expectedRevision, "expectedRevision", 0);
+  if (typeof input.tombstone !== "boolean") {
+    throw new CrossReferenceValidationError("tombstone must be a boolean.");
+  }
+  if (!Array.isArray(input.targets) || input.targets.length > MAX_TARGETS) {
+    throw new CrossReferenceValidationError(`targets must contain at most ${MAX_TARGETS} resources.`);
+  }
+  const source = canonicalizeResource(input.source);
+  const targets = input.targets.map((target) => canonicalizeResource(target));
+  const identitySet = new Set;
+  for (const target of targets) {
+    if (identitySet.has(target.canonicalIdentityJson)) {
+      throw new CrossReferenceValidationError("targets must not contain duplicate resource identities.");
+    }
+    identitySet.add(target.canonicalIdentityJson);
+  }
+  if (input.tombstone && targets.length !== 0) {
+    throw new CrossReferenceValidationError("a tombstone must have an empty target list.");
+  }
+  const payloadJson = projectionPayloadJson(producerPluginId, source, input.tombstone, targets);
+  const computedPayloadDigest = sha256Hex(payloadJson);
+  const payloadDigest = validateDigest(input.payloadDigest);
+  if (payloadDigest !== computedPayloadDigest) {
+    throw new CrossReferenceValidationError("payloadDigest does not match the canonical projection payload.");
+  }
+  return {
+    protocolVersion: PROTOCOL_VERSION,
+    producerPluginId,
+    mutationId,
+    source,
+    revision,
+    expectedRevision,
+    payloadDigest,
+    tombstone: input.tombstone,
+    targets,
+    payloadJson,
+    computedPayloadDigest
+  };
+}
+function normalizeIdentityInput(input) {
+  return canonicalizeIdentity(input);
+}
+function defaultPageSize(pageSize) {
+  if (pageSize === undefined)
+    return 25;
+  const validated = validateRevision(pageSize, "pageSize", 1);
+  if (validated > 100) {
+    throw new CrossReferenceValidationError("pageSize must be between 1 and 100.");
+  }
+  return validated;
+}
+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()
+}).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) });
+  }
+});
+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)),
+  presentation: presentationSchema
+}).strict().superRefine((value, context) => {
+  try {
+    canonicalizeResource(value);
+  } catch (cause) {
+    context.addIssue({ code: "custom", message: cause instanceof Error ? cause.message : String(cause) });
+  }
+});
+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))
+}).strict().superRefine((value, context) => {
+  try {
+    canonicalizeIdentity(value);
+  } catch (cause) {
+    context.addIssue({ code: "custom", message: cause instanceof Error ? cause.message : String(cause) });
+  }
+});
+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),
+  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)
+}).strict().superRefine((value, context) => {
+  try {
+    normalizeProjectionCommand(value);
+  } catch (cause) {
+    context.addIssue({ code: "custom", message: cause instanceof Error ? cause.message : String(cause) });
+  }
+});
+var applyProjectionResponseSchema = z.object({
+  outcome: z.enum(["applied", "duplicate", "equal", "stale", "conflict", "cas-mismatch"]),
+  currentRevision: revisionSchema.nonnegative(),
+  currentDigest: z.string().regex(digestPattern).nullable()
+}).strict();
+var projectionSchema = z.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)
+}).strict();
+var getProjectionInputSchema = z.object({
+  producerPluginId: producerPluginIdSchema,
+  source: resourceIdentitySchema
+}).strict();
+var getProjectionOutputSchema = z.object({ projection: projectionSchema.nullable() }).strict();
+var backlinkRowSchema = z.object({
+  source: resourceSchema,
+  producerPluginId: producerPluginIdSchema,
+  revision: revisionSchema.nonnegative(),
+  targetPresentation: presentationSchema,
+  position: z.number().int().min(0).max(MAX_TARGETS - 1).refine(Number.isSafeInteger),
+  lastSeenAt: revisionSchema.nonnegative().nullable().optional()
+}).strict();
+var listBacklinksInputSchema = z.object({
+  target: resourceIdentitySchema,
+  pageSize: z.number().int().min(1).max(100).refine(Number.isSafeInteger).optional(),
+  cursor: z.string().max(4096).optional()
+}).strict();
+var listBacklinksOutputSchema = z.object({
+  rows: z.array(backlinkRowSchema).max(100),
+  total: revisionSchema.nonnegative(),
+  nextCursor: z.string().max(4096).nullable()
+}).strict();
+var forwardReferenceRowSchema = z.object({
+  target: resourceSchema,
+  producerPluginId: producerPluginIdSchema,
+  revision: revisionSchema.nonnegative(),
+  position: z.number().int().min(0).max(MAX_TARGETS - 1).refine(Number.isSafeInteger),
+  lastSeenAt: revisionSchema.nonnegative().nullable().optional()
+}).strict();
+var listForwardReferencesInputSchema = z.object({
+  source: resourceIdentitySchema,
+  producerPluginId: producerPluginIdSchema.optional(),
+  pageSize: z.number().int().min(1).max(100).refine(Number.isSafeInteger).optional(),
+  cursor: z.string().max(4096).optional()
+}).strict();
+var listForwardReferencesOutputSchema = z.object({
+  rows: z.array(forwardReferenceRowSchema).max(100),
+  total: revisionSchema.nonnegative(),
+  nextCursor: z.string().max(4096).nullable()
+}).strict();
+var checkForwardReferencesInputSchema = z.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)
+}).strict();
+var checkForwardReferencesOutputSchema = z.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 crossReferencesRpcSchemas = {
+  "crossReferences.describe": { input: describeInputSchema, output: describeOutputSchema },
+  applyProjection: { input: applyProjectionInputSchema, output: applyProjectionResponseSchema },
+  getProjection: { input: getProjectionInputSchema, output: getProjectionOutputSchema },
+  listBacklinks: { input: listBacklinksInputSchema, output: listBacklinksOutputSchema },
+  listForwardReferences: { input: listForwardReferencesInputSchema, output: listForwardReferencesOutputSchema },
+  checkForwardReferences: { input: checkForwardReferencesInputSchema, output: checkForwardReferencesOutputSchema }
+};
+var referenceSnapshotSchema = z.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() })
+});
+
+// src/react.tsx
+import { useCallback, useEffect, useId, useMemo, useRef, useState } from "react";
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+var MAX_SEARCH_RESULTS = 24;
+var MAX_REFERENCE_INPUT_LENGTH = 2048;
+function targetThread(target) {
+  if (target.provider !== "bb" || Object.keys(target.keys).length !== 2)
+    return null;
+  const projectId = target.keys.project;
+  const threadId = target.keys.thread;
+  return typeof projectId === "string" && typeof threadId === "string" ? { projectId, threadId } : null;
+}
+function targetUrl(target) {
+  return target.provider === "url" && Object.keys(target.keys).length === 1 && typeof target.keys.href === "string" && target.presentation.url === target.keys.href ? target.keys.href : null;
+}
+function threadResource2(thread) {
+  return {
+    provider: "bb",
+    keys: { project: thread.projectId, thread: thread.id },
+    presentation: {
+      label: thread.title,
+      detail: `Project ${thread.projectId}`
+    }
+  };
+}
+function resourceKey(resource) {
+  return JSON.stringify([resource.provider, Object.entries(resource.keys).sort(([left], [right]) => left.localeCompare(right))]);
+}
+function referenceInput(value, origin) {
+  const input = value.trim();
+  if (input.length === 0)
+    return { kind: "empty" };
+  if (!/^https?:\/\//iu.test(input))
+    return { kind: "query", query: input };
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    return { kind: "invalid", input, message: "Enter a valid HTTP or HTTPS URL." };
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    return { kind: "invalid", input, message: "Only HTTP and HTTPS links can be attached." };
+  }
+  if (url.username !== "" || url.password !== "" || hasSensitiveUrlParameter(url)) {
+    return { kind: "invalid", input, message: "Links containing credentials or sensitive parameters cannot be attached." };
+  }
+  if (utf8ByteLength(url.href) > MAX_REFERENCE_URL_BYTES) {
+    return { kind: "invalid", input, message: `Links are limited to ${MAX_REFERENCE_URL_BYTES} UTF-8 bytes after URL encoding.` };
+  }
+  if (url.origin === origin) {
+    const projectRoute = url.pathname.match(/^\/projects\/([A-Za-z0-9_-]{1,128})\/threads\/([A-Za-z0-9_-]{1,128})\/?$/u);
+    if (projectRoute != null) {
+      return { kind: "thread-url", input, projectId: projectRoute[1], threadId: projectRoute[2] };
+    }
+    const personalRoute = url.pathname.match(/^\/threads\/([A-Za-z0-9_-]{1,128})\/?$/u);
+    if (personalRoute != null)
+      return { kind: "thread-url", input, projectId: null, threadId: personalRoute[1] };
+  }
+  return {
+    kind: "external-url",
+    href: url.href,
+    suggestedLabel: url.hostname.replace(/^www\./u, "") || "External link"
+  };
+}
+function useThreadSearch(query, retry, api, connection, origin) {
+  const apiRef = useRef(api);
+  apiRef.current = api;
+  const input = query.trim();
+  const [state, setState] = useState({ status: "idle", input: "" });
+  useEffect(() => {
+    const parsed = referenceInput(input, origin);
+    if (parsed.kind === "empty" || parsed.kind === "query" && parsed.query.length < 2) {
+      setState({ status: "idle", input });
+      return;
+    }
+    if (parsed.kind === "invalid") {
+      setState({ status: "error", input, message: parsed.message });
+      return;
+    }
+    if (parsed.kind === "external-url") {
+      setState({ status: "external", input, href: parsed.href, suggestedLabel: parsed.suggestedLabel });
+      return;
+    }
+    if (parsed.kind === "query" && parsed.query.length > 256) {
+      setState({ status: "error", input, message: "Thread searches are limited to 256 characters." });
+      return;
+    }
+    if (connection !== "connected") {
+      setState({ status: "waiting", input });
+      return;
+    }
+    let active = true;
+    setState({ status: "searching", input });
+    const timer = window.setTimeout(() => {
+      if (parsed.kind === "thread-url") {
+        const href = new URL(parsed.input).href;
+        apiRef.current.thread(parsed.threadId).then((thread) => {
+          if (!active)
+            return;
+          if (parsed.projectId == null || thread.projectId === parsed.projectId) {
+            setState({ status: "ready", input, threads: [thread] });
+          } else {
+            setState({ status: "external", input, href, suggestedLabel: "BB thread link" });
+          }
+        }, () => {
+          if (active)
+            setState({
+              status: "external",
+              input,
+              href,
+              suggestedLabel: "BB thread link",
+              resolutionError: "Could not resolve this BB thread. Retry the lookup or save the URL as an external reference.",
+              canRetry: true
+            });
+        });
+        return;
+      }
+      apiRef.current.search(parsed.query).then((response) => {
+        if (active)
+          setState({ status: "ready", input, threads: response.threads.slice(0, MAX_SEARCH_RESULTS) });
+      }, (cause) => {
+        if (active)
+          setState({
+            status: "error",
+            input,
+            message: cause instanceof Error ? cause.message : "Could not search BB threads."
+          });
+      });
+    }, 180);
+    return () => {
+      active = false;
+      window.clearTimeout(timer);
+    };
+  }, [connection, input, retry, origin, api]);
+  return state.input === input ? state : { status: "searching", input };
+}
+function useAttachments(api, connection, refreshToken) {
+  const apiRef = useRef(api);
+  apiRef.current = api;
+  const [snapshot, setSnapshot] = useState(null);
+  const snapshotRef = useRef(null);
+  snapshotRef.current = snapshot;
+  const [loading, setLoading] = useState(true);
+  const [readError, setReadError] = useState(null);
+  const [mutationError, setMutationError] = useState(null);
+  const [stale, setStale] = useState(false);
+  const [saving, setSaving] = useState(false);
+  const mounted = useRef(true);
+  const mutationInFlight = useRef(false);
+  const readControl = useRef({ generation: 0, inFlight: false, pending: false });
+  const applySnapshot = useCallback((next) => {
+    snapshotRef.current = next;
+    setSnapshot(next);
+  }, []);
+  const restartReads = useCallback(() => {
+    readControl.current = {
+      generation: readControl.current.generation + 1,
+      inFlight: false,
+      pending: false
+    };
+  }, []);
+  const refresh = useCallback(async () => {
+    const control = readControl.current;
+    control.pending = true;
+    if (!mounted.current || mutationInFlight.current || control.inFlight)
+      return;
+    control.inFlight = true;
+    try {
+      while (mounted.current && !mutationInFlight.current && readControl.current === control && control.pending) {
+        control.pending = false;
+        try {
+          const next = await apiRef.current.get();
+          if (mounted.current && readControl.current === control && !mutationInFlight.current) {
+            applySnapshot(next);
+            setReadError(null);
+            setStale(false);
+            setLoading(false);
+          }
+        } catch (cause) {
+          if (mounted.current && readControl.current === control && !mutationInFlight.current) {
+            setReadError(cause instanceof Error ? cause.message : "Could not read saved references.");
+            setLoading(false);
+          }
+        }
+      }
+    } finally {
+      if (readControl.current === control)
+        control.inFlight = false;
+    }
+  }, [applySnapshot]);
+  useEffect(() => {
+    mounted.current = true;
+    restartReads();
+    setLoading(snapshotRef.current == null);
+    refresh();
+    return () => {
+      mounted.current = false;
+      restartReads();
+    };
+  }, [refresh, restartReads]);
+  const previousToken = useRef(refreshToken);
+  useEffect(() => {
+    if (previousToken.current !== refreshToken) {
+      previousToken.current = refreshToken;
+      refresh();
+    }
+  }, [refresh, refreshToken]);
+  const previousConnection = useRef(connection);
+  useEffect(() => {
+    if (connection === "reconnecting") {
+      setStale(true);
+      restartReads();
+      previousConnection.current = connection;
+      return;
+    }
+    if (connection === "connected" && previousConnection.current !== "connected") {
+      restartReads();
+      refresh();
+    }
+    previousConnection.current = connection;
+  }, [connection, refresh, restartReads]);
+  const mutate = useCallback(async (transform) => {
+    if (mutationInFlight.current)
+      return false;
+    const current = snapshotRef.current;
+    if (current == null)
+      return false;
+    const targets = transform(current.targets);
+    if (targets == null)
+      return true;
+    mutationInFlight.current = true;
+    setSaving(true);
+    setMutationError(null);
+    restartReads();
+    try {
+      const result = await apiRef.current.replace(current.revision, targets);
+      if (!mounted.current)
+        return false;
+      applySnapshot(result);
+      if (result.outcome === "cas-mismatch") {
+        setMutationError("These saved links changed in another window. The latest list is shown below.");
+        return false;
+      }
+      return true;
+    } catch (cause) {
+      if (mounted.current) {
+        setMutationError(cause instanceof Error ? cause.message : "Could not save this thread link.");
+      }
+      return false;
+    } finally {
+      mutationInFlight.current = false;
+      if (mounted.current)
+        setSaving(false);
+      refresh();
+    }
+  }, [applySnapshot, refresh, restartReads]);
+  const add = useCallback((thread) => mutate((targets) => {
+    const target = threadResource2(thread);
+    const key = resourceKey(target);
+    return targets.some((candidate) => resourceKey(candidate) === key) ? null : [...targets, target];
+  }), [mutate]);
+  const addResource = useCallback((target) => mutate((targets) => {
+    const key = resourceKey(target);
+    return targets.some((candidate) => resourceKey(candidate) === key) ? null : [...targets, target];
+  }), [mutate]);
+  const remove = useCallback((target) => mutate((targets) => {
+    const key = resourceKey(target);
+    return targets.filter((candidate) => resourceKey(candidate) !== key);
+  }), [mutate]);
+  return { snapshot, loading, readError, mutationError, stale, saving, refresh, add, addResource, remove };
+}
+var PERSONAL_PROJECT_ID = "proj_personal";
+function threadHref(projectId, threadId) {
+  const encodedProjectId = encodeURIComponent(projectId);
+  const encodedThreadId = encodeURIComponent(threadId);
+  return projectId === PERSONAL_PROJECT_ID ? `/threads/${encodedThreadId}` : `/projects/${encodedProjectId}/threads/${encodedThreadId}`;
+}
+function ThreadLink({ projectId, threadId, label, navigateThread }) {
+  return /* @__PURE__ */ jsx("a", {
+    className: "bb-reference-links__reference-link",
+    href: threadHref(projectId, threadId),
+    onClick: (event) => {
+      if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey)
+        return;
+      event.preventDefault();
+      navigateThread(threadId);
+    },
+    children: label
+  });
+}
+function ReferenceLink({ target, navigateThread }) {
+  const thread = targetThread(target);
+  if (thread != null) {
+    return /* @__PURE__ */ jsx(ThreadLink, {
+      projectId: thread.projectId,
+      threadId: thread.threadId,
+      label: target.presentation.label,
+      navigateThread
+    });
+  }
+  const href = targetUrl(target);
+  if (href == null)
+    return /* @__PURE__ */ jsx("span", {
+      className: "bb-reference-links__reference-link",
+      children: target.presentation.label
+    });
+  return /* @__PURE__ */ jsx("a", {
+    className: "bb-reference-links__reference-link",
+    href,
+    children: target.presentation.label
+  });
+}
+function ThreadPicker({
+  api,
+  connection,
+  origin,
+  attached,
+  disabled,
+  onAdd,
+  onAddResource,
+  searchInputRef
+}) {
+  const apiRef = useRef(api);
+  apiRef.current = api;
+  const searchId = `bb-reference-thread-search-${useId().replaceAll(":", "")}`;
+  const nameId = `${searchId}-external-name`;
+  const [query, setQuery] = useState("");
+  const queryRef = useRef(query);
+  queryRef.current = query;
+  const [searchRetry, setSearchRetry] = useState(0);
+  const search = useThreadSearch(query, searchRetry, api, connection, origin);
+  const [externalName, setExternalName] = useState("");
+  const [externalNameError, setExternalNameError] = useState(null);
+  const [selectingId, setSelectingId] = useState(null);
+  const [selectionError, setSelectionError] = useState(null);
+  const selectionSequence = useRef(0);
+  const [returnFocus, setReturnFocus] = useState(null);
+  useEffect(() => {
+    if (!returnFocus || disabled || selectingId !== null || query !== "")
+      return;
+    if (document.activeElement === document.body || document.activeElement === returnFocus.trigger)
+      searchInputRef.current?.focus();
+    setReturnFocus(null);
+  }, [returnFocus, disabled, selectingId, query, searchInputRef]);
+  useEffect(() => {
+    return () => {
+      selectionSequence.current += 1;
+    };
+  }, []);
+  useEffect(() => {
+    if (search.status === "external") {
+      setExternalName(search.suggestedLabel);
+      setExternalNameError(null);
+    }
+  }, [search.status === "external" ? search.href : null]);
+  const select = async (thread, restoreKeyboardFocus) => {
+    const sequence = ++selectionSequence.current;
+    const selectedQuery = queryRef.current;
+    const trigger = document.activeElement;
+    setSelectingId(thread.id);
+    setSelectionError(null);
+    try {
+      const fresh = await apiRef.current.thread(thread.id);
+      if (sequence !== selectionSequence.current)
+        return;
+      if (await onAdd(fresh) && queryRef.current === selectedQuery) {
+        setQuery("");
+        if (restoreKeyboardFocus)
+          setReturnFocus({ trigger });
+      }
+    } catch (cause) {
+      if (sequence === selectionSequence.current) {
+        setSelectionError(cause instanceof Error ? cause.message : "Could not attach this thread.");
+      }
+    } finally {
+      if (sequence === selectionSequence.current)
+        setSelectingId(null);
+    }
+  };
+  const attachExternal = async (restoreKeyboardFocus) => {
+    if (search.status !== "external")
+      return;
+    const label = externalName.trim();
+    const labelError = referenceLabelError(label);
+    if (labelError != null) {
+      setExternalNameError(labelError);
+      return;
+    }
+    const sequence = ++selectionSequence.current;
+    const selectedQuery = queryRef.current;
+    const trigger = document.activeElement;
+    setSelectingId(search.href);
+    setSelectionError(null);
+    const resource = {
+      provider: "url",
+      keys: { href: search.href },
+      presentation: { label, detail: new URL(search.href).hostname, url: search.href }
+    };
+    try {
+      if (await onAddResource(resource) && sequence === selectionSequence.current && queryRef.current === selectedQuery) {
+        setQuery("");
+        if (restoreKeyboardFocus)
+          setReturnFocus({ trigger });
+      }
+    } finally {
+      if (sequence === selectionSequence.current)
+        setSelectingId(null);
+    }
+  };
+  const results = search.status === "ready" ? search.threads : [];
+  const externalAttached = search.status === "external" && attached.has(resourceKey({
+    provider: "url",
+    keys: { href: search.href },
+    presentation: { label: externalName || search.suggestedLabel, url: search.href }
+  }));
+  const statusText = search.status === "searching" ? "Searching threads…" : search.status === "waiting" ? "Search will resume when the connection returns." : search.status === "ready" && search.threads.length === 0 ? "No matching threads." : search.status === "ready" ? `${search.threads.length} matching thread${search.threads.length === 1 ? "" : "s"}.` : "";
+  return /* @__PURE__ */ jsxs("div", {
+    className: "bb-reference-links__reference-picker",
+    children: [
+      /* @__PURE__ */ jsx("label", {
+        htmlFor: searchId,
+        children: "Add a thread or link"
+      }),
+      /* @__PURE__ */ jsx("input", {
+        ref: searchInputRef,
+        id: searchId,
+        type: "search",
+        value: query,
+        disabled,
+        maxLength: MAX_REFERENCE_INPUT_LENGTH,
+        onChange: (event) => {
+          setQuery(event.target.value);
+          setSelectionError(null);
+        },
+        placeholder: "Search threads or paste a URL…",
+        "aria-invalid": search.status === "error" || undefined,
+        "aria-describedby": `${searchId}-help${search.status === "error" ? ` ${searchId}-error` : ""}`
+      }),
+      /* @__PURE__ */ jsx("p", {
+        id: `${searchId}-help`,
+        className: "bb-reference-links__reference-help",
+        children: "Search active and archived threads, or paste a link. BB thread links on this host resolve to their thread."
+      }),
+      /* @__PURE__ */ jsx("p", {
+        className: "bb-reference-links__reference-status",
+        role: "status",
+        "aria-live": "polite",
+        children: statusText
+      }),
+      search.status === "error" && /* @__PURE__ */ jsx("p", {
+        id: `${searchId}-error`,
+        className: "bb-reference-links__reference-error",
+        role: "alert",
+        children: search.message
+      }),
+      selectionError != null && /* @__PURE__ */ jsx("p", {
+        className: "bb-reference-links__reference-error",
+        role: "alert",
+        children: selectionError
+      }),
+      results.length > 0 && /* @__PURE__ */ jsx("ul", {
+        className: "bb-reference-links__reference-search-results",
+        children: results.map((thread) => {
+          const key = resourceKey(threadResource2(thread));
+          const isAttached = attached.has(key);
+          return /* @__PURE__ */ jsxs("li", {
+            children: [
+              /* @__PURE__ */ jsxs("span", {
+                children: [
+                  /* @__PURE__ */ jsx("strong", {
+                    children: thread.title
+                  }),
+                  /* @__PURE__ */ jsxs("small", {
+                    id: `${searchId}-result-${thread.id}`,
+                    children: [
+                      thread.archived ? "Archived" : "Active",
+                      thread.detail == null ? ` · Project ${thread.projectId}` : ` · ${thread.detail}`
+                    ]
+                  })
+                ]
+              }),
+              /* @__PURE__ */ jsx("button", {
+                type: "button",
+                className: "bb-reference-links__reference-add",
+                disabled: disabled || isAttached || selectingId !== null,
+                onClick: (event) => void select(thread, event.detail === 0),
+                "aria-label": isAttached ? `${thread.title} is already linked` : `Link ${thread.title}`,
+                "aria-describedby": `${searchId}-result-${thread.id}`,
+                children: isAttached ? "Linked" : selectingId === thread.id ? "Adding…" : "Link"
+              })
+            ]
+          }, key);
+        })
+      }),
+      search.status === "external" && /* @__PURE__ */ jsxs("div", {
+        className: "bb-reference-links__reference-external",
+        children: [
+          /* @__PURE__ */ jsxs("span", {
+            children: [
+              /* @__PURE__ */ jsx("strong", {
+                children: "External link"
+              }),
+              /* @__PURE__ */ jsx("small", {
+                children: search.href
+              })
+            ]
+          }),
+          search.resolutionError != null && /* @__PURE__ */ jsxs("p", {
+            className: "bb-reference-links__reference-error",
+            role: "alert",
+            children: [
+              search.resolutionError,
+              search.canRetry === true && /* @__PURE__ */ jsxs(Fragment, {
+                children: [
+                  " ",
+                  /* @__PURE__ */ jsx("button", {
+                    type: "button",
+                    className: "bb-reference-links__reference-retry",
+                    onClick: () => setSearchRetry((value) => value + 1),
+                    children: "Retry thread lookup"
+                  })
+                ]
+              })
+            ]
+          }),
+          /* @__PURE__ */ jsx("label", {
+            htmlFor: nameId,
+            children: "Reference name"
+          }),
+          /* @__PURE__ */ jsxs("div", {
+            children: [
+              /* @__PURE__ */ jsx("input", {
+                id: nameId,
+                type: "text",
+                value: externalName,
+                disabled: disabled || selectingId !== null,
+                "aria-invalid": externalNameError != null || undefined,
+                "aria-describedby": externalNameError == null ? undefined : `${nameId}-error`,
+                onChange: (event) => {
+                  setExternalName(event.target.value);
+                  setExternalNameError(null);
+                }
+              }),
+              /* @__PURE__ */ jsx("button", {
+                type: "button",
+                className: "bb-reference-links__reference-add",
+                disabled: disabled || selectingId !== null || externalAttached,
+                onClick: (event) => void attachExternal(event.detail === 0),
+                "aria-label": externalAttached ? `${externalName || search.suggestedLabel} is already linked` : `Link ${externalName || search.suggestedLabel}`,
+                children: externalAttached ? "Linked" : selectingId === search.href ? "Adding…" : "Link"
+              })
+            ]
+          }),
+          externalNameError != null && /* @__PURE__ */ jsx("p", {
+            id: `${nameId}-error`,
+            className: "bb-reference-links__reference-error",
+            role: "alert",
+            children: externalNameError
+          })
+        ]
+      })
+    ]
+  });
+}
+function attachmentStatusText(snapshot) {
+  switch (snapshot.status.state) {
+    case "synced":
+      return "Saved locally and shared with Cross References.";
+    case "pending":
+      return "Saved locally. Sharing with Cross References will finish shortly.";
+    case "degraded":
+      return "Saved locally. Cross References is unavailable; sharing will retry when it returns.";
+    case "blocked":
+      return "Saved locally, but Cross References could not accept the latest update.";
+  }
+}
+function LinkedReferencesEditor({ api, connection = "connected", refreshToken = 0, navigateThread, origin = window.location.origin, title = "Linked references", description, maxTargets = 256 }) {
+  const { snapshot, loading, readError, mutationError, stale, saving, refresh, add, addResource, remove } = useAttachments(api, connection, refreshToken);
+  const sectionRef = useRef(null);
+  const searchInputRef = useRef(null);
+  const [removalFocus, setRemovalFocus] = useState(null);
+  const targets = snapshot?.targets ?? [];
+  const attached = useMemo(() => new Set(targets.map(resourceKey)), [snapshot?.targets]);
+  useEffect(() => {
+    if (removalFocus == null)
+      return;
+    if (document.activeElement !== document.body && document.activeElement !== removalFocus.button) {
+      setRemovalFocus(null);
+      return;
+    }
+    const remaining = [...sectionRef.current?.querySelectorAll(".bb-reference-links__reference-remove") ?? []];
+    remaining[Math.min(removalFocus.index, remaining.length - 1)]?.focus();
+    if (remaining.length === 0)
+      searchInputRef.current?.focus();
+    setRemovalFocus(null);
+  }, [removalFocus, targets.length]);
+  const titleId = useId();
+  return /* @__PURE__ */ jsxs("section", {
+    ref: sectionRef,
+    className: "bb-reference-links__references",
+    "aria-labelledby": titleId,
+    children: [
+      /* @__PURE__ */ jsxs("header", {
+        children: [
+          /* @__PURE__ */ jsxs("div", {
+            children: [
+              /* @__PURE__ */ jsx("h2", {
+                id: titleId,
+                children: title
+              }),
+              description && /* @__PURE__ */ jsx("p", {
+                children: description
+              })
+            ]
+          }),
+          /* @__PURE__ */ jsx("button", {
+            type: "button",
+            className: "bb-reference-links__reference-retry",
+            disabled: saving,
+            onClick: () => void refresh(),
+            children: "Refresh links"
+          }),
+          /* @__PURE__ */ jsx("span", {
+            className: "bb-reference-links__reference-count",
+            "aria-label": `${targets.length} linked reference${targets.length === 1 ? "" : "s"}`,
+            children: targets.length
+          })
+        ]
+      }),
+      loading && snapshot == null && /* @__PURE__ */ jsx("p", {
+        className: "bb-reference-links__reference-status",
+        role: "status",
+        children: "Loading saved references…"
+      }),
+      snapshot != null && /* @__PURE__ */ jsx("p", {
+        className: `bb-reference-links__reference-status bb-reference-links__reference-status--${snapshot.status.state}`,
+        role: "status",
+        title: snapshot.status.error ?? undefined,
+        children: attachmentStatusText(snapshot)
+      }),
+      stale && /* @__PURE__ */ jsx("p", {
+        className: "bb-reference-links__reference-status",
+        role: "status",
+        children: "The connection is recovering; this list may be briefly out of date."
+      }),
+      readError != null && /* @__PURE__ */ jsxs("p", {
+        className: "bb-reference-links__reference-error",
+        role: "alert",
+        children: [
+          readError,
+          " ",
+          /* @__PURE__ */ jsx("button", {
+            type: "button",
+            className: "bb-reference-links__reference-retry",
+            disabled: saving,
+            onClick: () => void refresh(),
+            children: "Try again"
+          })
+        ]
+      }),
+      mutationError != null && /* @__PURE__ */ jsx("p", {
+        className: "bb-reference-links__reference-error",
+        role: "alert",
+        children: mutationError
+      }),
+      targets.length === 0 && snapshot != null && /* @__PURE__ */ jsx("p", {
+        className: "bb-reference-links__reference-empty",
+        children: "No references linked yet."
+      }),
+      targets.length > 0 && /* @__PURE__ */ jsx("ul", {
+        className: "bb-reference-links__reference-list",
+        children: targets.map((target) => {
+          return /* @__PURE__ */ jsxs("li", {
+            children: [
+              /* @__PURE__ */ jsxs("span", {
+                children: [
+                  /* @__PURE__ */ jsx(ReferenceLink, {
+                    target,
+                    navigateThread
+                  }),
+                  /* @__PURE__ */ jsx("small", {
+                    children: target.presentation.detail ?? (targetThread(target) == null ? target.presentation.url : `Project ${targetThread(target).projectId}`)
+                  })
+                ]
+              }),
+              /* @__PURE__ */ jsx("button", {
+                type: "button",
+                className: "bb-reference-links__reference-remove",
+                disabled: saving,
+                onClick: (event) => {
+                  const restoreKeyboardFocus = event.detail === 0;
+                  const button = event.currentTarget;
+                  const buttons = [...sectionRef.current?.querySelectorAll(".bb-reference-links__reference-remove") ?? []];
+                  const index = buttons.indexOf(button);
+                  remove(target).then((removed) => {
+                    if (!removed || !restoreKeyboardFocus)
+                      return;
+                    setRemovalFocus({ index, button });
+                  });
+                },
+                "aria-label": `Remove ${target.presentation.label}`,
+                children: "Remove"
+              })
+            ]
+          }, resourceKey(target));
+        })
+      }),
+      /* @__PURE__ */ jsx(ThreadPicker, {
+        api,
+        connection,
+        origin,
+        attached,
+        disabled: saving || snapshot == null || targets.length >= maxTargets,
+        onAdd: add,
+        onAddResource: addResource,
+        searchInputRef
+      })
+    ]
+  });
+}
+function LinkedReferences(props) {
+  return /* @__PURE__ */ jsx(LinkedReferencesEditor, {
+    ...props
+  }, props.ownerKey);
+}
+export {
+  LinkedReferences
+};