@parallelworks/ui 0.2.0 → 0.3.1

package/dist/file-explorer/lib/batch.d.ts

@@ -0,0 +1,3 @@
+export declare function paginate<TPage>(fetchPage: (cursor?: string) => Promise<TPage>, nextCursor: (page: TPage) => string | undefined): AsyncGenerator<TPage>;
+export declare function chunk<T>(items: readonly T[], size: number): T[][];
+export declare function mapWithConcurrency<T, R>(items: readonly T[], limit: number, worker: (item: T) => Promise<R>): Promise<PromiseSettledResult<R>[]>;

package/dist/file-explorer/lib/errors.d.ts

@@ -0,0 +1,3 @@
+export declare class CorsError extends Error {
+    constructor(message?: string);
+}

package/dist/file-explorer/lib/fileExplorer.d.ts

@@ -0,0 +1,32 @@
+import type { TListPageRequest } from './paging.js';
+import type { TreeNode, TStorage, TStorageObject } from './types.js';
+/** Every provider resolves get-file as a [url, error] tuple. */
+export type FileExplorerGetFileResult = [string | null, Error | null];
+/** The UI only checks Errors?.length; each provider's richer error entries
+ *  satisfy this structurally. */
+export interface FileExplorerDeleteFilesResult {
+    Errors?: unknown[];
+}
+export interface IFileExplorerClient {
+    getStorageName(): string;
+    getExpiresAt(): Date;
+    getFile(input: unknown): Promise<FileExplorerGetFileResult>;
+    listDirectory(input: unknown): Promise<unknown>;
+    deleteFiles(input: unknown): Promise<FileExplorerDeleteFilesResult>;
+    uploadFile(input: unknown, onProgress?: (progress: {
+        loadedBytes: number;
+        totalBytes: number;
+        percentage: number;
+    }) => void, abortController?: AbortController): Promise<unknown>;
+}
+export interface IFileExplorerProvider {
+    createClient: ((organization: string, username: string, name: string) => Promise<IFileExplorerClient | null>) | null;
+    convertDataToStorageObjects?(data: unknown): TStorageObject[];
+    /** Absent ⇒ the explorer treats one page as the whole directory. Method syntax for
+     *  the same bivariance reason as the two above. */
+    nextPageCursor?(data: unknown): string | undefined;
+    listDirectoryInput?: ((storage: TStorage, dir_path?: string, page?: TListPageRequest) => unknown) | null;
+    getFileInput?: ((storageName: string, node: TreeNode, presignedUrlExpiresIn?: number) => unknown) | null;
+    deleteFilesInput?: ((storageName: string, nodes: TreeNode[]) => unknown) | null;
+    uploadFileInput?: ((storageName: string, objectPath: string, file: File | Blob) => unknown) | null;
+}

package/dist/file-explorer/lib/paging.d.ts

@@ -0,0 +1,93 @@
+import type { TStorageObject } from './types.js';
+/** Both providers already cap an unqualified list at 1,000, so stating it leaves
+ *  single-page directories byte-identical. */
+export declare const LIST_PAGE_SIZE = 1000;
+export type TListPageRequest = {
+    cursor?: string;
+    /** Overridable so a test can page without seeding 2,000 objects. */
+    pageSize?: number;
+};
+/** Keyed by tree path. A storage's flat `objects` bag cannot say whether a directory
+ *  was listed at all, only whether anything landed under it. */
+export type TDirectoryListing = {
+    /** Present ⇒ more entries exist and the provider can resume from here. */
+    cursor?: string;
+    /** 0 ⇒ never listed, which is what tells "empty" apart from "not asked yet". */
+    pagesLoaded: number;
+    /** Not `loadingPaths`, which swaps the whole table for a skeleton and would blank
+     *  the rows being read. */
+    loadingMore: boolean;
+    /** The storage-level error surfaces only on an empty folder, so without this a
+     *  failure mid-folder is invisible. */
+    error?: string;
+};
+/** Uncapped, opening a 200k-object folder and scrolling would walk all of it. */
+export declare const MAX_AUTO_PAGES = 5;
+export type TListings = ReadonlyMap<string, TDirectoryListing>;
+export declare function isListed(listings: TListings, path: string): boolean;
+/** True even while a request is in flight, so the sentinel stays put. */
+export declare function hasMore(listings: TListings, path: string): boolean;
+/** Auto-load stops at the cap; past it the user asks for each page. */
+export declare function canAutoLoadMore(listings: TListings, path: string): boolean;
+export declare function isLoadingMore(listings: TListings, path: string): boolean;
+export declare function loadMoreError(listings: TListings, path: string): string | undefined;
+export declare function beginLoadingMore(listings: TListings, path: string): TListings;
+/** `expectedPagesLoaded` is captured before the request: a mismatch means a refresh
+ *  reset this directory while the page was in flight. */
+export declare function advanceListing(listings: TListings, path: string, page: {
+    cursor?: string;
+}, expectedPagesLoaded: number): TListings;
+/** Always a new map, since the hydration walk only re-runs on a `listings` change.
+ *  `pagesLoaded` stays put, so a failed first page still reads as unlisted. */
+export declare function recordListingError(listings: TListings, path: string, error: string): TListings;
+/** Slash-terminates the prefix: without it, clearing `logs` would also clear
+ *  `logs-archive/`. */
+export declare function clearListingsUnder(listings: TListings, path: string): TListings;
+/** The same prefix rule for the attempt sets that shadow `listings`. They gate
+ *  re-listing, so a path left behind here reads as tried-and-empty forever. */
+export declare function forgetPathsUnder(paths: Set<string>, path: string): void;
+/** Tree paths whose children should keep arrival order, since sorting them would
+ *  reshuffle rows under the user mid-scroll. */
+export declare function incompletePaths(listings: TListings): Set<string>;
+/** Reached only when the target is deep inside a directory of well over 20,000
+ *  entries, where the alternative is draining it all. */
+export declare const MAX_HYDRATION_PAGES = 20;
+type THydrationStep = 
+/** List this directory's first page. */
+{
+    kind: 'fetch';
+    path: string;
+}
+/** Pull another page; the target is not in what we have. */
+ | {
+    kind: 'more';
+    path: string;
+} | {
+    kind: 'stuck';
+}
+/** Either resolved, or a request is already in flight. */
+ | {
+    kind: 'done';
+};
+/** What a deep link needs next. Pure so the walk is table-testable. */
+export declare function nextHydrationStep({ targetResolved, ancestors, isListableDir, listings, inFlight, attempted, pagesPulled, }: {
+    targetResolved: boolean;
+    /** Directory paths from the storage root down to the target.  */
+    ancestors: readonly string[];
+    /** False above the storage root, and false for a directory a page has not
+     *  introduced yet. */
+    isListableDir: (path: string) => boolean;
+    listings: TListings;
+    /** Must not be a state value: `attempted` is a ref, so a state-backed signal would
+     *  lag it by a render and make an in-flight ancestor read as stuck. */
+    inFlight: ReadonlySet<string>;
+    attempted: ReadonlySet<string>;
+    pagesPulled: number;
+}): THydrationStep;
+/** `replace` drops the directory's previous contents first, which is how a refresh
+ *  sheds deleted objects rather than re-adding them. */
+export declare function nextObjects(previous: TStorageObject[], page: TStorageObject[], options: {
+    replace?: boolean;
+    dirPath: string;
+}): TStorageObject[];
+export {};

package/dist/file-explorer/lib/types.d.ts

@@ -0,0 +1,92 @@
+import type { IFileExplorerClient, IFileExplorerProvider } from './fileExplorer.js';
+export type TStorage = {
+    id: string;
+    name: string;
+    bucketName?: string;
+    user: string;
+    displayName?: string;
+    type?: string;
+    created?: string;
+    modified?: string;
+    region?: string;
+    csp?: string;
+    imageUrl?: string;
+    canWrite?: boolean | undefined;
+    canUpload?: boolean | undefined;
+    canShare?: boolean | undefined;
+    canManageAccess?: boolean | undefined;
+    supportsPwUri?: boolean | undefined;
+    objects?: TStorageObject[];
+};
+export type TStorageObject = {
+    path: string;
+    type: 'file' | 'directory';
+    key?: string;
+    size?: number;
+    created?: string;
+    modified?: string;
+    contentType?: string;
+    hash?: string;
+    storageClass?: string;
+};
+export type TreeNode = {
+    name: string;
+    displayName?: string;
+    path: string;
+    relativePath?: string;
+    type: 'file' | 'directory';
+    size?: number;
+    created?: string;
+    modified?: string;
+    contentType?: string;
+    hash?: string;
+    storageClass?: string;
+    storageId?: string;
+    storageName?: string;
+    storageNodeIcon?: string;
+    storageImageUrl?: string;
+    storageType?: string;
+    root?: boolean;
+};
+export type TreeMap = {
+    [path: string]: TreeNode;
+};
+export type UploadNode = {
+    name: string;
+    file: File | Blob;
+    relativePath: string;
+};
+export interface UploadFileProgress {
+    fileKey: string;
+    fileSizeBytes: number;
+    loadedBytes?: number;
+    totalBytes?: number;
+    percentage?: number;
+    abortController?: AbortController;
+    status?: 'pending' | 'uploading' | 'completed' | 'failed' | 'cancelled';
+}
+export interface UploadSession {
+    id: string;
+    storageName: string;
+    targetPath: string;
+    uploadNodes: UploadNode[];
+    status: 'queued' | 'uploading' | 'completed' | 'failed' | 'cancelled';
+    queueIndex: number;
+    client: IFileExplorerClient;
+    provider: IFileExplorerProvider;
+    progress?: {
+        completedFiles: number;
+        totalFiles: number;
+        totalSizeBytes: number;
+        allFiles?: Map<string, UploadFileProgress>;
+        overallProgress?: number;
+        totalLoadedBytes?: number;
+        lastProgressTime?: number;
+        lastProgressBytes?: number;
+        estimatedSecondsLeft?: number;
+    };
+    toastId: string;
+    abortController?: AbortController;
+    targetNode: TreeNode;
+    refreshTargetNode: (targetNode: TreeNode) => Promise<unknown>;
+}

package/dist/file-explorer/lib/utils.d.ts

@@ -0,0 +1,37 @@
+import type { IFileExplorerClient } from './fileExplorer.js';
+import type { TStorage, TreeMap, TreeNode, UploadNode } from './types.js';
+export declare function formatFileSize(bytes: number): string;
+export declare function getFileExtension(filename: string): string | null;
+export declare function buildTreeFromUserStorages(storages: TStorage[], options?: {
+    forceUserHierarchy?: boolean;
+    unsortedParents?: ReadonlySet<string>;
+}): {
+    treeMap: TreeMap;
+    parentToChildrenMap: Record<string, TreeNode[]>;
+};
+export declare function getNodeChildren(parentToChildrenMap: Record<string, TreeNode[]>, parentPath: string): TreeNode[];
+export declare function getParentPath(currentPath: string): string;
+export type DirectoryNameError = 'reserved' | 'separator' | 'exists';
+export declare function getDirectoryNameError(name: string, siblings: TreeNode[]): DirectoryNameError | null;
+export declare function getDirectoryObjectPath(parentNode: TreeNode, directoryName: string): string;
+export declare function getUploadNodesFromDataTransferItems(items: DataTransferItemList): Promise<{
+    uploadNodes: UploadNode[];
+    totalSize: number;
+}>;
+export declare function calculateUploadNodesTotalSize(uploadNodes: UploadNode[]): number;
+export declare function getObjectKeyFromNode(node: TreeNode): string;
+export declare function getDirectoryPrefixFromNode(node: TreeNode): string;
+export declare function pruneNodesInsideSelectedDirectories(nodes: TreeNode[]): TreeNode[];
+export declare function collectObjectKeysToDelete(nodes: TreeNode[], listKeysUnderPrefix: (prefix: string) => Promise<string[]>): Promise<string[]>;
+export declare function getPwUri(username: string, pwName: string, key: string): string;
+export declare function getCspUri(csp: string, cspBucketName: string, key: string): string | null;
+export declare function removeLeadingSlash(path: string): string;
+export declare function removeLeadingAndTrailingSlashes(path: string): string;
+export declare function isClientValid(client: IFileExplorerClient): boolean;
+export declare function getUploadSessionETA(totalLoadedBytes: number, totalSizeBytes: number, lastProgressTime?: number, lastProgressBytes?: number): {
+    estimatedSecondsLeft?: number;
+    lastProgressTime: number;
+    lastProgressBytes: number;
+    shouldUpdateETA: boolean;
+};
+export declare function formatETA(seconds: number): string;

package/dist/file-explorer/toasts.d.ts

@@ -0,0 +1,9 @@
+import type { UploadSession } from './lib/types.js';
+interface UploadSessionToastProps {
+    session: UploadSession;
+    queueLength: number;
+    onCancel?: () => void;
+    onCancelFile?: (relativePath: string) => void;
+}
+export declare function UploadSessionToast({ session, queueLength, onCancel, onCancelFile, }: UploadSessionToastProps): import("react").JSX.Element;
+export {};

package/dist/file-explorer/treeRows.d.ts

@@ -0,0 +1,35 @@
+import type { TreeNode } from './lib/types.js';
+/** 10,000 file rows render cheaply but stand 300,000px tall, burying the folder's
+ *  next sibling. Directories are never held back. */
+export declare const TREE_FILE_CAP = 50;
+/** One visible line in the sidebar tree. */
+export interface TreeRow {
+    kind: 'node' | 'skeleton' | 'more';
+    /** Non-node rows suffix the parent path after a NUL, which object keys effectively
+     *  never contain; nothing is derived from the key, so a collision only warns. */
+    key: string;
+    node: TreeNode;
+    /** Roots are 0. Drives indent and aria-level (which is 1-based). */
+    depth: number;
+    posInSet: number;
+    /** The true sibling count, which aria-setsize wants even when the cap shows fewer. */
+    setSize: number;
+    isExpanded: boolean;
+    /** `more` rows only: files held back by the cap, 0 when only pages remain. */
+    hiddenFiles?: number;
+}
+interface FlattenTreeOptions {
+    loadingPaths?: ReadonlySet<string>;
+    incompletePaths?: ReadonlySet<string>;
+    /** Absent means `TREE_FILE_CAP`. */
+    fileLimits?: ReadonlyMap<string, number>;
+}
+/** Flattens the tree to exactly the rows that should be on screen, so the sidebar
+ *  can be windowed and keyboard navigation can move by index instead of by DOM. */
+export declare function flattenTreeRows(roots: TreeNode[], parentToChildrenMap: Record<string, TreeNode[]>, expandedPaths: ReadonlySet<string>, options?: FlattenTreeOptions): TreeRow[];
+export declare function nextFileLimit(current: number | undefined): number;
+/** Index of `path` among the visible rows, or -1. */
+export declare function findRowIndex(rows: readonly TreeRow[], path: string): number;
+/** The next selectable row in `direction`, skipping skeleton and more rows. */
+export declare function stepRow(rows: readonly TreeRow[], from: number, direction: 1 | -1): TreeRow | undefined;
+export {};

package/dist/file-explorer/useNearEnd.d.ts

@@ -0,0 +1,7 @@
+import { type RefObject } from 'react';
+/** Fires once the element comes within 100px of the bottom of `root`. */
+export declare function useNearEnd(ref: RefObject<Element | null>, { active, root, onNear, }: {
+    active: boolean;
+    root: HTMLElement | null;
+    onNear: () => void;
+}): void;

package/dist/form/index.js

@@ -1,8 +1,10 @@
 import { AngleRightIcon, EyeIcon, EyeOffIcon, SuccessCheckmark, TrashIcon } from "../icons.js";
-import { a as useSlots, o as useStrings } from "../chunks/Provider-C2VtPnh5.js";
+import { c as useStrings, s as useSlots } from "../chunks/Provider-DvVvScTQ.js";
 import { n as TOOLTIP_ID, r as TooltipInfo } from "../chunks/Tooltip-WgbiC_nd.js";
-import { a as StatusDot, d as CustomListbox, f as Dropdown, g as isCategory, l as UncontrolledCollapsiblePanel, n as Table, o as SectionHeader, r as SwitchToggle, s as ControlledCollapsiblePanel, u as MultiSelectDropdown } from "../chunks/Table-DWuRINhu.js";
+import { a as UncontrolledCollapsiblePanel, c as Dropdown, f as isCategory, n as SectionHeader, o as MultiSelectDropdown, r as ControlledCollapsiblePanel, s as CustomListbox, t as SwitchToggle } from "../chunks/SwitchToggle-2uRw8ZeJ.js";
 import { t as Loader } from "../chunks/Loader-DQiZ75fa.js";
+import { n as StatusDot } from "../chunks/StatusBadge-DXp4zkSd.js";
+import { n as Table } from "../chunks/Table-C5z6qWjM.js";
 import { a as resolvedFlag, c as FieldWrapper, i as initializeValues, n as flattenGroups, o as applySecondaryField, r as impureSetValueFromPath, s as findSecondaryOption, t as enforceOneMustBeTrue } from "../chunks/lib-DTgL8klR.js";
 import cx from "classnames";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";

package/dist/index.d.ts

@@ -16,7 +16,7 @@ export type { MarkdownProps } from './components/Markdown.js';
 export { default as Modal, type ModalProps } from './components/Modal.js';
 export { default as MultiSelectDropdown } from './components/MultiSelect.js';
 export { Overview } from './components/Overview.js';
-export { UIProvider, useNavigation, useNotify, useRunFile, useSlots, useStrings, useWorkflowJsonResolver, type RunFileResult, type WorkflowJsonRef, type UIData, type UINavigation, type UINotify, type UISlots, type UIStrings, } from './components/Provider.js';
+export { UIProvider, useNavigation, useNotify, useProvisionCorsRules, useRunFile, useSlots, useStrings, useWorkflowJsonResolver, type RunFileResult, type WorkflowJsonRef, type UIData, type UINavigation, type UINotify, type UISlots, type UIStrings, } from './components/Provider.js';
 export { Indicator } from './components/Indicator.js';
 export { ControlledCollapsiblePanel, MaybeCollapsible, UncontrolledCollapsiblePanel, } from './components/CollapsiblePanel.js';
 export { default as SectionHeader } from './components/SectionHeader.js';

package/dist/index.js

@@ -1,98 +1,18 @@
 import { DEFAULT_PRESET, THEME_PRESETS, THEME_TOKENS, applyTheme, contrastRatio, deriveTheme, isDarkColor } from "./theme/index.js";
-import { AlertIcon, CheckIcon, ClipboardIcon, CopyIcon, HiddenFalseIcon, HiddenTrueIcon, InfoIcon } from "./icons.js";
-import { a as useSlots, i as useRunFile, n as useNavigation, o as useStrings, r as useNotify, s as useWorkflowJsonResolver, t as UIProvider } from "./chunks/Provider-C2VtPnh5.js";
+import { i as Callout, n as CopyCodeBlock, r as CopyToClipboard, t as Markdown } from "./chunks/Markdown-C5Re2ezs.js";
+import { a as useProvisionCorsRules, c as useStrings, i as useNotify, l as useWorkflowJsonResolver, o as useRunFile, r as useNavigation, s as useSlots, t as UIProvider } from "./chunks/Provider-DvVvScTQ.js";
 import { i as formatTooltipContent, n as TOOLTIP_ID, r as TooltipInfo, t as GlobalTooltip } from "./chunks/Tooltip-WgbiC_nd.js";
-import { _ as isOption, a as StatusDot, c as MaybeCollapsible, d as CustomListbox, f as Dropdown, g as isCategory, h as flattenOptions, i as StatusBadge, l as UncontrolledCollapsiblePanel, m as filterOption, n as Table, o as SectionHeader, p as DropdownCaret, r as SwitchToggle, s as ControlledCollapsiblePanel, t as CompactTable, u as MultiSelectDropdown } from "./chunks/Table-DWuRINhu.js";
+import { a as UncontrolledCollapsiblePanel, c as Dropdown, d as flattenOptions, f as isCategory, i as MaybeCollapsible, l as DropdownCaret, n as SectionHeader, o as MultiSelectDropdown, p as isOption, r as ControlledCollapsiblePanel, s as CustomListbox, t as SwitchToggle, u as filterOption } from "./chunks/SwitchToggle-2uRw8ZeJ.js";
 import { t as Loader } from "./chunks/Loader-DQiZ75fa.js";
-import { n as Modal, t as Indicator } from "./chunks/Indicator-fF8AVbjQ.js";
+import { t as Modal } from "./chunks/Modal-sOUEwebV.js";
+import { t as Indicator } from "./chunks/Indicator-hBSIxOPK.js";
 import { t as SwitchToggleSmall } from "./chunks/SwitchToggleSmall-FcsaYSTs.js";
+import { n as StatusDot, t as StatusBadge } from "./chunks/StatusBadge-DXp4zkSd.js";
+import { n as Table, t as CompactTable } from "./chunks/Table-C5z6qWjM.js";
 import cx from "classnames";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-import React, { Suspense, lazy, useState } from "react";
+import React from "react";
 import Skeleton from "react-loading-skeleton";
-//#region src/components/Callout.tsx
-function CalloutIcon({ type }) {
-	if (type === "warning" || type === "error") return /* @__PURE__ */ jsx(AlertIcon, { className: "h-6 w-6 mr-4 text-lg" });
-	else return /* @__PURE__ */ jsx(InfoIcon, { className: "h-6 w-6 mr-4 text-lg" });
-}
-function Callout({ type, className = "", children }) {
-	return /* @__PURE__ */ jsx("div", {
-		className: cx(className, type === "warning" && "bg-orange-100 border-orange-500 text-orange-700", type === "error" && "bg-red-100 border-red-500 text-red-700", type === "info" && "bg-blue-100 border-blue-500 text-blue-700", "border-t-4 rounded-b px-4 py-3 shadow-md my-4"),
-		role: "alert",
-		children: /* @__PURE__ */ jsxs("div", {
-			className: "flex",
-			children: [/* @__PURE__ */ jsx("div", {
-				className: "py-1",
-				children: /* @__PURE__ */ jsx(CalloutIcon, { type })
-			}), /* @__PURE__ */ jsx("div", { children })]
-		})
-	});
-}
-//#endregion
-//#region src/components/CopyToClipboard.tsx
-function CopyToClipboard({ as = "div", text, className, children, showIcon = true }) {
-	const notify = useNotify();
-	const handleCopy = async () => {
-		try {
-			await navigator.clipboard.writeText(text);
-			notify.info("Copied to clipboard");
-		} catch {
-			notify.error("Failed to copy to clipboard");
-		}
-	};
-	return /* @__PURE__ */ jsxs(as, {
-		className,
-		onClick: handleCopy,
-		...as === "button" ? { type: "button" } : {},
-		children: [showIcon && /* @__PURE__ */ jsx(ClipboardIcon, {}), children]
-	});
-}
-function CopyCodeBlock({ textToCopy, children, secret = false, isRevealed = false, onRevealToggle }) {
-	const notify = useNotify();
-	const [copied, setCopied] = useState(false);
-	const handleCopy = async () => {
-		if (copied) return;
-		try {
-			await navigator.clipboard.writeText(textToCopy);
-			setCopied(true);
-			notify.info("Copied to clipboard");
-			setTimeout(() => setCopied(false), 2e3);
-		} catch {
-			notify.error("Failed to copy to clipboard");
-		}
-	};
-	return /* @__PURE__ */ jsxs("div", {
-		className: "group relative",
-		onClick: handleCopy,
-		children: [/* @__PURE__ */ jsx("pre", {
-			className: `p-4 theme-hover border rounded-lg text-left font-mono text-sm overflow-x-auto ${secret ? "pr-24" : "pr-12"}`,
-			children
-		}), /* @__PURE__ */ jsxs("div", {
-			className: "absolute top-0 right-0 bottom-0 flex items-center gap-1 pl-8 pr-2 bg-gradient-to-l from-[var(--color-panel)] from-70% to-transparent rounded-r-lg",
-			children: [secret && /* @__PURE__ */ jsx("button", {
-				type: "button",
-				onClick: (e) => {
-					e.stopPropagation();
-					onRevealToggle?.();
-				},
-				className: "p-2 rounded-md opacity-0 group-hover:opacity-100 transition-all duration-150",
-				"aria-label": isRevealed ? "Hide secret" : "Reveal secret",
-				title: isRevealed ? "Hide secret" : "Reveal secret",
-				children: isRevealed ? /* @__PURE__ */ jsx(HiddenFalseIcon, {}) : /* @__PURE__ */ jsx(HiddenTrueIcon, {})
-			}), /* @__PURE__ */ jsx("button", {
-				type: "button",
-				onClick: (e) => {
-					e.stopPropagation();
-					handleCopy();
-				},
-				className: "p-2 rounded-md opacity-0 group-hover:opacity-100 transition-all duration-150",
-				"aria-label": copied ? "Copied" : "Copy to clipboard",
-				children: copied ? /* @__PURE__ */ jsx(CheckIcon, { className: "text-green-400" }) : /* @__PURE__ */ jsx(CopyIcon, {})
-			})]
-		})]
-	});
-}
-//#endregion
 //#region src/components/DescriptionList.tsx
 function DescriptionListItem({ label, children, tooltip, className, ...props }) {
 	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsxs("dt", {
@@ -155,18 +75,6 @@ function EmptyState({ title, description, action, icon: Icon }) {
 	});
 }
 //#endregion
-//#region src/components/Markdown.tsx
-var MarkdownImpl = lazy(() => import("./chunks/MarkdownImpl-Bq4QhrtA.js"));
-function Markdown(props) {
-	return /* @__PURE__ */ jsx(Suspense, {
-		fallback: /* @__PURE__ */ jsx("div", {
-			className: "markdown whitespace-pre-wrap text-start w-full",
-			children: props.children
-		}),
-		children: /* @__PURE__ */ jsx(MarkdownImpl, { ...props })
-	});
-}
-//#endregion
 //#region src/components/Overview.tsx
 function Overview({ Icon, name, type, children, right, className, loading, iconSize = 75 }) {
 	return /* @__PURE__ */ jsxs("div", {
@@ -202,4 +110,4 @@ function Overview({ Icon, name, type, children, right, className, loading, iconS
 	});
 }
 //#endregion
-export { Callout, CompactTable, ControlledCollapsiblePanel, CopyCodeBlock, CopyToClipboard, CustomListbox, DEFAULT_PRESET, DescriptionList, DescriptionListItem, Dropdown, DropdownCaret, EmptyState, GlobalTooltip, Indicator, Loader, Markdown, MaybeCollapsible, Modal, MultiSelectDropdown, Overview, SectionHeader, StatusBadge, StatusDot, SwitchToggle, SwitchToggleSmall, THEME_PRESETS, THEME_TOKENS, TOOLTIP_ID, Table, TooltipInfo, UIProvider, UncontrolledCollapsiblePanel, applyTheme, contrastRatio, deriveTheme, filterOption, flattenOptions, formatTooltipContent, isCategory, isDarkColor, isOption, useNavigation, useNotify, useRunFile, useSlots, useStrings, useWorkflowJsonResolver };
+export { Callout, CompactTable, ControlledCollapsiblePanel, CopyCodeBlock, CopyToClipboard, CustomListbox, DEFAULT_PRESET, DescriptionList, DescriptionListItem, Dropdown, DropdownCaret, EmptyState, GlobalTooltip, Indicator, Loader, Markdown, MaybeCollapsible, Modal, MultiSelectDropdown, Overview, SectionHeader, StatusBadge, StatusDot, SwitchToggle, SwitchToggleSmall, THEME_PRESETS, THEME_TOKENS, TOOLTIP_ID, Table, TooltipInfo, UIProvider, UncontrolledCollapsiblePanel, applyTheme, contrastRatio, deriveTheme, filterOption, flattenOptions, formatTooltipContent, isCategory, isDarkColor, isOption, useNavigation, useNotify, useProvisionCorsRules, useRunFile, useSlots, useStrings, useWorkflowJsonResolver };

package/dist/list/ListTable.d.ts

@@ -0,0 +1,63 @@
+import type { MouseEvent as ReactMouseEvent, ReactNode } from 'react';
+/** table-auto + horizontal scroll; the name column has a min-width floor so it can't be crushed. */
+export declare const listTableProps: {
+    readonly borderless: true;
+    readonly panel: false;
+    readonly rounded: false;
+    readonly theadClassName: 'text-(--theme-muted-text-color)';
+    readonly tbodyClassName: 'divide-y border-b border-(--theme-border) divide-(--theme-border)';
+    readonly className: 'table-auto w-full [&_td:first-child]:pl-4 [&_th:first-child]:pl-4 [&_td:last-child]:pr-4 [&_th:last-child]:pr-4';
+};
+/** Widths come only from the header row, so a windowed body cannot shift the
+ *  columns as different content scrolls into view. */
+export declare const listTableFixedProps: {
+    readonly borderless: true;
+    readonly panel: false;
+    readonly rounded: false;
+    readonly theadClassName: 'text-(--theme-muted-text-color)';
+    readonly tbodyClassName: 'divide-y border-b border-(--theme-border) divide-(--theme-border)';
+    readonly className: string;
+};
+export declare function NameCell({ icon, name, subtitle, href, }: {
+    icon: ReactNode;
+    name: string;
+    subtitle?: string;
+    href: string | null;
+}): import("react").JSX.Element;
+export declare function GroupRow({ label, count, colSpan, }: {
+    label: string;
+    count: number;
+    colSpan: number;
+}): import("react").JSX.Element;
+export declare function ListError({ error, noun, }: {
+    error: unknown;
+    noun?: string;
+}): import("react").JSX.Element;
+export declare function ListSkeleton({ rows }: {
+    rows?: number;
+}): import("react").JSX.Element;
+/** Prevents the name column from being crushed under table-auto layout during horizontal overflow. */
+export declare const NAME_MIN_WIDTH_PX = 200;
+/** Width the trailing actions column reserves for `count` always-visible
+ * buttons plus the hover `⋯` trigger. */
+export declare function actionsColumnWidth(count: number): number;
+/** Shared leading selection checkbox for multi-select rows: stops the row-click
+ * and suppresses shift-click text selection. Wrap in <Table.Item> for `leading`. */
+export declare function RowSelectCheckbox({ checked, label, onToggle, }: {
+    checked: boolean;
+    label: string;
+    onToggle: (e: ReactMouseEvent) => void;
+}): import("react").JSX.Element;
+/** Sizes to fit pinned buttons + ⋯; below ~44rem only ⋯ remains. Pass a view's
+ * chrome (structurally: showActions + actionsWidth) or actionCount. */
+export declare function ListActionsHeader({ view, actionCount, className, }: {
+    view?: {
+        showActions: boolean;
+        actionsWidth: number;
+    };
+    actionCount?: number;
+    className?: string;
+}): import("react").JSX.Element | null;
+export declare namespace ListActionsHeader {
+    var isTableHeader: boolean;
+}

package/dist/list/RowContextMenu.d.ts

@@ -0,0 +1,113 @@
+import type { ComponentType, MouseEvent as ReactMouseEvent, ReactNode } from 'react';
+export type RowMenuItem = {
+    kind: 'link';
+    label: string;
+    to: string;
+    icon?: ReactNode;
+    destructive?: boolean;
+} | {
+    kind: 'action';
+    label: string;
+    onSelect?: () => void;
+    icon?: ReactNode;
+    destructive?: boolean;
+    disabled?: boolean;
+    /** Trailing checkmark, e.g. the active option in a radio-style submenu. */
+    selected?: boolean;
+    /** Declarative clipboard copy: the menu performs it and notifies, so
+     * builders like copySubmenu need no toast or clipboard access. */
+    copy?: {
+        text: string;
+        label: string;
+    };
+} | {
+    kind: 'submenu';
+    label: string;
+    icon?: ReactNode;
+    items: RowMenuItem[];
+} | {
+    kind: 'divider';
+};
+export type OpenMenu = (x: number, y: number, items: RowMenuItem[], onClose?: () => void) => void;
+/** The shared shape every entity action hook's per-row actions boil down to.
+ * Each hook's bespoke `*RowAction` type is structurally assignable to this. */
+export interface RowAction {
+    key: string;
+    label: string;
+    icon: ReactNode;
+    onSelect?: () => void;
+    to?: string;
+    disabled?: boolean;
+    destructive?: boolean;
+}
+/** Converts a single row action to a menu item: a `to` makes it a link, otherwise an action. */
+export declare function toRowMenuItem(action: RowAction): RowMenuItem;
+/** Bridges a toolbar action (icon component, `onClick`/`href`) onto the shared
+ * `RowAction` shape. Typed structurally so any toolbar action shape matching
+ * these fields is assignable. */
+export declare function toolbarActionToRowAction(action: {
+    key: string;
+    label: string;
+    icon: ComponentType<{
+        className?: string;
+    }>;
+    onClick?: () => void;
+    href?: string;
+    disabled?: boolean;
+}): RowAction;
+/** Assembles a row's context menu in the shared order: leading link(s) → middle
+ * actions → extra items → Copy submenu → trailing (destructive) actions last. */
+export declare function assembleRowMenu({ lead, actions, exclude, order, trailing, extra, copy, }: {
+    /** Pre-built leading link(s), e.g. "View details". */
+    lead?: RowMenuItem[];
+    /** The row's full action list. */
+    actions: RowAction[];
+    /** Keys already rendered in `lead`/`extra`; dropped from the middle. */
+    exclude?: string[];
+    /** Explicit middle order; keys absent from `actions` are skipped, keys absent from `order` are dropped. */
+    order?: string[];
+    /** Keys rendered last, in this order (default `['delete']`). */
+    trailing?: string[];
+    /** Items inserted after the middle actions and before Copy, e.g. a marketplace link. */
+    extra?: RowMenuItem[];
+    /** The Copy submenu from `copySubmenu(...)`. */
+    copy?: RowMenuItem;
+}): RowMenuItem[];
+export declare function useRowMenu(): {
+    openMenu: OpenMenu;
+    contextMenu: import("react").JSX.Element;
+};
+/** The full-screen menu overlay drops CSS :hover on the triggering row; wrap openMenu here to substitute a JS-driven `active` highlight. */
+export declare function useRowMenuActive(openMenu: OpenMenu): {
+    active: boolean;
+    openMenu: OpenMenu;
+};
+export declare function rowContextMenuProps(openMenu: OpenMenu, items: RowMenuItem[]): {
+    onContextMenu: (e: ReactMouseEvent) => void;
+};
+/** Builds the Copy submenu entries for whichever fields a row has, in stable
+ * order. The menu itself performs the copy and notifies; `t` is an optional
+ * host translator for the field labels (falls back to the provider defaults'
+ * English). */
+export declare function copySubmenu({ name, nameLabel, email, username, uid, id, url, extra, t, }: {
+    name?: string | null;
+    /** Overrides the "name" label (raw, pre-translated) for entities whose primary field isn't a name, e.g. "domain". */
+    nameLabel?: string;
+    email?: string | null;
+    username?: string | null;
+    uid?: string | number | null;
+    id?: string | null;
+    url?: string | null;
+    extra?: {
+        label: string;
+        value?: string | null;
+        icon?: ReactNode;
+    }[];
+    t?: (key: string, values?: Record<string, string | number>) => string;
+}): RowMenuItem;
+/** Stays visible while active (menu open) so it doesn't vanish behind the overlay. */
+export declare function MoreButton({ onOpen, active, className, }: {
+    onOpen: (x: number, y: number) => void;
+    active?: boolean;
+    className?: string;
+}): import("react").JSX.Element;