@xenosystem/blocks 0.2.1 → 0.3.0

package/dist/trust/index.js

@@ -0,0 +1,1003 @@
+// src/trust/consent/panel.ts
+import { createElement } from "react";
+import { createRoot } from "react-dom/client";
+import {
+  isRecord,
+  bindConfig
+} from "@xenosystem/panel-sdk";
+
+// src/trust/consent/types.ts
+function allowedDurations(request) {
+  return request.remember === "forbidden" ? ["once"] : ["once", "session", "always"];
+}
+function selectableScopes(request) {
+  return request.scopes.filter((s) => !s.alreadyGranted);
+}
+function effectiveRisk(request) {
+  const order = ["low", "medium", "high"];
+  let highest = request.risk;
+  for (const scope of request.scopes ?? []) {
+    if (scope.risk && order.indexOf(scope.risk) > order.indexOf(highest)) highest = scope.risk;
+  }
+  return highest;
+}
+function isExpired(request, now) {
+  return request.expiresAt !== void 0 && now >= request.expiresAt;
+}
+function isConsentRequest(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  if (v.ask !== void 0 && v.ask !== "permission") return false;
+  return typeof v.id === "string" && typeof v.title === "string" && Array.isArray(v.scopes) && typeof v.risk === "string" && typeof v.requestedAt === "number";
+}
+function autoDeny(request, reason) {
+  return { id: request.id, decision: "deny", scope: "once", reason };
+}
+
+// src/trust/consent/elicitation.ts
+var ELICITATION_SCHEMA = "xeno.elicitation@1";
+var ELICITATION_RESULT_SCHEMA = "xeno.elicitationresult@1";
+function elicitationAsk(value) {
+  return value.ask ?? "permission";
+}
+function isPermissionElicitation(value) {
+  return elicitationAsk(value) === "permission";
+}
+function elicitationOptions(value) {
+  const options = value.options;
+  return Array.isArray(options) ? options : [];
+}
+function findOption(value, optionId) {
+  if (optionId === null) return void 0;
+  return elicitationOptions(value).find((option) => option.id === optionId);
+}
+function maxTextLength(value) {
+  const max = value.maxLength;
+  return typeof max === "number" && Number.isFinite(max) && max > 0 ? max : null;
+}
+function hasElicitationBase(v) {
+  return typeof v.id === "string" && typeof v.title === "string" && typeof v.risk === "string" && typeof v.requestedAt === "number";
+}
+function areOptions(value, required) {
+  if (value === void 0) return !required;
+  if (!Array.isArray(value) || required && value.length === 0) return false;
+  return value.every(
+    (o) => !!o && typeof o === "object" && typeof o.id === "string" && typeof o.label === "string"
+  );
+}
+function isElicitation(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const v = value;
+  const ask = v.ask;
+  if (ask === void 0 || ask === "permission") return isConsentRequest(value);
+  if (!hasElicitationBase(v)) return false;
+  switch (ask) {
+    case "text":
+      return areOptions(v.options, false);
+    case "path":
+      return (v.pathKind === "file" || v.pathKind === "directory") && areOptions(v.options, false);
+    case "choice":
+      return areOptions(v.options, true);
+    default:
+      return false;
+  }
+}
+function isElicitationAnswer(value) {
+  return !!value && typeof value === "object" && value.answered === true;
+}
+function isElicitationCancelled(value) {
+  return !!value && typeof value === "object" && value.answered === false;
+}
+function autoCancel(request, reason) {
+  const ask = elicitationAsk(request);
+  return {
+    id: request.id,
+    // A permission never reaches here — the controller routes those to `autoDeny` — but the type
+    // must still be total, and `'text'` is the inert choice: a cancellation carries no answer for
+    // ANY ask, so the field is a label, never a behaviour.
+    ask: ask === "permission" ? "text" : ask,
+    answered: false,
+    reason
+  };
+}
+
+// src/trust/consent/controller.ts
+var ConsentController = class {
+  host;
+  listeners = /* @__PURE__ */ new Set();
+  now;
+  setTimer;
+  clearTimer;
+  perScope;
+  defaultDuration;
+  queue = [];
+  selected = /* @__PURE__ */ new Set();
+  duration;
+  /** What the user has typed for the head question. Discarded whenever the head changes. */
+  draftText = "";
+  /** The option highlighted for the head question. Highlighting is not answering. */
+  selectedOptionId = null;
+  expiryTimer = null;
+  /** Ids already decided, so a re-delivery cannot produce a second decision. */
+  resolved = /* @__PURE__ */ new Set();
+  snapshot = null;
+  constructor(options) {
+    this.host = options.host;
+    this.now = options.host.now ?? (() => Date.now());
+    this.setTimer = options.host.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+    this.clearTimer = options.host.clearTimer ?? ((h) => clearTimeout(h));
+    this.perScope = options.perScope !== false;
+    this.defaultDuration = options.defaultDuration ?? "once";
+    this.duration = this.defaultDuration;
+  }
+  /* ── Subscription ──────────────────────────────────────────────────────── */
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+  getState = () => {
+    if (!this.snapshot) {
+      const current = this.queue[0] ?? null;
+      this.snapshot = {
+        current,
+        queued: this.queue.slice(1),
+        pending: this.queue.length,
+        selectedScopeIds: [...this.selected],
+        duration: this.duration,
+        expiresInMs: current?.expiresAt === void 0 ? null : Math.max(0, current.expiresAt - this.now()),
+        draftText: this.draftText,
+        selectedOptionId: this.selectedOptionId,
+        canSubmit: this.answerFor(current) !== null
+      };
+    }
+    return this.snapshot;
+  };
+  notify() {
+    this.snapshot = null;
+    for (const listener of this.listeners) listener();
+  }
+  /* ── Queue ─────────────────────────────────────────────────────────────── */
+  /**
+   * Enqueue a request.
+   *
+   * Requests are **ordered and individually resolvable**. They are never merged, never deduplicated
+   * into one "allow all", and a second request does not supersede the first — bulk approval is how
+   * consent fatigue turns into a security hole.
+   *
+   * @returns `true` if enqueued; `false` if already pending or already decided.
+   */
+  enqueue(request) {
+    if (!isElicitation(request)) return false;
+    if (this.resolved.has(request.id)) return false;
+    if (this.queue.some((r) => r.id === request.id)) return false;
+    if (isExpired(request, this.now())) {
+      this.settleUnanswered(request, "expired");
+      return false;
+    }
+    const wasEmpty = this.queue.length === 0;
+    this.queue.push(request);
+    this.queue.sort((a, b) => a.requestedAt - b.requestedAt || (a.id < b.id ? -1 : 1));
+    if (wasEmpty || this.queue[0]?.id === request.id) this.resetSelection();
+    this.armExpiry();
+    this.notify();
+    return true;
+  }
+  /** Enqueue several. */
+  enqueueMany(requests) {
+    let added = 0;
+    for (const request of requests) if (this.enqueue(request)) added += 1;
+    return added;
+  }
+  /**
+   * Withdraw a request the host no longer needs an answer to.
+   *
+   * Emits `superseded` so the host's awaiting promise resolves — a withdrawn request that resolves
+   * nothing leaves the caller hanging forever.
+   */
+  withdraw(id) {
+    const index = this.queue.findIndex((r) => r.id === id);
+    if (index < 0) return false;
+    const [request] = this.queue.splice(index, 1);
+    if (request) this.settleUnanswered(request, "superseded");
+    this.resetSelection();
+    this.armExpiry();
+    this.notify();
+    return true;
+  }
+  /**
+   * Selection state for the head of the queue.
+   *
+   * 🔴 **Called on every head change, and that is what stops a draft leaking between questions.**
+   * A name typed for one ask must never arrive as the answer to the next one — the ids differ, so
+   * the host would attribute it to a question the user never saw.
+   */
+  resetSelection() {
+    const current = this.queue[0];
+    const permission = current && isPermissionElicitation(current) ? current : null;
+    this.selected = new Set(permission ? selectableScopes(permission).map((s) => s.id) : []);
+    const durations = permission ? allowedDurations(permission) : ["once"];
+    this.duration = durations.includes(this.defaultDuration) ? this.defaultDuration : "once";
+    this.draftText = current && !permission ? String(current.initialValue ?? "") : "";
+    const preferred = current && elicitationAsk(current) === "choice" ? current.defaultOptionId ?? null : null;
+    this.selectedOptionId = typeof preferred === "string" && findOption(current, preferred) ? preferred : null;
+  }
+  /* ── Expiry ────────────────────────────────────────────────────────────── */
+  /**
+   * Arm a timer for the head request's expiry.
+   *
+   * **Expiry denies.** There is no configuration that makes a timeout allow — a grant nobody was
+   * present to give is not a grant.
+   */
+  armExpiry() {
+    if (this.expiryTimer !== null) {
+      this.clearTimer(this.expiryTimer);
+      this.expiryTimer = null;
+    }
+    const current = this.queue[0];
+    if (!current?.expiresAt) return;
+    const delay = Math.max(0, current.expiresAt - this.now());
+    this.expiryTimer = this.setTimer(() => {
+      this.expiryTimer = null;
+      this.expireDue();
+    }, delay);
+  }
+  /**
+   * Settle every request whose deadline has passed — permissions as a deny, questions as a
+   * cancellation.
+   *
+   * Sweeps the WHOLE queue, not just the head: a request waiting behind a slow decision can expire
+   * while it is still queued, and showing it afterwards would ask for an answer nobody can use.
+   *
+   * @returns How many expired.
+   */
+  expireDue() {
+    const now = this.now();
+    const due = this.queue.filter((r) => isExpired(r, now));
+    if (due.length === 0) {
+      this.armExpiry();
+      return 0;
+    }
+    this.queue = this.queue.filter((r) => !isExpired(r, now));
+    for (const request of due) this.settleUnanswered(request, "expired");
+    this.resetSelection();
+    this.armExpiry();
+    this.notify();
+    return due.length;
+  }
+  /* ── Selection ─────────────────────────────────────────────────────────── */
+  /** Toggle one scope of the current request. Refused when the head is not a permission. */
+  toggleScope(scopeId, selected) {
+    const current = this.currentPermission();
+    if (!current || !this.perScope) return false;
+    if (!selectableScopes(current).some((s) => s.id === scopeId)) return false;
+    const next = selected ?? !this.selected.has(scopeId);
+    if (next) this.selected.add(scopeId);
+    else this.selected.delete(scopeId);
+    this.notify();
+    return true;
+  }
+  /** Choose how long the grant lasts. Refuses a duration the request forbids. */
+  setDuration(duration) {
+    const current = this.currentPermission();
+    if (!current) return false;
+    if (!allowedDurations(current).includes(duration)) return false;
+    this.duration = duration;
+    this.notify();
+    return true;
+  }
+  /* ── Drafting an answer ────────────────────────────────────────────────── */
+  /**
+   * Record what the user has typed.
+   *
+   * ⚠️ **A draft is not an answer and never leaves the panel on its own.** Only `submit()` emits,
+   * and every other settlement path discards this — so a half-typed name cannot escape through a
+   * timeout.
+   *
+   * @param value - The current field contents.
+   * @returns `true` when the head is a question that takes a value.
+   */
+  setDraftText(value) {
+    const current = this.currentQuestion();
+    if (!current) return false;
+    if (typeof value !== "string") return false;
+    this.draftText = value;
+    this.notify();
+    return true;
+  }
+  /**
+   * Highlight one of the offered options.
+   *
+   * For a `choice` this IS the answer-in-progress; for `text`/`path` it is a shortcut that also
+   * fills the field. Either way nothing is emitted — highlighting is not answering.
+   *
+   * @param optionId - The option, or `null` to clear.
+   * @returns `true` when the option belongs to the current question.
+   */
+  selectOption(optionId) {
+    const current = this.currentQuestion();
+    if (!current) return false;
+    if (optionId === null) {
+      this.selectedOptionId = null;
+      this.notify();
+      return true;
+    }
+    const option = findOption(current, optionId);
+    if (!option) return false;
+    this.selectedOptionId = optionId;
+    if (elicitationAsk(current) !== "choice" && !option.requiresText) this.draftText = option.label;
+    this.notify();
+    return true;
+  }
+  /* ── Decisions ─────────────────────────────────────────────────────────── */
+  /**
+   * Allow the current request.
+   *
+   * The ONLY path in this controller that produces `decision: 'allow'`, and it requires a call from
+   * a user gesture. Refuses when nothing is selected — an "Allow" that grants nothing is a button
+   * that lies about what it did.
+   */
+  allow() {
+    const current = this.currentPermission();
+    if (!current) return false;
+    const selectable = selectableScopes(current);
+    const granted = this.perScope ? [...this.selected] : selectable.map((s) => s.id);
+    if (selectable.length > 0 && granted.length === 0) return false;
+    this.resolveHead({
+      id: current.id,
+      decision: "allow",
+      scope: this.duration,
+      reason: "user",
+      grantedScopeIds: granted
+    });
+    return true;
+  }
+  /**
+   * Deny the current request.
+   *
+   * ⚠️ **Permissions only.** "Deny" is a permission verb; a question is refused with
+   * {@link ConsentController.dismiss}, which is what `cancel_request` calls. Returning `false`
+   * here rather than quietly cancelling keeps the two refusals distinguishable to a caller.
+   */
+  deny() {
+    const current = this.currentPermission();
+    if (!current) return false;
+    this.resolveHead({ id: current.id, decision: "deny", scope: "once", reason: "user" });
+    return true;
+  }
+  /**
+   * Submit the answer to the current QUESTION.
+   *
+   * 🔴 **The only path in this controller that produces an answer**, and the exact counterpart of
+   * `allow()`: it requires a user gesture and it refuses to emit something the user did not
+   * supply. An empty text answer, a choice with nothing chosen, or a `requiresText` option with no
+   * value are all refusals — for the same reason `allow()` refuses to grant nothing. A control
+   * that reports success while carrying nothing is a control that lies about what it did.
+   *
+   * @returns `true` when an answer was emitted.
+   */
+  submit() {
+    const current = this.currentQuestion();
+    if (!current) return false;
+    const answer = this.answerFor(current);
+    if (answer === null) return false;
+    this.resolveHead(answer);
+    return true;
+  }
+  /**
+   * The user dismissed the prompt without answering.
+   *
+   * Resolves as **deny** for a permission and as a **cancellation** for a question — never as an
+   * allow, never as an answer, and never as "ask again later": an unanswered request that stays
+   * pending forever blocks the host that is awaiting it.
+   */
+  dismiss() {
+    const current = this.queue[0];
+    if (!current) return false;
+    this.queue.shift();
+    this.settleUnanswered(current, "dismissed");
+    this.resetSelection();
+    this.armExpiry();
+    this.notify();
+    return true;
+  }
+  /* ── Emission ──────────────────────────────────────────────────────────── */
+  /** The head of the queue when it is a permission. */
+  currentPermission() {
+    const current = this.queue[0];
+    return current && isPermissionElicitation(current) ? current : null;
+  }
+  /** The head of the queue when it is a question rather than a permission. */
+  currentQuestion() {
+    const current = this.queue[0];
+    if (!current || isPermissionElicitation(current)) return null;
+    return current;
+  }
+  /**
+   * The answer the current draft would produce, or `null` when it would produce none.
+   *
+   * ⚠️ **Pure, and shared with `getState().canSubmit`.** One predicate drives both the guard and
+   * the button's enabled state, so an enabled button cannot be a button that refuses — the class of
+   * bug where an affordance and its guard disagree has no representation here.
+   */
+  answerFor(current) {
+    if (!current || isPermissionElicitation(current)) return null;
+    const ask = elicitationAsk(current);
+    const value = this.draftText;
+    const max = maxTextLength(current);
+    if (max !== null && value.length > max) return null;
+    const optionId = this.selectedOptionId;
+    if (ask === "choice") {
+      if (optionId === null) return null;
+      const option = findOption(current, optionId);
+      if (!option) return null;
+      if (option.requiresText && value.trim() === "") return null;
+      const answer = {
+        id: current.id,
+        ask: "choice",
+        answered: true,
+        reason: "user",
+        optionId
+      };
+      return option.requiresText ? { ...answer, value } : answer;
+    }
+    const allowEmpty = ask === "text" && current.allowEmpty === true;
+    if (value.trim() === "" && !allowEmpty) return null;
+    return {
+      id: current.id,
+      ask: ask === "path" ? "path" : "text",
+      answered: true,
+      reason: "user",
+      value,
+      ...optionId !== null && findOption(current, optionId) ? { optionId } : {}
+    };
+  }
+  /**
+   * Settle a request the user did not answer.
+   *
+   * 🔴 **The generalised safe default lives here, and it is kind-dependent BY NECESSITY.** A
+   * permission's safe outcome is `deny`; a question's safe outcome is the absence of an answer.
+   * There is no third branch and no configuration that reaches one.
+   */
+  settleUnanswered(request, reason) {
+    if (isPermissionElicitation(request)) this.emitResolution(autoDeny(request, reason));
+    else this.emitResolution(autoCancel(request, reason));
+  }
+  resolveHead(resolution) {
+    this.queue.shift();
+    this.emitResolution(resolution);
+    this.resetSelection();
+    this.armExpiry();
+    this.notify();
+  }
+  /**
+   * Emit one resolution, on exactly one port.
+   *
+   * ⚠️ **The two output ports PARTITION the outcomes** — a permission answer only ever appears on
+   * `decision`, a question result only ever on `result`. Emitting a permission on both would let a
+   * host that wired both ports apply the same grant twice, which on a security surface is a defect
+   * to design out rather than to document.
+   */
+  emitResolution(resolution) {
+    if (this.resolved.has(resolution.id)) return;
+    this.resolved.add(resolution.id);
+    const isPermissionDecision = "decision" in resolution;
+    this.host.emit(isPermissionDecision ? "decision" : "result", resolution);
+  }
+  /** Has this request already been answered? */
+  isResolved(id) {
+    return this.resolved.has(id);
+  }
+  /**
+   * Pending requests, in order.
+   *
+   * ⚠️ Widened from `XenoConsentRequest[]` with the question kinds. A host that only enqueues
+   * permissions only ever gets permissions back; narrow with `isPermissionElicitation()`.
+   */
+  pending() {
+    return [...this.queue];
+  }
+  /* ── Lifecycle ─────────────────────────────────────────────────────────── */
+  /**
+   * Serialize — deliberately empty.
+   *
+   * **A pending decision must never survive a reload.** Restoring one would show a prompt whose
+   * host is long gone, and any answer would resolve nothing.
+   */
+  serialize() {
+    return {};
+  }
+  /** Restore — a no-op, for the same reason. */
+  deserialize() {
+  }
+  /**
+   * Tear down.
+   *
+   * Every still-pending request is settled — permissions **denied**, questions **cancelled** — so a
+   * host awaiting one is never left hanging by a panel that simply vanished.
+   *
+   * 🔴 **Disposal is not the same event as unmounting, and the difference matters for a question.**
+   * `render()`/`unrender()` only move the DOM; the controller and its queue outlive them, so
+   * hiding a panel tab does NOT answer or cancel anything and a half-typed draft survives being
+   * hidden. `dispose()` is the panel going away for good, and THAT is what settles the queue. A
+   * host that tears the panel down mid-question receives `answered: false` with reason
+   * `'dismissed'` — never an empty string, which it could not distinguish from a deliberate blank.
+   */
+  dispose() {
+    if (this.expiryTimer !== null) {
+      this.clearTimer(this.expiryTimer);
+      this.expiryTimer = null;
+    }
+    for (const request of this.queue) this.settleUnanswered(request, "dismissed");
+    this.queue = [];
+    this.listeners.clear();
+  }
+};
+
+// src/trust/consent/manifest.ts
+import { WELL_KNOWN_PORT_SCHEMAS } from "@xenosystem/panel-sdk";
+var CONSENT_PANEL_ID = "xeno.core.consent";
+var consentManifest = {
+  id: CONSENT_PANEL_ID,
+  version: "0.1.0",
+  title: "Consent",
+  icon: "shield-check",
+  description: "A blocking, request-scoped, decision-returning surface. Queued requests are answered individually, decisions are explicit, and scope and duration are visible in the answer. Beyond permissions it elicits text, a path, or one of a closed set of choices \u2014 none of which auto-resolve: a permission nobody answered denies, and a question nobody answered yields no answer at all.",
+  defaultSlot: "inspector",
+  inputs: [
+    {
+      id: "requests",
+      name: "Requests",
+      type: "object",
+      schema: WELL_KNOWN_PORT_SCHEMAS.CONSENT_REQUEST,
+      description: "A request, or {requests: [...]}. Queued in arrival order and answered one at a time \u2014 never merged into an allow-all.",
+      multiple: true
+    },
+    {
+      id: "elicitations",
+      name: "Elicitations",
+      type: "object",
+      schema: ELICITATION_SCHEMA,
+      description: "A question, or {requests: [...]}. `ask` selects the kind: permission | text | path | choice. Shares ONE ordered queue with `requests` \u2014 a question and a grant block the same user, so they cannot be two queues.",
+      multiple: true
+    },
+    {
+      id: "withdraw",
+      name: "Withdraw",
+      type: "string",
+      description: "Withdraw a request id. Resolves as deny/superseded (permission) or cancelled/superseded (question) so the awaiting host is not left hanging.",
+      multiple: false
+    }
+  ],
+  outputs: [
+    {
+      id: "decision",
+      name: "Decision",
+      type: "object",
+      schema: WELL_KNOWN_PORT_SCHEMAS.CONSENT_DECISION,
+      description: "{id, decision, scope, rememberedUntil?, reason?, grantedScopeIds?}. PERMISSIONS ONLY, in the shape this port has always carried. Exactly one per request id, ever. The host enforces; the panel grants nothing."
+    },
+    {
+      id: "result",
+      name: "Result",
+      type: "object",
+      schema: ELICITATION_RESULT_SCHEMA,
+      description: 'QUESTIONS ONLY. {id, ask, answered: true, reason: "user", value|optionId} when the user answered, or {id, ask, answered: false, reason} when it expired, was withdrawn or was dismissed \u2014 a cancellation carries NO value field at all. Partitioned from `decision`: a permission never appears here, so wiring both ports can never apply one grant twice.'
+    }
+  ],
+  commands: [
+    {
+      id: "get_pending",
+      title: "Get Pending",
+      description: "Return the queued requests, in order.",
+      parameters: {}
+    },
+    {
+      id: "deny_request",
+      title: "Deny Request",
+      description: 'Deny the current request. Permissions only \u2014 a question is refused with cancel_request, because "deny" and "no answer" are different outcomes to the host.',
+      parameters: {}
+    },
+    {
+      id: "cancel_request",
+      title: "Cancel Request",
+      description: "Settle the current request without answering it: a permission is denied, a question is cancelled. There is deliberately no command that ANSWERS one \u2014 see the note beside deny_request in panel.ts.",
+      parameters: {}
+    },
+    {
+      id: "set_duration",
+      title: "Set Duration",
+      description: "Choose once | session | always. Refused when the request forbids remembering.",
+      parameters: { duration: { type: "string", description: "once|session|always", required: true } }
+    },
+    {
+      id: "expire_due",
+      title: "Expire Due",
+      description: "Deny every request past its deadline. Expiry always denies.",
+      parameters: {}
+    }
+  ],
+  config: [
+    {
+      key: "perScope",
+      label: "Per-scope choices",
+      type: "boolean",
+      defaultValue: true,
+      description: "Let the user grant part of a request rather than all of it."
+    },
+    {
+      key: "defaultDuration",
+      label: "Default duration",
+      type: "select",
+      defaultValue: "once",
+      options: [
+        { label: "Once", value: "once" },
+        { label: "This session", value: "session" },
+        { label: "Always", value: "always" }
+      ],
+      description: "Pre-selected duration. Defaults to `once` deliberately \u2014 the safe option must be the default one."
+    },
+    {
+      key: "showQueueCount",
+      label: "Show queue count",
+      type: "boolean",
+      defaultValue: true,
+      description: "Show how many other requests are waiting."
+    },
+    {
+      key: "emptyHint",
+      label: "Empty hint",
+      type: "text",
+      description: "Shown when nothing is pending.",
+      placeholder: "Nothing is waiting for your approval."
+    }
+  ],
+  capabilities: ["storage.local"],
+  sdk: "^1.1.0"
+};
+
+// src/trust/consent/react/ConsentPanelView.tsx
+import { useSyncExternalStore } from "react";
+import {
+  Badge,
+  EmptyState,
+  Row,
+  RowList,
+  ScrollArea,
+  SegmentedControl,
+  StatusBar,
+  TextButton,
+  Toggle,
+  Toolbar,
+  ToolbarGroup
+} from "@xenosystem/workbench/primitives/react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var RISK_TONE = {
+  low: "neutral",
+  medium: "warning",
+  high: "error"
+};
+var DURATION_LABEL = { once: "Once", session: "Session", always: "Always" };
+var FIELD_STYLE = {
+  width: "100%",
+  fontSize: 11,
+  background: "var(--xeno-canvas)",
+  border: "1px solid var(--xeno-border-subtle)",
+  borderRadius: 2,
+  padding: 4,
+  color: "inherit",
+  // 🔴 Text entry never takes the global focus ring: `outline-offset` draws it OUTSIDE the field,
+  // so on dark chrome it reads as a stray stroke over the container and the control looks broken.
+  outline: "none",
+  resize: "none"
+};
+var SUBMIT_LABEL = {
+  text: "Submit",
+  path: "Use this path",
+  choice: "Confirm"
+};
+function ConsentPanelView({
+  controller,
+  showQueueCount = true,
+  emptyHint
+}) {
+  const state = useSyncExternalStore(controller.subscribe, controller.getState, controller.getState);
+  const request = state.current;
+  if (!request) {
+    return /* @__PURE__ */ jsx(
+      EmptyState,
+      {
+        title: "Nothing pending",
+        hint: emptyHint ?? "Requests needing your approval appear here."
+      }
+    );
+  }
+  const risk = effectiveRisk(request);
+  const ask = elicitationAsk(request);
+  const permission = isPermissionElicitation(request) ? request : null;
+  return /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", height: "100%", minHeight: 0 }, children: [
+    /* @__PURE__ */ jsx(
+      Toolbar,
+      {
+        left: /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(Badge, { tone: RISK_TONE[risk], children: `${risk} risk` }),
+          /* @__PURE__ */ jsx(Badge, { children: permission ? permission.kind : ask }),
+          request.subject ? /* @__PURE__ */ jsx("span", { style: { fontSize: 11 }, children: request.subject }) : null
+        ] }),
+        right: showQueueCount && state.queued.length > 0 ? /* @__PURE__ */ jsx(ToolbarGroup, { end: true, children: /* @__PURE__ */ jsx(Badge, { title: "Answered one at a time \u2014 never in bulk.", children: `+${state.queued.length} waiting` }) }) : void 0
+      }
+    ),
+    /* @__PURE__ */ jsxs(ScrollArea, { children: [
+      /* @__PURE__ */ jsxs("div", { style: { padding: 8, display: "flex", flexDirection: "column", gap: 6 }, children: [
+        /* @__PURE__ */ jsx("div", { style: { fontSize: 12, fontWeight: 600 }, children: request.title }),
+        request.detail ? (
+          // The HOST's sentence, verbatim. The panel never composes consent prose.
+          /* @__PURE__ */ jsx("div", { style: { fontSize: 11, opacity: 0.8, lineHeight: 1.45 }, children: request.detail })
+        ) : null,
+        request.fields ? Object.entries(request.fields).map(([key, value]) => /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: 6, fontSize: 10 }, children: [
+          /* @__PURE__ */ jsx("span", { style: { opacity: 0.55, minWidth: 72 }, children: key }),
+          /* @__PURE__ */ jsx("code", { style: { userSelect: "all", wordBreak: "break-all" }, children: value })
+        ] }, key)) : null
+      ] }),
+      permission ? /* @__PURE__ */ jsx(RowList, { children: permission.scopes.map((scope) => /* @__PURE__ */ jsx(
+        Row,
+        {
+          noIcon: true,
+          label: /* @__PURE__ */ jsxs("span", { style: { display: "flex", flexDirection: "column", gap: 1, minWidth: 0 }, children: [
+            /* @__PURE__ */ jsx("span", { children: scope.label }),
+            scope.detail ? /* @__PURE__ */ jsx("span", { style: { fontSize: 10, opacity: 0.6 }, children: scope.detail }) : null
+          ] }),
+          meta: scope.risk && scope.risk !== risk ? /* @__PURE__ */ jsx(Badge, { tone: RISK_TONE[scope.risk], children: scope.risk }) : null,
+          trailing: scope.alreadyGranted ? (
+            // Shown for context, not as a choice — hiding it would make the new ask look
+            // bigger than it is.
+            /* @__PURE__ */ jsx(Badge, { title: "Already granted", children: "granted" })
+          ) : /* @__PURE__ */ jsx(
+            Toggle,
+            {
+              size: "sm",
+              label: `Grant ${scope.label}`,
+              checked: state.selectedScopeIds.includes(scope.id),
+              onChange: (next) => controller.toggleScope(scope.id, next)
+            }
+          )
+        },
+        scope.id
+      )) }) : /* @__PURE__ */ jsx(QuestionForm, { controller, request, state, risk })
+    ] }),
+    permission ? /* @__PURE__ */ jsxs("div", { style: { padding: "4px 8px", display: "flex", alignItems: "center", gap: 8 }, children: [
+      /* @__PURE__ */ jsx(
+        SegmentedControl,
+        {
+          size: "sm",
+          label: "How long",
+          options: allowedDurations(permission).map((d) => ({
+            value: d,
+            label: DURATION_LABEL[d]
+          })),
+          value: state.duration,
+          onChange: (d) => controller.setDuration(d)
+        }
+      ),
+      permission.remember === "forbidden" ? /* @__PURE__ */ jsx("span", { style: { fontSize: 9, opacity: 0.6 }, children: "This grant cannot be remembered." }) : null
+    ] }) : null,
+    /* @__PURE__ */ jsx(
+      Toolbar,
+      {
+        divided: false,
+        right: /* @__PURE__ */ jsx(ToolbarGroup, { end: true, children: permission ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(TextButton, { onClick: () => controller.deny(), children: "Deny" }),
+          /* @__PURE__ */ jsx(
+            TextButton,
+            {
+              strong: true,
+              disabled: permission.scopes.some((s) => !s.alreadyGranted) && state.selectedScopeIds.length === 0,
+              onClick: () => controller.allow(),
+              children: "Allow"
+            }
+          )
+        ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(TextButton, { onClick: () => controller.dismiss(), children: "Cancel" }),
+          /* @__PURE__ */ jsx(
+            TextButton,
+            {
+              strong: true,
+              disabled: !state.canSubmit,
+              onClick: () => controller.submit(),
+              children: SUBMIT_LABEL[ask] ?? "Submit"
+            }
+          )
+        ] }) })
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      StatusBar,
+      {
+        left: `${state.pending} pending`,
+        right: state.expiresInMs !== null ? `expires in ${Math.ceil(state.expiresInMs / 1e3)}s \u2014 ${permission ? "denies" : "cancels"}` : void 0
+      }
+    )
+  ] });
+}
+function QuestionForm({ controller, request, state, risk }) {
+  const ask = elicitationAsk(request);
+  const options = elicitationOptions(request);
+  const max = maxTextLength(request);
+  const chosen = options.find((o) => o.id === state.selectedOptionId);
+  const multiline = ask === "text" && request.multiline === true;
+  const placeholder = request.placeholder ?? (ask === "path" ? "Type or paste a path\u2026" : "Type your answer\u2026");
+  const wantsText = ask !== "choice" || chosen?.requiresText === true;
+  const textLabel = request.textLabel;
+  return /* @__PURE__ */ jsxs("div", { style: { padding: "0 8px 8px", display: "flex", flexDirection: "column", gap: 6 }, children: [
+    options.length > 0 ? /* @__PURE__ */ jsx(RowList, { children: options.map((option) => /* @__PURE__ */ jsx(
+      Row,
+      {
+        noIcon: true,
+        label: /* @__PURE__ */ jsxs("span", { style: { display: "flex", flexDirection: "column", gap: 1, minWidth: 0 }, children: [
+          /* @__PURE__ */ jsx("span", { children: option.label }),
+          option.detail ? /* @__PURE__ */ jsx("span", { style: { fontSize: 10, opacity: 0.6 }, children: option.detail }) : null
+        ] }),
+        meta: option.risk && option.risk !== risk ? /* @__PURE__ */ jsx(Badge, { tone: RISK_TONE[option.risk], children: option.risk }) : null,
+        trailing: /* @__PURE__ */ jsx(
+          Toggle,
+          {
+            size: "sm",
+            label: `Choose ${option.label}`,
+            checked: state.selectedOptionId === option.id,
+            onChange: (next) => controller.selectOption(next ? option.id : null)
+          }
+        )
+      },
+      option.id
+    )) }) : null,
+    wantsText ? /* @__PURE__ */ jsxs("label", { style: { display: "flex", flexDirection: "column", gap: 3 }, children: [
+      textLabel ? /* @__PURE__ */ jsx("span", { style: { fontSize: 10, opacity: 0.6 }, children: textLabel }) : null,
+      multiline ? /* @__PURE__ */ jsx(
+        "textarea",
+        {
+          value: state.draftText,
+          onChange: (event) => controller.setDraftText(event.target.value),
+          placeholder,
+          rows: 3,
+          spellCheck: false,
+          style: FIELD_STYLE
+        }
+      ) : /* @__PURE__ */ jsx(
+        "input",
+        {
+          type: "text",
+          value: state.draftText,
+          onChange: (event) => controller.setDraftText(event.target.value),
+          placeholder,
+          spellCheck: false,
+          autoComplete: "off",
+          style: FIELD_STYLE
+        }
+      ),
+      max !== null ? /* @__PURE__ */ jsx(
+        "span",
+        {
+          style: {
+            fontSize: 9,
+            opacity: 0.6,
+            alignSelf: "flex-end",
+            // Over the limit the answer is REFUSED, not truncated — so the counter has to say
+            // so rather than implying the extra characters are merely ignored.
+            color: state.draftText.length > max ? "var(--xeno-danger)" : void 0
+          },
+          children: `${state.draftText.length} / ${max}`
+        }
+      ) : null
+    ] }) : null
+  ] });
+}
+
+// src/trust/consent/panel.ts
+function createConsentPanel(options = {}) {
+  return {
+    manifest: consentManifest,
+    activate(host) {
+      const config = host.config ?? {};
+      const controller = new ConsentController({
+        host: { emit: (portId, value) => host.emit(portId, value) },
+        perScope: config.perScope !== false,
+        defaultDuration: config.defaultDuration ?? "once"
+      });
+      const resolve = (config2) => ({
+        showQueueCount: config2.showQueueCount !== false,
+        emptyHint: typeof config2.emptyHint === "string" ? config2.emptyHint : void 0
+      });
+      let renderConfig = resolve(host.config ?? {});
+      let unrender = null;
+      let root = null;
+      let currentEl = null;
+      const draw = (el) => {
+        unrender?.();
+        if (options.render) {
+          unrender = options.render(el, { controller, config: renderConfig });
+          return;
+        }
+        root = createRoot(el);
+        root.render(createElement(ConsentPanelView, { controller, ...renderConfig }));
+        unrender = () => {
+          root?.unmount();
+          root = null;
+        };
+      };
+      const unbindConfig = bindConfig(host, (config2) => {
+        renderConfig = resolve(config2);
+        if (currentEl) draw(currentEl);
+      });
+      return {
+        render(el) {
+          currentEl = el;
+          draw(el);
+        },
+        onInput(portId, value) {
+          const accept = portId === "requests" ? isConsentRequest : isElicitation;
+          if (portId === "requests" || portId === "elicitations") {
+            const many = Array.isArray(value) ? value : isRecord(value) && Array.isArray(value.requests) ? value.requests : null;
+            if (many) controller.enqueueMany(many.filter(accept));
+            else if (accept(value)) controller.enqueue(value);
+          } else if (portId === "withdraw" && typeof value === "string") {
+            controller.withdraw(value);
+          }
+        },
+        async onCommand(commandId, params) {
+          switch (commandId) {
+            case "get_pending":
+              return controller.pending();
+            case "deny_request":
+              return controller.deny();
+            case "cancel_request":
+              return controller.dismiss();
+            case "set_duration":
+              return controller.setDuration(params.duration);
+            case "expire_due":
+              return controller.expireDue();
+            default:
+              return;
+          }
+        },
+        serialize() {
+          return controller.serialize();
+        },
+        deserialize() {
+          controller.deserialize();
+        },
+        dispose() {
+          unbindConfig();
+          currentEl = null;
+          unrender?.();
+          unrender = null;
+          controller.dispose();
+        }
+      };
+    }
+  };
+}
+var consentPanel = createConsentPanel();
+export {
+  CONSENT_PANEL_ID,
+  ConsentController,
+  ConsentPanelView,
+  ELICITATION_RESULT_SCHEMA,
+  ELICITATION_SCHEMA,
+  allowedDurations,
+  autoCancel,
+  autoDeny,
+  consentManifest,
+  consentPanel,
+  createConsentPanel,
+  effectiveRisk,
+  elicitationAsk,
+  elicitationOptions,
+  findOption,
+  isConsentRequest,
+  isElicitation,
+  isElicitationAnswer,
+  isElicitationCancelled,
+  isExpired,
+  isPermissionElicitation,
+  maxTextLength,
+  selectableScopes
+};