openplanr 3.3.0 → 3.5.0

package/lib/host-packages/openai/openplanr/runtime/design/scripts/runtime/packages/artifact/templates/artifact-review-stage.js.sources/06-artifact-review-ui.js

@@ -1,1755 +0,0 @@
-
-
-  // lib/artifact/ui/review-outbox.mjs
-  function createReviewOutbox({
-    scope,
-    indexedDB = globalThis.indexedDB,
-    databaseName = "openplanr-review-outbox-v1",
-    leaseMs = 3e4,
-    now = Date.now,
-    validatePayload = (payload) => payload !== null && typeof payload === "object"
-  }) {
-    for (const value of [scope.workspaceId, scope.revisionId, scope.actorId])
-      if (typeof value !== "string" || !value || value.length > 512)
-        throw new TypeError("Review custody requires workspace, revision and actor identities.");
-    if (!Number.isFinite(leaseMs) || leaseMs < 300)
-      throw new TypeError("A review lease must be at least 300ms.");
-    const scopeKey = JSON.stringify([scope.workspaceId, scope.revisionId, scope.actorId]);
-    const key = (id7) => {
-      if (typeof id7 !== "string" || !id7 || id7.length > 512)
-        throw new TypeError("A review operation needs a stable identity.");
-      return JSON.stringify([scopeKey, id7]);
-    };
-    let closed7 = false, draining = null;
-    const listeners = /* @__PURE__ */ new Set();
-    const heartbeats = /* @__PURE__ */ new Set();
-    const channel = typeof globalThis.BroadcastChannel === "function" ? new globalThis.BroadcastChannel(databaseName) : null;
-    const notify = () => {
-      listeners.forEach((listener) => {
-        listener();
-      });
-      channel?.postMessage(scopeKey);
-    };
-    if (channel)
-      channel.onmessage = (event) => {
-        if (event.data === scopeKey)
-          listeners.forEach((listener) => {
-            listener();
-          });
-      };
-    const database = new Promise((resolve, reject) => {
-      if (!indexedDB) {
-        reject(
-          new Error(
-            "Durable review storage is unavailable. Enable browser storage before sending feedback."
-          )
-        );
-        return;
-      }
-      const request = indexedDB.open(databaseName, 1);
-      request.onupgradeneeded = () => {
-        const store = request.result.createObjectStore("operations", { keyPath: "key" });
-        store.createIndex("scope", "scopeKey", { unique: false });
-      };
-      request.onerror = () => reject(request.error ?? new Error("Durable review storage could not open."));
-      request.onblocked = () => reject(new Error("Close older review tabs to open durable review storage."));
-      request.onsuccess = () => {
-        const db = request.result;
-        db.onversionchange = () => db.close();
-        if (closed7) db.close();
-        resolve(db);
-      };
-    });
-    void database.catch(() => {
-    });
-    async function transaction(mode, work) {
-      if (closed7) throw new Error("Review custody has closed.");
-      const db = await database;
-      return new Promise((resolve, reject) => {
-        const tx = db.transaction("operations", mode), store = tx.objectStore("operations");
-        let value;
-        tx.oncomplete = () => resolve(value);
-        tx.onerror = () => reject(tx.error ?? new Error("Review storage could not commit."));
-        tx.onabort = () => reject(tx.error ?? new Error("Review storage did not commit."));
-        const guard = (callback) => () => {
-          try {
-            callback();
-          } catch (error) {
-            try {
-              tx.abort();
-            } catch {
-            }
-            reject(error);
-          }
-        };
-        guard(
-          () => work(
-            store,
-            (next) => {
-              value = next;
-            },
-            guard
-          )
-        )();
-      });
-    }
-    const publicEntry = ({
-      key: _key,
-      scopeKey: _scope,
-      leaseOwner: _owner,
-      leaseUntil: _until,
-      custodyInvalid: _invalid,
-      invalidRecord: _record,
-      ...entry
-    }) => entry;
-    function payloadValid(payload) {
-      try {
-        return validatePayload(payload);
-      } catch {
-        return false;
-      }
-    }
-    function keyedIdentity(primaryKey) {
-      if (typeof primaryKey !== "string") return null;
-      try {
-        const value = JSON.parse(primaryKey);
-        return Array.isArray(value) && value.length === 2 && value[0] === scopeKey && typeof value[1] === "string" && value[1].length > 0 && value[1].length <= 512 ? value[1] : null;
-      } catch {
-        return null;
-      }
-    }
-    function storedEntry(raw, primaryKey, store) {
-      const record2 = raw !== null && typeof raw === "object" ? raw : null;
-      const fromKey = keyedIdentity(primaryKey);
-      if (record2?.scopeKey !== scopeKey && !fromKey) return null;
-      const allowed = /* @__PURE__ */ new Set([
-        "key",
-        "scopeKey",
-        "operationId",
-        "payload",
-        "status",
-        "attempts",
-        "createdAt",
-        "nextAttemptAt",
-        "errorCode",
-        "leaseOwner",
-        "leaseUntil",
-        "custodyInvalid",
-        "invalidRecord"
-      ]);
-      const finiteTime = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
-      const integer3 = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-      if (record2 && Object.keys(record2).every((name) => allowed.has(name)) && fromKey !== null && fromKey === record2.operationId && record2.key === primaryKey && record2.scopeKey === scopeKey && Object.hasOwn(record2, "payload") && ["pending", "quarantined"].includes(String(record2.status)) && integer3(record2.attempts) && finiteTime(record2.createdAt) && finiteTime(record2.nextAttemptAt) && (record2.errorCode === void 0 || typeof record2.errorCode === "string" && record2.errorCode.length <= 120) && (record2.leaseOwner === void 0 && record2.leaseUntil === void 0 || typeof record2.leaseOwner === "string" && record2.leaseOwner.length > 0 && record2.leaseOwner.length <= 128 && finiteTime(record2.leaseUntil)) && (record2.custodyInvalid === true ? record2.status === "quarantined" && record2.errorCode === "malformed_custody" : record2.custodyInvalid === void 0 && record2.invalidRecord === void 0 && payloadValid(record2.payload)))
-        return record2;
-      const operationId = fromKey ?? `invalid-${globalThis.crypto.randomUUID()}`;
-      const repaired = {
-        key: key(operationId),
-        scopeKey,
-        operationId,
-        payload: record2 && Object.hasOwn(record2, "payload") ? record2.payload : null,
-        status: "quarantined",
-        attempts: 0,
-        createdAt: 0,
-        nextAttemptAt: 0,
-        errorCode: "malformed_custody",
-        custodyInvalid: true,
-        invalidRecord: raw
-      };
-      store.put(repaired);
-      if (primaryKey !== repaired.key) store.delete(primaryKey);
-      return repaired;
-    }
-    function readScoped(store, result, guard) {
-      const entries = [];
-      const seen = /* @__PURE__ */ new Set();
-      const request = store.openCursor();
-      request.onsuccess = guard(() => {
-        const cursor = request.result;
-        if (!cursor) {
-          result(entries);
-          return;
-        }
-        const entry = storedEntry(cursor.value, cursor.primaryKey, store);
-        if (entry && !seen.has(entry.key)) {
-          seen.add(entry.key);
-          entries.push(entry);
-        }
-        cursor.continue();
-      });
-    }
-    async function mutate(id7, update) {
-      await transaction("readwrite", (store, _result, guard) => {
-        const operationKey = key(id7);
-        const request = store.get(operationKey);
-        request.onsuccess = guard(() => {
-          if (request.result === void 0) return;
-          const entry = storedEntry(request.result, operationKey, store);
-          if (entry) update(entry, store);
-        });
-      });
-      notify();
-    }
-    async function claim(owner) {
-      return transaction("readwrite", (store, result, guard) => {
-        readScoped(
-          store,
-          (entries) => {
-            const time = now();
-            const next = entries.filter(
-              (entry) => entry.status === "pending" && entry.nextAttemptAt <= time && (!entry.leaseUntil || entry.leaseUntil <= time)
-            ).sort(
-              (a, b) => a.createdAt - b.createdAt || a.operationId.localeCompare(b.operationId)
-            )[0];
-            if (!next) {
-              result(null);
-              return;
-            }
-            next.leaseOwner = owner;
-            next.leaseUntil = time + leaseMs;
-            store.put(next);
-            result(next);
-          },
-          guard
-        );
-      });
-    }
-    return {
-      async enqueue({ operationId, payload }) {
-        const immutable = structuredClone(payload), operationKey = key(operationId);
-        if (!payloadValid(immutable)) throw new TypeError("Prepared review custody is invalid.");
-        await transaction("readwrite", (store, _result, guard) => {
-          const request = store.get(operationKey);
-          request.onsuccess = guard(() => {
-            if (request.result !== void 0) {
-              storedEntry(request.result, operationKey, store);
-              return;
-            }
-            store.add({
-              key: operationKey,
-              scopeKey,
-              operationId,
-              payload: immutable,
-              status: "pending",
-              attempts: 0,
-              createdAt: now(),
-              nextAttemptAt: 0
-            });
-          });
-        });
-        notify();
-      },
-      async list() {
-        return transaction("readwrite", (store, result, guard) => {
-          readScoped(
-            store,
-            (entries) => result(
-              entries.sort(
-                (a, b) => a.createdAt - b.createdAt || a.operationId.localeCompare(b.operationId)
-              ).map(publicEntry)
-            ),
-            guard
-          );
-        });
-      },
-      async retry(id7) {
-        await mutate(id7, (entry, store) => {
-          if (entry.custodyInvalid || entry.leaseUntil && entry.leaseUntil > now()) return;
-          entry.status = "pending";
-          entry.nextAttemptAt = 0;
-          delete entry.errorCode;
-          store.put(entry);
-        });
-      },
-      async quarantine(id7, code) {
-        await mutate(id7, (entry, store) => {
-          if (entry.leaseUntil && entry.leaseUntil > now()) return;
-          entry.status = "quarantined";
-          entry.nextAttemptAt = 0;
-          entry.errorCode = entry.custodyInvalid ? "malformed_custody" : String(code).slice(0, 120);
-          store.put(entry);
-        });
-      },
-      async remove(id7) {
-        await mutate(id7, (entry, store) => {
-          if (!entry.leaseUntil || entry.leaseUntil <= now()) store.delete(entry.key);
-        });
-      },
-      drain(send) {
-        if (draining) return draining;
-        const owner = globalThis.crypto.randomUUID();
-        draining = (async () => {
-          while (!closed7) {
-            const entry = await claim(owner);
-            if (!entry) return;
-            const heartbeat = globalThis.setInterval(
-              () => {
-                void mutate(entry.operationId, (current, store) => {
-                  if (current.leaseOwner === owner) {
-                    current.leaseUntil = now() + leaseMs;
-                    store.put(current);
-                  }
-                }).catch(() => {
-                });
-              },
-              Math.floor(leaseMs / 3)
-            );
-            heartbeats.add(heartbeat);
-            let outcome;
-            try {
-              outcome = await send(publicEntry(entry));
-            } catch {
-              outcome = { status: "retry", code: "network" };
-            } finally {
-              globalThis.clearInterval(heartbeat);
-              heartbeats.delete(heartbeat);
-            }
-            if (!outcome || !["delivered", "retry", "rejected"].includes(outcome.status))
-              outcome = { status: "retry", code: "invalid-delivery-result" };
-            await mutate(entry.operationId, (current, store) => {
-              if (current.leaseOwner !== owner) return;
-              if (outcome.status === "delivered") {
-                store.delete(current.key);
-                return;
-              }
-              delete current.leaseOwner;
-              delete current.leaseUntil;
-              current.attempts += 1;
-              current.errorCode = typeof outcome.code === "string" ? outcome.code.slice(0, 120) : outcome.status;
-              current.status = outcome.status === "rejected" ? "quarantined" : "pending";
-              const requestedDelay = Number.isFinite(outcome.retryAfterMs) ? Math.max(0, Math.min(36e5, outcome.retryAfterMs)) : 0;
-              current.nextAttemptAt = outcome.status === "retry" ? now() + Math.max(
-                requestedDelay,
-                Math.min(6e4, 1e3 * 2 ** Math.min(current.attempts - 1, 6))
-              ) : 0;
-              store.put(current);
-            });
-          }
-        })().finally(() => {
-          draining = null;
-        });
-        return draining;
-      },
-      subscribe(listener) {
-        listeners.add(listener);
-        return () => listeners.delete(listener);
-      },
-      close() {
-        closed7 = true;
-        for (const heartbeat of heartbeats) globalThis.clearInterval(heartbeat);
-        heartbeats.clear();
-        channel?.close();
-        listeners.clear();
-        void database.then((db) => db.close()).catch(() => {
-        });
-      }
-    };
-  }
-
-  // lib/artifact/ui/durable-paste-share.mjs
-  var retainedPreparation = /* @__PURE__ */ Symbol("private-paste-preparation-retained");
-  function preparation(value) {
-    assertPreparedArtifactPaste(value);
-    return value;
-  }
-  function receipt(prepared, value) {
-    const url = new URL(`/p/${prepared.body.id}`, prepared.origin);
-    url.hash = `k=${prepared.key}&v=2`;
-    if (!value || value.url !== url.toString() || value.deletionToken !== prepared.custodyToken || typeof value.expiresAt !== "string" || !Number.isFinite(Date.parse(value.expiresAt)))
-      throw new Error("Paste receipt differs from saved private custody.");
-    return value;
-  }
-  function createDurablePasteShare({
-    scope,
-    create,
-    commit,
-    indexedDB = globalThis.indexedDB,
-    databaseName = "openplanr-paste-custody-v1"
-  }) {
-    const queues = /* @__PURE__ */ new Map();
-    function queueFor(request) {
-      const base = scope(), revisionId2 = `${base.revisionId}:${request.ttl ?? "7d"}`, identity = JSON.stringify({ ...base, revisionId: revisionId2 });
-      let queue = queues.get(identity);
-      if (!queue) {
-        queue = createReviewOutbox({ scope: { ...base, revisionId: revisionId2 }, indexedDB, databaseName });
-        queues.set(identity, queue);
-      }
-      return queue;
-    }
-    const activeReceipt = (entries) => entries.map((entry) => entry.payload).find(
-      (value) => value?.kind === "paste-receipt" && typeof value.result?.expiresAt === "string" && Date.parse(value.result.expiresAt) > Date.now()
-    );
-    return {
-      async run(request) {
-        if (request.transport !== "short") return create(request);
-        const queue = queueFor(request);
-        let entries = await queue.list();
-        const prior = activeReceipt(entries);
-        if (prior) return receipt(preparation(prior.prepared), prior.result ?? null);
-        let pending = entries.find(
-          (entry) => entry.payload?.kind === "prepared-paste"
-        );
-        if (pending?.status === "quarantined")
-          throw new Error(
-            "The saved paste operation was rejected. Its private recovery custody is retained."
-          );
-        if (!pending) {
-          try {
-            await create({
-              ...request,
-              onPreparedPaste: async (value) => {
-                const prepared = preparation(value);
-                if (prepared.body.ttl !== (request.ttl ?? "7d"))
-                  throw new Error("Prepared paste expiry differs.");
-                await queue.enqueue({
-                  operationId: prepared.body.creationId,
-                  payload: { kind: "prepared-paste", prepared }
-                });
-                throw retainedPreparation;
-              }
-            });
-          } catch (error) {
-            if (error !== retainedPreparation) throw error;
-          }
-          entries = await queue.list();
-          pending = entries.find(
-            (entry) => entry.payload?.kind === "prepared-paste"
-          );
-          if (!pending)
-            throw new Error(
-              "This host did not retain paste custody before publication. Update OpenPlanr and retry."
-            );
-        }
-        await queue.retry(pending.operationId);
-        let result = null;
-        await queue.drain(async (entry) => {
-          const value = entry.payload;
-          if (value?.kind === "paste-receipt")
-            return { status: "rejected", code: "private-custody-receipt" };
-          try {
-            const prepared = preparation(value?.prepared);
-            const created = receipt(prepared, await commit(prepared));
-            const receiptId = `${prepared.body.creationId}:receipt`;
-            await queue.enqueue({
-              operationId: receiptId,
-              payload: { kind: "paste-receipt", prepared, result: created }
-            });
-            await queue.quarantine(receiptId, "private-custody-receipt");
-            result = created;
-            return { status: "delivered" };
-          } catch (error) {
-            const code = error?.code;
-            return typeof code === "string" && ["E_ARTIFACT_SHARE_NETWORK", "E_ARTIFACT_PASTE_UNAVAILABLE"].includes(code) ? { status: "retry", code } : { status: "rejected", code: "paste-rejected" };
-          }
-        });
-        if (result) return result;
-        const completed = activeReceipt(await queue.list());
-        if (completed) return receipt(preparation(completed.prepared), completed.result ?? null);
-        throw new Error(
-          "Paste publication is pending. Retry this share to resume the saved encrypted operation; another tab may be sending it."
-        );
-      },
-      close() {
-        for (const queue of queues.values()) queue.close();
-        queues.clear();
-      }
-    };
-  }
-
-  // lib/artifact/ui/feedback-rail.mjs
-  var ARTIFACT_REVIEW_CHANGE_EVENT = "planr:artifact-review-change";
-  var ARTIFACT_REVIEW_SELECT_EVENT = "planr:artifact-review-select";
-  var ARTIFACT_REVIEW_DRAFT_CHANGE_EVENT = "planr:artifact-review-draft-change";
-  var ARTIFACT_REVIEW_LIMITS = Object.freeze({
-    id: 128,
-    authorName: 256,
-    artifactId: 128,
-    variant: 128,
-    anchor: 512,
-    screen: 128,
-    text: 65536,
-    pins: 1e4,
-    replies: 1e4,
-    viewport: 16384
-  });
-  var ARTIFACT_REVIEW_DECISIONS = Object.freeze([
-    "pending",
-    "approved",
-    "changes_requested"
-  ]);
-  var ARTIFACT_REVIEW_INTENTS = Object.freeze(["fix", "improve", "question"]);
-  var ARTIFACT_REVIEW_STATUSES = Object.freeze(["open", "addressed", "resolved"]);
-  var REVIEW_OF_RE = /^[a-f0-9]{64}$/;
-  var ArtifactReviewStateError = class extends Error {
-    constructor(code, message) {
-      super(message);
-      this.name = "ArtifactReviewStateError";
-      this.code = code;
-    }
-  };
-  function invalid(message) {
-    throw new ArtifactReviewStateError("E_ARTIFACT_REVIEW_INVALID", message);
-  }
-  function identityRequired() {
-    throw new ArtifactReviewStateError(
-      "E_ARTIFACT_REVIEW_IDENTITY_REQUIRED",
-      "Enter your name before adding a comment."
-    );
-  }
-  function clonePlain(value) {
-    if (Array.isArray(value)) return value.map(clonePlain);
-    if (!value || typeof value !== "object") return value;
-    const clone = {};
-    for (const [key, entry] of Object.entries(value)) clone[key] = clonePlain(entry);
-    return clone;
-  }
-  function cloneFrozenArtifactReview(review) {
-    return deepFreeze(clonePlain(review));
-  }
-  function boundedString(value, label, { min = 0, max, trim = false, pattern } = {}) {
-    if (typeof value !== "string") invalid(`${label} must be a string.`);
-    const normalized3 = trim ? value.trim() : value;
-    if (normalized3.length < min || max !== void 0 && normalized3.length > max) {
-      invalid(`${label} must contain ${min} through ${max ?? "unlimited"} characters.`);
-    }
-    if (pattern && !pattern.test(normalized3)) invalid(`${label} has an invalid format.`);
-    return normalized3;
-  }
-  function optionalString(value, label, options) {
-    if (value === void 0) return void 0;
-    return boundedString(value, label, options);
-  }
-  function enumValue(value, values, label) {
-    if (!values.includes(value)) invalid(`${label} must be one of: ${values.join(", ")}.`);
-    return value;
-  }
-  function isoTimestamp(value, label) {
-    const timestamp2 = value instanceof Date ? value.toISOString() : value;
-    if (typeof timestamp2 !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(timestamp2) || !Number.isFinite(Date.parse(timestamp2))) {
-      invalid(`${label} must be an ISO-8601 date-time.`);
-    }
-    return timestamp2;
-  }
-  function dependencyTimestamp(now) {
-    return isoTimestamp(now(), "now()");
-  }
-  function defaultNow() {
-    return (/* @__PURE__ */ new Date()).toISOString();
-  }
-  function createSecureArtifactReviewId(cryptoProvider = globalThis.crypto) {
-    const randomUuid = cryptoProvider?.randomUUID?.();
-    if (randomUuid) return randomUuid;
-    const bytes = new Uint8Array(16);
-    if (typeof cryptoProvider?.getRandomValues !== "function") {
-      throw new ArtifactReviewStateError(
-        "E_ARTIFACT_REVIEW_UUID_UNAVAILABLE",
-        "Secure UUID generation is unavailable in this browser."
-      );
-    }
-    cryptoProvider.getRandomValues(bytes);
-    bytes[6] = bytes[6] & 15 | 64;
-    bytes[8] = bytes[8] & 63 | 128;
-    const hex = [...bytes].map((value) => value.toString(16).padStart(2, "0")).join("");
-    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-  }
-  function defaultCreateId() {
-    return createSecureArtifactReviewId();
-  }
-  function dependencyId(createId, kind) {
-    return boundedString(createId(kind), `${kind} id`, {
-      min: 1,
-      max: ARTIFACT_REVIEW_LIMITS.id,
-      trim: true
-    });
-  }
-  function uniqueDependencyId(createId, kind, existingIds) {
-    for (let attempt = 0; attempt < 100; attempt += 1) {
-      const candidate = dependencyId(createId, kind);
-      if (!existingIds.has(candidate)) return candidate;
-    }
-    throw new ArtifactReviewStateError(
-      "E_ARTIFACT_REVIEW_ID_COLLISION",
-      `Could not create a unique ${kind} id.`
-    );
-  }
-  function normalizeArtifactReviewIdentity(value, { allowEmpty = false } = {}) {
-    if (value === null || value === void 0 || value === "") {
-      if (allowEmpty) return null;
-      identityRequired();
-    }
-    const source = typeof value === "string" ? { name: value } : value;
-    if (!source || typeof source !== "object" || Array.isArray(source)) identityRequired();
-    const name = boundedString(source.name, "author.name", {
-      min: 1,
-      max: ARTIFACT_REVIEW_LIMITS.authorName,
-      trim: true
-    });
-    const id7 = optionalString(source.id, "author.id", {
-      min: 1,
-      max: ARTIFACT_REVIEW_LIMITS.id,
-      trim: true
-    });
-    return deepFreeze(id7 === void 0 ? { name } : { id: id7, name });
-  }
-  function normalizeRegion(region) {
-    if (!region || typeof region !== "object" || Array.isArray(region)) {
-      invalid("pin.region must be an object.");
-    }
-    const finite3 = (value, label) => {
-      if (typeof value !== "number" || !Number.isFinite(value)) invalid(`${label} must be finite.`);
-      return value;
-    };
-    const x = finite3(region.x, "pin.region.x");
-    const y = finite3(region.y, "pin.region.y");
-    const w = finite3(region.w, "pin.region.w");
-    const h = finite3(region.h, "pin.region.h");
-    if (x >= 0 && y >= 0 && w >= 0 && h >= 0 && x + w <= 1 && y + h <= 1) {
-      return { x, y, w, h };
-    }
-    const unit2 = (value) => Math.round(Math.min(1, Math.max(0, value)) * 1e6) / 1e6;
-    const boundedX = unit2(x);
-    const boundedY = unit2(y);
-    return {
-      x: boundedX,
-      y: boundedY,
-      w: Math.round(Math.min(unit2(w), 1 - boundedX) * 1e6) / 1e6,
-      h: Math.round(Math.min(unit2(h), 1 - boundedY) * 1e6) / 1e6
-    };
-  }
-  function normalizeViewport(viewport) {
-    if (!viewport || typeof viewport !== "object" || Array.isArray(viewport)) {
-      invalid("pin.viewport must be an object.");
-    }
-    const dimension = (value, label) => {
-      if (!Number.isInteger(value) || value < 1 || value > ARTIFACT_REVIEW_LIMITS.viewport) {
-        invalid(`${label} must be an integer from 1 through ${ARTIFACT_REVIEW_LIMITS.viewport}.`);
-      }
-      return value;
-    };
-    return {
-      width: dimension(viewport.width, "pin.viewport.width"),
-      height: dimension(viewport.height, "pin.viewport.height")
-    };
-  }
-  function normalizeAnchor(anchor2) {
-    if (anchor2 === void 0 || anchor2 === null) return void 0;
-    if (typeof anchor2 !== "object" || Array.isArray(anchor2)) invalid("pin.anchor must be an object.");
-    const planrId = boundedString(anchor2.planrId, "pin.anchor.planrId", {
-      min: 1,
-      max: ARTIFACT_REVIEW_LIMITS.anchor,
-      trim: true
-    });
-    const screen = optionalString(anchor2.screen, "pin.anchor.screen", {
-      min: 1,
-      max: ARTIFACT_REVIEW_LIMITS.screen,
-      trim: true
-    });
-    return screen === void 0 ? { planrId } : { planrId, screen };
-  }
-  function normalizeReply(reply2, label = "reply") {
-    if (!reply2 || typeof reply2 !== "object" || Array.isArray(reply2))
-      invalid(`${label} must be an object.`);
-    return {
-      id: boundedString(reply2.id, `${label}.id`, {
-        min: 1,
-        max: ARTIFACT_REVIEW_LIMITS.id,
-        trim: true
-      }),
-      author: normalizeArtifactReviewIdentity(reply2.author),
-      comment: boundedString(reply2.comment, `${label}.comment`, {
-        min: 1,
-        max: ARTIFACT_REVIEW_LIMITS.text,
-        trim: true
-      }),
-      createdAt: isoTimestamp(reply2.createdAt, `${label}.createdAt`)
-    };
-  }
-  function compareTimestampThenId(left, right) {
-    const byTime = left.createdAt.localeCompare(right.createdAt);
-    return byTime === 0 ? left.id.localeCompare(right.id) : byTime;
-  }
-  function normalizePin(pin, label = "pin") {
-    if (!pin || typeof pin !== "object" || Array.isArray(pin)) invalid(`${label} must be an object.`);
-    if (!Array.isArray(pin.replies) || pin.replies.length > ARTIFACT_REVIEW_LIMITS.replies) {
-      invalid(`${label}.replies must contain no more than ${ARTIFACT_REVIEW_LIMITS.replies} items.`);
-    }
-    const replies = pin.replies.map(
-      (reply2, index2) => normalizeReply(reply2, `${label}.replies[${index2}]`)
-    );
-    const replyIds = new Set(replies.map(({ id: id7 }) => id7));
-    if (replyIds.size !== replies.length) invalid(`${label}.replies must have unique ids.`);
-    const normalized3 = {
-      id: boundedString(pin.id, `${label}.id`, {
-        min: 1,
-        max: ARTIFACT_REVIEW_LIMITS.id,
-        trim: true
-      }),
-      author: normalizeArtifactReviewIdentity(pin.author),
-      artifactId: boundedString(pin.artifactId, `${label}.artifactId`, {
-        min: 1,
-        max: ARTIFACT_REVIEW_LIMITS.artifactId,
-        trim: true
-      }),
-      region: normalizeRegion(pin.region),
-      viewport: normalizeViewport(pin.viewport),
-      intent: enumValue(pin.intent, ARTIFACT_REVIEW_INTENTS, `${label}.intent`),
-      status: enumValue(pin.status, ARTIFACT_REVIEW_STATUSES, `${label}.status`),
-      comment: boundedString(pin.comment, `${label}.comment`, {
-        min: 1,
-        max: ARTIFACT_REVIEW_LIMITS.text,
-        trim: true
-      }),
-      replies: replies.sort(compareTimestampThenId),
-      createdAt: isoTimestamp(pin.createdAt, `${label}.createdAt`),
-      updatedAt: isoTimestamp(pin.updatedAt, `${label}.updatedAt`)
-    };
-    const variant = optionalString(pin.variant, `${label}.variant`, {
-      min: 1,
-      max: ARTIFACT_REVIEW_LIMITS.variant,
-      trim: true
-    });
-    const anchor2 = normalizeAnchor(pin.anchor);
-    if (variant !== void 0) normalized3.variant = variant;
-    if (anchor2 !== void 0) normalized3.anchor = anchor2;
-    return normalized3;
-  }
-  function normalizeArtifactReview(review) {
-    if (!review || typeof review !== "object" || Array.isArray(review)) {
-      invalid("Artifact review must be an object.");
-    }
-    if (!Array.isArray(review.pins) || review.pins.length > ARTIFACT_REVIEW_LIMITS.pins) {
-      invalid(`review.pins must contain no more than ${ARTIFACT_REVIEW_LIMITS.pins} items.`);
-    }
-    const pins = review.pins.map((pin, index2) => normalizePin(pin, `review.pins[${index2}]`));
-    const pinIds = new Set(pins.map(({ id: id7 }) => id7));
-    if (pinIds.size !== pins.length) invalid("review.pins must have unique ids.");
-    const normalized3 = {
-      schemaVersion: enumValue(review.schemaVersion, ["1.0.0"], "review.schemaVersion"),
-      reviewId: boundedString(review.reviewId, "review.reviewId", {
-        min: 1,
-        max: ARTIFACT_REVIEW_LIMITS.id,
-        trim: true
-      }),
-      reviewOf: boundedString(review.reviewOf, "review.reviewOf", {
-        min: 64,
-        max: 64,
-        pattern: REVIEW_OF_RE
-      }),
-      decision: enumValue(review.decision, ARTIFACT_REVIEW_DECISIONS, "review.decision"),
-      overall: boundedString(review.overall, "review.overall", {
-        max: ARTIFACT_REVIEW_LIMITS.text
-      }),
-      pins: pins.sort(compareTimestampThenId)
-    };
-    if (review.createdAt !== void 0)
-      normalized3.createdAt = isoTimestamp(review.createdAt, "review.createdAt");
-    if (review.updatedAt !== void 0)
-      normalized3.updatedAt = isoTimestamp(review.updatedAt, "review.updatedAt");
-    return deepFreeze(normalized3);
-  }
-  function createArtifactReview({ reviewId, reviewOf, createId = defaultCreateId } = {}) {
-    const normalizedReviewId = reviewId === void 0 ? dependencyId(createId, "review") : boundedString(reviewId, "reviewId", {
-      min: 1,
-      max: ARTIFACT_REVIEW_LIMITS.id,
-      trim: true
-    });
-    return normalizeArtifactReview({
-      schemaVersion: "1.0.0",
-      reviewId: normalizedReviewId,
-      reviewOf: boundedString(reviewOf, "reviewOf", {
-        min: 64,
-        max: 64,
-        pattern: REVIEW_OF_RE
-      }),
-      decision: "pending",
-      overall: "",
-      pins: []
-    });
-  }
-  function replacePin(review, pin) {
-    return review.pins.map((candidate) => candidate.id === pin.id ? pin : candidate);
-  }
-  function findPin(review, pinId) {
-    const normalizedId = boundedString(pinId, "pinId", {
-      min: 1,
-      max: ARTIFACT_REVIEW_LIMITS.id,
-      trim: true
-    });
-    const pin = review.pins.find(({ id: id7 }) => id7 === normalizedId);
-    if (!pin) {
-      throw new ArtifactReviewStateError(
-        "E_ARTIFACT_REVIEW_PIN_NOT_FOUND",
-        `Unknown feedback pin: ${normalizedId}`
-      );
-    }
-    return pin;
-  }
-  function preserveOptionalReviewTimestamps(review, next, timestamp2) {
-    if (review.createdAt !== void 0) next.createdAt = review.createdAt;
-    if (review.updatedAt !== void 0) next.updatedAt = timestamp2;
-    return next;
-  }
-  function reduceArtifactReview(review, action, { createId = defaultCreateId, now = defaultNow } = {}) {
-    const current = normalizeArtifactReview(review);
-    if (!action || typeof action !== "object" || Array.isArray(action))
-      invalid("Review action must be an object.");
-    const timestamp2 = dependencyTimestamp(now);
-    let next;
-    switch (action.type) {
-      case "add-pin": {
-        if (current.pins.length >= ARTIFACT_REVIEW_LIMITS.pins) {
-          invalid(`A review can contain at most ${ARTIFACT_REVIEW_LIMITS.pins} pins.`);
-        }
-        const author = normalizeArtifactReviewIdentity(action.author);
-        const pinInput = action.pin && typeof action.pin === "object" ? action.pin : {};
-        const pinId = pinInput.id === void 0 ? uniqueDependencyId(createId, "pin", new Set(current.pins.map(({ id: id7 }) => id7))) : boundedString(pinInput.id, "pin.id", {
-          min: 1,
-          max: ARTIFACT_REVIEW_LIMITS.id,
-          trim: true
-        });
-        if (current.pins.some(({ id: id7 }) => id7 === pinId)) {
-          throw new ArtifactReviewStateError(
-            "E_ARTIFACT_REVIEW_ID_COLLISION",
-            `Duplicate pin id: ${pinId}`
-          );
-        }
-        const pin = normalizePin({
-          ...pinInput,
-          id: pinId,
-          author,
-          status: pinInput.status ?? "open",
-          replies: [],
-          createdAt: pinInput.createdAt ?? timestamp2,
-          updatedAt: pinInput.updatedAt ?? timestamp2
-        });
-        next = preserveOptionalReviewTimestamps(
-          current,
-          {
-            ...current,
-            pins: [...current.pins, pin]
-          },
-          timestamp2
-        );
-        break;
-      }
-      case "add-reply": {
-        const pin = findPin(current, action.pinId);
-        if (pin.replies.length >= ARTIFACT_REVIEW_LIMITS.replies) {
-          invalid(`A feedback thread can contain at most ${ARTIFACT_REVIEW_LIMITS.replies} replies.`);
-        }
-        const replyId = action.id === void 0 ? uniqueDependencyId(createId, "reply", new Set(pin.replies.map(({ id: id7 }) => id7))) : boundedString(action.id, "reply.id", {
-          min: 1,
-          max: ARTIFACT_REVIEW_LIMITS.id,
-          trim: true
-        });
-        if (pin.replies.some(({ id: id7 }) => id7 === replyId)) {
-          throw new ArtifactReviewStateError(
-            "E_ARTIFACT_REVIEW_ID_COLLISION",
-            `Duplicate reply id: ${replyId}`
-          );
-        }
-        const reply2 = normalizeReply({
-          id: replyId,
-          author: normalizeArtifactReviewIdentity(action.author),
-          comment: action.comment,
-          createdAt: action.createdAt ?? timestamp2
-        });
-        const updatedPin = normalizePin({
-          ...pin,
-          replies: [...pin.replies, reply2],
-          updatedAt: timestamp2
-        });
-        next = preserveOptionalReviewTimestamps(
-          current,
-          {
-            ...current,
-            pins: replacePin(current, updatedPin)
-          },
-          timestamp2
-        );
-        break;
-      }
-      case "set-status": {
-        const pin = findPin(current, action.pinId);
-        const updatedPin = normalizePin({
-          ...pin,
-          status: enumValue(action.status, ARTIFACT_REVIEW_STATUSES, "status"),
-          updatedAt: timestamp2
-        });
-        next = preserveOptionalReviewTimestamps(
-          current,
-          {
-            ...current,
-            pins: replacePin(current, updatedPin)
-          },
-          timestamp2
-        );
-        break;
-      }
-      case "set-overall":
-        next = preserveOptionalReviewTimestamps(
-          current,
-          {
-            ...current,
-            overall: boundedString(action.overall, "overall", { max: ARTIFACT_REVIEW_LIMITS.text })
-          },
-          timestamp2
-        );
-        break;
-      case "set-decision":
-        next = preserveOptionalReviewTimestamps(
-          current,
-          {
-            ...current,
-            decision: enumValue(action.decision, ARTIFACT_REVIEW_DECISIONS, "decision")
-          },
-          timestamp2
-        );
-        break;
-      default:
-        throw new ArtifactReviewStateError(
-          "E_ARTIFACT_REVIEW_ACTION_UNKNOWN",
-          `Unknown artifact review action: ${String(action.type)}`
-        );
-    }
-    return normalizeArtifactReview(next);
-  }
-  function createArtifactReviewController({
-    initialReview = null,
-    reviewOf,
-    reviewId,
-    identity = null,
-    createId = defaultCreateId,
-    now = defaultNow
-  } = {}) {
-    let review = initialReview === null || initialReview === void 0 ? null : normalizeArtifactReview(initialReview);
-    if (review && reviewOf !== void 0 && review.reviewOf !== reviewOf) {
-      throw new ArtifactReviewStateError(
-        "E_ARTIFACT_REVIEW_DIGEST_MISMATCH",
-        "The initial review does not match the artifact envelope digest."
-      );
-    }
-    let localIdentity = normalizeArtifactReviewIdentity(identity, { allowEmpty: true });
-    let activePinId = null;
-    let destroyed = false;
-    const listeners = /* @__PURE__ */ new Set();
-    const assertAlive = () => {
-      if (destroyed) {
-        throw new ArtifactReviewStateError(
-          "E_ARTIFACT_REVIEW_DESTROYED",
-          "Artifact review controller is destroyed."
-        );
-      }
-    };
-    const ensureReview = () => {
-      review ??= createArtifactReview({ reviewId, reviewOf, createId });
-      return review;
-    };
-    const getState = () => deepFreeze({
-      review,
-      identity: localIdentity,
-      activePinId
-    });
-    const notify = (change) => {
-      const state = getState();
-      for (const listener of [...listeners]) listener(state, deepFreeze({ ...change }));
-    };
-    const controller = {
-      getReview() {
-        return review;
-      },
-      getState,
-      getIdentity() {
-        return localIdentity;
-      },
-      setIdentity(value) {
-        assertAlive();
-        localIdentity = normalizeArtifactReviewIdentity(value, { allowEmpty: true });
-        notify({ type: "identity" });
-        return localIdentity;
-      },
-      dispatch(action) {
-        assertAlive();
-        const authored = action?.type === "add-pin" || action?.type === "add-reply";
-        const nextAction = authored && action.author === void 0 ? { ...action, author: localIdentity ?? identityRequired() } : action;
-        const previousPinIds = nextAction?.type === "add-pin" ? new Set(review?.pins.map(({ id: id7 }) => id7) ?? []) : null;
-        review = reduceArtifactReview(ensureReview(), nextAction, { createId, now });
-        if (previousPinIds) {
-          activePinId = review.pins.find(({ id: id7 }) => !previousPinIds.has(id7))?.id ?? activePinId;
-        }
-        notify({ type: "review", action: nextAction.type });
-        return review;
-      },
-      replaceReview(value) {
-        assertAlive();
-        const next = value === null || value === void 0 ? null : normalizeArtifactReview(value);
-        if (next && reviewOf !== void 0 && next.reviewOf !== reviewOf) {
-          throw new ArtifactReviewStateError(
-            "E_ARTIFACT_REVIEW_DIGEST_MISMATCH",
-            "The replacement review does not match the artifact envelope digest."
-          );
-        }
-        review = next;
-        if (activePinId && !review?.pins.some(({ id: id7 }) => id7 === activePinId)) activePinId = null;
-        notify({ type: "review-replaced" });
-        return review;
-      },
-      selectPin(pinId) {
-        assertAlive();
-        if (pinId === null || pinId === void 0) {
-          activePinId = null;
-        } else {
-          activePinId = findPin(ensureReview(), pinId).id;
-        }
-        notify({ type: "selection" });
-        return activePinId;
-      },
-      subscribe(listener) {
-        assertAlive();
-        if (typeof listener !== "function") invalid("Review subscriber must be a function.");
-        listeners.add(listener);
-        return () => listeners.delete(listener);
-      },
-      destroy() {
-        if (destroyed) return;
-        destroyed = true;
-        listeners.clear();
-        review = null;
-        localIdentity = null;
-        activePinId = null;
-      }
-    };
-    return Object.freeze(controller);
-  }
-  function createElement(document2, tagName, { className, text: text5, attributes = {} } = {}) {
-    const element = document2.createElement(tagName);
-    if (className) element.className = className;
-    if (text5 !== void 0) element.textContent = text5;
-    for (const [name, value] of Object.entries(attributes)) {
-      if (value !== void 0 && value !== null) element.setAttribute(name, String(value));
-    }
-    return element;
-  }
-  function artifactReviewThreadDomId(pinId) {
-    return annotationDomIds(pinId).thread;
-  }
-  function displayTimestamp(timestamp2) {
-    const canonical = new Date(timestamp2).toISOString();
-    return `${canonical.slice(0, 10)} ${canonical.slice(11, 16)} UTC`;
-  }
-  function renderReply(document2, reply2) {
-    const item2 = createElement(document2, "li", {
-      className: "planr-reply",
-      attributes: { "data-planr-reply-id": reply2.id }
-    });
-    const heading = createElement(document2, "header");
-    heading.append(createElement(document2, "strong", { text: reply2.author.name }));
-    const time = createElement(document2, "time", {
-      text: displayTimestamp(reply2.createdAt),
-      attributes: { datetime: reply2.createdAt }
-    });
-    heading.append(time);
-    item2.append(heading, createElement(document2, "p", { text: reply2.comment }));
-    return item2;
-  }
-  function renderReplyForm(document2, pin, expanded = false) {
-    const fieldId = `${annotationDomIds(pin.id).thread}-reply`;
-    const wrapper = createElement(document2, "div", { className: "planr-reply-editor" });
-    const toggle = createElement(document2, "button", {
-      className: "planr-reply-toggle",
-      text: expanded ? "− Reply" : "+ Reply",
-      attributes: {
-        type: "button",
-        id: `${fieldId}-toggle`,
-        "data-planr-reply-toggle": pin.id,
-        "aria-expanded": String(expanded),
-        "aria-controls": `${fieldId}-form`,
-        title: expanded ? "Collapse reply" : "Reply to this comment"
-      }
-    });
-    const form = createElement(document2, "form", {
-      className: "planr-reply-form",
-      attributes: {
-        "data-planr-reply-form": pin.id,
-        id: `${fieldId}-form`,
-        ...expanded ? {} : { hidden: "" }
-      }
-    });
-    const label = createElement(document2, "label", {
-      className: "planr-reply-label",
-      text: "Reply to thread",
-      attributes: { for: fieldId }
-    });
-    const textarea = createElement(document2, "textarea", {
-      attributes: {
-        id: fieldId,
-        name: "reply",
-        maxlength: ARTIFACT_REVIEW_LIMITS.text,
-        rows: 2,
-        placeholder: "Write a reply…",
-        required: "",
-        "aria-describedby": "planr-review-error"
-      }
-    });
-    const controls = createElement(document2, "div", { className: "planr-reply-controls" });
-    const hint = createElement(document2, "span", {
-      className: "planr-reply-hint",
-      text: "Ctrl/⌘ + Enter to send"
-    });
-    const submit = createElement(document2, "button", {
-      className: "planr-reply-send",
-      attributes: {
-        type: "submit",
-        disabled: "",
-        "aria-label": "Send reply",
-        title: "Send reply (Ctrl/⌘ + Enter)"
-      }
-    });
-    const svg = document2.createElementNS("http://www.w3.org/2000/svg", "svg");
-    for (const [name, value] of Object.entries({
-      viewBox: "0 0 24 24",
-      width: "16",
-      height: "16",
-      fill: "none",
-      stroke: "currentColor",
-      "stroke-width": "1.8",
-      "stroke-linecap": "round",
-      "stroke-linejoin": "round",
-      "aria-hidden": "true",
-      focusable: "false"
-    }))
-      svg.setAttribute(name, value);
-    const path = document2.createElementNS("http://www.w3.org/2000/svg", "path");
-    path.setAttribute("d", "M12 19V5m-6 6 6-6 6 6");
-    svg.append(path);
-    submit.append(svg);
-    controls.append(hint, submit);
-    form.append(label, textarea, controls);
-    wrapper.append(toggle, form);
-    return wrapper;
-  }
-  function renderThread(document2, pin, active, description = {}) {
-    const intentLabel = typeof description.intentLabel === "string" ? description.intentLabel.slice(0, 128) : pin.intent;
-    const article = createElement(document2, "article", {
-      className: `planr-thread${active ? " is-active" : ""}`,
-      attributes: {
-        id: artifactReviewThreadDomId(pin.id),
-        tabindex: "-1",
-        "data-planr-pin-id": pin.id,
-        "data-planr-intent": pin.intent,
-        "data-planr-status": pin.status,
-        "aria-controls": annotationDomIds(pin.id).pin,
-        "aria-label": `${intentLabel} comment by ${pin.author.name}`,
-        "data-planr-unread": description.unread === true ? "true" : "false",
-        ...description.compact ? { "data-planr-compact": "true" } : {}
-      }
-    });
-    const header = createElement(document2, "header");
-    const byline = createElement(document2, "div", { className: "planr-review-byline" });
-    byline.append(
-      createElement(document2, "strong", { text: pin.author.name }),
-      createElement(document2, "span", { className: "planr-intent", text: intentLabel })
-    );
-    const time = createElement(document2, "time", {
-      text: description.compact ? `${new Date(pin.createdAt).toISOString().slice(11, 16)} UTC` : displayTimestamp(pin.createdAt),
-      attributes: { datetime: pin.createdAt, title: displayTimestamp(pin.createdAt) }
-    });
-    header.append(byline, time);
-    const comment = createElement(document2, "p", {
-      className: "planr-thread-comment",
-      text: pin.comment
-    });
-    const lifecycle = createElement(document2, "div", { className: "planr-thread-actions" });
-    lifecycle.append(
-      createElement(document2, "span", {
-        className: "planr-thread-status",
-        text: pin.status,
-        attributes: { title: `Status: ${pin.status}` }
-      }),
-      createElement(document2, "button", {
-        text: pin.status === "resolved" ? "Reopen" : "Resolve",
-        attributes: {
-          type: "button",
-          "data-planr-thread-action": pin.status === "resolved" ? "reopen" : "resolve",
-          "data-planr-pin-id": pin.id
-        }
-      }),
-      createElement(document2, "button", {
-        text: "Show pin",
-        attributes: {
-          type: "button",
-          "data-planr-thread-focus": pin.id,
-          "aria-controls": annotationDomIds(pin.id).pin
-        }
-      })
-    );
-    const replies = createElement(document2, "ol", {
-      className: "planr-replies",
-      attributes: { "aria-label": "Replies" }
-    });
-    const earlierReplies = description.compact ? Math.max(0, pin.replies.length - (description.replyLimit || 2)) : 0;
-    for (const reply2 of pin.replies.slice(earlierReplies))
-      replies.append(renderReply(document2, reply2));
-    const editor = renderReplyForm(document2, pin, description.replyExpanded);
-    article.append(header, comment);
-    if (description.compact && pin.comment.length > 240) {
-      comment.dataset.planrCommentCollapsed = String(!description.commentExpanded);
-      article.append(
-        createElement(document2, "button", {
-          className: "planr-comment-expand",
-          text: description.commentExpanded ? "Show less" : "Read full comment",
-          attributes: {
-            type: "button",
-            id: `${annotationDomIds(pin.id).thread}-expand`,
-            "data-planr-comment-expand": pin.id,
-            "aria-expanded": String(Boolean(description.commentExpanded))
-          }
-        })
-      );
-    }
-    if (earlierReplies)
-      article.append(
-        createElement(document2, "button", {
-          className: "planr-history-expand",
-          text: `Show ${earlierReplies} earlier ${earlierReplies === 1 ? "reply" : "replies"}`,
-          attributes: {
-            type: "button",
-            id: `${annotationDomIds(pin.id).thread}-history`,
-            "data-planr-history-expand": pin.id,
-            "aria-expanded": "false"
-          }
-        })
-      );
-    if (pin.replies.length) article.append(replies);
-    if (description.compact) {
-      lifecycle.append(editor.querySelector("[data-planr-reply-toggle]"));
-      article.append(lifecycle, editor);
-    } else article.append(lifecycle, editor);
-    return article;
-  }
-  function decisionCopy(decision) {
-    if (decision === "approved") return "Review approved";
-    if (decision === "changes_requested") return "Changes requested";
-    return "Decision pending";
-  }
-  function mountArtifactFeedbackRail({
-    root,
-    document: document2 = root?.ownerDocument,
-    window = document2?.defaultView,
-    controller: providedController,
-    initialReview = null,
-    reviewOf,
-    reviewId,
-    identity = null,
-    createId = defaultCreateId,
-    now = defaultNow,
-    onSelectPin,
-    presentation: initialPresentation = {}
-  } = {}) {
-    if (!root || !document2 || !window) invalid("A browser root, document, and window are required.");
-    const slot = root.querySelector('[data-planr-slot="feedback-rail"]');
-    const identityInput = root.querySelector("[data-planr-reviewer-name]");
-    const identityStatus = root.querySelector("[data-planr-identity-status]");
-    const overall = root.querySelector("#planr-overall-note");
-    const decisionStatus = root.querySelector('[data-planr-slot="decision-status"]');
-    const decisionButtons = [...root.querySelectorAll("[data-planr-decision]")];
-    if (!slot || !identityInput || !overall || !decisionStatus || decisionButtons.length === 0) {
-      invalid("Artifact feedback renderer slots are missing.");
-    }
-    const ownsController = !providedController;
-    const controller = providedController ?? createArtifactReviewController({
-      initialReview,
-      reviewOf,
-      reviewId,
-      identity,
-      createId,
-      now
-    });
-    let destroyed = false;
-    let presentation = { ...initialPresentation };
-    const replyDrafts = /* @__PURE__ */ new Map();
-    const expandedReplies = /* @__PURE__ */ new Set();
-    const expandedHistory = /* @__PURE__ */ new Map(), expandedComments = /* @__PURE__ */ new Set();
-    let visibleLimit = Number.isInteger(initialPresentation.pageSize) ? initialPresentation.pageSize : Infinity;
-    const extraDrafts = /* @__PURE__ */ new Map();
-    let overallDirty = false;
-    let composing = false;
-    let renderQueued = false;
-    const captureDrafts = () => {
-      for (const form of slot.querySelectorAll("[data-planr-reply-form]")) {
-        const field = form.elements.namedItem("reply");
-        if (field) replyDrafts.set(form.dataset.planrReplyForm, field.value);
-      }
-      for (const field of slot.querySelectorAll("[data-planr-draft-key]")) {
-        if (typeof field.value === "string")
-          extraDrafts.set(field.dataset.planrDraftKey, field.value);
-      }
-    };
-    const snapshotDrafts = () => {
-      captureDrafts();
-      return cloneFrozenArtifactReview({
-        reviewOf: controller.getReview()?.reviewOf ?? reviewOf,
-        replies: Object.fromEntries(replyDrafts),
-        expandedReplies: [...expandedReplies],
-        fields: Object.fromEntries(extraDrafts),
-        overall: { value: overall.value, dirty: overallDirty },
-        identity: identityInput.value
-      });
-    };
-    const emitDraftChange = () => root.dispatchEvent(
-      new window.CustomEvent(ARTIFACT_REVIEW_DRAFT_CHANGE_EVENT, {
-        bubbles: true,
-        detail: snapshotDrafts()
-      })
-    );
-    const focusDescriptor = () => {
-      const element = document2.activeElement;
-      if (!element || !slot.contains(element)) return null;
-      const thread2 = element.closest("[data-planr-pin-id]");
-      return {
-        id: element.id,
-        pinId: thread2?.dataset.planrPinId,
-        draftKey: element.dataset.planrDraftKey,
-        action: element.dataset.planrThreadAction,
-        showPin: element.dataset.planrThreadFocus,
-        tag: element.tagName,
-        name: element.name,
-        start: element.selectionStart,
-        end: element.selectionEnd,
-        direction: element.selectionDirection
-      };
-    };
-    const restoreFocus = (descriptor) => {
-      if (!descriptor) return;
-      const thread2 = descriptor.pinId && document2.getElementById(artifactReviewThreadDomId(descriptor.pinId));
-      const target = descriptor.id && document2.getElementById(descriptor.id) || descriptor.draftKey && [...slot.querySelectorAll("[data-planr-draft-key]")].find(
-        (field) => field.dataset.planrDraftKey === descriptor.draftKey
-      ) || descriptor.action && [...thread2?.querySelectorAll("[data-planr-thread-action]") ?? []].find(
-        (button) => button.dataset.planrThreadAction === descriptor.action
-      ) || descriptor.showPin && thread2?.querySelector("[data-planr-thread-focus]") || [...thread2?.querySelectorAll("button,input,select,textarea") ?? []].find(
-        (field) => field.tagName === descriptor.tag && field.name === descriptor.name
-      );
-      target?.focus?.({ preventScroll: true });
-      if (Number.isInteger(descriptor.start))
-        target?.setSelectionRange?.(descriptor.start, descriptor.end, descriptor.direction);
-    };
-    const showError = (error) => {
-      const target = root.querySelector("#planr-review-error");
-      if (!target) return;
-      target.textContent = error?.message ?? String(error);
-      target.hidden = false;
-    };
-    const clearError = () => {
-      const target = root.querySelector("#planr-review-error");
-      if (!target) return;
-      target.textContent = "";
-      target.hidden = true;
-    };
-    const announce2 = (message) => {
-      decisionStatus.textContent = message;
-      const live = root.parentElement?.querySelector('[data-planr-slot="review-announcer"]') ?? document2.querySelector('[data-planr-slot="review-announcer"]');
-      if (live) live.textContent = message;
-    };
-    const updateCounts = (pins) => {
-      const label = `${pins.length} ${pins.length === 1 ? "comment" : "comments"}`;
-      for (const count2 of root.querySelectorAll(
-        '[data-planr-action="feedback"] .planr-count, .planr-review-rail > header .planr-count'
-      )) {
-        count2.textContent = String(pins.length);
-        count2.setAttribute("aria-label", label);
-      }
-      const commentsButton = root.querySelector('[data-planr-action="feedback"]');
-      commentsButton?.setAttribute("aria-label", commentsButton.dataset.planrReviewLabel || label);
-      if (commentsButton?.dataset.planrReviewLabel)
-        commentsButton.setAttribute("aria-description", label);
-    };
-    const render = ({ capture = true } = {}) => {
-      if (composing) {
-        renderQueued = true;
-        return;
-      }
-      if (capture) captureDrafts();
-      const focus = focusDescriptor();
-      const scroll = [];
-      for (let node2 = slot; node2 && root.contains(node2); node2 = node2.parentElement)
-        scroll.push([node2, node2.scrollTop, node2.scrollLeft]);
-      const state = controller.getState();
-      const { review, activePinId } = state;
-      const allPins = review?.pins ?? [];
-      const pins = typeof presentation.filterPin === "function" ? allPins.filter((pin) => presentation.filterPin(pin, state)) : allPins;
-      const activeIndex = pins.findIndex((pin) => pin.id === activePinId);
-      const visiblePins = pins.slice(0, visibleLimit);
-      if (activeIndex >= visibleLimit) visiblePins.push(pins[activeIndex]);
-      const fragment = document2.createDocumentFragment();
-      const list3 = createElement(document2, "div", {
-        className: "planr-thread-list",
-        attributes: { "aria-label": "Comment threads" }
-      });
-      if (pins.length === 0) {
-        list3.append(
-          createElement(document2, "p", {
-            className: "planr-review-empty",
-            text: typeof presentation.emptyMessage === "string" ? presentation.emptyMessage : allPins.length ? "No comments match these filters." : "No comments yet. Choose Add comment, then select a point or region in the artifact."
-          })
-        );
-      } else {
-        for (const pin of visiblePins) {
-          const thread2 = renderThread(document2, pin, pin.id === activePinId, {
-            ...presentation.describePin?.(pin, state),
-            compact: presentation.compact === true,
-            replyLimit: expandedHistory.get(pin.id) || 2,
-            commentExpanded: expandedComments.has(pin.id),
-            replyExpanded: expandedReplies.has(pin.id)
-          });
-          presentation.decorateThread?.({ element: thread2, pin, state, document: document2 });
-          const reply2 = thread2.querySelector('[name="reply"]');
-          if (replyDrafts.has(pin.id)) reply2.value = replyDrafts.get(pin.id);
-          thread2.querySelector(".planr-reply-send").disabled = !reply2.value.trim();
-          for (const field of thread2.querySelectorAll("[data-planr-draft-key]")) {
-            if (extraDrafts.has(field.dataset.planrDraftKey))
-              field.value = extraDrafts.get(field.dataset.planrDraftKey);
-          }
-          list3.append(thread2);
-        }
-      }
-      if (pins.length > visibleLimit)
-        list3.append(
-          createElement(document2, "button", {
-            className: "planr-threads-more",
-            text: `Show more comments · ${Math.min(visibleLimit, pins.length)} of ${pins.length}`,
-            attributes: { type: "button", "data-planr-threads-more": "" }
-          })
-        );
-      fragment.append(list3);
-      slot.replaceChildren(fragment);
-      const identityName2 = controller.getIdentity()?.name ?? "";
-      if (document2.activeElement !== identityInput) identityInput.value = identityName2;
-      if (identityStatus) {
-        identityStatus.dataset.planrIdentityReady = String(Boolean(identityName2));
-        identityStatus.textContent = identityName2 ? `Comments will appear as ${identityName2}.` : "Used to sign your comments.";
-      }
-      overall.maxLength = ARTIFACT_REVIEW_LIMITS.text;
-      if (!overallDirty && document2.activeElement !== overall) overall.value = review?.overall ?? "";
-      for (const button of decisionButtons) {
-        button.setAttribute(
-          "aria-pressed",
-          String(button.dataset.planrDecision === (review?.decision ?? "pending"))
-        );
-      }
-      decisionStatus.textContent = decisionCopy(review?.decision ?? "pending");
-      updateCounts(allPins);
-      restoreFocus(focus);
-      for (const [node2, top, left] of scroll) {
-        node2.scrollTop = top;
-        node2.scrollLeft = left;
-      }
-      const openMetric = root.querySelector('[data-planr-metric="open"]');
-      if (openMetric)
-        openMetric.textContent = `${allPins.filter(({ status }) => status !== "resolved").length} open`;
-    };
-    const focusThread = (pinId) => {
-      const thread2 = document2.getElementById(artifactReviewThreadDomId(pinId));
-      thread2?.focus({ preventScroll: true });
-      thread2?.scrollIntoView?.({ block: "nearest" });
-    };
-    const emitReview = (review) => {
-      const detail = cloneFrozenArtifactReview(review);
-      root.dispatchEvent(
-        new window.CustomEvent(ARTIFACT_REVIEW_CHANGE_EVENT, {
-          detail,
-          bubbles: true
-        })
-      );
-    };
-    const unsubscribe = controller.subscribe((state, change) => {
-      if (destroyed) return;
-      if (["review", "review-replaced", "selection"].includes(change.type)) render();
-      if (["review", "review-replaced"].includes(change.type) && state.review)
-        emitReview(state.review);
-    });
-    const onInput = (event) => {
-      if (event.target !== identityInput) return;
-      try {
-        controller.setIdentity(event.target.value ? { name: event.target.value } : null);
-        const name = controller.getIdentity()?.name ?? "";
-        if (identityStatus) {
-          identityStatus.dataset.planrIdentityReady = String(Boolean(name));
-          identityStatus.textContent = name ? `Comments will appear as ${name}.` : "Used to sign your comments.";
-        }
-        clearError();
-      } catch (error) {
-        showError(error);
-      }
-    };
-    const setReplyExpanded = (pinId, expanded, { focus = false } = {}) => {
-      const thread2 = document2.getElementById(artifactReviewThreadDomId(pinId));
-      const form = thread2?.querySelector("[data-planr-reply-form]");
-      const toggle = thread2?.querySelector("[data-planr-reply-toggle]");
-      if (!form || !toggle) return;
-      if (expanded) expandedReplies.add(pinId);
-      else expandedReplies.delete(pinId);
-      form.hidden = !expanded;
-      toggle.setAttribute("aria-expanded", String(expanded));
-      toggle.textContent = expanded ? "− Reply" : "+ Reply";
-      toggle.title = expanded ? "Collapse reply" : "Reply to this comment";
-      if (focus)
-        (expanded ? form.elements.namedItem("reply") : toggle).focus({ preventScroll: true });
-      emitDraftChange();
-    };
-    const onKeyDown = (event) => {
-      const form = event.target?.closest?.("[data-planr-reply-form]");
-      if (!form || event.isComposing) return;
-      if (event.key === "Escape") {
-        event.preventDefault();
-        event.stopPropagation();
-        setReplyExpanded(form.dataset.planrReplyForm, false, { focus: true });
-      } else if (event.key === "Enter" && (event.metaKey || event.ctrlKey)) {
-        event.preventDefault();
-        if (form.elements.namedItem("reply").value.trim()) form.requestSubmit();
-      }
-    };
-    const emitSelection = (pinId) => {
-      controller.selectPin(pinId);
-      root.dispatchEvent(
-        new window.CustomEvent(ARTIFACT_REVIEW_SELECT_EVENT, {
-          detail: deepFreeze({ pinId, source: "thread" }),
-          bubbles: true
-        })
-      );
-      onSelectPin?.(pinId);
-    };
-    const onClick = (event) => {
-      if (event.target.closest?.("[data-planr-threads-more]")) {
-        visibleLimit += presentation.pageSize || 40;
-        render();
-        return;
-      }
-      const historyToggle = event.target.closest?.("[data-planr-history-expand]");
-      if (historyToggle) {
-        const id7 = historyToggle.dataset.planrHistoryExpand;
-        expandedHistory.set(id7, (expandedHistory.get(id7) || 2) + 20);
-        render();
-        return;
-      }
-      const commentToggle = event.target.closest?.("[data-planr-comment-expand]");
-      if (commentToggle) {
-        const id7 = commentToggle.dataset.planrCommentExpand;
-        if (expandedComments.has(id7)) expandedComments.delete(id7);
-        else expandedComments.add(id7);
-        render();
-        return;
-      }
-      const replyToggle = event.target?.closest?.("[data-planr-reply-toggle]");
-      if (replyToggle) {
-        setReplyExpanded(
-          replyToggle.dataset.planrReplyToggle,
-          replyToggle.getAttribute("aria-expanded") !== "true",
-          { focus: true }
-        );
-        return;
-      }
-      const action = event.target?.closest?.("[data-planr-thread-action]");
-      const focus = event.target?.closest?.("[data-planr-thread-focus]");
-      if (action) {
-        try {
-          const pinId = action.dataset.planrPinId;
-          controller.dispatch({
-            type: "set-status",
-            pinId,
-            status: action.dataset.planrThreadAction === "resolve" ? "resolved" : "open"
-          });
-          announce2(
-            action.dataset.planrThreadAction === "resolve" ? "Comment resolved" : "Comment reopened"
-          );
-          focusThread(pinId);
-          clearError();
-        } catch (error) {
-          showError(error);
-        }
-        return;
-      }
-      if (focus) emitSelection(focus.dataset.planrThreadFocus);
-    };
-    const onSubmit = (event) => {
-      const form = event.target?.closest?.("[data-planr-reply-form]");
-      if (!form) return;
-      event.preventDefault();
-      const textarea = form.elements.namedItem("reply");
-      const comment = textarea.value;
-      if (!comment.trim()) return;
-      const wasExpanded = expandedReplies.has(form.dataset.planrReplyForm);
-      try {
-        textarea.setAttribute("aria-invalid", "false");
-        textarea.value = "";
-        replyDrafts.delete(form.dataset.planrReplyForm);
-        expandedReplies.delete(form.dataset.planrReplyForm);
-        controller.dispatch({
-          type: "add-reply",
-          pinId: form.dataset.planrReplyForm,
-          comment
-        });
-        emitDraftChange();
-        announce2("Reply added");
-        focusThread(form.dataset.planrReplyForm);
-        clearError();
-      } catch (error) {
-        textarea.value = comment;
-        replyDrafts.set(form.dataset.planrReplyForm, comment);
-        if (wasExpanded) expandedReplies.add(form.dataset.planrReplyForm);
-        textarea?.setAttribute("aria-invalid", "true");
-        showError(error);
-        textarea?.focus();
-      }
-    };
-    const onOverallChange = () => {
-      try {
-        const value = overall.value;
-        controller.dispatch({ type: "set-overall", overall: value });
-        overallDirty = false;
-        announce2("Overall note updated");
-        clearError();
-      } catch (error) {
-        showError(error);
-      }
-    };
-    const onDecision = (event) => {
-      try {
-        const selected = event.currentTarget.dataset.planrDecision;
-        const decision = controller.getReview()?.decision === selected ? "pending" : selected;
-        controller.dispatch({ type: "set-decision", decision });
-        announce2(decisionCopy(decision));
-        clearError();
-      } catch (error) {
-        showError(error);
-      }
-    };
-    const onSelect = (event) => {
-      if (event.detail?.source === "thread" || typeof event.detail?.pinId !== "string") return;
-      try {
-        controller.selectPin(event.detail.pinId);
-        focusThread(event.detail.pinId);
-      } catch (error) {
-        showError(error);
-      }
-    };
-    let lastOpened = null;
-    const onThreadOpen = (event) => {
-      const thread2 = event.target.closest?.(".planr-thread[data-planr-pin-id]");
-      if (!thread2 || !slot.contains(thread2)) return;
-      const pin = controller.getReview()?.pins.find((entry) => entry.id === thread2.dataset.planrPinId);
-      const key = pin && `${pin.id}:${pin.replies.map((reply2) => reply2.id).join(",")}`;
-      if (!key || lastOpened === key) return;
-      lastOpened = key;
-      presentation.onThreadOpen?.(pin.id, controller.getState());
-      root.dispatchEvent(
-        new window.CustomEvent("planr:artifact-thread-open", {
-          bubbles: true,
-          detail: Object.freeze({ pinId: pin.id })
-        })
-      );
-    };
-    const onDraftInput = (event) => {
-      const form = event.target.closest?.("[data-planr-reply-form]");
-      if (form)
-        form.querySelector(".planr-reply-send").disabled = !form.elements.namedItem("reply").value.trim();
-      emitDraftChange();
-    };
-    const onOverallInput = () => {
-      overallDirty = true;
-      emitDraftChange();
-    };
-    const onCompositionStart = () => {
-      composing = true;
-    };
-    const onCompositionEnd = () => {
-      composing = false;
-      if (renderQueued) {
-        renderQueued = false;
-        render();
-      }
-    };
-    slot.addEventListener("input", onDraftInput);
-    slot.addEventListener("focusin", onThreadOpen);
-    slot.addEventListener("click", onThreadOpen);
-    slot.addEventListener("compositionstart", onCompositionStart);
-    slot.addEventListener("compositionend", onCompositionEnd);
-    overall.addEventListener("input", onOverallInput);
-    identityInput.addEventListener("input", onInput);
-    slot.addEventListener("click", onClick);
-    slot.addEventListener("submit", onSubmit);
-    slot.addEventListener("keydown", onKeyDown);
-    overall.addEventListener("change", onOverallChange);
-    for (const button of decisionButtons) button.addEventListener("click", onDecision);
-    root.addEventListener(ARTIFACT_REVIEW_SELECT_EVENT, onSelect);
-    render();
-    return Object.freeze({
-      controller,
-      getReview: () => controller.getReview(),
-      getState: () => controller.getState(),
-      getIdentity: () => controller.getIdentity(),
-      setIdentity: (value) => controller.setIdentity(value),
-      dispatch: (action) => controller.dispatch(action),
-      replaceReview: (review) => controller.replaceReview(review),
-      selectPin: (pinId) => controller.selectPin(pinId),
-      render,
-      setPresentation(options = {}) {
-        if (options.filterKey !== presentation.filterKey || options.pageSize !== void 0 && options.pageSize !== presentation.pageSize)
-          visibleLimit = options.pageSize || presentation.pageSize || Infinity;
-        presentation = { ...presentation, ...options };
-        render();
-      },
-      snapshotDrafts,
-      getReviewOf: () => controller.getReview()?.reviewOf ?? reviewOf,
-      restoreDrafts(snapshot2) {
-        const digest8 = controller.getReview()?.reviewOf ?? reviewOf;
-        if (!snapshot2 || snapshot2.reviewOf !== digest8) return false;
-        if (typeof snapshot2.identity === "string") {
-          const name = snapshot2.identity.slice(0, ARTIFACT_REVIEW_LIMITS.authorName);
-          controller.setIdentity(name.trim() ? { ...controller.getIdentity(), name } : null);
-        }
-        for (const [id7, value] of Object.entries(snapshot2.replies ?? {}).slice(
-          0,
-          ARTIFACT_REVIEW_LIMITS.pins
-        )) {
-          if (id7.length <= ARTIFACT_REVIEW_LIMITS.id && typeof value === "string")
-            replyDrafts.set(id7, value.slice(0, ARTIFACT_REVIEW_LIMITS.text));
-        }
-        expandedReplies.clear();
-        const expanded = Array.isArray(snapshot2.expandedReplies) ? snapshot2.expandedReplies : [...replyDrafts.keys()];
-        for (const id7 of expanded.slice(0, ARTIFACT_REVIEW_LIMITS.pins))
-          if (typeof id7 === "string" && id7.length <= ARTIFACT_REVIEW_LIMITS.id)
-            expandedReplies.add(id7);
-        for (const [key, value] of Object.entries(snapshot2.fields ?? {}).slice(
-          0,
-          ARTIFACT_REVIEW_LIMITS.pins
-        )) {
-          if (key.length <= 512 && typeof value === "string")
-            extraDrafts.set(key, value.slice(0, ARTIFACT_REVIEW_LIMITS.text));
-        }
-        overallDirty = snapshot2.overall?.dirty === true;
-        if (overallDirty && typeof snapshot2.overall?.value === "string")
-          overall.value = snapshot2.overall.value.slice(0, ARTIFACT_REVIEW_LIMITS.text);
-        render({ capture: false });
-        return true;
-      },
-      focusThread,
-      destroy() {
-        if (destroyed) return;
-        destroyed = true;
-        unsubscribe();
-        slot.removeEventListener("input", onDraftInput);
-        slot.removeEventListener("focusin", onThreadOpen);
-        slot.removeEventListener("click", onThreadOpen);
-        slot.removeEventListener("compositionstart", onCompositionStart);
-        slot.removeEventListener("compositionend", onCompositionEnd);
-        overall.removeEventListener("input", onOverallInput);
-        identityInput.removeEventListener("input", onInput);
-        slot.removeEventListener("click", onClick);
-        slot.removeEventListener("submit", onSubmit);
-        slot.removeEventListener("keydown", onKeyDown);
-        overall.removeEventListener("change", onOverallChange);
-        for (const button of decisionButtons) button.removeEventListener("click", onDecision);
-        root.removeEventListener(ARTIFACT_REVIEW_SELECT_EVENT, onSelect);
-        if (ownsController) controller.destroy();
-      }
-    });
-  }