@stigmer/react 3.2.3 → 3.4.0

package/src/iam-policy/__tests__/useCheckPermission.test.tsx

@@ -0,0 +1,221 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { cleanup, render, screen, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { StigmerContext } from "../../context";
+import {
+  useCheckPermission,
+  type CheckPermissionOptions,
+  type PermissionCheckResource,
+} from "../useCheckPermission";
+
+function createMockStigmer(checkMyPermission: ReturnType<typeof vi.fn>) {
+  return { iamPolicy: { checkMyPermission } } as never;
+}
+
+function wrapper(client: unknown) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <StigmerContext.Provider value={client as never}>
+        {children}
+      </StigmerContext.Provider>
+    );
+  };
+}
+
+/** Renders the hook and exposes its state via data attributes. */
+function Probe({
+  resource,
+  relation = "can_edit",
+  options,
+}: {
+  resource: PermissionCheckResource | null;
+  relation?: string;
+  options?: CheckPermissionOptions;
+}) {
+  const { allowed, isLoading, error } = useCheckPermission(
+    resource,
+    relation,
+    options,
+  );
+  return (
+    <div
+      data-testid="probe"
+      data-allowed={String(allowed)}
+      data-loading={String(isLoading)}
+      data-error={String(error !== null)}
+    />
+  );
+}
+
+const AGENT: PermissionCheckResource = { kind: "agent", id: "agt_1" };
+
+/** A checkMyPermission stub that stays pending until resolved manually. */
+function pendingCheck() {
+  let resolve!: (value: { isAuthorized: boolean }) => void;
+  let reject!: (err: unknown) => void;
+  const check = vi.fn().mockReturnValue(
+    new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    }),
+  );
+  return { check, resolve: (v: boolean) => resolve({ isAuthorized: v }), reject: (e: unknown) => reject(e) };
+}
+
+afterEach(cleanup);
+
+describe("useCheckPermission — fail-open (default)", () => {
+  it("is allowed while the check is in flight", async () => {
+    const { check } = pendingCheck();
+    render(<Probe resource={AGENT} />, {
+      wrapper: wrapper(createMockStigmer(check)),
+    });
+
+    const probe = screen.getByTestId("probe");
+    expect(probe.getAttribute("data-allowed")).toBe("true");
+    await waitFor(() =>
+      expect(probe.getAttribute("data-loading")).toBe("true"),
+    );
+  });
+
+  it("respects an explicit server denial", async () => {
+    const check = vi.fn().mockResolvedValue({ isAuthorized: false });
+    render(<Probe resource={AGENT} />, {
+      wrapper: wrapper(createMockStigmer(check)),
+    });
+
+    await waitFor(() =>
+      expect(screen.getByTestId("probe").getAttribute("data-allowed")).toBe("false"),
+    );
+  });
+
+  it("respects an explicit server grant", async () => {
+    const check = vi.fn().mockResolvedValue({ isAuthorized: true });
+    render(<Probe resource={AGENT} />, {
+      wrapper: wrapper(createMockStigmer(check)),
+    });
+
+    const probe = screen.getByTestId("probe");
+    await waitFor(() => expect(probe.getAttribute("data-loading")).toBe("false"));
+    expect(probe.getAttribute("data-allowed")).toBe("true");
+    expect(probe.getAttribute("data-error")).toBe("false");
+  });
+
+  it("fails open on RPC rejection (OSS single-user mode)", async () => {
+    const check = vi.fn().mockRejectedValue(new Error("unimplemented"));
+    render(<Probe resource={AGENT} />, {
+      wrapper: wrapper(createMockStigmer(check)),
+    });
+
+    const probe = screen.getByTestId("probe");
+    await waitFor(() => expect(probe.getAttribute("data-error")).toBe("true"));
+    expect(probe.getAttribute("data-allowed")).toBe("true");
+    expect(probe.getAttribute("data-loading")).toBe("false");
+  });
+
+  it("is allowed when resource is null (check skipped, no RPC)", () => {
+    const check = vi.fn();
+    render(<Probe resource={null} />, {
+      wrapper: wrapper(createMockStigmer(check)),
+    });
+
+    expect(screen.getByTestId("probe").getAttribute("data-allowed")).toBe("true");
+    expect(check).not.toHaveBeenCalled();
+  });
+});
+
+describe("useCheckPermission — fail-closed", () => {
+  const CLOSED: CheckPermissionOptions = { fail: "closed" };
+
+  it("is denied while the check is in flight (no flash of gated UI)", async () => {
+    const { check } = pendingCheck();
+    render(<Probe resource={AGENT} options={CLOSED} />, {
+      wrapper: wrapper(createMockStigmer(check)),
+    });
+
+    const probe = screen.getByTestId("probe");
+    expect(probe.getAttribute("data-allowed")).toBe("false");
+    await waitFor(() =>
+      expect(probe.getAttribute("data-loading")).toBe("true"),
+    );
+    expect(probe.getAttribute("data-allowed")).toBe("false");
+  });
+
+  it("is allowed only on an explicit server grant", async () => {
+    const check = vi.fn().mockResolvedValue({ isAuthorized: true });
+    render(<Probe resource={AGENT} options={CLOSED} />, {
+      wrapper: wrapper(createMockStigmer(check)),
+    });
+
+    await waitFor(() =>
+      expect(screen.getByTestId("probe").getAttribute("data-allowed")).toBe("true"),
+    );
+  });
+
+  it("fails closed on RPC rejection", async () => {
+    const check = vi.fn().mockRejectedValue(new Error("unimplemented"));
+    render(<Probe resource={AGENT} options={CLOSED} />, {
+      wrapper: wrapper(createMockStigmer(check)),
+    });
+
+    const probe = screen.getByTestId("probe");
+    await waitFor(() => expect(probe.getAttribute("data-error")).toBe("true"));
+    expect(probe.getAttribute("data-allowed")).toBe("false");
+    expect(probe.getAttribute("data-loading")).toBe("false");
+  });
+
+  it("is denied when resource is null (check skipped)", () => {
+    const check = vi.fn();
+    render(<Probe resource={null} options={CLOSED} />, {
+      wrapper: wrapper(createMockStigmer(check)),
+    });
+
+    expect(screen.getByTestId("probe").getAttribute("data-allowed")).toBe("false");
+    expect(check).not.toHaveBeenCalled();
+  });
+});
+
+describe("useCheckPermission — caching", () => {
+  it("serves repeat checks of the same triple from the mount cache", async () => {
+    const check = vi.fn().mockResolvedValue({ isAuthorized: true });
+    const { rerender } = render(<Probe resource={AGENT} />, {
+      wrapper: wrapper(createMockStigmer(check)),
+    });
+    await waitFor(() =>
+      expect(screen.getByTestId("probe").getAttribute("data-allowed")).toBe("true"),
+    );
+
+    // Switch relation (new triple → one more RPC), then switch back
+    // (cached triple → served without an RPC).
+    rerender(<Probe resource={AGENT} relation="can_delete" />);
+    await waitFor(() => expect(check).toHaveBeenCalledTimes(2));
+    rerender(<Probe resource={AGENT} relation="can_edit" />);
+    await waitFor(() =>
+      expect(screen.getByTestId("probe").getAttribute("data-allowed")).toBe("true"),
+    );
+    expect(check).toHaveBeenCalledTimes(2);
+  });
+
+  it("does not cache a failed check as a verdict", async () => {
+    // First mount errors; the error must not be pinned as `true` — a
+    // remount (fresh cache) with a healthy server gets the real verdict.
+    const failing = vi.fn().mockRejectedValue(new Error("blip"));
+    const { unmount } = render(
+      <Probe resource={AGENT} options={{ fail: "closed" }} />,
+      { wrapper: wrapper(createMockStigmer(failing)) },
+    );
+    await waitFor(() =>
+      expect(screen.getByTestId("probe").getAttribute("data-error")).toBe("true"),
+    );
+    expect(screen.getByTestId("probe").getAttribute("data-allowed")).toBe("false");
+    unmount();
+
+    const healthy = vi.fn().mockResolvedValue({ isAuthorized: true });
+    render(<Probe resource={AGENT} options={{ fail: "closed" }} />, {
+      wrapper: wrapper(createMockStigmer(healthy)),
+    });
+    await waitFor(() =>
+      expect(screen.getByTestId("probe").getAttribute("data-allowed")).toBe("true"),
+    );
+  });
+});

package/src/iam-policy/index.ts

@@ -75,6 +75,7 @@ export {
 
 export {
   useCheckPermission,
+  type CheckPermissionOptions,
   type PermissionCheckResource,
   type UseCheckPermissionReturn,
 } from "./useCheckPermission.js";

package/src/iam-policy/useCheckPermission.ts

@@ -1,6 +1,6 @@
 "use client";
 
-import { useEffect, useMemo, useRef, useState } from "react";
+import { useEffect, useRef, useState } from "react";
 import { create } from "@bufbuild/protobuf";
 import {
   CheckMyPermissionInputSchema,
@@ -18,6 +18,25 @@ export interface PermissionCheckResource {
   readonly id: string;
 }
 
+/** Options for {@link useCheckPermission}. */
+export interface CheckPermissionOptions {
+  /**
+   * Behavior when authorization cannot be confirmed — the check is in
+   * flight, the RPC failed, the resource is `null`, or the server does
+   * not implement authorization checks (OSS edition).
+   *
+   * - `"open"` (default): `allowed` is `true`. Right for gating
+   *   *capabilities* (buttons, actions) — the server re-checks every
+   *   request anyway, and all UI stays visible in single-user local
+   *   mode.
+   * - `"closed"`: `allowed` is `false` until the server explicitly
+   *   authorizes. Right for *discoverability* surfaces (navigation to
+   *   operator-only areas) that must not appear on deployments where
+   *   the feature does not exist.
+   */
+  readonly fail?: "open" | "closed";
+}
+
 /** Return value of {@link useCheckPermission}. */
 export interface UseCheckPermissionReturn {
   /** Whether the current user has the specified permission. */
@@ -34,21 +53,24 @@ export interface UseCheckPermissionReturn {
  *
  * Wraps `iamPolicy.checkMyPermission()` — the dedicated self-check RPC
  * where the server derives the principal from the authenticated token
- * (the client never names a principal) — with caching and graceful
- * degradation. When the server does not support authorization checks
- * (OSS edition where the IAM service is not registered), the hook
- * returns `allowed: true` — ensuring all UI is visible in single-user
- * local mode.
+ * (the client never names a principal) — with caching and configurable
+ * degradation. By default the hook *fails open*: when the server does
+ * not support authorization checks (OSS edition where the IAM service
+ * is not registered), it returns `allowed: true` so all UI remains
+ * visible in single-user local mode. Pass `{ fail: "closed" }` for
+ * surfaces that must stay hidden until authorization is confirmed
+ * (see {@link CheckPermissionOptions}).
  *
- * Pass `null` as `resource` to skip the check (returns `allowed: true`
- * immediately — the "no resource yet" case is permissive to avoid
- * flashing hidden UI).
+ * Pass `null` as `resource` to skip the check — the result resolves
+ * through the fail mode (`allowed: true` under the default fail-open).
  *
- * Results are cached per (kind, id, relation) triple for the lifetime
- * of the component mount. Re-mount or change inputs to re-check.
+ * Only genuine server verdicts are cached (per (kind, id, relation)
+ * triple, for the lifetime of the component mount). A failed check is
+ * never cached, so a transient error does not pin a wrong answer.
  *
  * @param resource  - The resource to check, or `null` to skip.
  * @param relation  - The permission to check (e.g. "can_edit", "can_grant_access").
+ * @param options   - Fail-mode configuration; see {@link CheckPermissionOptions}.
  *
  * @example
  * ```tsx
@@ -63,9 +85,13 @@ export interface UseCheckPermissionReturn {
 export function useCheckPermission(
   resource: PermissionCheckResource | null,
   relation: string,
+  options?: CheckPermissionOptions,
 ): UseCheckPermissionReturn {
   const stigmer = useStigmer();
-  const [allowed, setAllowed] = useState(true);
+  const failMode = options?.fail ?? "open";
+  const failValue = failMode === "open";
+
+  const [allowed, setAllowed] = useState(failValue);
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState<Error | null>(null);
 
@@ -74,7 +100,7 @@ export function useCheckPermission(
 
   useEffect(() => {
     if (!resource || !cacheKey) {
-      setAllowed(true);
+      setAllowed(failValue);
       setIsLoading(false);
       return;
     }
@@ -87,6 +113,7 @@ export function useCheckPermission(
     }
 
     let cancelled = false;
+    setAllowed(failValue);
     setIsLoading(true);
 
     const input = create(CheckMyPermissionInputSchema, {
@@ -108,11 +135,10 @@ export function useCheckPermission(
       })
       .catch((err: unknown) => {
         if (cancelled) return;
-        // Graceful degradation: if the IAM service is unavailable
-        // (OSS edition), default to permissive. This ensures all
-        // UI remains visible in single-user local mode.
-        cacheRef.current.set(cacheKey, true);
-        setAllowed(true);
+        // Degradation is fail-mode-resolved and deliberately NOT cached:
+        // an error is not an authorization verdict, and caching it would
+        // pin a possibly-wrong answer for the mount's lifetime.
+        setAllowed(failValue);
         setError(err instanceof Error ? err : new Error(String(err)));
       })
       .finally(() => {
@@ -122,7 +148,7 @@ export function useCheckPermission(
     return () => {
       cancelled = true;
     };
-  }, [cacheKey, resource?.kind, resource?.id, relation, stigmer]);
+  }, [cacheKey, resource?.kind, resource?.id, relation, failValue, stigmer]);
 
   return { allowed, isLoading, error };
 }

package/src/index.ts

@@ -677,6 +677,88 @@ export type {
   AgentWizardData,
 } from "./agent/index.js";
 
+// Datastore — data hooks (kind family + describe projection), record
+// hooks (find/insert/update/delete + grid collection), guarded delete,
+// the canonical value semantics of declared fields, the typed filter
+// model, and the six styled components (detail view, records browser,
+// filter builder, record form, schema view, sync report, delete dialog)
+export {
+  useDatastore,
+  useDatastoreList,
+  useDatastoreCount,
+  useDatastoreSearch,
+  useDatastoreDescription,
+  DEFAULT_PARTITION,
+  useRecordList,
+  useInsertRecord,
+  useUpdateRecord,
+  useDeleteRecord,
+  useRecordCollection,
+  useDeleteDatastore,
+  buildUpdateFields,
+  coerceFieldValue,
+  formatFieldValue,
+  formatSystemTimestamp,
+  isListOperator,
+  isSortableField,
+  isValuelessOperator,
+  operatorsForField,
+  OPERATOR_LABELS,
+  RESERVED_FIELD_NAMES,
+  SYSTEM_FIELD_OPERATORS,
+  buildRecordFilter,
+  filterableFields,
+  formatConditionChip,
+  isConditionComplete,
+  FieldValueControl,
+  FIELD_INPUT_CLASSES,
+  CollectionSchemaView,
+  formatSubject,
+  DatastoreSyncReport,
+  RecordFilterBuilder,
+  RecordFormPanel,
+  CollectionRecordsBrowser,
+  DeleteDatastoreDialog,
+  DatastoreDetailView,
+  DatastoreIcon,
+} from "./datastore/index.js";
+export type {
+  UseDatastoreReturn,
+  UseDatastoreListOptions,
+  UseDatastoreListReturn,
+  UseDatastoreCountOptions,
+  UseDatastoreCountReturn,
+  UseDatastoreSearchOptions,
+  UseDatastoreSearchReturn,
+  UseDatastoreDescriptionReturn,
+  RecordScope,
+  UseRecordListParams,
+  UseRecordListReturn,
+  InsertRecordArgs,
+  UseInsertRecordReturn,
+  UpdateRecordArgs,
+  UseUpdateRecordReturn,
+  DeleteRecordArgs,
+  UseDeleteRecordReturn,
+  RecordColumnDef,
+  UseRecordCollectionOptions,
+  UseRecordCollectionReturn,
+  DeleteDatastoreArgs,
+  UseDeleteDatastoreReturn,
+  CoerceResult,
+  FilterableField,
+  RecordConditionDraft,
+  FieldValueControlProps,
+  CollectionSchemaViewProps,
+  DatastoreSyncReportProps,
+  RecordFilterBuilderProps,
+  RecordFormPanelProps,
+  CollectionRecordsBrowserProps,
+  DeleteDatastoreDialogProps,
+  DatastoreDetailTab,
+  DatastoreDetailViewProps,
+} from "./datastore/index.js";
+
 // Environment — data hooks, list hook, personal convenience hook, secret reveal, variable management, env var form, system env vars, and styled components
 export {
   useEnvironment,
@@ -770,6 +852,7 @@ export type {
   UseShareFlowReturn,
   ShareFlowResource,
   UseCheckPermissionReturn,
+  CheckPermissionOptions,
   PermissionCheckResource,
   RoleSelectorProps,
   PrincipalPickerProps,
@@ -826,7 +909,8 @@ export type {
   OrgSwitcherProps,
 } from "./organization/index.js";
 
-// Billing — data hooks, behavior hooks, styled components, catalog, and formatting utilities
+// Billing — customer-facing data hooks, behavior hooks, styled components,
+// catalog, and formatting utilities
 export {
   useBillingAccount,
   useCreditLedger,
@@ -873,8 +957,71 @@ export type {
   CreditPackInfo,
 } from "./billing/index.js";
 
+// Pricing governance — platform-operator authoring of the model registry
+// baseline and pricing-override sign-offs (gated on can_manage_model_pricing)
+export {
+  usePricingGovernance,
+  useModelPricingBaselines,
+  useModelGovernanceView,
+  useDecidePricingOverride,
+  useUpsertModelPricingBaseline,
+  useRetireModelPricingBaseline,
+  PricingGovernancePanel,
+  ModelCatalogPanel,
+  PricingGovernanceConsole,
+} from "./pricing-governance/index.js";
+export type {
+  UsePricingGovernanceReturn,
+  UseModelPricingBaselinesOptions,
+  UseModelPricingBaselinesReturn,
+  GovernanceFlow,
+  ModelGovernanceRow,
+  UseModelGovernanceViewReturn,
+  DecidePricingOverrideInput,
+  UseDecidePricingOverrideReturn,
+  UpsertModelPricingBaselineInput,
+  UseUpsertModelPricingBaselineReturn,
+  RetireModelPricingBaselineInput,
+  UseRetireModelPricingBaselineReturn,
+  PricingGovernancePanelProps,
+  ModelCatalogPanelProps,
+  PricingGovernanceConsoleProps,
+  PricingGovernanceTab,
+} from "./pricing-governance/index.js";
+
+// Cursor accounts — platform-operator management of managed Cursor teams
+// (admin keys, member execution keys, org assignments, roster/spend)
+export {
+  useCursorAccounts,
+  useCursorAccountView,
+  useUpsertCursorAccount,
+  useDeleteCursorAccount,
+  useCursorMemberKeyActions,
+  useSyncCursorAccount,
+  CursorAccountsConsole,
+  CursorAccountEditor,
+  CursorAccountsAccessNotice,
+} from "./cursor-accounts/index.js";
+export type {
+  UseCursorAccountsReturn,
+  UseCursorAccountViewReturn,
+  UseUpsertCursorAccountReturn,
+  DeleteCursorAccountInput,
+  UseDeleteCursorAccountReturn,
+  AddCursorMemberKeyInput,
+  RemoveCursorMemberKeyInput,
+  UseCursorMemberKeyActionsReturn,
+  UseSyncCursorAccountReturn,
+  CursorAccountsConsoleProps,
+  CursorAccountEditorProps,
+} from "./cursor-accounts/index.js";
+
 // Settings — navigation structure + section components shared across app shells
-export { SETTINGS_NAV_GROUPS } from "./settings/index.js";
+export {
+  SETTINGS_NAV_GROUPS,
+  PLATFORM_SETTINGS_NAV_GROUP,
+  useSettingsNavGroups,
+} from "./settings/index.js";
 export type { SettingsNavItem, SettingsNavGroup } from "./settings/index.js";
 export { ApiKeysSection } from "./settings/index.js";
 export { MembersSection } from "./settings/index.js";
@@ -1138,15 +1285,8 @@ export {
   findStreamingPlan,
   PLAN_ARTIFACT_NAME,
   PLAN_ARTIFACT_SUFFIX,
-  parseResourceYaml,
-  serializeAgentYaml,
-  serializeMcpServerYaml,
-  serializeAgentInputYaml,
-  serializeMcpServerInputYaml,
   useApplyResource,
   useExportResource,
-  useImportResource,
-  ImportResourceDialog,
   VisibilitySelector,
   VisibilityBadge,
   blueprintVisibilityLevels,
@@ -1163,16 +1303,11 @@ export type {
   SessionPlan,
   StreamingPlan,
   UseDetectSkillPackageReturn,
-  ParsedResource,
   UseApplyResourceReturn,
   ApplyResourceResult,
   PushSkillParams,
   UseExportResourceOptions,
   UseExportResourceReturn,
-  ImportFormat,
-  ImportPreview,
-  UseImportResourceReturn,
-  ImportResourceDialogProps,
   VisibilitySelectorProps,
   VisibilityBadgeProps,
   VisibilityLevelOption,
@@ -1181,6 +1316,29 @@ export type {
   UseUpdateVisibilityReturn,
 } from "./library/index.js";
 
+// Manifest — kind-agnostic YAML edit/apply (editor, hooks, dialogs)
+export {
+  YamlEditor,
+  useEditResourceYaml,
+  useApplyManifest,
+  EditResourceYamlDialog,
+  ApplyManifestDialog,
+  RedactedSecretsNotice,
+} from "./manifest/index.js";
+export type {
+  YamlEditorProps,
+  EditYamlTarget,
+  EditYamlValidation,
+  UseEditResourceYamlOptions,
+  UseEditResourceYamlReturn,
+  ManifestEntryStatus,
+  ManifestPreviewEntry,
+  UseApplyManifestReturn,
+  EditResourceYamlDialogProps,
+  ApplyManifestDialogProps,
+  RedactedSecretsNoticeProps,
+} from "./manifest/index.js";
+
 // Action menu — compound component for resource item actions
 export { ActionMenu } from "./action-menu/index.js";
 export type {

package/src/internal/form-primitives.tsx

@@ -0,0 +1,40 @@
+"use client";
+
+import { cn } from "@stigmer/theme";
+
+// ---------------------------------------------------------------------------
+// Shared form primitives for the operator consoles (pricing-governance
+// editors and search inputs, cursor-accounts editor and key forms).
+// Internal — never exported from the package barrel.
+// ---------------------------------------------------------------------------
+
+/** Standard text-input styling for the operator consoles. */
+export const INPUT_CLASSES = cn(
+  "w-full rounded-md border border-input bg-background px-2.5 py-1.5 text-xs text-foreground",
+  "placeholder:text-muted-foreground",
+  "focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring",
+  "disabled:pointer-events-none disabled:opacity-50",
+);
+
+/** Labelled form field wrapper. */
+export function Field({
+  label,
+  required,
+  className,
+  children,
+}: {
+  readonly label: string;
+  readonly required?: boolean;
+  readonly className?: string;
+  readonly children: React.ReactNode;
+}) {
+  return (
+    <label className={cn("block space-y-1", className)}>
+      <span className="text-[11px] font-medium text-muted-foreground">
+        {label}
+        {required ? " *" : ""}
+      </span>
+      {children}
+    </label>
+  );
+}

package/src/library/index.ts

@@ -40,16 +40,6 @@ export type { StreamingPlan } from "./detect-streaming-plan.js";
 export { useDetectSkillPackage } from "./useDetectSkillPackage.js";
 export type { UseDetectSkillPackageReturn } from "./useDetectSkillPackage.js";
 
-export { parseResourceYaml } from "./parse-resource-yaml.js";
-export type { ParsedResource } from "./parse-resource-yaml.js";
-
-export {
-  serializeAgentYaml,
-  serializeMcpServerYaml,
-  serializeAgentInputYaml,
-  serializeMcpServerInputYaml,
-} from "./serialize-resource-yaml.js";
-
 export { serializeWorkflowYaml, parseWorkflowYaml } from "../workflow/serialize-workflow-yaml.js";
 
 export { useApplyResource } from "./useApplyResource.js";
@@ -65,16 +55,6 @@ export type {
   UseExportResourceReturn,
 } from "./useExportResource.js";
 
-export { useImportResource } from "./useImportResource.js";
-export type {
-  ImportFormat,
-  ImportPreview,
-  UseImportResourceReturn,
-} from "./useImportResource.js";
-
-export { ImportResourceDialog } from "./ImportResourceDialog.js";
-export type { ImportResourceDialogProps } from "./ImportResourceDialog.js";
-
 export { VisibilitySelector, VisibilityBadge } from "./VisibilitySelector.js";
 export type {
   VisibilitySelectorProps,