import { useCallback, useMemo } from "react";import { useAtomSet, useAtomValue } from "@effect/atom-react";import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";import { generateKeyBetween } from "fractional-indexing";import { PolicyId, type Owner, type ToolPolicyAction } from "@executor-js/sdk/shared"; import {  createPolicyOptimistic,  policiesOptimisticAtom,  removePolicyOptimistic,  updatePolicyOptimistic,} from "../api/atoms";import { policyWriteKeys } from "../api/reactivity-keys";import { trackEvent } from "../api/analytics"; // Specificity score for ordering. Higher = more specific = should sit at a// lower position-key (higher precedence). New rules are auto-placed below// any more-specific existing rules so a freshly-added group rule never// silently shadows an existing leaf rule.//   `*`            → 0//   `vercel.*`     → 2  (1 literal segment, wildcard)//   `vercel.dns.*` → 4  (2 literal segments, wildcard)//   `vercel.dns`   → 5  (2 literal segments, exact — beats same-prefix wildcard)//   `vercel.dns.create` → 7  (3 literal segments, exact)const specificity = (pattern: string): number => {  if (pattern === "*") return 0;  if (pattern.endsWith(".*")) {    const prefix = pattern.slice(0, -2);    return prefix.split(".").length * 2;  }  return pattern.split(".").length * 2 + 1;}; export interface PolicyAction {  /** Set the action on a pattern. If a user rule with this exact pattern   *  already exists, update it. Otherwise create with auto-placed   *  position so more-specific rules keep precedence. */  readonly set: (pattern: string, action: ToolPolicyAction) => Promise<void>;  /** Remove the user rule with this exact pattern, if any. No-op if none. */  readonly clear: (pattern: string) => Promise<void>;  /** True while a write is in flight. */  readonly busy: boolean;} /** * Policy write actions, scoped to an explicit `owner` (Personal vs Workspace). * * The global owner toggle is retired, so this hook no longer reads an ambient * owner. Owner is a REAL partition for policy writes (`byOwner(input.owner)` on * the server), so the caller chooses it explicitly. It defaults to `"org"` * (Workspace) — the same value the old `DEFAULT_OWNER` produced — so existing * policy behavior is preserved exactly. The hook filters exact-match candidates * to this owner and writes create/update/remove against it. */export const usePolicyActions = (owner: Owner = "org"): PolicyAction => {  const policies = useAtomValue(policiesOptimisticAtom);  const doCreate = useAtomSet(createPolicyOptimistic, { mode: "promise" });  const doUpdate = useAtomSet(updatePolicyOptimistic, { mode: "promise" });  const doRemove = useAtomSet(removePolicyOptimistic, { mode: "promise" });   // Sorted by position ASC (lowest position = highest precedence first),  // matching server evaluation order. Optimistic placeholder rows carry  // `position: ""` and sort to the very top — that's fine for lookup but  // they're skipped when computing insert position. Only this owner's rows are  // candidates for matching an exact pattern we'd update.  const sorted = useMemo(() => {    if (!AsyncResult.isSuccess(policies))      return [] as ReadonlyArray<{        readonly id: string;        readonly owner: Owner;        readonly pattern: string;        readonly action: ToolPolicyAction;        readonly position: string;      }>;    return [...policies.value]      .filter((p) => p.owner === owner)      .sort((a, b) => {        if (a.position < b.position) return -1;        if (a.position > b.position) return 1;        return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;      });  }, [policies, owner]);   const busy = policies.waiting;   const computePosition = useCallback(    (newPattern: string): string | undefined => {      const committed = sorted.filter((r) => r.position !== "");      if (committed.length === 0) return undefined;      const newScore = specificity(newPattern);      // Walk down the list (most-precedent first); place the new rule      // just before the first existing rule whose specificity is <= the      // new one. That way more-specific rules stay above us, and we win      // against everything equally or less specific.      let idx = committed.findIndex((r) => specificity(r.pattern) <= newScore);      if (idx === -1) idx = committed.length; // append at bottom      const prev = idx === 0 ? null : committed[idx - 1]!.position;      const next = idx === committed.length ? null : committed[idx]!.position;      return generateKeyBetween(prev, next);    },    [sorted],  );   const findExact = useCallback(    (pattern: string) => sorted.find((r) => r.pattern === pattern && r.position !== ""),    [sorted],  );   const set = useCallback(    async (pattern: string, action: ToolPolicyAction) => {      const patternKind = pattern.endsWith(".*") ? "group" : "exact";      const existing = findExact(pattern);      if (existing) {        if (existing.action === action) return;        await doUpdate({          params: { policyId: PolicyId.make(existing.id) },          payload: { owner, action },          reactivityKeys: policyWriteKeys,        });        trackEvent("tool_policy_set", { action, pattern_kind: patternKind, owner });        return;      }      const position = computePosition(pattern);      await doCreate({        payload:          position === undefined            ? { owner, pattern, action }            : { owner, pattern, action, position },        reactivityKeys: policyWriteKeys,      });      trackEvent("tool_policy_set", { action, pattern_kind: patternKind, owner });    },    [owner, doCreate, doUpdate, findExact, computePosition],  );   const clear = useCallback(    async (pattern: string) => {      const existing = findExact(pattern);      if (!existing) return;      await doRemove({        params: { policyId: PolicyId.make(existing.id) },        payload: { owner },        reactivityKeys: policyWriteKeys,      });      trackEvent("tool_policy_cleared", {        pattern_kind: pattern.endsWith(".*") ? "group" : "exact",        owner,      });    },    [owner, doRemove, findExact],  );   return { set, clear, busy };};