@flanksource/clicky-ui 0.3.39 → 0.3.41

package/dist/icons/registry.d.ts

@@ -1,5 +1,5 @@
 import { ComponentType } from 'react';
-import { FallbackIconComponent } from '../data/icon-fallback';
+import { FallbackIconComponent } from '../data/icon-fallback.js';
 type NamedIcon = ComponentType<{
     size?: string | number;
     className?: string;

package/dist/icons.d.ts

@@ -1,2 +1,2 @@
-export * from './icons/index';
+export * from './icons/index.js';
 //# sourceMappingURL=icons.d.ts.map

package/dist/index.cjs

@@ -21,6 +21,8 @@ const useDensity = require("./hooks/use-density.cjs");
 const densityProvider = require("./hooks/density-provider.cjs");
 const useSort = require("./hooks/use-sort.cjs");
 const useHistoryRoute = require("./hooks/use-history-route.cjs");
+const eventSource = require("./hooks/event-source.cjs");
+const eventSourceProvider = require("./hooks/event-source-provider.cjs");
 const useTaskRun = require("./hooks/use-task-run.cjs");
 const usePrompts = require("./hooks/use-prompts.cjs");
 const useHotkey = require("./hooks/use-hotkey.cjs");
@@ -91,6 +93,7 @@ const formLookupContext = require("./components/form-lookup-context.cjs");
 const jsonSchemaFormSize = require("./components/json-schema-form-size.cjs");
 const jsonSchemaFormPreferences = require("./components/json-schema-form-preferences.cjs");
 const jsonSchemaFormResolve = require("./components/json-schema-form-resolve.cjs");
+const jsonSchemaFormConditionals = require("./components/json-schema-form-conditionals.cjs");
 const jsonSchemaFormRefs = require("./components/json-schema-form-refs.cjs");
 const jsonSchemaFormTemplate = require("./components/json-schema-form-template.cjs");
 const jsonSchemaFormExtensions = require("./components/json-schema-form-extensions.cjs");
@@ -245,6 +248,7 @@ const CommentFilterBar = require("./comments/CommentFilterBar.cjs");
 const CommentProgress = require("./comments/CommentProgress.cjs");
 const Clicky = require("./data/Clicky.cjs");
 const OperationCatalog = require("./rpc/OperationCatalog.cjs");
+const OperationEntityPicker = require("./rpc/OperationEntityPicker.cjs");
 const SessionsCatalog = require("./rpc/SessionsCatalog.cjs");
 const SessionHeader = require("./rpc/SessionHeader.cjs");
 const useSession = require("./rpc/useSession.cjs");
@@ -978,6 +982,8 @@ exports.DensityProvider = densityProvider.DensityProvider;
 exports.DensityValueProvider = densityProvider.DensityValueProvider;
 exports.useSort = useSort.useSort;
 exports.useHistoryRoute = useHistoryRoute.useHistoryRoute;
+exports.useEventSourceFactory = eventSource.useEventSourceFactory;
+exports.EventSourceProvider = eventSourceProvider.EventSourceProvider;
 exports.useTaskRun = useTaskRun.useTaskRun;
 exports.useTaskRuns = useTaskRun.useTaskRuns;
 exports.answerPrompt = usePrompts.answerPrompt;
@@ -1083,10 +1089,10 @@ exports.DEFAULT_FORM_SIZE = jsonSchemaFormSize.DEFAULT_FORM_SIZE;
 exports.DEFAULT_PREFERENCES_STORAGE_KEY = jsonSchemaFormPreferences.DEFAULT_PREFERENCES_STORAGE_KEY;
 exports.readPreferences = jsonSchemaFormPreferences.readPreferences;
 exports.writePreferences = jsonSchemaFormPreferences.writePreferences;
-exports.effectiveProperties = jsonSchemaFormResolve.effectiveProperties;
 exports.isOpenStringMap = jsonSchemaFormResolve.isOpenStringMap;
-exports.matchesIf = jsonSchemaFormResolve.matchesIf;
 exports.resolveControl = jsonSchemaFormResolve.resolveControl;
+exports.effectiveProperties = jsonSchemaFormConditionals.effectiveProperties;
+exports.matchesIf = jsonSchemaFormConditionals.matchesIf;
 exports.rehydrateRefs = jsonSchemaFormRefs.rehydrateRefs;
 exports.templateValuePre = jsonSchemaFormTemplate.templateValuePre;
 exports.applyPostExtensions = jsonSchemaFormExtensions.applyPostExtensions;
@@ -1381,6 +1387,7 @@ exports.Clicky = Clicky.Clicky;
 exports.ClickyNodeView = Clicky.ClickyNodeView;
 exports.ClickyTable = Clicky.ClickyTable;
 exports.OperationCatalog = OperationCatalog.OperationCatalog;
+exports.OperationEntityPicker = OperationEntityPicker.OperationEntityPicker;
 exports.SESSIONS_SURFACE_KEY = SessionsCatalog.SESSIONS_SURFACE_KEY;
 exports.SessionsCatalog = SessionsCatalog.SessionsCatalog;
 exports.SessionHeader = SessionHeader.SessionHeader;

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export * from './utils';
-export * from './hooks';
-export * from './components';
-export * from './data';
-export * from './comments';
-export * from './clicky';
-export * from './rpc';
+export * from './utils.js';
+export * from './hooks.js';
+export * from './components.js';
+export * from './data.js';
+export * from './comments.js';
+export * from './clicky.js';
+export * from './rpc.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -19,6 +19,8 @@ import { useDensity, useDensityValue } from "./hooks/use-density.js";
 import { DensityProvider, DensityValueProvider } from "./hooks/density-provider.js";
 import { useSort } from "./hooks/use-sort.js";
 import { useHistoryRoute } from "./hooks/use-history-route.js";
+import { useEventSourceFactory } from "./hooks/event-source.js";
+import { EventSourceProvider } from "./hooks/event-source-provider.js";
 import { useTaskRun, useTaskRuns } from "./hooks/use-task-run.js";
 import { answerPrompt, usePrompts } from "./hooks/use-prompts.js";
 import { formatHotkey, parseHotkey, useHotkey } from "./hooks/use-hotkey.js";
@@ -88,7 +90,8 @@ import { FormLookupProvider } from "./components/FormLookupProvider.js";
 import { resolveLookupScope, useLookupFetcher } from "./components/form-lookup-context.js";
 import { DEFAULT_FORM_SIZE } from "./components/json-schema-form-size.js";
 import { DEFAULT_PREFERENCES_STORAGE_KEY, readPreferences, writePreferences } from "./components/json-schema-form-preferences.js";
-import { effectiveProperties, isOpenStringMap, matchesIf, resolveControl } from "./components/json-schema-form-resolve.js";
+import { isOpenStringMap, resolveControl } from "./components/json-schema-form-resolve.js";
+import { effectiveProperties, matchesIf } from "./components/json-schema-form-conditionals.js";
 import { rehydrateRefs } from "./components/json-schema-form-refs.js";
 import { templateValuePre } from "./components/json-schema-form-template.js";
 import { applyPostExtensions } from "./components/json-schema-form-extensions.js";
@@ -243,6 +246,7 @@ import { CommentFilterBar } from "./comments/CommentFilterBar.js";
 import { CommentProgress } from "./comments/CommentProgress.js";
 import { Clicky, ClickyNodeView, ClickyTable } from "./data/Clicky.js";
 import { OperationCatalog } from "./rpc/OperationCatalog.js";
+import { OperationEntityPicker } from "./rpc/OperationEntityPicker.js";
 import { SESSIONS_SURFACE_KEY, SessionsCatalog } from "./rpc/SessionsCatalog.js";
 import { SessionHeader } from "./rpc/SessionHeader.js";
 import { SESSION_POLL_MS, useSession } from "./rpc/useSession.js";
@@ -980,6 +984,7 @@ export {
   EntityExplorerApp,
   ErrorDetails,
   ErrorWrapper,
+  EventSourceProvider,
   ExecutionTree,
   Field,
   FieldErrorText,
@@ -1052,6 +1057,7 @@ export {
   OperationCommandPage,
   OperationEntityContextPicker,
   OperationEntityPage,
+  OperationEntityPicker,
   OperationPicker,
   OperationResultView,
   OperationScheduleDialog,
@@ -2549,6 +2555,7 @@ export {
   useDensity,
   useDensityValue,
   useEscapeLayer,
+  useEventSourceFactory,
   useFloatingZIndex,
   useForm,
   useHistoryRoute,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/jotai.d.ts

@@ -1,4 +1,4 @@
-export { JotaiFilterBar, JotaiJsonSchemaForm, } from './components/jotai-bindings';
-export { useJotaiFilterBarProps, useJotaiJsonSchemaFormProps, } from './components/jotai-bindings-core';
-export type { JotaiFilterBarBooleanFilter, JotaiFilterBarDurationFilter, JotaiFilterBarEnumFilter, JotaiFilterBarFilter, JotaiFilterBarLookupFilter, JotaiFilterBarLookupMultiFilter, JotaiFilterBarMultiFilter, JotaiFilterBarNestedMultiFilter, JotaiFilterBarNumberFilter, JotaiFilterBarProps, JotaiFilterBarRangeProps, JotaiFilterBarRangeValue, JotaiFilterBarSearchProps, JotaiFilterBarSelectMultiFilter, JotaiFilterBarTextFilter, JotaiFilterBarWorkloadFilter, JotaiJsonSchemaFormAtom, JotaiJsonSchemaFormProps, JotaiWritableAtom, } from './components/jotai-bindings-core';
+export { JotaiFilterBar, JotaiJsonSchemaForm, } from './components/jotai-bindings.js';
+export { useJotaiFilterBarProps, useJotaiJsonSchemaFormProps, } from './components/jotai-bindings-core.js';
+export type { JotaiFilterBarBooleanFilter, JotaiFilterBarDurationFilter, JotaiFilterBarEnumFilter, JotaiFilterBarFilter, JotaiFilterBarLookupFilter, JotaiFilterBarLookupMultiFilter, JotaiFilterBarMultiFilter, JotaiFilterBarNestedMultiFilter, JotaiFilterBarNumberFilter, JotaiFilterBarProps, JotaiFilterBarRangeProps, JotaiFilterBarRangeValue, JotaiFilterBarSearchProps, JotaiFilterBarSelectMultiFilter, JotaiFilterBarTextFilter, JotaiFilterBarWorkloadFilter, JotaiJsonSchemaFormAtom, JotaiJsonSchemaFormProps, JotaiWritableAtom, } from './components/jotai-bindings-core.js';
 //# sourceMappingURL=jotai.d.ts.map

package/dist/layout/AppShell.d.ts

@@ -1,8 +1,8 @@
 import { ReactNode } from 'react';
-import { StaticIconComponent } from '../data/Icon';
-import { DropdownMenuItem } from '../overlay/DropdownMenu';
-import { AppShellNavDrag } from './AppShell.nav.drag';
-import { ContentWidth } from './content-width';
+import { StaticIconComponent } from '../data/Icon.js';
+import { DropdownMenuItem } from '../overlay/DropdownMenu.js';
+import { AppShellNavDrag } from './AppShell.nav.drag.js';
+import { ContentWidth } from './content-width.js';
 export type AppShellNavItem = {
     /** Stable key; also the React key. */
     key: string;

package/dist/layout/AppShell.nav.d.ts

@@ -1,4 +1,4 @@
-import { AppShellNavSection } from './AppShell';
+import { AppShellNavSection } from './AppShell.js';
 export interface GroupState {
     isCollapsed: (key: string, fallback: boolean) => boolean;
     toggle: (key: string, fallback: boolean) => void;

package/dist/layout/AppSidebar.d.ts

@@ -1,6 +1,6 @@
 import { ReactNode } from 'react';
-import { RenderLink } from '../rpc/EndpointList';
-import { ContentWidth } from './content-width';
+import { RenderLink } from '../rpc/EndpointList.js';
+import { ContentWidth } from './content-width.js';
 export interface AppNavItem {
     /** Stable key; also used as the React key. */
     key: string;

package/dist/layout/Panel.d.ts

@@ -1,7 +1,7 @@
 import { ReactNode } from 'react';
-import { StaticIconComponent } from '../data/Icon';
-import { PanelTone } from './PanelFrame';
-export type { PanelTone } from './PanelFrame';
+import { StaticIconComponent } from '../data/Icon.js';
+import { PanelTone } from './PanelFrame.js';
+export type { PanelTone } from './PanelFrame.js';
 export type PanelProps = {
     /** Header title. Omit (with no icon/count/actions) to render a headerless card. */
     title?: ReactNode;

package/dist/layout/Section.d.ts

@@ -1,6 +1,6 @@
 import { ReactNode } from 'react';
-import { StaticIconComponent } from '../data/Icon';
-import { PanelTone } from './PanelFrame';
+import { StaticIconComponent } from '../data/Icon.js';
+import { PanelTone } from './PanelFrame.js';
 export type SectionProps = {
     /** Header title. */
     title: ReactNode;

package/dist/layout/Tabs.d.ts

@@ -1,6 +1,6 @@
 import { ReactNode } from 'react';
-import { TabButtonVariant } from '../data/TabButton';
-import { StaticIconComponent } from '../data/Icon';
+import { TabButtonVariant } from '../data/TabButton.js';
+import { StaticIconComponent } from '../data/Icon.js';
 export type TabItem = {
     /** Stable id; also the value compared against the selected `value`. */
     id: string;

package/dist/layout/Workspace.d.ts

@@ -1,6 +1,6 @@
 import { ReactNode } from 'react';
-import { WorkspaceLayoutDefaults, WorkspaceLayoutState, WorkspacePaneSpec } from './Workspace.model';
-export type { WorkspaceLayoutDefaults, WorkspaceLayoutState, WorkspacePaneLocation, WorkspacePaneSlots, WorkspacePaneSpec, WorkspaceSideLocation, } from './Workspace.model';
+import { WorkspaceLayoutDefaults, WorkspaceLayoutState, WorkspacePaneSpec } from './Workspace.model.js';
+export type { WorkspaceLayoutDefaults, WorkspaceLayoutState, WorkspacePaneLocation, WorkspacePaneSlots, WorkspacePaneSpec, WorkspaceSideLocation, } from './Workspace.model.js';
 export type WorkspaceSlots = {
     topRightActions?: ReactNode;
 };

package/dist/layout/Workspace.regions.d.ts

@@ -1,4 +1,4 @@
-import { WorkspaceLayoutState, WorkspacePaneSpec } from './Workspace.model';
+import { WorkspaceLayoutState, WorkspacePaneSpec } from './Workspace.model.js';
 export type WorkspaceUpdate = (change: (current: WorkspaceLayoutState) => WorkspaceLayoutState) => void;
 type SideRegionProps = {
     location: "left" | "right";

package/dist/lib/combobox-values.d.ts

@@ -1,5 +1,5 @@
 import { CSSProperties, ReactNode } from 'react';
-import { ComboboxOption } from '../components/combobox-types';
+import { ComboboxOption } from '../components/combobox-types.js';
 export declare function comboboxLabelPadding(label: ReactNode, measuredWidth: number): CSSProperties;
 export declare function withSelectedComboboxOptions(options: ComboboxOption[], selectedValues: string[]): ComboboxOption[];
 export declare function multipleComboboxLabel(options: ComboboxOption[], selectedValues: string[]): string;

package/dist/lib/comment-stage.d.ts

@@ -1,4 +1,4 @@
-import { Comment, CommentConfig, CommentStatusConfig, CommentStatusStage } from '../comments/comment-types';
+import { Comment, CommentConfig, CommentStatusConfig, CommentStatusStage } from '../comments/comment-types.js';
 /** Resolves a stored status to its lifecycle stage. */
 export declare function resolveCommentStage(config: CommentConfig, status: string | undefined): CommentStatusStage | undefined;
 /** Returns the first configured stored status for a lifecycle stage. */

package/dist/lib/permission-strategies.d.ts

@@ -1,5 +1,5 @@
-import { MatchPatterns, PermissionRule } from '../data/chat/tool-policy';
-import { ToolMeta } from '../data/chat/types';
+import { MatchPatterns, PermissionRule } from '../data/chat/tool-policy.js';
+import { ToolMeta } from '../data/chat/types.js';
 export declare const PATTERN_FIELDS: readonly ["name", "group", "parent", "entity", "action", "verb", "method", "scope"];
 export declare const HINT_FIELDS: readonly ["readOnly", "destructive", "idempotent"];
 export declare const MATCH_FIELDS: readonly ["name", "group", "parent", "entity", "action", "verb", "method", "scope", "readOnly", "destructive", "idempotent"];

package/dist/lib/runtime-profile-model.d.ts

@@ -1,7 +1,7 @@
-import { SpecRuntimeFamily } from '../data/runtime/runtime-mode';
-import { RuntimePreset, RuntimeProfile } from '../data/ai/runtime-profile';
-import { AISpecRuntimeSpec } from '../data/ai/SpecRuntimeEditor.model';
-import { RuntimePermissionTarget } from '../data/ai/runtime-profiles/types';
+import { SpecRuntimeFamily } from '../data/runtime/runtime-mode.js';
+import { RuntimePreset, RuntimeProfile } from '../data/ai/runtime-profile.js';
+import { AISpecRuntimeSpec } from '../data/ai/SpecRuntimeEditor.model.js';
+import { RuntimePermissionTarget } from '../data/ai/runtime-profiles/types.js';
 export declare function reorderProfilePresets(profile: RuntimeProfile, from: number, to: number): RuntimeProfile;
 export declare function presetForRef(ref: string, presets: RuntimePreset[]): RuntimePreset | undefined;
 export declare function presetsOf(profile: Pick<RuntimeProfile, "presets">, presets: RuntimePreset[]): {

package/dist/lib/size.d.ts

@@ -1,4 +1,4 @@
-import { Density } from '../hooks/use-density';
+import { Density } from '../hooks/use-density.js';
 export type SizeToken = "xs" | "sm" | "md" | "lg" | "xl";
 export declare const SIZE_TOKENS: SizeToken[];
 export declare function resolveSize(size: SizeToken, density?: Density): number;

package/dist/mdx-editor.d.ts

@@ -1,5 +1,5 @@
-export { MdxEditorField, type MdxEditorAdmonitionOptions, type MdxEditorCalloutOptions, type MdxEditorCodeBlockEditorContext, type MdxEditorCodeBlockEditorDescriptor, type MdxEditorCodeBlockEditorProps, type MdxEditorCodeBlockLanguage, type MdxEditorCodeBlockOptions, type MdxEditorCodeMirrorOptions, type MdxEditorDiffModeOptions, type MdxEditorFieldProps, type MdxEditorHeadingLevel, type MdxEditorImageOptions, type MdxEditorImagePreviewHandler, type MdxEditorImageUploadHandler, type MdxEditorJsxAttribute, type MdxEditorJsxComponentDescriptor, type MdxEditorJsxEditorProps, type MdxEditorJsxNode, type MdxEditorLinkOptions, type MdxEditorPlugin, type MdxEditorInsertJsx, type MdxEditorPluginOptions, type MdxEditorRuntime, type MdxEditorToolbarOptions, type MdxEditorViewMode, } from './components/MdxEditorField';
-export { CALLOUT_JSX_NAME, calloutJsxDescriptor, calloutToolbarButton, } from './components/mdx-editor-callout';
-export { CALLOUT_ATTRIBUTE_OPTIONS, CALLOUT_ATTRIBUTES, CALLOUT_JSX_PROPS, readCalloutAttributes, type CalloutAttribute, } from './components/mdx-editor-callout-model';
-export { readJsxAttributes, writeJsxAttribute, } from './components/mdx-editor-jsx-attributes';
+export { MdxEditorField, type MdxEditorAdmonitionOptions, type MdxEditorCalloutOptions, type MdxEditorCodeBlockEditorContext, type MdxEditorCodeBlockEditorDescriptor, type MdxEditorCodeBlockEditorProps, type MdxEditorCodeBlockLanguage, type MdxEditorCodeBlockOptions, type MdxEditorCodeMirrorOptions, type MdxEditorDiffModeOptions, type MdxEditorFieldProps, type MdxEditorHeadingLevel, type MdxEditorImageOptions, type MdxEditorImagePreviewHandler, type MdxEditorImageUploadHandler, type MdxEditorJsxAttribute, type MdxEditorJsxComponentDescriptor, type MdxEditorJsxEditorProps, type MdxEditorJsxNode, type MdxEditorLinkOptions, type MdxEditorPlugin, type MdxEditorInsertJsx, type MdxEditorPluginOptions, type MdxEditorRuntime, type MdxEditorToolbarOptions, type MdxEditorViewMode, } from './components/MdxEditorField.js';
+export { CALLOUT_JSX_NAME, calloutJsxDescriptor, calloutToolbarButton, } from './components/mdx-editor-callout.js';
+export { CALLOUT_ATTRIBUTE_OPTIONS, CALLOUT_ATTRIBUTES, CALLOUT_JSX_PROPS, readCalloutAttributes, type CalloutAttribute, } from './components/mdx-editor-callout-model.js';
+export { readJsxAttributes, writeJsxAttribute, } from './components/mdx-editor-jsx-attributes.js';
 //# sourceMappingURL=mdx-editor.d.ts.map

package/dist/monaco/MonacoEditor.cjs

@@ -27,6 +27,7 @@ Editor.loader.config({ monaco: monacoEditor__namespace });
 function MonacoEditor({
   value,
   onChange,
+  readOnly = false,
   language,
   path,
   height = "20rem",
@@ -34,6 +35,7 @@ function MonacoEditor({
   onMount,
   onValidate
 }) {
+  if (!readOnly && !onChange) throw new Error("MonacoEditor requires onChange when editing");
   const workers = useMonacoWorker.useMonacoWorkerFactory();
   const theme = useTheme.useResolvedTheme() === "dark" ? "vs-dark" : "light";
   const latestValue = react.useRef(value);
@@ -45,7 +47,7 @@ function MonacoEditor({
     Editor,
     {
       value,
-      onChange: (next) => onChange(next ?? ""),
+      onChange: (next) => onChange == null ? void 0 : onChange(next ?? ""),
       language,
       path,
       height,
@@ -58,6 +60,7 @@ function MonacoEditor({
       },
       ...onValidate ? { onValidate } : {},
       options: {
+        readOnly,
         automaticLayout: true,
         fontFamily: "var(--font-mono, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace)",
         fontSize: 13,

package/dist/monaco/MonacoEditor.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"MonacoEditor.cjs","sources":["../../src/monaco/MonacoEditor.tsx"],"sourcesContent":["import Editor, { loader, type Monaco } from \"@monaco-editor/react\";\nimport * as monaco from \"monaco-editor\";\nimport { useRef } from \"react\";\nimport { useResolvedTheme } from \"../hooks/use-theme\";\nimport { useMonacoWorkerFactory } from \"./use-monaco-worker\";\nimport type { MonacoEditorProps } from \"./types\";\n\nloader.config({ monaco });\n\nexport function MonacoEditor({\n  value,\n  onChange,\n  language,\n  path,\n  height = \"20rem\",\n  beforeMount,\n  onMount,\n  onValidate,\n}: MonacoEditorProps) {\n  const workers = useMonacoWorkerFactory();\n  const theme = useResolvedTheme() === \"dark\" ? \"vs-dark\" : \"light\";\n  // @monaco-editor/react keeps the first onMount it sees, so read the value at\n  // mount time through a ref rather than that render's closure.\n  const latestValue = useRef(value);\n  latestValue.current = value;\n\n  if (!workers) {\n    return <div role=\"alert\" className=\"rounded-md border border-destructive/40 p-3 text-sm text-destructive\">Monaco workers are not configured.</div>;\n  }\n\n  return (\n    <div className=\"overflow-hidden rounded-md border border-input\" data-slot=\"monaco-editor\">\n      <Editor\n        value={value}\n        onChange={(next) => onChange(next ?? \"\")}\n        language={language}\n        path={path}\n        height={height}\n        theme={theme}\n        keepCurrentModel\n        {...(beforeMount ? { beforeMount } : {})}\n        onMount={(instance, monacoInstance) => {\n          // keepCurrentModel remounts onto the model already at `path`, which\n          // still holds the text from when the previous editor unmounted.\n          if (instance.getValue() !== latestValue.current) instance.setValue(latestValue.current);\n          onMount?.(instance, monacoInstance);\n        }}\n        {...(onValidate ? { onValidate } : {})}\n        options={{\n          automaticLayout: true,\n          fontFamily: \"var(--font-mono, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace)\",\n          fontSize: 13,\n          lineHeight: 20,\n          minimap: { enabled: false },\n          scrollBeyondLastLine: false,\n          tabSize: 2,\n          wordWrap: \"on\",\n          quickSuggestions: { other: true, comments: true, strings: true },\n        }}\n      />\n    </div>\n  );\n}\n\nexport type { Monaco };\n"],"names":["loader","monaco","useMonacoWorkerFactory","useResolvedTheme","useRef","jsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAOAA,OAAAA,OAAO,OAAO,EAAA,QAAEC,yBAAQ;AAEjB,SAAS,aAAa;AAAA,EAC3B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,SAAS;AAAA,EACT;AAAA,EACA;AAAA,EACA;AACF,GAAsB;AACpB,QAAM,UAAUC,gBAAAA,uBAAA;AAChB,QAAM,QAAQC,SAAAA,iBAAA,MAAuB,SAAS,YAAY;AAG1D,QAAM,cAAcC,MAAAA,OAAO,KAAK;AAChC,cAAY,UAAU;AAEtB,MAAI,CAAC,SAAS;AACZ,0CAAQ,OAAA,EAAI,MAAK,SAAQ,WAAU,wEAAuE,UAAA,sCAAkC;AAAA,EAC9I;AAEA,SACEC,2BAAAA,IAAC,OAAA,EAAI,WAAU,kDAAiD,aAAU,iBACxE,UAAAA,2BAAAA;AAAAA,IAAC;AAAA,IAAA;AAAA,MACC;AAAA,MACA,UAAU,CAAC,SAAS,SAAS,QAAQ,EAAE;AAAA,MACvC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,kBAAgB;AAAA,MACf,GAAI,cAAc,EAAE,YAAA,IAAgB,CAAA;AAAA,MACrC,SAAS,CAAC,UAAU,mBAAmB;AAGrC,YAAI,SAAS,eAAe,YAAY,QAAS,UAAS,SAAS,YAAY,OAAO;AACtF,2CAAU,UAAU;AAAA,MACtB;AAAA,MACC,GAAI,aAAa,EAAE,WAAA,IAAe,CAAA;AAAA,MACnC,SAAS;AAAA,QACP,iBAAiB;AAAA,QACjB,YAAY;AAAA,QACZ,UAAU;AAAA,QACV,YAAY;AAAA,QACZ,SAAS,EAAE,SAAS,MAAA;AAAA,QACpB,sBAAsB;AAAA,QACtB,SAAS;AAAA,QACT,UAAU;AAAA,QACV,kBAAkB,EAAE,OAAO,MAAM,UAAU,MAAM,SAAS,KAAA;AAAA,MAAK;AAAA,IACjE;AAAA,EAAA,GAEJ;AAEJ;;"}
+{"version":3,"file":"MonacoEditor.cjs","sources":["../../src/monaco/MonacoEditor.tsx"],"sourcesContent":["import Editor, { loader, type Monaco } from \"@monaco-editor/react\";\nimport * as monaco from \"monaco-editor\";\nimport { useRef } from \"react\";\nimport { useResolvedTheme } from \"../hooks/use-theme\";\nimport { useMonacoWorkerFactory } from \"./use-monaco-worker\";\nimport type { MonacoEditorProps } from \"./types\";\n\nloader.config({ monaco });\n\nexport function MonacoEditor({\n  value,\n  onChange,\n  readOnly = false,\n  language,\n  path,\n  height = \"20rem\",\n  beforeMount,\n  onMount,\n  onValidate,\n}: MonacoEditorProps) {\n  if (!readOnly && !onChange) throw new Error(\"MonacoEditor requires onChange when editing\");\n  const workers = useMonacoWorkerFactory();\n  const theme = useResolvedTheme() === \"dark\" ? \"vs-dark\" : \"light\";\n  // @monaco-editor/react keeps the first onMount it sees, so read the value at\n  // mount time through a ref rather than that render's closure.\n  const latestValue = useRef(value);\n  latestValue.current = value;\n\n  if (!workers) {\n    return <div role=\"alert\" className=\"rounded-md border border-destructive/40 p-3 text-sm text-destructive\">Monaco workers are not configured.</div>;\n  }\n\n  return (\n    <div className=\"overflow-hidden rounded-md border border-input\" data-slot=\"monaco-editor\">\n      <Editor\n        value={value}\n        onChange={(next) => onChange?.(next ?? \"\")}\n        language={language}\n        path={path}\n        height={height}\n        theme={theme}\n        keepCurrentModel\n        {...(beforeMount ? { beforeMount } : {})}\n        onMount={(instance, monacoInstance) => {\n          // keepCurrentModel remounts onto the model already at `path`, which\n          // still holds the text from when the previous editor unmounted.\n          if (instance.getValue() !== latestValue.current) instance.setValue(latestValue.current);\n          onMount?.(instance, monacoInstance);\n        }}\n        {...(onValidate ? { onValidate } : {})}\n        options={{\n          readOnly,\n          automaticLayout: true,\n          fontFamily: \"var(--font-mono, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace)\",\n          fontSize: 13,\n          lineHeight: 20,\n          minimap: { enabled: false },\n          scrollBeyondLastLine: false,\n          tabSize: 2,\n          wordWrap: \"on\",\n          quickSuggestions: { other: true, comments: true, strings: true },\n        }}\n      />\n    </div>\n  );\n}\n\nexport type { Monaco };\n"],"names":["loader","monaco","useMonacoWorkerFactory","useResolvedTheme","useRef","jsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAOAA,OAAAA,OAAO,OAAO,EAAA,QAAEC,yBAAQ;AAEjB,SAAS,aAAa;AAAA,EAC3B;AAAA,EACA;AAAA,EACA,WAAW;AAAA,EACX;AAAA,EACA;AAAA,EACA,SAAS;AAAA,EACT;AAAA,EACA;AAAA,EACA;AACF,GAAsB;AACpB,MAAI,CAAC,YAAY,CAAC,SAAU,OAAM,IAAI,MAAM,6CAA6C;AACzF,QAAM,UAAUC,gBAAAA,uBAAA;AAChB,QAAM,QAAQC,SAAAA,iBAAA,MAAuB,SAAS,YAAY;AAG1D,QAAM,cAAcC,MAAAA,OAAO,KAAK;AAChC,cAAY,UAAU;AAEtB,MAAI,CAAC,SAAS;AACZ,0CAAQ,OAAA,EAAI,MAAK,SAAQ,WAAU,wEAAuE,UAAA,sCAAkC;AAAA,EAC9I;AAEA,SACEC,2BAAAA,IAAC,OAAA,EAAI,WAAU,kDAAiD,aAAU,iBACxE,UAAAA,2BAAAA;AAAAA,IAAC;AAAA,IAAA;AAAA,MACC;AAAA,MACA,UAAU,CAAC,SAAS,qCAAW,QAAQ;AAAA,MACvC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,kBAAgB;AAAA,MACf,GAAI,cAAc,EAAE,YAAA,IAAgB,CAAA;AAAA,MACrC,SAAS,CAAC,UAAU,mBAAmB;AAGrC,YAAI,SAAS,eAAe,YAAY,QAAS,UAAS,SAAS,YAAY,OAAO;AACtF,2CAAU,UAAU;AAAA,MACtB;AAAA,MACC,GAAI,aAAa,EAAE,WAAA,IAAe,CAAA;AAAA,MACnC,SAAS;AAAA,QACP;AAAA,QACA,iBAAiB;AAAA,QACjB,YAAY;AAAA,QACZ,UAAU;AAAA,QACV,YAAY;AAAA,QACZ,SAAS,EAAE,SAAS,MAAA;AAAA,QACpB,sBAAsB;AAAA,QACtB,SAAS;AAAA,QACT,UAAU;AAAA,QACV,kBAAkB,EAAE,OAAO,MAAM,UAAU,MAAM,SAAS,KAAA;AAAA,MAAK;AAAA,IACjE;AAAA,EAAA,GAEJ;AAEJ;;"}

package/dist/monaco/MonacoEditor.d.ts

@@ -1,5 +1,5 @@
 import { Monaco } from '@monaco-editor/react';
-import { MonacoEditorProps } from './types';
-export declare function MonacoEditor({ value, onChange, language, path, height, beforeMount, onMount, onValidate, }: MonacoEditorProps): import("react").JSX.Element;
+import { MonacoEditorProps } from './types.js';
+export declare function MonacoEditor({ value, onChange, readOnly, language, path, height, beforeMount, onMount, onValidate, }: MonacoEditorProps): import("react").JSX.Element;
 export type { Monaco };
 //# sourceMappingURL=MonacoEditor.d.ts.map

package/dist/monaco/MonacoEditor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MonacoEditor.d.ts","sourceRoot":"","sources":["../../src/monaco/MonacoEditor.tsx"],"names":[],"mappings":"AAAA,OAAe,EAAU,KAAK,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAKnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAIjD,wBAAgB,YAAY,CAAC,EAC3B,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,IAAI,EACJ,MAAgB,EAChB,WAAW,EACX,OAAO,EACP,UAAU,GACX,EAAE,iBAAiB,+BA4CnB;AAED,YAAY,EAAE,MAAM,EAAE,CAAC"}
+{"version":3,"file":"MonacoEditor.d.ts","sourceRoot":"","sources":["../../src/monaco/MonacoEditor.tsx"],"names":[],"mappings":"AAAA,OAAe,EAAU,KAAK,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAKnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAIjD,wBAAgB,YAAY,CAAC,EAC3B,KAAK,EACL,QAAQ,EACR,QAAgB,EAChB,QAAQ,EACR,IAAI,EACJ,MAAgB,EAChB,WAAW,EACX,OAAO,EACP,UAAU,GACX,EAAE,iBAAiB,+BA8CnB;AAED,YAAY,EAAE,MAAM,EAAE,CAAC"}

package/dist/monaco/MonacoEditor.js

@@ -8,6 +8,7 @@ loader.config({ monaco: monacoEditor });
 function MonacoEditor({
   value,
   onChange,
+  readOnly = false,
   language,
   path,
   height = "20rem",
@@ -15,6 +16,7 @@ function MonacoEditor({
   onMount,
   onValidate
 }) {
+  if (!readOnly && !onChange) throw new Error("MonacoEditor requires onChange when editing");
   const workers = useMonacoWorkerFactory();
   const theme = useResolvedTheme() === "dark" ? "vs-dark" : "light";
   const latestValue = useRef(value);
@@ -26,7 +28,7 @@ function MonacoEditor({
     Editor,
     {
       value,
-      onChange: (next) => onChange(next ?? ""),
+      onChange: (next) => onChange == null ? void 0 : onChange(next ?? ""),
       language,
       path,
       height,
@@ -39,6 +41,7 @@ function MonacoEditor({
       },
       ...onValidate ? { onValidate } : {},
       options: {
+        readOnly,
         automaticLayout: true,
         fontFamily: "var(--font-mono, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace)",
         fontSize: 13,

package/dist/monaco/MonacoEditor.js.map

@@ -1 +1 @@
-{"version":3,"file":"MonacoEditor.js","sources":["../../src/monaco/MonacoEditor.tsx"],"sourcesContent":["import Editor, { loader, type Monaco } from \"@monaco-editor/react\";\nimport * as monaco from \"monaco-editor\";\nimport { useRef } from \"react\";\nimport { useResolvedTheme } from \"../hooks/use-theme\";\nimport { useMonacoWorkerFactory } from \"./use-monaco-worker\";\nimport type { MonacoEditorProps } from \"./types\";\n\nloader.config({ monaco });\n\nexport function MonacoEditor({\n  value,\n  onChange,\n  language,\n  path,\n  height = \"20rem\",\n  beforeMount,\n  onMount,\n  onValidate,\n}: MonacoEditorProps) {\n  const workers = useMonacoWorkerFactory();\n  const theme = useResolvedTheme() === \"dark\" ? \"vs-dark\" : \"light\";\n  // @monaco-editor/react keeps the first onMount it sees, so read the value at\n  // mount time through a ref rather than that render's closure.\n  const latestValue = useRef(value);\n  latestValue.current = value;\n\n  if (!workers) {\n    return <div role=\"alert\" className=\"rounded-md border border-destructive/40 p-3 text-sm text-destructive\">Monaco workers are not configured.</div>;\n  }\n\n  return (\n    <div className=\"overflow-hidden rounded-md border border-input\" data-slot=\"monaco-editor\">\n      <Editor\n        value={value}\n        onChange={(next) => onChange(next ?? \"\")}\n        language={language}\n        path={path}\n        height={height}\n        theme={theme}\n        keepCurrentModel\n        {...(beforeMount ? { beforeMount } : {})}\n        onMount={(instance, monacoInstance) => {\n          // keepCurrentModel remounts onto the model already at `path`, which\n          // still holds the text from when the previous editor unmounted.\n          if (instance.getValue() !== latestValue.current) instance.setValue(latestValue.current);\n          onMount?.(instance, monacoInstance);\n        }}\n        {...(onValidate ? { onValidate } : {})}\n        options={{\n          automaticLayout: true,\n          fontFamily: \"var(--font-mono, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace)\",\n          fontSize: 13,\n          lineHeight: 20,\n          minimap: { enabled: false },\n          scrollBeyondLastLine: false,\n          tabSize: 2,\n          wordWrap: \"on\",\n          quickSuggestions: { other: true, comments: true, strings: true },\n        }}\n      />\n    </div>\n  );\n}\n\nexport type { Monaco };\n"],"names":["monaco"],"mappings":";;;;;;AAOA,OAAO,OAAO,EAAA,QAAEA,cAAQ;AAEjB,SAAS,aAAa;AAAA,EAC3B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,SAAS;AAAA,EACT;AAAA,EACA;AAAA,EACA;AACF,GAAsB;AACpB,QAAM,UAAU,uBAAA;AAChB,QAAM,QAAQ,iBAAA,MAAuB,SAAS,YAAY;AAG1D,QAAM,cAAc,OAAO,KAAK;AAChC,cAAY,UAAU;AAEtB,MAAI,CAAC,SAAS;AACZ,+BAAQ,OAAA,EAAI,MAAK,SAAQ,WAAU,wEAAuE,UAAA,sCAAkC;AAAA,EAC9I;AAEA,SACE,oBAAC,OAAA,EAAI,WAAU,kDAAiD,aAAU,iBACxE,UAAA;AAAA,IAAC;AAAA,IAAA;AAAA,MACC;AAAA,MACA,UAAU,CAAC,SAAS,SAAS,QAAQ,EAAE;AAAA,MACvC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,kBAAgB;AAAA,MACf,GAAI,cAAc,EAAE,YAAA,IAAgB,CAAA;AAAA,MACrC,SAAS,CAAC,UAAU,mBAAmB;AAGrC,YAAI,SAAS,eAAe,YAAY,QAAS,UAAS,SAAS,YAAY,OAAO;AACtF,2CAAU,UAAU;AAAA,MACtB;AAAA,MACC,GAAI,aAAa,EAAE,WAAA,IAAe,CAAA;AAAA,MACnC,SAAS;AAAA,QACP,iBAAiB;AAAA,QACjB,YAAY;AAAA,QACZ,UAAU;AAAA,QACV,YAAY;AAAA,QACZ,SAAS,EAAE,SAAS,MAAA;AAAA,QACpB,sBAAsB;AAAA,QACtB,SAAS;AAAA,QACT,UAAU;AAAA,QACV,kBAAkB,EAAE,OAAO,MAAM,UAAU,MAAM,SAAS,KAAA;AAAA,MAAK;AAAA,IACjE;AAAA,EAAA,GAEJ;AAEJ;"}
+{"version":3,"file":"MonacoEditor.js","sources":["../../src/monaco/MonacoEditor.tsx"],"sourcesContent":["import Editor, { loader, type Monaco } from \"@monaco-editor/react\";\nimport * as monaco from \"monaco-editor\";\nimport { useRef } from \"react\";\nimport { useResolvedTheme } from \"../hooks/use-theme\";\nimport { useMonacoWorkerFactory } from \"./use-monaco-worker\";\nimport type { MonacoEditorProps } from \"./types\";\n\nloader.config({ monaco });\n\nexport function MonacoEditor({\n  value,\n  onChange,\n  readOnly = false,\n  language,\n  path,\n  height = \"20rem\",\n  beforeMount,\n  onMount,\n  onValidate,\n}: MonacoEditorProps) {\n  if (!readOnly && !onChange) throw new Error(\"MonacoEditor requires onChange when editing\");\n  const workers = useMonacoWorkerFactory();\n  const theme = useResolvedTheme() === \"dark\" ? \"vs-dark\" : \"light\";\n  // @monaco-editor/react keeps the first onMount it sees, so read the value at\n  // mount time through a ref rather than that render's closure.\n  const latestValue = useRef(value);\n  latestValue.current = value;\n\n  if (!workers) {\n    return <div role=\"alert\" className=\"rounded-md border border-destructive/40 p-3 text-sm text-destructive\">Monaco workers are not configured.</div>;\n  }\n\n  return (\n    <div className=\"overflow-hidden rounded-md border border-input\" data-slot=\"monaco-editor\">\n      <Editor\n        value={value}\n        onChange={(next) => onChange?.(next ?? \"\")}\n        language={language}\n        path={path}\n        height={height}\n        theme={theme}\n        keepCurrentModel\n        {...(beforeMount ? { beforeMount } : {})}\n        onMount={(instance, monacoInstance) => {\n          // keepCurrentModel remounts onto the model already at `path`, which\n          // still holds the text from when the previous editor unmounted.\n          if (instance.getValue() !== latestValue.current) instance.setValue(latestValue.current);\n          onMount?.(instance, monacoInstance);\n        }}\n        {...(onValidate ? { onValidate } : {})}\n        options={{\n          readOnly,\n          automaticLayout: true,\n          fontFamily: \"var(--font-mono, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace)\",\n          fontSize: 13,\n          lineHeight: 20,\n          minimap: { enabled: false },\n          scrollBeyondLastLine: false,\n          tabSize: 2,\n          wordWrap: \"on\",\n          quickSuggestions: { other: true, comments: true, strings: true },\n        }}\n      />\n    </div>\n  );\n}\n\nexport type { Monaco };\n"],"names":["monaco"],"mappings":";;;;;;AAOA,OAAO,OAAO,EAAA,QAAEA,cAAQ;AAEjB,SAAS,aAAa;AAAA,EAC3B;AAAA,EACA;AAAA,EACA,WAAW;AAAA,EACX;AAAA,EACA;AAAA,EACA,SAAS;AAAA,EACT;AAAA,EACA;AAAA,EACA;AACF,GAAsB;AACpB,MAAI,CAAC,YAAY,CAAC,SAAU,OAAM,IAAI,MAAM,6CAA6C;AACzF,QAAM,UAAU,uBAAA;AAChB,QAAM,QAAQ,iBAAA,MAAuB,SAAS,YAAY;AAG1D,QAAM,cAAc,OAAO,KAAK;AAChC,cAAY,UAAU;AAEtB,MAAI,CAAC,SAAS;AACZ,+BAAQ,OAAA,EAAI,MAAK,SAAQ,WAAU,wEAAuE,UAAA,sCAAkC;AAAA,EAC9I;AAEA,SACE,oBAAC,OAAA,EAAI,WAAU,kDAAiD,aAAU,iBACxE,UAAA;AAAA,IAAC;AAAA,IAAA;AAAA,MACC;AAAA,MACA,UAAU,CAAC,SAAS,qCAAW,QAAQ;AAAA,MACvC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,kBAAgB;AAAA,MACf,GAAI,cAAc,EAAE,YAAA,IAAgB,CAAA;AAAA,MACrC,SAAS,CAAC,UAAU,mBAAmB;AAGrC,YAAI,SAAS,eAAe,YAAY,QAAS,UAAS,SAAS,YAAY,OAAO;AACtF,2CAAU,UAAU;AAAA,MACtB;AAAA,MACC,GAAI,aAAa,EAAE,WAAA,IAAe,CAAA;AAAA,MACnC,SAAS;AAAA,QACP;AAAA,QACA,iBAAiB;AAAA,QACjB,YAAY;AAAA,QACZ,UAAU;AAAA,QACV,YAAY;AAAA,QACZ,SAAS,EAAE,SAAS,MAAA;AAAA,QACpB,sBAAsB;AAAA,QACtB,SAAS;AAAA,QACT,UAAU;AAAA,QACV,kBAAkB,EAAE,OAAO,MAAM,UAAU,MAAM,SAAS,KAAA;AAAA,MAAK;AAAA,IACjE;AAAA,EAAA,GAEJ;AAEJ;"}

package/dist/monaco/MonacoProvider.d.ts

@@ -1,3 +1,3 @@
-import { MonacoProviderProps } from './types';
+import { MonacoProviderProps } from './types.js';
 export declare function MonacoProvider({ getWorker, children }: MonacoProviderProps): import("react").JSX.Element;
 //# sourceMappingURL=MonacoProvider.d.ts.map

package/dist/monaco/MonacoSchemaEditor.d.ts

@@ -1,4 +1,4 @@
-import { MonacoSchemaEditorProps, MonacoValidationState } from './types';
+import { MonacoSchemaEditorProps, MonacoValidationState } from './types.js';
 export declare function MonacoSchemaEditor(props: MonacoSchemaEditorProps): import("react").JSX.Element;
 export type { MonacoValidationState };
 //# sourceMappingURL=MonacoSchemaEditor.d.ts.map

package/dist/monaco/schema-normalizer.d.ts

@@ -1,4 +1,4 @@
-import { JsonSchemaObject } from '../components/json-schema-form-types';
+import { JsonSchemaObject } from '../components/json-schema-form-types.js';
 export type MonacoSchemaNormalization = {
     schema?: Record<string, unknown>;
     unsupportedKeywords: string[];

package/dist/monaco/types.d.ts

@@ -1,7 +1,7 @@
 import { ReactNode } from 'react';
 import { editor } from 'monaco-editor';
 import { Monaco } from '@monaco-editor/react';
-import { JsonSchemaObject } from '../components/json-schema-form-types';
+import { JsonSchemaObject } from '../components/json-schema-form-types.js';
 export type MonacoValidationStatus = "loading" | "valid" | "invalid" | "unavailable";
 export type MonacoValidationState = {
     status: MonacoValidationStatus;
@@ -14,7 +14,8 @@ export type MonacoProviderProps = {
 };
 export type MonacoEditorProps = {
     value: string;
-    onChange: (value: string) => void;
+    onChange?: (value: string) => void;
+    readOnly?: boolean;
     language: string;
     path: string;
     height?: string | number;

package/dist/monaco/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/monaco/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAE7E,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,aAAa,CAAC;AAErF,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,sBAAsB,CAAC;IAC/B,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;AAE5D,MAAM,MAAM,mBAAmB,GAAG;IAChC,SAAS,EAAE,mBAAmB,CAAC;IAC/B,QAAQ,EAAE,SAAS,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,qBAAqB,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACzE,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,KAAK,IAAI,CAAC;CAClD,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,IAAI,CAAC,iBAAiB,EAAE,UAAU,GAAG,aAAa,GAAG,SAAS,GAAG,YAAY,CAAC,GAAG;IACrH,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1B,MAAM,EAAE,gBAAgB,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAC;CAC5D,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/monaco/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAE7E,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,aAAa,CAAC;AAErF,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,sBAAsB,CAAC;IAC/B,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;AAE5D,MAAM,MAAM,mBAAmB,GAAG;IAChC,SAAS,EAAE,mBAAmB,CAAC;IAC/B,QAAQ,EAAE,SAAS,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,qBAAqB,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACzE,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,KAAK,IAAI,CAAC;CAClD,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,IAAI,CAAC,iBAAiB,EAAE,UAAU,GAAG,aAAa,GAAG,SAAS,GAAG,YAAY,CAAC,GAAG;IACrH,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1B,MAAM,EAAE,gBAAgB,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAC;CAC5D,CAAC"}

package/dist/monaco/use-monaco-worker.d.ts

@@ -1,4 +1,4 @@
-import { MonacoWorkerFactory } from './types';
+import { MonacoWorkerFactory } from './types.js';
 export declare const WorkerContext: import('react').Context<MonacoWorkerFactory | null>;
 export declare function useMonacoWorkerFactory(): MonacoWorkerFactory | null;
 //# sourceMappingURL=use-monaco-worker.d.ts.map

package/dist/monaco-schema.d.ts

@@ -1,3 +1,3 @@
-export { normalizeSchemaForMonaco } from './monaco/schema-normalizer';
-export type { MonacoSchemaNormalization } from './monaco/schema-normalizer';
+export { normalizeSchemaForMonaco } from './monaco/schema-normalizer.js';
+export type { MonacoSchemaNormalization } from './monaco/schema-normalizer.js';
 //# sourceMappingURL=monaco-schema.d.ts.map

package/dist/monaco.d.ts

@@ -1,7 +1,7 @@
-export { MonacoProvider } from './monaco/MonacoProvider';
-export { MonacoEditor } from './monaco/MonacoEditor';
-export { MonacoSchemaEditor } from './monaco/MonacoSchemaEditor';
-export { normalizeSchemaForMonaco } from './monaco/schema-normalizer';
+export { MonacoProvider } from './monaco/MonacoProvider.js';
+export { MonacoEditor } from './monaco/MonacoEditor.js';
+export { MonacoSchemaEditor } from './monaco/MonacoSchemaEditor.js';
+export { normalizeSchemaForMonaco } from './monaco/schema-normalizer.js';
 export type { Monaco } from '@monaco-editor/react';
-export type { MonacoEditorProps, MonacoProviderProps, MonacoSchemaEditorProps, MonacoValidationState, MonacoValidationStatus, MonacoWorkerFactory, } from './monaco/types';
+export type { MonacoEditorProps, MonacoProviderProps, MonacoSchemaEditorProps, MonacoValidationState, MonacoValidationStatus, MonacoWorkerFactory, } from './monaco/types.js';
 //# sourceMappingURL=monaco.d.ts.map

package/dist/overlay/CellActions.d.ts

@@ -1,6 +1,6 @@
 import { ButtonHTMLAttributes, ReactNode } from 'react';
-import { StaticIconComponent } from '../data/Icon';
-import { DropdownMenuItem } from './DropdownMenu';
+import { StaticIconComponent } from '../data/Icon.js';
+import { DropdownMenuItem } from './DropdownMenu.js';
 export type CellActionsProps = {
     contextTarget: HTMLElement | null;
     menuLabel: string;

package/dist/overlay/CommandPalette.cjs

@@ -21,6 +21,8 @@ function CommandPalette({
   groups,
   query,
   onQueryChange,
+  customInput,
+  focusListKey,
   hotkey = "mod+k",
   placeholder = "Type a command or search…",
   loading,
@@ -45,6 +47,7 @@ function CommandPalette({
   const restoreFocusRef = react.useRef(null);
   const isOpen = open ?? selfOpen;
   const currentQuery = query ?? selfQuery;
+  const usesCustomInput = customInput !== void 0;
   const setOpen = react.useCallback(
     (next) => {
       if (open === void 0) setSelfOpen(next);
@@ -80,7 +83,11 @@ function CommandPalette({
     }
     restoreFocusRef.current = document.activeElement;
     (_c = inputRef.current) == null ? void 0 : _c.focus();
-  }, [isOpen, resetQueryOnClose, query]);
+  }, [isOpen, resetQueryOnClose, query, usesCustomInput]);
+  react.useEffect(() => {
+    var _a;
+    if (isOpen && focusListKey !== void 0) (_a = listRef.current) == null ? void 0 : _a.focus();
+  }, [isOpen, focusListKey]);
   react.useEffect(() => {
     var _a;
     if (activeIndex < 0) return;
@@ -151,14 +158,15 @@ function CommandPalette({
           "aria-modal": "true",
           "aria-label": ariaLabel,
           className: utils.cn(
-            "flex h-fit w-full flex-col overflow-hidden rounded-lg border border-border bg-background shadow-xl",
+            "flex h-fit w-full flex-col rounded-lg border border-border bg-background shadow-xl",
+            usesCustomInput ? "overflow-visible" : "overflow-hidden",
             SIZE_CLASS[size],
             className
           ),
           style: { marginTop: topOffset },
           onClick: (event) => event.stopPropagation(),
           children: [
-            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-density-2 border-b border-border px-density-3", children: [
+            !usesCustomInput ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-density-2 border-b border-border px-density-3", children: [
               /* @__PURE__ */ jsxRuntime.jsx(Icon.Icon, { icon: UiSearch.UiSearch, className: "shrink-0 text-muted-foreground" }),
               /* @__PURE__ */ jsxRuntime.jsx(
                 "input",
@@ -178,7 +186,7 @@ function CommandPalette({
                   className: "h-12 min-w-0 flex-1 bg-transparent text-sm outline-none placeholder:text-placeholder"
                 }
               )
-            ] }),
+            ] }) : /* @__PURE__ */ jsxRuntime.jsx("div", { className: "border-b border-border p-density-3", children: customInput }),
             /* @__PURE__ */ jsxRuntime.jsx(
               CommandPaletteList.CommandPaletteList,
               {
@@ -189,6 +197,8 @@ function CommandPalette({
                 optionId,
                 onActivate: activate,
                 onHover: setActiveIndex,
+                onKeyDown,
+                activeItemId: activeItem ? optionId(activeItem) : void 0,
                 listRef,
                 loading,
                 emptyState,