@agentconsent/react 0.1.0

package/dist/index.js

@@ -0,0 +1,2243 @@
+// src/action-preview/action-preview.tsx
+import * as React from "react";
+import * as AlertDialog from "@radix-ui/react-alert-dialog";
+import { jsx, jsxs } from "react/jsx-runtime";
+var ActionPreviewContext = React.createContext(null);
+function useActionPreviewContext(part) {
+  const ctx = React.useContext(ActionPreviewContext);
+  if (!ctx) {
+    throw new Error(
+      `ActionPreview.${part} must be rendered inside ActionPreview.Root`
+    );
+  }
+  return ctx;
+}
+var Root2 = React.forwardRef(
+  function ActionPreviewRoot({
+    onApprove,
+    onReject,
+    consequence = "reversible",
+    asModal = false,
+    open,
+    onOpenChange,
+    children,
+    ...rest
+  }, ref) {
+    const titleId = React.useId();
+    const ctx = React.useMemo(
+      () => ({ consequence, onApprove, onReject, asModal, titleId }),
+      [consequence, onApprove, onReject, asModal, titleId]
+    );
+    if (asModal) {
+      return /* @__PURE__ */ jsx(ActionPreviewContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx(AlertDialog.Root, { open, onOpenChange, children: /* @__PURE__ */ jsxs(AlertDialog.Portal, { children: [
+        /* @__PURE__ */ jsx(AlertDialog.Overlay, { "data-acp": "overlay" }),
+        /* @__PURE__ */ jsx(
+          AlertDialog.Content,
+          {
+            ref,
+            "data-acp": "root",
+            "data-modal": "",
+            "data-consequence": consequence,
+            "aria-describedby": void 0,
+            onEscapeKeyDown: onReject,
+            ...rest,
+            children
+          }
+        )
+      ] }) }) });
+    }
+    return /* @__PURE__ */ jsx(ActionPreviewContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx(
+      "section",
+      {
+        ref,
+        role: "group",
+        "aria-labelledby": titleId,
+        "data-acp": "root",
+        "data-consequence": consequence,
+        ...rest,
+        children
+      }
+    ) });
+  }
+);
+function Header(props) {
+  useActionPreviewContext("Header");
+  return /* @__PURE__ */ jsx("div", { "data-acp": "header", ...props });
+}
+function Icon(props) {
+  useActionPreviewContext("Icon");
+  return /* @__PURE__ */ jsx("span", { "aria-hidden": true, "data-acp": "icon", ...props });
+}
+function Title2(props) {
+  const { asModal, titleId } = useActionPreviewContext("Title");
+  if (asModal) {
+    return /* @__PURE__ */ jsx(AlertDialog.Title, { "data-acp": "title", ...props });
+  }
+  return /* @__PURE__ */ jsx("h2", { id: titleId, "data-acp": "title", ...props });
+}
+function Fields(props) {
+  useActionPreviewContext("Fields");
+  return /* @__PURE__ */ jsx("dl", { "data-acp": "fields", ...props });
+}
+function Field({ label, children, ...rest }) {
+  useActionPreviewContext("Field");
+  return /* @__PURE__ */ jsxs("div", { "data-acp": "field", ...rest, children: [
+    /* @__PURE__ */ jsx("dt", { "data-acp": "field-label", children: label }),
+    /* @__PURE__ */ jsx("dd", { "data-acp": "field-value", children })
+  ] });
+}
+function Content2({
+  label,
+  defaultExpanded = false,
+  children,
+  ...rest
+}) {
+  useActionPreviewContext("Content");
+  const [expanded, setExpanded] = React.useState(defaultExpanded);
+  const bodyId = React.useId();
+  return /* @__PURE__ */ jsxs("div", { "data-acp": "content", "data-expanded": expanded ? "" : void 0, ...rest, children: [
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        "data-acp": "content-toggle",
+        "aria-expanded": expanded,
+        "aria-controls": bodyId,
+        onClick: () => setExpanded((v) => !v),
+        children: label
+      }
+    ),
+    /* @__PURE__ */ jsx("div", { id: bodyId, "data-acp": "content-body", hidden: !expanded, children })
+  ] });
+}
+function Source({ agent, authority, children, ...rest }) {
+  useActionPreviewContext("Source");
+  return /* @__PURE__ */ jsxs("div", { "data-acp": "source", ...rest, children: [
+    /* @__PURE__ */ jsx("span", { "data-acp": "source-agent", children: agent }),
+    authority != null && /* @__PURE__ */ jsx("span", { "data-acp": "source-authority", children: authority }),
+    children
+  ] });
+}
+function Actions(props) {
+  useActionPreviewContext("Actions");
+  return /* @__PURE__ */ jsx("div", { "data-acp": "actions", ...props });
+}
+var Approve = React.forwardRef(
+  function ActionPreviewApprove({ onClick, ...rest }, ref) {
+    const { onApprove, asModal, consequence } = useActionPreviewContext("Approve");
+    const handleClick = (event) => {
+      onClick?.(event);
+      if (!event.defaultPrevented) onApprove();
+    };
+    const button = /* @__PURE__ */ jsx(
+      "button",
+      {
+        ref,
+        type: "button",
+        "data-acp": "approve",
+        "data-consequence": consequence,
+        onClick: handleClick,
+        ...rest
+      }
+    );
+    return asModal ? /* @__PURE__ */ jsx(AlertDialog.Action, { asChild: true, children: button }) : button;
+  }
+);
+var Reject = React.forwardRef(
+  function ActionPreviewReject({ onClick, ...rest }, ref) {
+    const { onReject, asModal } = useActionPreviewContext("Reject");
+    const handleClick = (event) => {
+      onClick?.(event);
+      if (!event.defaultPrevented) onReject();
+    };
+    const button = /* @__PURE__ */ jsx(
+      "button",
+      {
+        ref,
+        type: "button",
+        "data-acp": "reject",
+        onClick: handleClick,
+        ...rest
+      }
+    );
+    return asModal ? /* @__PURE__ */ jsx(AlertDialog.Cancel, { asChild: true, children: button }) : button;
+  }
+);
+var ActionPreview = {
+  Root: Root2,
+  Header,
+  Icon,
+  Title: Title2,
+  Fields,
+  Field,
+  Content: Content2,
+  Source,
+  Actions,
+  Approve,
+  Reject
+};
+
+// src/irreversibility-gate/irreversibility-gate.tsx
+import * as React2 from "react";
+import * as AlertDialog2 from "@radix-ui/react-alert-dialog";
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var IrreversibilityGateContext = React2.createContext(null);
+function useGateContext(part) {
+  const ctx = React2.useContext(IrreversibilityGateContext);
+  if (!ctx) {
+    throw new Error(
+      `IrreversibilityGate.${part} must be rendered inside IrreversibilityGate.Root`
+    );
+  }
+  return ctx;
+}
+var Root4 = React2.forwardRef(
+  function IrreversibilityGateRoot({
+    onConfirm,
+    onCancel,
+    severity = "irreversible",
+    confirmPhrase,
+    asModal = false,
+    open,
+    onOpenChange,
+    children,
+    ...rest
+  }, ref) {
+    const titleId = React2.useId();
+    const descId = React2.useId();
+    const fieldId = React2.useId();
+    const [typed, setTyped] = React2.useState("");
+    const requirePhrase = severity === "irreversible" && confirmPhrase ? confirmPhrase : null;
+    const canConfirm = requirePhrase === null || typed.trim() === requirePhrase;
+    const [prevOpen, setPrevOpen] = React2.useState(open);
+    if (asModal && open !== prevOpen) {
+      setPrevOpen(open);
+      if (open === false && typed !== "") setTyped("");
+    }
+    const ctx = React2.useMemo(
+      () => ({
+        severity,
+        onConfirm,
+        onCancel,
+        asModal,
+        titleId,
+        descId,
+        fieldId,
+        requirePhrase,
+        typed,
+        setTyped,
+        canConfirm
+      }),
+      [
+        severity,
+        onConfirm,
+        onCancel,
+        asModal,
+        titleId,
+        descId,
+        fieldId,
+        requirePhrase,
+        typed,
+        canConfirm
+      ]
+    );
+    if (asModal) {
+      return /* @__PURE__ */ jsx2(IrreversibilityGateContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx2(AlertDialog2.Root, { open, onOpenChange, children: /* @__PURE__ */ jsxs2(AlertDialog2.Portal, { children: [
+        /* @__PURE__ */ jsx2(AlertDialog2.Overlay, { "data-acp": "overlay" }),
+        /* @__PURE__ */ jsx2(
+          AlertDialog2.Content,
+          {
+            ref,
+            "data-acp": "root",
+            "data-gate": "",
+            "data-modal": "",
+            "data-severity": severity,
+            "aria-describedby": void 0,
+            onEscapeKeyDown: onCancel,
+            ...rest,
+            children
+          }
+        )
+      ] }) }) });
+    }
+    return /* @__PURE__ */ jsx2(IrreversibilityGateContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx2(
+      "section",
+      {
+        ref,
+        role: "group",
+        "aria-labelledby": titleId,
+        "data-acp": "root",
+        "data-gate": "",
+        "data-severity": severity,
+        ...rest,
+        children
+      }
+    ) });
+  }
+);
+function Header2(props) {
+  useGateContext("Header");
+  return /* @__PURE__ */ jsx2("div", { "data-acp": "header", ...props });
+}
+function Icon2(props) {
+  const { severity } = useGateContext("Icon");
+  return /* @__PURE__ */ jsx2("span", { "aria-hidden": true, "data-acp": "gate-icon", "data-severity": severity, ...props });
+}
+function Title4(props) {
+  const { asModal, titleId } = useGateContext("Title");
+  if (asModal) {
+    return /* @__PURE__ */ jsx2(AlertDialog2.Title, { "data-acp": "title", ...props });
+  }
+  return /* @__PURE__ */ jsx2("h2", { id: titleId, "data-acp": "title", ...props });
+}
+function Description(props) {
+  const { descId } = useGateContext("Description");
+  return /* @__PURE__ */ jsx2("p", { id: descId, "data-acp": "gate-description", ...props });
+}
+function Consequences(props) {
+  useGateContext("Consequences");
+  return /* @__PURE__ */ jsx2("ul", { "data-acp": "gate-consequences", ...props });
+}
+function Consequence({ children, ...rest }) {
+  useGateContext("Consequence");
+  return /* @__PURE__ */ jsxs2("li", { "data-acp": "gate-consequence", ...rest, children: [
+    /* @__PURE__ */ jsx2("span", { "aria-hidden": true, "data-acp": "gate-consequence-marker" }),
+    /* @__PURE__ */ jsx2("span", { "data-acp": "gate-consequence-text", children })
+  ] });
+}
+function ConfirmField({
+  children,
+  ...rest
+}) {
+  const { requirePhrase, typed, setTyped, fieldId } = useGateContext("ConfirmField");
+  if (requirePhrase === null) return null;
+  return /* @__PURE__ */ jsxs2("div", { "data-acp": "confirm-field", children: [
+    /* @__PURE__ */ jsx2("label", { htmlFor: fieldId, "data-acp": "confirm-field-label", children: children ?? /* @__PURE__ */ jsxs2(Fragment, { children: [
+      "Type ",
+      /* @__PURE__ */ jsx2("code", { "data-acp": "confirm-field-phrase", children: requirePhrase }),
+      " to confirm"
+    ] }) }),
+    /* @__PURE__ */ jsx2(
+      "input",
+      {
+        id: fieldId,
+        "data-acp": "confirm-field-input",
+        type: "text",
+        autoComplete: "off",
+        autoCapitalize: "off",
+        autoCorrect: "off",
+        spellCheck: false,
+        value: typed,
+        onChange: (event) => setTyped(event.target.value),
+        ...rest
+      }
+    )
+  ] });
+}
+function Actions2(props) {
+  useGateContext("Actions");
+  return /* @__PURE__ */ jsx2("div", { "data-acp": "actions", ...props });
+}
+var Confirm = React2.forwardRef(function IrreversibilityGateConfirm({ onClick, disabled, ...rest }, ref) {
+  const { onConfirm, asModal, severity, canConfirm } = useGateContext("Confirm");
+  const isDisabled = disabled || !canConfirm;
+  const handleClick = (event) => {
+    onClick?.(event);
+    if (!event.defaultPrevented) onConfirm();
+  };
+  const button = /* @__PURE__ */ jsx2(
+    "button",
+    {
+      ref,
+      type: "button",
+      "data-acp": "confirm",
+      "data-severity": severity,
+      disabled: isDisabled,
+      "aria-disabled": isDisabled || void 0,
+      onClick: handleClick,
+      ...rest
+    }
+  );
+  return asModal ? /* @__PURE__ */ jsx2(AlertDialog2.Action, { asChild: true, children: button }) : button;
+});
+var Cancel3 = React2.forwardRef(function IrreversibilityGateCancel({ onClick, ...rest }, ref) {
+  const { onCancel, asModal } = useGateContext("Cancel");
+  const handleClick = (event) => {
+    onClick?.(event);
+    if (!event.defaultPrevented) onCancel();
+  };
+  const button = /* @__PURE__ */ jsx2(
+    "button",
+    {
+      ref,
+      type: "button",
+      "data-acp": "cancel",
+      onClick: handleClick,
+      ...rest
+    }
+  );
+  return asModal ? /* @__PURE__ */ jsx2(AlertDialog2.Cancel, { asChild: true, children: button }) : button;
+});
+var IrreversibilityGate = {
+  Root: Root4,
+  Header: Header2,
+  Icon: Icon2,
+  Title: Title4,
+  Description,
+  Consequences,
+  Consequence,
+  ConfirmField,
+  Actions: Actions2,
+  Confirm,
+  Cancel: Cancel3
+};
+
+// src/scoped-grant/scoped-grant.tsx
+import * as React3 from "react";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var ScopedGrantContext = React3.createContext(null);
+function useScopedGrantContext(part) {
+  const ctx = React3.useContext(ScopedGrantContext);
+  if (!ctx) {
+    throw new Error(
+      `ScopedGrant.${part} must be rendered inside ScopedGrant.Root`
+    );
+  }
+  return ctx;
+}
+function useGrantedSet(value, defaultValue, onValueChange) {
+  const isControlled = value !== void 0;
+  const [internal, setInternal] = React3.useState(
+    () => new Set(defaultValue ?? [])
+  );
+  const current = React3.useMemo(
+    () => isControlled ? new Set(value) : internal,
+    [isControlled, value, internal]
+  );
+  const setValue = React3.useCallback(
+    (updater) => {
+      const next = updater(current);
+      if (!isControlled) setInternal(next);
+      onValueChange?.([...next]);
+    },
+    [current, isControlled, onValueChange]
+  );
+  return [current, setValue];
+}
+var Root5 = React3.forwardRef(
+  function ScopedGrantRoot({
+    value,
+    defaultValue,
+    onValueChange,
+    requiredScopes,
+    onGrant,
+    onCancel,
+    children,
+    ...rest
+  }, ref) {
+    const titleId = React3.useId();
+    const [selected, setSelected] = useGrantedSet(
+      value,
+      defaultValue,
+      onValueChange
+    );
+    const requiredSet = React3.useMemo(
+      () => new Set(requiredScopes ?? []),
+      [requiredScopes]
+    );
+    const granted = React3.useMemo(() => {
+      const set = new Set(selected);
+      for (const id of requiredSet) set.add(id);
+      return [...set];
+    }, [selected, requiredSet]);
+    const ctx = React3.useMemo(() => {
+      const grantedSet = new Set(granted);
+      return {
+        isGranted: (id) => grantedSet.has(id),
+        isRequired: (id) => requiredSet.has(id),
+        toggle: (id) => {
+          if (requiredSet.has(id)) return;
+          setSelected((prev) => {
+            const next = new Set(prev);
+            if (next.has(id)) next.delete(id);
+            else next.add(id);
+            return next;
+          });
+        },
+        granted,
+        count: grantedSet.size,
+        onGrant,
+        onCancel,
+        titleId
+      };
+    }, [granted, requiredSet, setSelected, onGrant, onCancel, titleId]);
+    return /* @__PURE__ */ jsx3(ScopedGrantContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx3(
+      "form",
+      {
+        ref,
+        "data-acp": "root",
+        "data-grant": "",
+        "aria-labelledby": titleId,
+        onSubmit: (event) => {
+          event.preventDefault();
+          onGrant(granted);
+        },
+        ...rest,
+        children
+      }
+    ) });
+  }
+);
+function Header3(props) {
+  useScopedGrantContext("Header");
+  return /* @__PURE__ */ jsx3("div", { "data-acp": "header", ...props });
+}
+function Icon3(props) {
+  useScopedGrantContext("Icon");
+  return /* @__PURE__ */ jsx3("span", { "aria-hidden": true, "data-acp": "icon", ...props });
+}
+function Title5(props) {
+  const { titleId } = useScopedGrantContext("Title");
+  return /* @__PURE__ */ jsx3("h2", { id: titleId, "data-acp": "title", ...props });
+}
+function Description2(props) {
+  useScopedGrantContext("Description");
+  return /* @__PURE__ */ jsx3("p", { "data-acp": "grant-description", ...props });
+}
+function Group({ label, resource, children, ...rest }) {
+  useScopedGrantContext("Group");
+  return /* @__PURE__ */ jsxs3("fieldset", { "data-acp": "grant-group", ...rest, children: [
+    /* @__PURE__ */ jsxs3("legend", { "data-acp": "grant-group-legend", children: [
+      /* @__PURE__ */ jsx3("span", { "data-acp": "grant-group-label", children: label }),
+      resource != null && /* @__PURE__ */ jsx3("span", { "data-acp": "grant-group-resource", children: resource })
+    ] }),
+    children
+  ] });
+}
+var ACCESS_LABEL = {
+  read: "Read",
+  write: "Write",
+  delete: "Delete"
+};
+function Scope({
+  id,
+  access,
+  label,
+  description,
+  ...rest
+}) {
+  const { isGranted, isRequired, toggle } = useScopedGrantContext("Scope");
+  const inputId = React3.useId();
+  const descId = React3.useId();
+  const granted = isGranted(id);
+  const required = isRequired(id);
+  return /* @__PURE__ */ jsxs3(
+    "div",
+    {
+      "data-acp": "scope",
+      "data-access": access,
+      "data-granted": granted ? "" : void 0,
+      "data-required": required ? "" : void 0,
+      ...rest,
+      children: [
+        /* @__PURE__ */ jsx3(
+          "input",
+          {
+            type: "checkbox",
+            id: inputId,
+            "data-acp": "scope-checkbox",
+            checked: granted,
+            disabled: required,
+            "aria-describedby": description != null ? descId : void 0,
+            onChange: () => toggle(id)
+          }
+        ),
+        /* @__PURE__ */ jsxs3("div", { "data-acp": "scope-body", children: [
+          /* @__PURE__ */ jsxs3("label", { htmlFor: inputId, "data-acp": "scope-label", children: [
+            /* @__PURE__ */ jsx3("span", { "data-acp": "scope-access", "data-access": access, children: ACCESS_LABEL[access] }),
+            /* @__PURE__ */ jsx3("span", { "data-acp": "scope-name", children: label }),
+            required && /* @__PURE__ */ jsx3("span", { "data-acp": "scope-required-tag", children: " \xB7 required" })
+          ] }),
+          description != null && /* @__PURE__ */ jsx3("p", { id: descId, "data-acp": "scope-description", children: description })
+        ] })
+      ]
+    }
+  );
+}
+function Actions3(props) {
+  useScopedGrantContext("Actions");
+  return /* @__PURE__ */ jsx3("div", { "data-acp": "actions", ...props });
+}
+var Grant = React3.forwardRef(
+  function ScopedGrantGrant({ children, ...rest }, ref) {
+    const { count } = useScopedGrantContext("Grant");
+    return /* @__PURE__ */ jsx3("button", { ref, type: "submit", "data-acp": "grant", ...rest, children: typeof children === "function" ? children({ count }) : children });
+  }
+);
+var Cancel4 = React3.forwardRef(
+  function ScopedGrantCancel({ onClick, ...rest }, ref) {
+    const { onCancel } = useScopedGrantContext("Cancel");
+    const handleClick = (event) => {
+      onClick?.(event);
+      if (!event.defaultPrevented) onCancel?.();
+    };
+    return /* @__PURE__ */ jsx3(
+      "button",
+      {
+        ref,
+        type: "button",
+        "data-acp": "cancel",
+        onClick: handleClick,
+        ...rest
+      }
+    );
+  }
+);
+var ScopedGrant = {
+  Root: Root5,
+  Header: Header3,
+  Icon: Icon3,
+  Title: Title5,
+  Description: Description2,
+  Group,
+  Scope,
+  Actions: Actions3,
+  Grant,
+  Cancel: Cancel4
+};
+
+// src/progressive-scope/progressive-scope.tsx
+import * as React4 from "react";
+import * as AlertDialog3 from "@radix-ui/react-alert-dialog";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var ProgressiveScopeContext = React4.createContext(null);
+function useProgressiveScopeContext(part) {
+  const ctx = React4.useContext(ProgressiveScopeContext);
+  if (!ctx) {
+    throw new Error(
+      `ProgressiveScope.${part} must be rendered inside ProgressiveScope.Root`
+    );
+  }
+  return ctx;
+}
+var Root7 = React4.forwardRef(
+  function ProgressiveScopeRoot({
+    access = "read",
+    onAllowOnce,
+    onAllowAlways,
+    onDeny,
+    asModal = false,
+    open,
+    onOpenChange,
+    children,
+    ...rest
+  }, ref) {
+    const titleId = React4.useId();
+    const ctx = React4.useMemo(
+      () => ({
+        access,
+        onAllowOnce,
+        onAllowAlways,
+        onDeny,
+        asModal,
+        titleId
+      }),
+      [access, onAllowOnce, onAllowAlways, onDeny, asModal, titleId]
+    );
+    if (asModal) {
+      return /* @__PURE__ */ jsx4(ProgressiveScopeContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx4(AlertDialog3.Root, { open, onOpenChange, children: /* @__PURE__ */ jsxs4(AlertDialog3.Portal, { children: [
+        /* @__PURE__ */ jsx4(AlertDialog3.Overlay, { "data-acp": "overlay" }),
+        /* @__PURE__ */ jsx4(
+          AlertDialog3.Content,
+          {
+            ref,
+            "data-acp": "root",
+            "data-escalation": "",
+            "data-modal": "",
+            "data-access": access,
+            "aria-describedby": void 0,
+            onEscapeKeyDown: onDeny,
+            ...rest,
+            children
+          }
+        )
+      ] }) }) });
+    }
+    return /* @__PURE__ */ jsx4(ProgressiveScopeContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx4(
+      "section",
+      {
+        ref,
+        role: "group",
+        "aria-labelledby": titleId,
+        "data-acp": "root",
+        "data-escalation": "",
+        "data-access": access,
+        ...rest,
+        children
+      }
+    ) });
+  }
+);
+function Header4(props) {
+  useProgressiveScopeContext("Header");
+  return /* @__PURE__ */ jsx4("div", { "data-acp": "header", ...props });
+}
+function Icon4(props) {
+  useProgressiveScopeContext("Icon");
+  return /* @__PURE__ */ jsx4("span", { "aria-hidden": true, "data-acp": "icon", ...props });
+}
+function Title7(props) {
+  const { asModal, titleId } = useProgressiveScopeContext("Title");
+  if (asModal) {
+    return /* @__PURE__ */ jsx4(AlertDialog3.Title, { "data-acp": "title", ...props });
+  }
+  return /* @__PURE__ */ jsx4("h2", { id: titleId, "data-acp": "title", ...props });
+}
+function Reason(props) {
+  useProgressiveScopeContext("Reason");
+  return /* @__PURE__ */ jsx4("p", { "data-acp": "escalation-reason", ...props });
+}
+var ACCESS_LABEL2 = {
+  read: "Read",
+  write: "Write",
+  delete: "Delete"
+};
+function Request({ label, description, ...rest }) {
+  const { access } = useProgressiveScopeContext("Request");
+  return /* @__PURE__ */ jsxs4("div", { "data-acp": "request", "data-access": access, ...rest, children: [
+    /* @__PURE__ */ jsxs4("div", { "data-acp": "request-head", children: [
+      /* @__PURE__ */ jsx4("span", { "data-acp": "request-access", "data-access": access, children: ACCESS_LABEL2[access] }),
+      /* @__PURE__ */ jsx4("span", { "data-acp": "request-name", children: label })
+    ] }),
+    description != null && /* @__PURE__ */ jsx4("p", { "data-acp": "request-description", children: description })
+  ] });
+}
+function Current({ children, ...rest }) {
+  useProgressiveScopeContext("Current");
+  return /* @__PURE__ */ jsxs4("div", { "data-acp": "escalation-current", ...rest, children: [
+    /* @__PURE__ */ jsx4("span", { "aria-hidden": true, "data-acp": "escalation-current-marker" }),
+    /* @__PURE__ */ jsx4("span", { children })
+  ] });
+}
+function Actions4(props) {
+  useProgressiveScopeContext("Actions");
+  return /* @__PURE__ */ jsx4("div", { "data-acp": "actions", "data-escalation-actions": "", ...props });
+}
+function makeAllowButton(displayName, hook, pick) {
+  const Component = React4.forwardRef(function AllowButton({ onClick, ...rest }, ref) {
+    const ctx = useProgressiveScopeContext(displayName);
+    const action = pick(ctx);
+    const handleClick = (event) => {
+      onClick?.(event);
+      if (!event.defaultPrevented) action();
+    };
+    const button = /* @__PURE__ */ jsx4(
+      "button",
+      {
+        ref,
+        type: "button",
+        "data-acp": hook,
+        onClick: handleClick,
+        ...rest
+      }
+    );
+    return ctx.asModal ? /* @__PURE__ */ jsx4(AlertDialog3.Action, { asChild: true, children: button }) : button;
+  });
+  Component.displayName = displayName;
+  return Component;
+}
+var AllowOnce = makeAllowButton(
+  "ProgressiveScopeAllowOnce",
+  "allow-once",
+  (ctx) => ctx.onAllowOnce
+);
+var AllowAlways = makeAllowButton(
+  "ProgressiveScopeAllowAlways",
+  "allow-always",
+  (ctx) => ctx.onAllowAlways
+);
+var Deny = React4.forwardRef(
+  function ProgressiveScopeDeny({ onClick, ...rest }, ref) {
+    const { onDeny, asModal } = useProgressiveScopeContext("Deny");
+    const handleClick = (event) => {
+      onClick?.(event);
+      if (!event.defaultPrevented) onDeny();
+    };
+    const button = /* @__PURE__ */ jsx4(
+      "button",
+      {
+        ref,
+        type: "button",
+        "data-acp": "deny",
+        onClick: handleClick,
+        ...rest
+      }
+    );
+    return asModal ? /* @__PURE__ */ jsx4(AlertDialog3.Cancel, { asChild: true, children: button }) : button;
+  }
+);
+var ProgressiveScope = {
+  Root: Root7,
+  Header: Header4,
+  Icon: Icon4,
+  Title: Title7,
+  Reason,
+  Request,
+  Current,
+  Actions: Actions4,
+  AllowOnce,
+  AllowAlways,
+  Deny
+};
+
+// src/batch-approval/batch-approval.tsx
+import * as React5 from "react";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var BatchApprovalContext = React5.createContext(null);
+function useBatchApprovalContext(part) {
+  const ctx = React5.useContext(BatchApprovalContext);
+  if (!ctx) {
+    throw new Error(
+      `BatchApproval.${part} must be rendered inside BatchApproval.Root`
+    );
+  }
+  return ctx;
+}
+var BatchApprovalItemContext = React5.createContext(
+  null
+);
+function useItemId(part) {
+  const ctx = React5.useContext(BatchApprovalItemContext);
+  if (!ctx) {
+    throw new Error(
+      `BatchApproval.${part} must be rendered inside BatchApproval.Item`
+    );
+  }
+  return ctx.id;
+}
+function useSelectedSet(value, defaultValue, onValueChange) {
+  const isControlled = value !== void 0;
+  const [internal, setInternal] = React5.useState(
+    () => new Set(defaultValue ?? [])
+  );
+  const current = React5.useMemo(
+    () => isControlled ? new Set(value) : internal,
+    [isControlled, value, internal]
+  );
+  const setValue = React5.useCallback(
+    (updater) => {
+      const next = updater(current);
+      if (!isControlled) setInternal(next);
+      onValueChange?.([...next]);
+    },
+    [current, isControlled, onValueChange]
+  );
+  return [current, setValue];
+}
+var Root8 = React5.forwardRef(
+  function BatchApprovalRoot({
+    items,
+    value,
+    defaultValue,
+    onValueChange,
+    onApprove,
+    onReject,
+    children,
+    ...rest
+  }, ref) {
+    const titleId = React5.useId();
+    const [selected, setSelected] = useSelectedSet(
+      value,
+      defaultValue,
+      onValueChange
+    );
+    const reviewSet = React5.useMemo(
+      () => new Set(items.filter((i) => i.requiresReview).map((i) => i.id)),
+      [items]
+    );
+    const selectableIds = React5.useMemo(
+      () => items.filter((i) => !i.requiresReview).map((i) => i.id),
+      [items]
+    );
+    const ctx = React5.useMemo(() => {
+      const selectedSelectable = selectableIds.filter(
+        (id) => selected.has(id)
+      );
+      const selectedCount = selectedSelectable.length;
+      const selectableCount = selectableIds.length;
+      const clearFrom = (prev, ids) => {
+        const next = new Set(prev);
+        for (const id of ids) next.delete(id);
+        return next;
+      };
+      return {
+        isSelected: (id) => selected.has(id),
+        toggle: (id) => {
+          if (reviewSet.has(id)) return;
+          setSelected((prev) => {
+            const next = new Set(prev);
+            if (next.has(id)) next.delete(id);
+            else next.add(id);
+            return next;
+          });
+        },
+        requiresReview: (id) => reviewSet.has(id),
+        selectableIds,
+        selectedIds: selectedSelectable,
+        selectedCount,
+        selectableCount,
+        allSelected: selectableCount > 0 && selectedCount === selectableCount,
+        someSelected: selectedCount > 0 && selectedCount < selectableCount,
+        setAllSelected: (checked) => {
+          setSelected((prev) => {
+            if (!checked) return clearFrom(prev, selectableIds);
+            const next = new Set(prev);
+            for (const id of selectableIds) next.add(id);
+            return next;
+          });
+        },
+        approve: (ids) => {
+          onApprove(ids);
+          setSelected((prev) => clearFrom(prev, ids));
+        },
+        reject: (ids) => {
+          onReject(ids);
+          setSelected((prev) => clearFrom(prev, ids));
+        },
+        titleId
+      };
+    }, [
+      selected,
+      selectableIds,
+      reviewSet,
+      setSelected,
+      onApprove,
+      onReject,
+      titleId
+    ]);
+    return /* @__PURE__ */ jsx5(BatchApprovalContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx5(
+      "section",
+      {
+        ref,
+        role: "group",
+        "aria-labelledby": titleId,
+        "data-acp": "root",
+        "data-batch": "",
+        ...rest,
+        children
+      }
+    ) });
+  }
+);
+function Header5(props) {
+  useBatchApprovalContext("Header");
+  return /* @__PURE__ */ jsx5("div", { "data-acp": "header", ...props });
+}
+function Icon5(props) {
+  useBatchApprovalContext("Icon");
+  return /* @__PURE__ */ jsx5("span", { "aria-hidden": true, "data-acp": "icon", ...props });
+}
+function Title8(props) {
+  const { titleId } = useBatchApprovalContext("Title");
+  return /* @__PURE__ */ jsx5("h2", { id: titleId, "data-acp": "title", ...props });
+}
+function Description3(props) {
+  useBatchApprovalContext("Description");
+  return /* @__PURE__ */ jsx5("p", { "data-acp": "batch-description", ...props });
+}
+function Toolbar(props) {
+  useBatchApprovalContext("Toolbar");
+  return /* @__PURE__ */ jsx5("div", { "data-acp": "batch-toolbar", role: "group", ...props });
+}
+function SelectAll({ children, ...rest }) {
+  const { allSelected, someSelected, setAllSelected, selectableCount } = useBatchApprovalContext("SelectAll");
+  const inputRef = React5.useRef(null);
+  const inputId = React5.useId();
+  React5.useEffect(() => {
+    if (inputRef.current) inputRef.current.indeterminate = someSelected;
+  }, [someSelected]);
+  return /* @__PURE__ */ jsxs5("div", { "data-acp": "batch-select-all", ...rest, children: [
+    /* @__PURE__ */ jsx5(
+      "input",
+      {
+        ref: inputRef,
+        id: inputId,
+        type: "checkbox",
+        "data-acp": "batch-select-all-checkbox",
+        checked: allSelected,
+        disabled: selectableCount === 0,
+        onChange: (event) => setAllSelected(event.target.checked)
+      }
+    ),
+    /* @__PURE__ */ jsx5("label", { htmlFor: inputId, "data-acp": "batch-select-all-label", children: children ?? "Select all reviewable" })
+  ] });
+}
+function SelectionCount({ children, ...rest }) {
+  const { selectedCount, selectableCount } = useBatchApprovalContext("SelectionCount");
+  return /* @__PURE__ */ jsx5("span", { "data-acp": "batch-selection-count", "aria-live": "polite", ...rest, children: children ? children({ selectedCount, selectableCount }) : `${selectedCount} selected` });
+}
+var BatchApprove = React5.forwardRef(function BatchApprovalBatchApprove({ onClick, disabled, ...rest }, ref) {
+  const { approve, selectedIds, selectedCount } = useBatchApprovalContext("BatchApprove");
+  const isDisabled = disabled || selectedCount === 0;
+  return /* @__PURE__ */ jsx5(
+    "button",
+    {
+      ref,
+      type: "button",
+      "data-acp": "approve",
+      "data-batch-action": "approve",
+      disabled: isDisabled,
+      "aria-disabled": isDisabled || void 0,
+      onClick: (event) => {
+        onClick?.(event);
+        if (!event.defaultPrevented) approve(selectedIds);
+      },
+      ...rest
+    }
+  );
+});
+var BatchReject = React5.forwardRef(function BatchApprovalBatchReject({ onClick, disabled, ...rest }, ref) {
+  const { reject, selectedIds, selectedCount } = useBatchApprovalContext("BatchReject");
+  const isDisabled = disabled || selectedCount === 0;
+  return /* @__PURE__ */ jsx5(
+    "button",
+    {
+      ref,
+      type: "button",
+      "data-acp": "reject",
+      "data-batch-action": "reject",
+      disabled: isDisabled,
+      "aria-disabled": isDisabled || void 0,
+      onClick: (event) => {
+        onClick?.(event);
+        if (!event.defaultPrevented) reject(selectedIds);
+      },
+      ...rest
+    }
+  );
+});
+function List(props) {
+  useBatchApprovalContext("List");
+  return /* @__PURE__ */ jsx5("ul", { "data-acp": "batch-list", ...props });
+}
+function Item({ id, title, detail, children, ...rest }) {
+  const { isSelected, toggle, requiresReview } = useBatchApprovalContext("Item");
+  const inputId = React5.useId();
+  const detailId = React5.useId();
+  const selected = isSelected(id);
+  const review = requiresReview(id);
+  const itemCtx = React5.useMemo(() => ({ id }), [id]);
+  return /* @__PURE__ */ jsx5(BatchApprovalItemContext.Provider, { value: itemCtx, children: /* @__PURE__ */ jsxs5(
+    "li",
+    {
+      "data-acp": "batch-item",
+      "data-selected": selected ? "" : void 0,
+      "data-review": review ? "" : void 0,
+      ...rest,
+      children: [
+        /* @__PURE__ */ jsx5("div", { "data-acp": "batch-item-select", children: review ? /* @__PURE__ */ jsx5("span", { "data-acp": "batch-item-flag", children: "Review individually" }) : /* @__PURE__ */ jsx5(
+          "input",
+          {
+            id: inputId,
+            type: "checkbox",
+            "data-acp": "batch-item-checkbox",
+            checked: selected,
+            "aria-describedby": detail != null ? detailId : void 0,
+            onChange: () => toggle(id)
+          }
+        ) }),
+        /* @__PURE__ */ jsxs5("div", { "data-acp": "batch-item-body", children: [
+          review ? /* @__PURE__ */ jsx5("span", { "data-acp": "batch-item-title", children: title }) : /* @__PURE__ */ jsx5("label", { htmlFor: inputId, "data-acp": "batch-item-title", children: title }),
+          detail != null && /* @__PURE__ */ jsx5("p", { id: detailId, "data-acp": "batch-item-detail", children: detail })
+        ] }),
+        children != null && /* @__PURE__ */ jsx5("div", { "data-acp": "batch-item-actions", children })
+      ]
+    }
+  ) });
+}
+var ItemApprove = React5.forwardRef(function BatchApprovalItemApprove({ onClick, ...rest }, ref) {
+  const { approve } = useBatchApprovalContext("Item.Approve");
+  const id = useItemId("Item.Approve");
+  return /* @__PURE__ */ jsx5(
+    "button",
+    {
+      ref,
+      type: "button",
+      "data-acp": "batch-item-approve",
+      onClick: (event) => {
+        onClick?.(event);
+        if (!event.defaultPrevented) approve([id]);
+      },
+      ...rest
+    }
+  );
+});
+var ItemReject = React5.forwardRef(function BatchApprovalItemReject({ onClick, ...rest }, ref) {
+  const { reject } = useBatchApprovalContext("Item.Reject");
+  const id = useItemId("Item.Reject");
+  return /* @__PURE__ */ jsx5(
+    "button",
+    {
+      ref,
+      type: "button",
+      "data-acp": "batch-item-reject",
+      onClick: (event) => {
+        onClick?.(event);
+        if (!event.defaultPrevented) reject([id]);
+      },
+      ...rest
+    }
+  );
+});
+var BatchApproval = {
+  Root: Root8,
+  Header: Header5,
+  Icon: Icon5,
+  Title: Title8,
+  Description: Description3,
+  Toolbar,
+  SelectAll,
+  SelectionCount,
+  BatchApprove,
+  BatchReject,
+  List,
+  Item,
+  ItemApprove,
+  ItemReject
+};
+
+// src/consent-memory/consent-memory.tsx
+import * as React6 from "react";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var ConsentMemoryContext = React6.createContext(null);
+function useConsentMemoryContext(part) {
+  const ctx = React6.useContext(ConsentMemoryContext);
+  if (!ctx) {
+    throw new Error(
+      `ConsentMemory.${part} must be rendered inside ConsentMemory.Root`
+    );
+  }
+  return ctx;
+}
+function useControllableValue(value, defaultValue, onValueChange) {
+  const isControlled = value !== void 0;
+  const [internal, setInternal] = React6.useState(defaultValue);
+  const current = isControlled ? value : internal;
+  const setValue = React6.useCallback(
+    (next) => {
+      if (!isControlled) setInternal(next);
+      onValueChange?.(next);
+    },
+    [isControlled, onValueChange]
+  );
+  return [current, setValue];
+}
+var Root9 = React6.forwardRef(
+  function ConsentMemoryRoot({ value, defaultValue, onValueChange, onAllow, onDeny, children, ...rest }, ref) {
+    const titleId = React6.useId();
+    const name = React6.useId();
+    const [selected, setSelected] = useControllableValue(
+      value,
+      defaultValue,
+      onValueChange
+    );
+    const durabilityRef = React6.useRef(
+      /* @__PURE__ */ new Map()
+    );
+    const ctx = React6.useMemo(
+      () => ({
+        value: selected ?? null,
+        register: (next, durability) => {
+          durabilityRef.current.set(next, durability);
+        },
+        getDurability: () => selected != null ? durabilityRef.current.get(selected) ?? null : null,
+        select: setSelected,
+        name,
+        onAllow,
+        onDeny,
+        titleId
+      }),
+      [selected, setSelected, name, onAllow, onDeny, titleId]
+    );
+    return /* @__PURE__ */ jsx6(ConsentMemoryContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx6(
+      "form",
+      {
+        ref,
+        "data-acp": "root",
+        "data-memory": "",
+        "aria-labelledby": titleId,
+        onSubmit: (event) => {
+          event.preventDefault();
+          if (selected != null) onAllow(selected);
+        },
+        ...rest,
+        children
+      }
+    ) });
+  }
+);
+function Header6(props) {
+  useConsentMemoryContext("Header");
+  return /* @__PURE__ */ jsx6("div", { "data-acp": "header", ...props });
+}
+function Icon6(props) {
+  useConsentMemoryContext("Icon");
+  return /* @__PURE__ */ jsx6("span", { "aria-hidden": true, "data-acp": "icon", ...props });
+}
+function Title9(props) {
+  const { titleId } = useConsentMemoryContext("Title");
+  return /* @__PURE__ */ jsx6("h2", { id: titleId, "data-acp": "title", ...props });
+}
+function Description4(props) {
+  useConsentMemoryContext("Description");
+  return /* @__PURE__ */ jsx6("p", { "data-acp": "memory-description", ...props });
+}
+function Options({ legend, children, ...rest }) {
+  useConsentMemoryContext("Options");
+  return /* @__PURE__ */ jsxs6("fieldset", { "data-acp": "memory-options", ...rest, children: [
+    /* @__PURE__ */ jsx6("legend", { "data-acp": "memory-options-legend", children: legend ?? "Apply this decision:" }),
+    children
+  ] });
+}
+var DURABILITY_HINT = {
+  once: "This time",
+  session: "This session",
+  scoped: "Standing \xB7 scoped",
+  always: "Standing \xB7 always"
+};
+function Option({
+  value,
+  durability,
+  label,
+  consequence,
+  ...rest
+}) {
+  const { value: selected, select, register, name } = useConsentMemoryContext("Option");
+  register(value, durability);
+  const inputId = React6.useId();
+  const consequenceId = React6.useId();
+  const checked = selected === value;
+  return /* @__PURE__ */ jsxs6(
+    "div",
+    {
+      "data-acp": "memory-option",
+      "data-durability": durability,
+      "data-selected": checked ? "" : void 0,
+      ...rest,
+      children: [
+        /* @__PURE__ */ jsx6(
+          "input",
+          {
+            id: inputId,
+            type: "radio",
+            name,
+            value,
+            "data-acp": "memory-option-radio",
+            checked,
+            "aria-describedby": consequenceId,
+            onChange: () => select(value)
+          }
+        ),
+        /* @__PURE__ */ jsxs6("div", { "data-acp": "memory-option-body", children: [
+          /* @__PURE__ */ jsxs6("label", { htmlFor: inputId, "data-acp": "memory-option-label", children: [
+            /* @__PURE__ */ jsx6("span", { "data-acp": "memory-option-name", children: label }),
+            /* @__PURE__ */ jsx6("span", { "data-acp": "memory-option-hint", "data-durability": durability, children: DURABILITY_HINT[durability] })
+          ] }),
+          /* @__PURE__ */ jsx6("p", { id: consequenceId, "data-acp": "memory-option-consequence", children: consequence })
+        ] })
+      ]
+    }
+  );
+}
+function Actions5(props) {
+  useConsentMemoryContext("Actions");
+  return /* @__PURE__ */ jsx6("div", { "data-acp": "actions", ...props });
+}
+var Allow = React6.forwardRef(
+  function ConsentMemoryAllow({ children, ...rest }, ref) {
+    const { getDurability } = useConsentMemoryContext("Allow");
+    const durability = getDurability();
+    return /* @__PURE__ */ jsx6(
+      "button",
+      {
+        ref,
+        type: "submit",
+        "data-acp": "allow-once",
+        "data-memory-allow": "",
+        "data-durability": durability ?? void 0,
+        ...rest,
+        children: typeof children === "function" ? children({ durability }) : children
+      }
+    );
+  }
+);
+var Deny2 = React6.forwardRef(
+  function ConsentMemoryDeny({ onClick, ...rest }, ref) {
+    const { onDeny } = useConsentMemoryContext("Deny");
+    return /* @__PURE__ */ jsx6(
+      "button",
+      {
+        ref,
+        type: "button",
+        "data-acp": "deny",
+        onClick: (event) => {
+          onClick?.(event);
+          if (!event.defaultPrevented) onDeny();
+        },
+        ...rest
+      }
+    );
+  }
+);
+var ConsentMemory = {
+  Root: Root9,
+  Header: Header6,
+  Icon: Icon6,
+  Title: Title9,
+  Description: Description4,
+  Options,
+  Option,
+  Actions: Actions5,
+  Allow,
+  Deny: Deny2
+};
+
+// src/authority-boundary/authority-boundary.tsx
+import * as React7 from "react";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var AUTHORITY_LEVELS = ["auto", "ask", "never"];
+var LEVEL_LABEL = {
+  auto: "Automatic",
+  ask: "Ask first",
+  never: "Never"
+};
+var AuthorityBoundaryContext = React7.createContext(null);
+function useAuthorityBoundaryContext(part) {
+  const ctx = React7.useContext(AuthorityBoundaryContext);
+  if (!ctx) {
+    throw new Error(
+      `AuthorityBoundary.${part} must be rendered inside AuthorityBoundary.Root`
+    );
+  }
+  return ctx;
+}
+function useControllableMap(value, defaultValue, onValueChange) {
+  const isControlled = value !== void 0;
+  const [internal, setInternal] = React7.useState(() => defaultValue ?? {});
+  const current = isControlled ? value : internal;
+  const setLevel = React7.useCallback(
+    (id, level) => {
+      const next = { ...current, [id]: level };
+      if (!isControlled) setInternal(next);
+      onValueChange?.(next);
+    },
+    [current, isControlled, onValueChange]
+  );
+  return [current, setLevel];
+}
+var Root10 = React7.forwardRef(
+  function AuthorityBoundaryRoot({ value, defaultValue, onValueChange, children, ...rest }, ref) {
+    const titleId = React7.useId();
+    const [levels, setLevel] = useControllableMap(
+      value,
+      defaultValue,
+      onValueChange
+    );
+    const ctx = React7.useMemo(() => {
+      const counts = {
+        auto: 0,
+        ask: 0,
+        never: 0
+      };
+      for (const level of Object.values(levels)) counts[level] += 1;
+      return {
+        getLevel: (id) => levels[id] ?? "ask",
+        setLevel,
+        counts,
+        titleId
+      };
+    }, [levels, setLevel, titleId]);
+    return /* @__PURE__ */ jsx7(AuthorityBoundaryContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx7(
+      "section",
+      {
+        ref,
+        role: "group",
+        "aria-labelledby": titleId,
+        "data-acp": "root",
+        "data-authority": "",
+        ...rest,
+        children
+      }
+    ) });
+  }
+);
+function Header7(props) {
+  useAuthorityBoundaryContext("Header");
+  return /* @__PURE__ */ jsx7("div", { "data-acp": "header", ...props });
+}
+function Icon7(props) {
+  useAuthorityBoundaryContext("Icon");
+  return /* @__PURE__ */ jsx7("span", { "aria-hidden": true, "data-acp": "icon", ...props });
+}
+function Title10(props) {
+  const { titleId } = useAuthorityBoundaryContext("Title");
+  return /* @__PURE__ */ jsx7("h2", { id: titleId, "data-acp": "title", ...props });
+}
+function Description5(props) {
+  useAuthorityBoundaryContext("Description");
+  return /* @__PURE__ */ jsx7("p", { "data-acp": "authority-description", ...props });
+}
+function Summary({ children, ...rest }) {
+  const { counts } = useAuthorityBoundaryContext("Summary");
+  return /* @__PURE__ */ jsx7("p", { "data-acp": "authority-summary", "aria-live": "polite", ...rest, children: children(counts) });
+}
+function List2(props) {
+  useAuthorityBoundaryContext("List");
+  return /* @__PURE__ */ jsx7("ul", { "data-acp": "authority-list", ...props });
+}
+var ACCESS_LABEL3 = {
+  read: "Read",
+  write: "Write",
+  delete: "Delete"
+};
+function Capability({
+  id,
+  access,
+  label,
+  description,
+  disallow,
+  ...rest
+}) {
+  const { getLevel, setLevel } = useAuthorityBoundaryContext("Capability");
+  const name = React7.useId();
+  const descId = React7.useId();
+  const level = getLevel(id);
+  const disallowed = new Set(disallow ?? []);
+  return /* @__PURE__ */ jsxs7(
+    "li",
+    {
+      "data-acp": "authority-capability",
+      "data-access": access,
+      "data-level": level,
+      ...rest,
+      children: [
+        /* @__PURE__ */ jsxs7("div", { "data-acp": "authority-capability-body", children: [
+          /* @__PURE__ */ jsxs7("span", { "data-acp": "authority-capability-head", children: [
+            /* @__PURE__ */ jsx7("span", { "data-acp": "authority-access", "data-access": access, children: ACCESS_LABEL3[access] }),
+            /* @__PURE__ */ jsx7("span", { "data-acp": "authority-capability-name", children: label })
+          ] }),
+          description != null && /* @__PURE__ */ jsx7("p", { id: descId, "data-acp": "authority-capability-description", children: description })
+        ] }),
+        /* @__PURE__ */ jsxs7(
+          "fieldset",
+          {
+            "data-acp": "authority-control",
+            "aria-describedby": description != null ? descId : void 0,
+            children: [
+              /* @__PURE__ */ jsxs7("legend", { "data-acp": "authority-control-legend", children: [
+                "Authority for ",
+                typeof label === "string" ? label : "this capability"
+              ] }),
+              AUTHORITY_LEVELS.map((option) => {
+                const optionId = `${name}-${option}`;
+                const blocked = disallowed.has(option);
+                return /* @__PURE__ */ jsxs7(React7.Fragment, { children: [
+                  /* @__PURE__ */ jsx7(
+                    "input",
+                    {
+                      id: optionId,
+                      type: "radio",
+                      name,
+                      value: option,
+                      "data-acp": "authority-radio",
+                      "data-level": option,
+                      checked: level === option,
+                      disabled: blocked,
+                      onChange: () => setLevel(id, option)
+                    }
+                  ),
+                  /* @__PURE__ */ jsx7(
+                    "label",
+                    {
+                      htmlFor: optionId,
+                      "data-acp": "authority-level-label",
+                      "data-level": option,
+                      children: LEVEL_LABEL[option]
+                    }
+                  )
+                ] }, option);
+              })
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+var AuthorityBoundary = {
+  Root: Root10,
+  Header: Header7,
+  Icon: Icon7,
+  Title: Title10,
+  Description: Description5,
+  Summary,
+  List: List2,
+  Capability
+};
+
+// src/spend-limits/spend-limits.tsx
+import * as React8 from "react";
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+var SpendLimitsContext = React8.createContext(null);
+function useSpendLimitsContext(part) {
+  const ctx = React8.useContext(SpendLimitsContext);
+  if (!ctx) {
+    throw new Error(
+      `SpendLimits.${part} must be rendered inside SpendLimits.Root`
+    );
+  }
+  return ctx;
+}
+function useControllableMap2(value, defaultValue, onValueChange) {
+  const isControlled = value !== void 0;
+  const [internal, setInternal] = React8.useState(
+    () => defaultValue ?? {}
+  );
+  const current = isControlled ? value : internal;
+  const setCap = React8.useCallback(
+    (id, cap) => {
+      const next = { ...current, [id]: cap };
+      if (!isControlled) setInternal(next);
+      onValueChange?.(next);
+    },
+    [current, isControlled, onValueChange]
+  );
+  return [current, setCap];
+}
+var WARNING_RATIO = 0.8;
+function stateFor(used, cap) {
+  if (cap == null) return "none";
+  if (used >= cap) return "reached";
+  if (used / cap >= WARNING_RATIO) return "warning";
+  return "ok";
+}
+var Root11 = React8.forwardRef(
+  function SpendLimitsRoot({ limits, value, defaultValue, onValueChange, children, ...rest }, ref) {
+    const titleId = React8.useId();
+    const [caps, setCap] = useControllableMap2(
+      value,
+      defaultValue,
+      onValueChange
+    );
+    const ctx = React8.useMemo(() => {
+      const usage = new Map(limits.map((l) => [l.id, l.used]));
+      const getUsed = (id) => usage.get(id) ?? 0;
+      const getCap = (id) => Object.prototype.hasOwnProperty.call(caps, id) ? caps[id] : null;
+      const summary = {
+        total: limits.length,
+        ok: 0,
+        warning: 0,
+        reached: 0
+      };
+      for (const limit of limits) {
+        const state = stateFor(limit.used, getCap(limit.id));
+        if (state === "ok") summary.ok += 1;
+        else if (state === "warning") summary.warning += 1;
+        else if (state === "reached") summary.reached += 1;
+      }
+      return {
+        getUsed,
+        getCap,
+        setCap,
+        getState: (id) => stateFor(getUsed(id), getCap(id)),
+        summary,
+        titleId
+      };
+    }, [limits, caps, setCap, titleId]);
+    return /* @__PURE__ */ jsx8(SpendLimitsContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx8(
+      "section",
+      {
+        ref,
+        role: "group",
+        "aria-labelledby": titleId,
+        "data-acp": "root",
+        "data-limits": "",
+        ...rest,
+        children
+      }
+    ) });
+  }
+);
+function Header8(props) {
+  useSpendLimitsContext("Header");
+  return /* @__PURE__ */ jsx8("div", { "data-acp": "header", ...props });
+}
+function Icon8(props) {
+  useSpendLimitsContext("Icon");
+  return /* @__PURE__ */ jsx8("span", { "aria-hidden": true, "data-acp": "icon", ...props });
+}
+function Title11(props) {
+  const { titleId } = useSpendLimitsContext("Title");
+  return /* @__PURE__ */ jsx8("h2", { id: titleId, "data-acp": "title", ...props });
+}
+function Description6(props) {
+  useSpendLimitsContext("Description");
+  return /* @__PURE__ */ jsx8("p", { "data-acp": "limits-description", ...props });
+}
+function Summary2({ children, ...rest }) {
+  const { summary } = useSpendLimitsContext("Summary");
+  return /* @__PURE__ */ jsx8("p", { "data-acp": "limits-summary", "aria-live": "polite", ...rest, children: children(summary) });
+}
+function List3(props) {
+  useSpendLimitsContext("List");
+  return /* @__PURE__ */ jsx8("ul", { "data-acp": "limits-list", ...props });
+}
+var KIND_LABEL = {
+  spend: "Budget",
+  rate: "Rate"
+};
+var STATE_NOTE = {
+  none: null,
+  ok: null,
+  warning: "Near cap",
+  reached: "Cap reached \u2014 agent will ask before doing more"
+};
+var PERIOD_PHRASE = {
+  day: "today",
+  week: "this week",
+  month: "this month"
+};
+function formatAmount(kind, unit, n) {
+  return kind === "spend" ? `${unit}${n.toLocaleString()}` : `${n.toLocaleString()} ${unit}`;
+}
+function formatRange(kind, unit, used, cap) {
+  return kind === "spend" ? `${unit}${used.toLocaleString()} of ${unit}${cap.toLocaleString()}` : `${used.toLocaleString()} of ${cap.toLocaleString()} ${unit}`;
+}
+function Limit({
+  id,
+  kind,
+  unit,
+  period,
+  label,
+  description,
+  ...rest
+}) {
+  const { getUsed, getCap, setCap, getState } = useSpendLimitsContext("Limit");
+  const descId = React8.useId();
+  const capId = React8.useId();
+  const readoutId = React8.useId();
+  const used = getUsed(id);
+  const cap = getCap(id);
+  const state = getState(id);
+  const pct = cap == null ? 0 : cap > 0 ? Math.min(100, used / cap * 100) : 100;
+  const readout = cap != null ? `${formatRange(kind, unit, used, cap)} ${PERIOD_PHRASE[period]}` : `${formatAmount(kind, unit, used)} used \xB7 no limit set`;
+  const note = STATE_NOTE[state];
+  const labelText = typeof label === "string" ? label : "this limit";
+  return /* @__PURE__ */ jsxs8(
+    "li",
+    {
+      "data-acp": "limits-limit",
+      "data-kind": kind,
+      "data-state": state,
+      ...rest,
+      children: [
+        /* @__PURE__ */ jsxs8("div", { "data-acp": "limits-limit-body", children: [
+          /* @__PURE__ */ jsxs8("span", { "data-acp": "limits-limit-head", children: [
+            /* @__PURE__ */ jsx8("span", { "data-acp": "limits-kind", "data-kind": kind, children: KIND_LABEL[kind] }),
+            /* @__PURE__ */ jsx8("span", { "data-acp": "limits-limit-name", children: label })
+          ] }),
+          description != null && /* @__PURE__ */ jsx8("p", { id: descId, "data-acp": "limits-limit-description", children: description }),
+          /* @__PURE__ */ jsxs8("div", { "data-acp": "limits-meter", "data-state": state, children: [
+            /* @__PURE__ */ jsx8("span", { "data-acp": "limits-meter-track", "aria-hidden": "true", children: /* @__PURE__ */ jsx8(
+              "span",
+              {
+                "data-acp": "limits-meter-fill",
+                "data-state": state,
+                style: { width: `${pct}%` }
+              }
+            ) }),
+            /* @__PURE__ */ jsx8("span", { id: readoutId, "data-acp": "limits-meter-readout", children: readout })
+          ] }),
+          note != null && /* @__PURE__ */ jsx8("p", { "data-acp": "limits-status", "data-state": state, children: note })
+        ] }),
+        /* @__PURE__ */ jsxs8("div", { "data-acp": "limits-cap", children: [
+          /* @__PURE__ */ jsx8("label", { htmlFor: capId, "data-acp": "limits-cap-label", children: "Cap" }),
+          /* @__PURE__ */ jsxs8("span", { "data-acp": "limits-cap-field", children: [
+            kind === "spend" && /* @__PURE__ */ jsx8("span", { "data-acp": "limits-cap-unit", "aria-hidden": "true", children: unit }),
+            /* @__PURE__ */ jsx8(
+              "input",
+              {
+                id: capId,
+                type: "number",
+                min: 0,
+                inputMode: "numeric",
+                "data-acp": "limits-cap-input",
+                "aria-label": `${labelText} cap, per ${period}`,
+                "aria-describedby": description != null ? descId : void 0,
+                value: cap ?? "",
+                onChange: (event) => {
+                  const next = event.target.valueAsNumber;
+                  setCap(id, Number.isNaN(next) ? 0 : Math.max(0, next));
+                }
+              }
+            ),
+            kind === "rate" && /* @__PURE__ */ jsx8("span", { "data-acp": "limits-cap-unit", children: unit }),
+            /* @__PURE__ */ jsxs8("span", { "data-acp": "limits-cap-period", children: [
+              "per ",
+              period
+            ] })
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+var SpendLimits = {
+  Root: Root11,
+  Header: Header8,
+  Icon: Icon8,
+  Title: Title11,
+  Description: Description6,
+  Summary: Summary2,
+  List: List3,
+  Limit
+};
+
+// src/credential-handoff/credential-handoff.tsx
+import * as React9 from "react";
+import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+var CredentialHandoffContext = React9.createContext(null);
+function useCredentialHandoffContext(part) {
+  const ctx = React9.useContext(CredentialHandoffContext);
+  if (!ctx) {
+    throw new Error(
+      `CredentialHandoff.${part} must be rendered inside CredentialHandoff.Root`
+    );
+  }
+  return ctx;
+}
+var Root12 = React9.forwardRef(
+  function CredentialHandoffRoot({ onHandoff, onCancel, children, ...rest }, ref) {
+    const titleId = React9.useId();
+    const ctx = React9.useMemo(
+      () => ({ onHandoff, onCancel, titleId }),
+      [onHandoff, onCancel, titleId]
+    );
+    return /* @__PURE__ */ jsx9(CredentialHandoffContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx9(
+      "section",
+      {
+        ref,
+        role: "group",
+        "aria-labelledby": titleId,
+        "data-acp": "root",
+        "data-handoff": "",
+        ...rest,
+        children
+      }
+    ) });
+  }
+);
+function Header9(props) {
+  useCredentialHandoffContext("Header");
+  return /* @__PURE__ */ jsx9("div", { "data-acp": "header", ...props });
+}
+function Icon9(props) {
+  useCredentialHandoffContext("Icon");
+  return /* @__PURE__ */ jsx9("span", { "aria-hidden": true, "data-acp": "icon", ...props });
+}
+function Title12(props) {
+  const { titleId } = useCredentialHandoffContext("Title");
+  return /* @__PURE__ */ jsx9("h2", { id: titleId, "data-acp": "title", ...props });
+}
+function Description7(props) {
+  useCredentialHandoffContext("Description");
+  return /* @__PURE__ */ jsx9("p", { "data-acp": "handoff-description", ...props });
+}
+var HANDLER_LABEL = {
+  "password-manager": "Password manager",
+  passkey: "Passkey",
+  payment: "Payment",
+  provider: "Provider"
+};
+function Handler({ kind, name, children, ...rest }) {
+  useCredentialHandoffContext("Handler");
+  return /* @__PURE__ */ jsxs9("div", { "data-acp": "handoff-handler", "data-kind": kind, ...rest, children: [
+    /* @__PURE__ */ jsx9("span", { "data-acp": "handoff-handler-kind", "data-kind": kind, children: HANDLER_LABEL[kind] }),
+    /* @__PURE__ */ jsx9("span", { "data-acp": "handoff-handler-name", children: name }),
+    children
+  ] });
+}
+function Boundary(props) {
+  useCredentialHandoffContext("Boundary");
+  return /* @__PURE__ */ jsx9("div", { role: "note", "data-acp": "handoff-boundary", ...props });
+}
+function Returns({ legend, children, ...rest }) {
+  useCredentialHandoffContext("Returns");
+  const labelId = React9.useId();
+  return /* @__PURE__ */ jsxs9("div", { "data-acp": "handoff-returns", children: [
+    /* @__PURE__ */ jsx9("p", { id: labelId, "data-acp": "handoff-returns-legend", children: legend ?? "The agent receives:" }),
+    /* @__PURE__ */ jsx9("ul", { "aria-labelledby": labelId, "data-acp": "handoff-returns-list", ...rest, children })
+  ] });
+}
+function Return(props) {
+  useCredentialHandoffContext("Return");
+  return /* @__PURE__ */ jsx9("li", { "data-acp": "handoff-return", ...props });
+}
+function Actions6(props) {
+  useCredentialHandoffContext("Actions");
+  return /* @__PURE__ */ jsx9("div", { "data-acp": "actions", ...props });
+}
+var Handoff = React9.forwardRef(function CredentialHandoffHandoff({ onClick, ...rest }, ref) {
+  const { onHandoff } = useCredentialHandoffContext("Handoff");
+  return /* @__PURE__ */ jsx9(
+    "button",
+    {
+      ref,
+      type: "button",
+      "data-acp": "handoff-continue",
+      onClick: (event) => {
+        onClick?.(event);
+        if (!event.defaultPrevented) onHandoff();
+      },
+      ...rest
+    }
+  );
+});
+var Cancel6 = React9.forwardRef(function CredentialHandoffCancel({ onClick, ...rest }, ref) {
+  const { onCancel } = useCredentialHandoffContext("Cancel");
+  return /* @__PURE__ */ jsx9(
+    "button",
+    {
+      ref,
+      type: "button",
+      "data-acp": "handoff-cancel",
+      onClick: (event) => {
+        onClick?.(event);
+        if (!event.defaultPrevented) onCancel();
+      },
+      ...rest
+    }
+  );
+});
+var CredentialHandoff = {
+  Root: Root12,
+  Header: Header9,
+  Icon: Icon9,
+  Title: Title12,
+  Description: Description7,
+  Handler,
+  Boundary,
+  Returns,
+  Return,
+  Actions: Actions6,
+  Handoff,
+  Cancel: Cancel6
+};
+
+// src/action-receipt/action-receipt.tsx
+import * as React10 from "react";
+import { jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
+var ActionReceiptContext = React10.createContext(null);
+function useActionReceiptContext(part) {
+  const ctx = React10.useContext(ActionReceiptContext);
+  if (!ctx) {
+    throw new Error(
+      `ActionReceipt.${part} must be rendered inside ActionReceipt.Root`
+    );
+  }
+  return ctx;
+}
+var Root13 = React10.forwardRef(
+  function ActionReceiptRoot({ outcome = "completed", reversibility = "reversible", children, ...rest }, ref) {
+    const titleId = React10.useId();
+    const ctx = React10.useMemo(
+      () => ({ outcome, reversibility, titleId }),
+      [outcome, reversibility, titleId]
+    );
+    return /* @__PURE__ */ jsx10(ActionReceiptContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx10(
+      "article",
+      {
+        ref,
+        "aria-labelledby": titleId,
+        "data-acp": "root",
+        "data-receipt": "",
+        "data-outcome": outcome,
+        ...rest,
+        children
+      }
+    ) });
+  }
+);
+function Header10(props) {
+  useActionReceiptContext("Header");
+  return /* @__PURE__ */ jsx10("div", { "data-acp": "header", "data-receipt-header": "", ...props });
+}
+function Icon10(props) {
+  useActionReceiptContext("Icon");
+  return /* @__PURE__ */ jsx10("span", { "aria-hidden": true, "data-acp": "icon", ...props });
+}
+function Title13(props) {
+  const { titleId } = useActionReceiptContext("Title");
+  return /* @__PURE__ */ jsx10("div", { id: titleId, "data-acp": "title", ...props });
+}
+var OUTCOME_LABEL = {
+  completed: "Completed",
+  undone: "Undone",
+  failed: "Failed"
+};
+function Outcome({ children, ...rest }) {
+  const { outcome } = useActionReceiptContext("Outcome");
+  return /* @__PURE__ */ jsx10("span", { "data-acp": "receipt-outcome", "data-outcome": outcome, ...rest, children: children ?? OUTCOME_LABEL[outcome] });
+}
+function Details(props) {
+  useActionReceiptContext("Details");
+  return /* @__PURE__ */ jsx10("dl", { "data-acp": "receipt-details", ...props });
+}
+function Detail({ label, children, ...rest }) {
+  useActionReceiptContext("Detail");
+  return /* @__PURE__ */ jsxs10("div", { "data-acp": "receipt-detail", ...rest, children: [
+    /* @__PURE__ */ jsx10("dt", { "data-acp": "receipt-detail-label", children: label }),
+    /* @__PURE__ */ jsx10("dd", { "data-acp": "receipt-detail-value", children })
+  ] });
+}
+function Authority({ grant, via, children, ...rest }) {
+  useActionReceiptContext("Authority");
+  return /* @__PURE__ */ jsxs10("div", { "data-acp": "receipt-authority", ...rest, children: [
+    /* @__PURE__ */ jsx10("span", { "data-acp": "receipt-authority-label", children: "Under authority" }),
+    /* @__PURE__ */ jsx10("span", { "data-acp": "receipt-authority-grant", children: grant }),
+    via != null && /* @__PURE__ */ jsx10("span", { "data-acp": "receipt-authority-via", children: via }),
+    children
+  ] });
+}
+function Meta(props) {
+  useActionReceiptContext("Meta");
+  return /* @__PURE__ */ jsx10("dl", { "data-acp": "receipt-meta", ...props });
+}
+function MetaItem({ label, children, ...rest }) {
+  useActionReceiptContext("MetaItem");
+  return /* @__PURE__ */ jsxs10("div", { "data-acp": "receipt-meta-item", ...rest, children: [
+    /* @__PURE__ */ jsx10("dt", { "data-acp": "receipt-meta-label", children: label }),
+    /* @__PURE__ */ jsx10("dd", { "data-acp": "receipt-meta-value", children })
+  ] });
+}
+function Actions7(props) {
+  useActionReceiptContext("Actions");
+  return /* @__PURE__ */ jsx10("div", { "data-acp": "actions", "data-receipt-actions": "", ...props });
+}
+var Undo = React10.forwardRef(
+  function ActionReceiptUndo({ children, irreversibleNote, undoneNote, ...rest }, ref) {
+    const { outcome, reversibility } = useActionReceiptContext("Undo");
+    if (outcome === "undone") {
+      return /* @__PURE__ */ jsx10("span", { "data-acp": "receipt-undo-note", "data-state": "undone", children: undoneNote ?? "Undone" });
+    }
+    if (reversibility === "irreversible") {
+      return /* @__PURE__ */ jsx10("span", { "data-acp": "receipt-undo-note", "data-state": "permanent", children: irreversibleNote ?? "Can't be undone" });
+    }
+    return /* @__PURE__ */ jsx10("button", { ref, type: "button", "data-acp": "receipt-undo", ...rest, children: children ?? "Undo" });
+  }
+);
+var ActionReceipt = {
+  Root: Root13,
+  Header: Header10,
+  Icon: Icon10,
+  Title: Title13,
+  Outcome,
+  Details,
+  Detail,
+  Authority,
+  Meta,
+  MetaItem,
+  Actions: Actions7,
+  Undo
+};
+
+// src/injection-flag/injection-flag.tsx
+import * as React11 from "react";
+import * as AlertDialog4 from "@radix-ui/react-alert-dialog";
+import { jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
+var InjectionFlagContext = React11.createContext(null);
+function useInjectionFlagContext(part) {
+  const ctx = React11.useContext(InjectionFlagContext);
+  if (!ctx) {
+    throw new Error(
+      `InjectionFlag.${part} must be rendered inside InjectionFlag.Root`
+    );
+  }
+  return ctx;
+}
+var Root15 = React11.forwardRef(
+  function InjectionFlagRoot({ onProceed, onDismiss, asModal = false, open, onOpenChange, children, ...rest }, ref) {
+    const titleId = React11.useId();
+    const ctx = React11.useMemo(
+      () => ({ onProceed, onDismiss, asModal, titleId }),
+      [onProceed, onDismiss, asModal, titleId]
+    );
+    if (asModal) {
+      return /* @__PURE__ */ jsx11(InjectionFlagContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx11(AlertDialog4.Root, { open, onOpenChange, children: /* @__PURE__ */ jsxs11(AlertDialog4.Portal, { children: [
+        /* @__PURE__ */ jsx11(AlertDialog4.Overlay, { "data-acp": "overlay" }),
+        /* @__PURE__ */ jsx11(
+          AlertDialog4.Content,
+          {
+            ref,
+            "data-acp": "root",
+            "data-injection": "",
+            "data-modal": "",
+            "aria-describedby": void 0,
+            onEscapeKeyDown: onDismiss,
+            ...rest,
+            children
+          }
+        )
+      ] }) }) });
+    }
+    return /* @__PURE__ */ jsx11(InjectionFlagContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx11(
+      "section",
+      {
+        ref,
+        role: "group",
+        "aria-labelledby": titleId,
+        "data-acp": "root",
+        "data-injection": "",
+        ...rest,
+        children
+      }
+    ) });
+  }
+);
+function Header11(props) {
+  useInjectionFlagContext("Header");
+  return /* @__PURE__ */ jsx11("div", { "data-acp": "header", ...props });
+}
+function Icon11(props) {
+  useInjectionFlagContext("Icon");
+  return /* @__PURE__ */ jsx11("span", { "aria-hidden": true, "data-acp": "icon", ...props });
+}
+function Title15(props) {
+  const { asModal, titleId } = useInjectionFlagContext("Title");
+  if (asModal) {
+    return /* @__PURE__ */ jsx11(AlertDialog4.Title, { "data-acp": "title", ...props });
+  }
+  return /* @__PURE__ */ jsx11("h2", { id: titleId, "data-acp": "title", ...props });
+}
+function Description8(props) {
+  useInjectionFlagContext("Description");
+  return /* @__PURE__ */ jsx11("p", { "data-acp": "injection-description", ...props });
+}
+function Source2({ origin, location, children, ...rest }) {
+  useInjectionFlagContext("Source");
+  return /* @__PURE__ */ jsxs11("div", { "data-acp": "injection-source", ...rest, children: [
+    /* @__PURE__ */ jsx11("span", { "data-acp": "injection-source-label", children: "Came from" }),
+    /* @__PURE__ */ jsx11("span", { "data-acp": "injection-origin", children: origin }),
+    location != null && /* @__PURE__ */ jsx11("span", { "data-acp": "injection-location", children: location }),
+    children
+  ] });
+}
+function Quote({ label, children, ...rest }) {
+  useInjectionFlagContext("Quote");
+  const labelId = React11.useId();
+  return /* @__PURE__ */ jsxs11("figure", { "data-acp": "injection-quote-figure", children: [
+    /* @__PURE__ */ jsx11("figcaption", { id: labelId, "data-acp": "injection-quote-label", children: label ?? "The instruction reads:" }),
+    /* @__PURE__ */ jsx11(
+      "blockquote",
+      {
+        "data-acp": "injection-quote",
+        "aria-labelledby": labelId,
+        ...rest,
+        children
+      }
+    )
+  ] });
+}
+function Consequence2(props) {
+  useInjectionFlagContext("Consequence");
+  return /* @__PURE__ */ jsx11("p", { "data-acp": "injection-consequence", ...props });
+}
+function Actions8(props) {
+  useInjectionFlagContext("Actions");
+  return /* @__PURE__ */ jsx11("div", { "data-acp": "actions", ...props });
+}
+var Proceed = React11.forwardRef(
+  function InjectionFlagProceed({ onClick, ...rest }, ref) {
+    const { onProceed, asModal } = useInjectionFlagContext("Proceed");
+    const handleClick = (event) => {
+      onClick?.(event);
+      if (!event.defaultPrevented) onProceed();
+    };
+    const button = /* @__PURE__ */ jsx11(
+      "button",
+      {
+        ref,
+        type: "button",
+        "data-acp": "injection-proceed",
+        onClick: handleClick,
+        ...rest
+      }
+    );
+    return asModal ? /* @__PURE__ */ jsx11(AlertDialog4.Action, { asChild: true, children: button }) : button;
+  }
+);
+var Dismiss = React11.forwardRef(
+  function InjectionFlagDismiss({ onClick, ...rest }, ref) {
+    const { onDismiss, asModal } = useInjectionFlagContext("Dismiss");
+    const handleClick = (event) => {
+      onClick?.(event);
+      if (!event.defaultPrevented) onDismiss();
+    };
+    const button = /* @__PURE__ */ jsx11(
+      "button",
+      {
+        ref,
+        type: "button",
+        "data-acp": "injection-dismiss",
+        onClick: handleClick,
+        ...rest
+      }
+    );
+    return asModal ? /* @__PURE__ */ jsx11(AlertDialog4.Cancel, { asChild: true, children: button }) : button;
+  }
+);
+var InjectionFlag = {
+  Root: Root15,
+  Header: Header11,
+  Icon: Icon11,
+  Title: Title15,
+  Description: Description8,
+  Source: Source2,
+  Quote,
+  Consequence: Consequence2,
+  Actions: Actions8,
+  Proceed,
+  Dismiss
+};
+
+// src/connection-card/connection-card.tsx
+import * as React12 from "react";
+import { jsx as jsx12, jsxs as jsxs12 } from "react/jsx-runtime";
+var ConnectionCardContext = React12.createContext(null);
+function useConnectionCardContext(part) {
+  const ctx = React12.useContext(ConnectionCardContext);
+  if (!ctx) {
+    throw new Error(
+      `ConnectionCard.${part} must be rendered inside ConnectionCard.Root`
+    );
+  }
+  return ctx;
+}
+var Root16 = React12.forwardRef(
+  function ConnectionCardRoot({ status = "active", children, ...rest }, ref) {
+    const titleId = React12.useId();
+    const ctx = React12.useMemo(
+      () => ({ status, titleId }),
+      [status, titleId]
+    );
+    return /* @__PURE__ */ jsx12(ConnectionCardContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx12(
+      "article",
+      {
+        ref,
+        "aria-labelledby": titleId,
+        "data-acp": "root",
+        "data-connection": "",
+        "data-status": status,
+        ...rest,
+        children
+      }
+    ) });
+  }
+);
+function Header12(props) {
+  useConnectionCardContext("Header");
+  return /* @__PURE__ */ jsx12("div", { "data-acp": "header", "data-connection-header": "", ...props });
+}
+function Icon12(props) {
+  useConnectionCardContext("Icon");
+  return /* @__PURE__ */ jsx12("span", { "aria-hidden": true, "data-acp": "icon", ...props });
+}
+function Title16(props) {
+  const { titleId } = useConnectionCardContext("Title");
+  return /* @__PURE__ */ jsx12("div", { id: titleId, "data-acp": "title", ...props });
+}
+var STATUS_LABEL = {
+  active: "Active",
+  paused: "Paused",
+  "needs-reauth": "Needs re-auth",
+  expired: "Expired"
+};
+function Status({ children, ...rest }) {
+  const { status } = useConnectionCardContext("Status");
+  return /* @__PURE__ */ jsx12("span", { "data-acp": "connection-status", "data-status": status, ...rest, children: children ?? STATUS_LABEL[status] });
+}
+function Scopes(props) {
+  useConnectionCardContext("Scopes");
+  return /* @__PURE__ */ jsx12("ul", { "data-acp": "connection-scopes", ...props });
+}
+var ACCESS_LABEL4 = {
+  read: "Read",
+  write: "Write",
+  delete: "Delete"
+};
+function Scope2({ access, children, ...rest }) {
+  useConnectionCardContext("Scope");
+  return /* @__PURE__ */ jsxs12("li", { "data-acp": "connection-scope", "data-access": access, ...rest, children: [
+    /* @__PURE__ */ jsx12("span", { "data-acp": "connection-access", "data-access": access, children: ACCESS_LABEL4[access] }),
+    /* @__PURE__ */ jsx12("span", { "data-acp": "connection-scope-name", children })
+  ] });
+}
+function Meta2(props) {
+  useConnectionCardContext("Meta");
+  return /* @__PURE__ */ jsx12("dl", { "data-acp": "connection-meta", ...props });
+}
+function MetaItem2({ label, children, ...rest }) {
+  useConnectionCardContext("MetaItem");
+  return /* @__PURE__ */ jsxs12("div", { "data-acp": "connection-meta-item", ...rest, children: [
+    /* @__PURE__ */ jsx12("dt", { "data-acp": "connection-meta-label", children: label }),
+    /* @__PURE__ */ jsx12("dd", { "data-acp": "connection-meta-value", children })
+  ] });
+}
+function Actions9(props) {
+  useConnectionCardContext("Actions");
+  return /* @__PURE__ */ jsx12("div", { "data-acp": "actions", "data-connection-actions": "", ...props });
+}
+var Action5 = React12.forwardRef(
+  function ConnectionCardAction({ tone = "default", type, ...rest }, ref) {
+    useConnectionCardContext("Action");
+    return /* @__PURE__ */ jsx12(
+      "button",
+      {
+        ref,
+        type: type ?? "button",
+        "data-acp": "connection-action",
+        "data-tone": tone,
+        ...rest
+      }
+    );
+  }
+);
+var ConnectionCard = {
+  Root: Root16,
+  Header: Header12,
+  Icon: Icon12,
+  Title: Title16,
+  Status,
+  Scopes,
+  Scope: Scope2,
+  Meta: Meta2,
+  MetaItem: MetaItem2,
+  Actions: Actions9,
+  Action: Action5
+};
+export {
+  AUTHORITY_LEVELS,
+  ActionPreview,
+  ActionReceipt,
+  AuthorityBoundary,
+  BatchApproval,
+  ConnectionCard,
+  ConsentMemory,
+  CredentialHandoff,
+  InjectionFlag,
+  IrreversibilityGate,
+  ProgressiveScope,
+  ScopedGrant,
+  SpendLimits
+};
+//# sourceMappingURL=index.js.map