@hachej/boring-workspace 0.1.71 → 0.1.72

package/dist/src/shared/plugins/appLeftOverlayChrome.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode, FunctionComponentElement, ProviderProps } from 'react';
+export interface AppLeftOverlayChromeValue {
+    headerInsetStart: boolean;
+    headerInsetEnd: boolean;
+}
+export declare function AppLeftOverlayChromeProvider({ value, children, }: {
+    value: AppLeftOverlayChromeValue;
+    children?: ReactNode;
+}): FunctionComponentElement<ProviderProps<AppLeftOverlayChromeValue>>;
+export declare function useAppLeftOverlayChrome(): AppLeftOverlayChromeValue;

package/dist/src/shared/plugins/bootstrap.d.ts

@@ -0,0 +1,41 @@
+import { BoringFrontFactoryWithId, BoringFrontPanelCommandRegistration, CapturedFrontPlugin } from './frontFactory';
+import { CatalogConfig } from './types';
+import { CommandConfig, PanelRegistration, WorkspaceSourceRegistration } from '../types/panel';
+import { SurfaceResolverRegistration } from '../types/surface';
+export interface PanelRegistryLike {
+    register(id: string, config: PanelRegistration): void;
+}
+export interface WorkspaceSourceRegistryLike {
+    register(id: string, config: WorkspaceSourceRegistration): void;
+}
+export interface CommandRegistryLike {
+    registerCommand(command: CommandConfig): void;
+}
+export interface CatalogRegistryLike {
+    register(catalog: CatalogConfig, pluginId: string): void;
+}
+export interface SurfaceResolverRegistryLike {
+    register(id: string, config: SurfaceResolverRegistration): void;
+}
+export interface BootstrapOptions {
+    chatPanel: unknown;
+    plugins?: BoringFrontFactoryWithId[];
+    capturedPlugins?: CapturedFrontPlugin[];
+    defaults?: BoringFrontFactoryWithId[];
+    excludeDefaults?: string[];
+    registries: {
+        panels: PanelRegistryLike;
+        workspaceSources?: WorkspaceSourceRegistryLike;
+        commands: CommandRegistryLike;
+        catalogs: CatalogRegistryLike;
+        surfaceResolvers?: SurfaceResolverRegistryLike;
+    };
+    panelCommandRunner?: (command: BoringFrontPanelCommandRegistration) => (() => void) | undefined;
+}
+export interface BootstrapResult {
+    registered: string[];
+    plugins: CapturedFrontPlugin[];
+}
+export declare function registerCapturedFrontPlugin(plugin: CapturedFrontPlugin, registries: BootstrapOptions["registries"], panelCommandRunner?: BootstrapOptions["panelCommandRunner"]): void;
+export declare function captureBootstrapPlugins(options: Pick<BootstrapOptions, "plugins" | "defaults" | "excludeDefaults" | "capturedPlugins">): CapturedFrontPlugin[];
+export declare function bootstrap(options: BootstrapOptions): BootstrapResult;

package/dist/src/shared/plugins/errors.d.ts

@@ -0,0 +1,5 @@
+export type PluginErrorKind = "duplicate-id" | "validation" | "runtime";
+export declare class PluginError extends Error {
+    readonly kind: PluginErrorKind;
+    constructor(kind: PluginErrorKind, message: string);
+}

package/dist/src/shared/plugins/frontFactory.d.ts

@@ -0,0 +1,166 @@
+import { ComponentType, ReactNode } from 'react';
+import { PanelConfig, PaneProps, WorkspaceSourceProps } from '../types/panel';
+import { SurfaceOpenRequest, SurfacePanelResolution, SurfaceResolverExample, SurfaceResolverRegistration } from '../types/surface';
+import { CatalogConfig, PluginBinding, PluginProvider } from './types';
+export interface BoringFrontPanelRegistration<T = unknown> {
+    id: string;
+    component: ComponentType<PaneProps<T>> | (() => Promise<{
+        default: ComponentType<PaneProps<T>>;
+    }>);
+    label?: string;
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    placement?: PanelConfig["placement"];
+    requiresCapabilities?: string[];
+    essential?: boolean;
+    lazy?: boolean;
+    chromeless?: boolean;
+    supportsFullPage?: boolean;
+    source?: string;
+}
+export interface BoringFrontWorkspaceSourceRegistration<T = unknown> {
+    id: string;
+    component: ComponentType<WorkspaceSourceProps<T>> | (() => Promise<{
+        default: ComponentType<WorkspaceSourceProps<T>>;
+    }>);
+    label?: string;
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    requiresCapabilities?: string[];
+    lazy?: boolean;
+    chromeless?: boolean;
+    defaultPanelId?: string;
+    source?: string;
+}
+export interface BoringFrontPanelCommandRegistration {
+    id: string;
+    title: string;
+    panelId?: string;
+    run?: () => void;
+    keywords?: string[];
+    shortcut?: string;
+    when?: () => boolean;
+}
+export interface BoringFrontProviderRegistration {
+    id: string;
+    component: PluginProvider;
+}
+export interface BoringFrontBindingRegistration {
+    id: string;
+    component: PluginBinding;
+}
+export interface BoringFrontAppLeftOverlayProps {
+    onClose: () => void;
+}
+export interface BoringFrontAppLeftActionRegistration {
+    id: string;
+    label: string;
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    trailing?: ComponentType;
+    overlay: ComponentType<BoringFrontAppLeftOverlayProps>;
+    order?: number;
+    emphasis?: boolean;
+}
+export interface BoringFrontSurfaceResolverRegistration {
+    id?: string;
+    kind: string;
+    title?: string;
+    description?: string;
+    targetHint?: string;
+    examples?: SurfaceResolverExample[];
+    metaSchema?: Record<string, unknown>;
+    source?: string;
+    resolve: (request: SurfaceOpenRequest) => SurfacePanelResolution | null | undefined;
+}
+export declare function normalizeFrontSurfaceResolver(resolver: BoringFrontSurfaceResolverRegistration, pluginId: string): {
+    id: string;
+    config: SurfaceResolverRegistration;
+};
+export type BoringFrontToolRenderer = (part: unknown) => ReactNode;
+export interface BoringFrontToolRendererRegistration {
+    id: string;
+    render: BoringFrontToolRenderer;
+}
+export interface BoringFrontAPI {
+    registerProvider(registration: BoringFrontProviderRegistration): void;
+    registerBinding(registration: BoringFrontBindingRegistration): void;
+    registerCatalog(registration: CatalogConfig): void;
+    registerPanel<T = unknown>(registration: BoringFrontPanelRegistration<T>): void;
+    registerWorkspaceSource<T = unknown>(registration: BoringFrontWorkspaceSourceRegistration<T>): void;
+    registerPanelCommand(registration: BoringFrontPanelCommandRegistration): void;
+    registerAppLeftAction(registration: BoringFrontAppLeftActionRegistration): void;
+    registerSurfaceResolver(registration: BoringFrontSurfaceResolverRegistration): void;
+    registerToolRenderer(registration: BoringFrontToolRendererRegistration): void;
+}
+export type BoringFrontFactory = (api: BoringFrontAPI) => void | Promise<void>;
+export type BoringFrontSetup = (api: BoringFrontAPI) => void;
+type RejectAsyncSetup<C> = C extends {
+    setup?: infer Setup;
+} ? Setup extends (...args: any[]) => infer Return ? Extract<Return, PromiseLike<unknown>> extends never ? unknown : never : unknown : unknown;
+/**
+ * A `BoringFrontFactory` that carries its own plugin id (and optional
+ * label) as static properties. Produced by `definePlugin({ ... })` and used
+ * directly by `WorkspaceProvider.plugins`.
+ */
+export type BoringFrontFactoryWithId = BoringFrontFactory & {
+    pluginId: string;
+    pluginLabel?: string;
+};
+/**
+ * Declarative plugin config — the canonical shape for `definePlugin`.
+ */
+export interface DefinePluginConfig {
+    id: string;
+    label?: string;
+    panels?: ReadonlyArray<BoringFrontPanelRegistration<any>>;
+    workspaceSources?: ReadonlyArray<BoringFrontWorkspaceSourceRegistration<any>>;
+    commands?: ReadonlyArray<BoringFrontPanelCommandRegistration>;
+    appLeftActions?: ReadonlyArray<BoringFrontAppLeftActionRegistration>;
+    surfaceResolvers?: ReadonlyArray<BoringFrontSurfaceResolverRegistration>;
+    providers?: ReadonlyArray<BoringFrontProviderRegistration>;
+    bindings?: ReadonlyArray<BoringFrontBindingRegistration>;
+    catalogs?: ReadonlyArray<CatalogConfig>;
+    toolRenderers?: ReadonlyArray<BoringFrontToolRendererRegistration>;
+    /**
+     * Escape hatch for registrations that can't be expressed declaratively.
+     * Called LAST, after every declarative field has been registered.
+     */
+    setup?: BoringFrontSetup;
+}
+/**
+ * Define a boring-ui plugin. Takes a single declarative config object and
+ * returns a branded front factory.
+ *
+ * Older positional signatures are not supported. The `setup` field is
+ * synchronous so statically composed plugins cannot return a Promise during
+ * provider bootstrap.
+ */
+export declare function definePlugin<const Config extends DefinePluginConfig>(config: Config & RejectAsyncSetup<Config>): BoringFrontFactoryWithId;
+export interface CapturedBoringFrontRegistrations {
+    providers: BoringFrontProviderRegistration[];
+    bindings: BoringFrontBindingRegistration[];
+    catalogs: CatalogConfig[];
+    panels: BoringFrontPanelRegistration<any>[];
+    workspaceSources: BoringFrontWorkspaceSourceRegistration<any>[];
+    panelCommands: BoringFrontPanelCommandRegistration[];
+    appLeftActions: BoringFrontAppLeftActionRegistration[];
+    surfaceResolvers: BoringFrontSurfaceResolverRegistration[];
+    toolRenderers: BoringFrontToolRendererRegistration[];
+}
+export interface CapturedFrontPlugin {
+    id: string;
+    label?: string;
+    registrations: CapturedBoringFrontRegistrations;
+}
+export interface CapturingBoringFrontAPIHandle extends BoringFrontAPI {
+    flush(): CapturedBoringFrontRegistrations;
+}
+export declare function createCapturingBoringFrontAPI(options?: {
+    pluginId?: string;
+}): CapturingBoringFrontAPIHandle;
+export declare function captureFrontPlugin(plugin: BoringFrontFactoryWithId): CapturedFrontPlugin;
+export {};

package/dist/src/shared/plugins/index.d.ts

@@ -0,0 +1,5 @@
+export { PluginError } from './errors';
+export type { PluginErrorKind } from './errors';
+export type { PluginBinding, CatalogAdapter, CatalogBadge, CatalogConfig, CatalogFacets, CatalogFacetsArgs, CatalogFacetConfig, CatalogFacetValue, CatalogRow, CatalogSearchArgs, CatalogSearchResult, LeftTabParams, LeftTabComponent, PluginProvider, PluginProviderProps, AgentTool, JSONSchema, ToolExecContext, ToolResult, } from './types';
+export { bootstrap } from './bootstrap';
+export type { BootstrapOptions, BootstrapResult, PanelRegistryLike, WorkspaceSourceRegistryLike, CommandRegistryLike, CatalogRegistryLike, SurfaceResolverRegistryLike, } from './bootstrap';

package/dist/src/shared/plugins/manifest.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Canonical package.json plugin shape for boring-ui workspace packages.
+ *
+ * Browser-safe: no node:* imports, no fs, no path.
+ *
+ * A plugin package has one package boundary and two namespaces:
+ * - `pi`: agent/Pi runtime contributions (extensions, skills, prompt, Pi packages)
+ * - `boring`: workspace/UI package discovery (front/server entrypoints and labels)
+ */
+export interface BoringPackageBoringField {
+    /** Optional stable plugin id. Defaults to package.json#name normalized for package discovery. */
+    id?: string;
+    /** Browser entry that default-exports a BoringFrontFactory. */
+    front?: string;
+    /** Workspace/UI support server entry. Set false to disable convention lookup. */
+    server?: string | false;
+    label?: string;
+}
+export interface BoringPackagePiSourceObject {
+    source: string;
+    extensions?: string[];
+    skills?: string[];
+    themes?: string[];
+    prompts?: string[];
+}
+export type BoringPackagePiSource = string | BoringPackagePiSourceObject;
+export interface BoringPackagePiField {
+    /** Native Pi extension entrypoints, relative to the package root. */
+    extensions?: string[];
+    /** Skill directories/files, relative to the package root. */
+    skills?: string[];
+    /** Additional Pi package sources to inject into Pi settings. */
+    packages?: BoringPackagePiSource[];
+    /** Agent context injected by the boring Pi extension. Prefer skills for large docs. */
+    systemPrompt?: string;
+}
+export interface BoringPluginPackageJson {
+    name?: string;
+    version?: string;
+    boring?: BoringPackageBoringField;
+    pi?: BoringPackagePiField;
+}
+export type BoringPluginManifestErrorCode = "INVALID_ID" | "INVALID_VERSION" | "INVALID_FIELD" | "INVALID_PATH" | "MISSING_REQUIRED_FIELD";
+export interface BoringPluginManifestIssue {
+    code: BoringPluginManifestErrorCode;
+    field: string;
+    message: string;
+}
+export type BoringPluginManifestValidationResult = {
+    valid: true;
+    packageJson: BoringPluginPackageJson;
+} | {
+    valid: false;
+    issues: BoringPluginManifestIssue[];
+};
+export declare function isValidBoringPluginId(id: string): boolean;
+export declare function isSafePluginRelativePath(value: string): boolean;
+export declare function validateBoringPluginManifest(raw: unknown): BoringPluginManifestValidationResult;

package/dist/src/shared/plugins/runtimePluginTypes.d.ts

@@ -0,0 +1,51 @@
+import { BoringPackageBoringField, BoringPackagePiField } from './manifest';
+export type BoringPluginNativeFrontTargetTrust = "local-trusted-native";
+/**
+ * Host-owned runtime import target for a plugin front entry.
+ *
+ * Only the trusted native/browser-module case exists today. Future
+ * target kinds (iframe/artifact/...) can extend the union without
+ * rewriting list/event payload shapes.
+ */
+export interface BoringPluginNativeFrontTarget {
+    kind: "native";
+    entryUrl: string;
+    revision: number;
+    trust: BoringPluginNativeFrontTargetTrust;
+}
+/**
+ * Plugin front served as a plain browser module URL — the Vite-dev transport
+ * (`/@fs/...`). Hosts running a Vite dev server let Vite transform the entry;
+ * the CLI's runtime host mints `native` targets instead.
+ */
+export interface BoringPluginModuleUrlFrontTarget {
+    kind: "module-url";
+    entryUrl: string;
+    revision: number;
+}
+export type BoringPluginFrontTarget = BoringPluginNativeFrontTarget | BoringPluginModuleUrlFrontTarget;
+export type BoringPluginEvent = {
+    type: "boring.plugin.load";
+    id: string;
+    boring: BoringPackageBoringField;
+    version: string;
+    revision: number;
+    frontTarget?: BoringPluginFrontTarget;
+} | {
+    type: "boring.plugin.unload";
+    id: string;
+    revision: number;
+} | {
+    type: "boring.plugin.error";
+    id: string;
+    revision: number;
+    message: string;
+};
+export interface BoringPluginListEntry {
+    id: string;
+    boring: BoringPackageBoringField;
+    pi?: BoringPackagePiField;
+    version: string;
+    revision: number;
+    frontTarget?: BoringPluginFrontTarget;
+}

package/dist/src/shared/plugins/types.d.ts

@@ -0,0 +1,84 @@
+import { ComponentType, ReactNode } from 'react';
+import { WorkspaceSourceProps } from '../types/panel';
+export type { AgentTool, JSONSchema, ToolExecContext, ToolResult, } from '../types/agent-tool';
+export type CatalogBadge = {
+    /** 1–4 char mono code rendered as a chip. */
+    code: string;
+    tooltip?: string;
+};
+export type CatalogRow = {
+    id: string;
+    title: string;
+    subtitle?: string;
+    group?: string;
+    leading?: CatalogBadge;
+    trailing?: CatalogBadge[];
+    meta?: string;
+};
+export type CatalogFacetValue = {
+    value: string;
+    count: number;
+};
+export type CatalogFacets = Record<string, CatalogFacetValue[]>;
+export type CatalogFacetConfig = {
+    key: string;
+    label: string;
+    order?: string[];
+    formatValue?: (value: string) => string;
+};
+export type CatalogSearchArgs = {
+    query: string;
+    filters: Record<string, string[]>;
+    group?: {
+        key: string;
+        value: string;
+    };
+    limit: number;
+    offset: number;
+    signal?: AbortSignal;
+};
+export type CatalogSearchResult = {
+    items: CatalogRow[];
+    total: number;
+    hasMore: boolean;
+};
+export type CatalogFacetsArgs = {
+    filters: Record<string, string[]>;
+    signal?: AbortSignal;
+};
+export type CatalogAdapter = {
+    search(args: CatalogSearchArgs): Promise<CatalogSearchResult>;
+    fetchFacets?(args: CatalogFacetsArgs): Promise<CatalogFacets>;
+};
+export type PluginBinding = ComponentType<unknown>;
+export interface PluginProviderProps {
+    apiBaseUrl: string;
+    authHeaders?: Record<string, string>;
+    onAuthError?: (statusCode: number) => void;
+    apiTimeout?: number;
+    activeSessionId?: string | null;
+    openSessionIds?: readonly string[];
+    children: ReactNode;
+}
+export type PluginProvider = ComponentType<PluginProviderProps>;
+export interface CatalogConfig {
+    id: string;
+    label: string;
+    adapter: CatalogAdapter;
+    onSelect: (row: CatalogRow) => void;
+    pluginId?: string;
+}
+export interface LeftTabParams {
+    rootDir?: string;
+    query?: string;
+    searchQuery?: string;
+    bridge?: unknown;
+    chromeless?: boolean;
+    /** Optional DOM target for left-tab toolbar actions owned by the pane. */
+    chromeActionsElement?: Element | null;
+    revealFileTreeRequest?: {
+        path: string;
+        seq: number;
+    } | null;
+}
+export type LeftTabComponent = ComponentType<WorkspaceSourceProps<LeftTabParams>>;

package/dist/src/shared/plugins/uiBridgeRegistry.d.ts

@@ -0,0 +1,44 @@
+import { CommandResult, UiBridge, UiCommand } from '../ui-bridge';
+/**
+ * Publish the workspace `UiBridge` for the current process so plugin slash
+ * commands can dispatch UI commands in-process. The agent server calls this
+ * once per server instance (see `createWorkspaceAgentServer`). Returns an
+ * unregister function — call it on server shutdown so a closed bridge is not
+ * left dangling for the next server in the same process (eval harness, tests).
+ */
+export declare function registerWorkspaceUiBridge(bridge: UiBridge): () => void;
+/** The active workspace `UiBridge`, or `undefined` when none is registered. */
+export declare function getWorkspaceUiBridge(): UiBridge | undefined;
+/**
+ * Thrown by the plugin-facing helpers when no workspace bridge is active — for
+ * example when plugin code runs under a bare Pi CLI with no workspace UI
+ * attached. The message is deliberately actionable.
+ */
+export declare class NoWorkspaceUiBridgeError extends Error {
+    constructor();
+}
+/**
+ * Dispatch an arbitrary UI command through the active workspace bridge. This is
+ * the same call the agent's `exec_ui` tool makes; the connected browser drains
+ * the command. Prefer the named helpers below for common actions.
+ */
+export declare function execWorkspaceUi(command: UiCommand): Promise<CommandResult>;
+export interface OpenPanelArgs {
+    /** Tab instance id. Reuse the same id to re-activate an existing tab. */
+    id: string;
+    /** Panel component id (one of the workspace's registered panels). */
+    component: string;
+    /** Optional params forwarded to the panel component. */
+    params?: Record<string, unknown>;
+}
+/**
+ * Open an app/plugin panel in the workspace from a plugin slash command.
+ * In-process — no URL, no env. Throws `NoWorkspaceUiBridgeError` if no bridge.
+ */
+export declare function openPanel(args: OpenPanelArgs): Promise<CommandResult>;
+/**
+ * Show a workspace notification (toast) from a plugin slash command. Unlike
+ * Pi's `ctx.ui.notify` (a terminal notification that is swallowed in
+ * server/headless mode), this surfaces in the browser via the UI bridge.
+ */
+export declare function notify(msg: string, level?: "info" | "warn" | "error"): Promise<CommandResult>;

package/dist/src/shared/plugins/workspaceShellCapabilities.d.ts

@@ -0,0 +1,44 @@
+import { ReactNode, FunctionComponentElement, ProviderProps } from 'react';
+export type WorkspaceShellArtifactTarget = {
+    type: "surface";
+    surfaceKind: string;
+    target?: string;
+    params?: Record<string, unknown>;
+} | {
+    type: "panel";
+    panelComponentId: string;
+    params?: Record<string, unknown>;
+};
+export type WorkspaceShellCapabilityResult = {
+    success: true;
+} | {
+    success: false;
+    reason: "no-artifact" | "open-failed" | "invalid-session" | "placement-failed";
+    message: string;
+};
+export interface WorkspaceShellAnchorRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export interface WorkspaceShellCapabilities {
+    openArtifact(target: WorkspaceShellArtifactTarget | null, options?: {
+        sessionId?: string | null;
+        title?: string;
+        instanceId?: string;
+    }): WorkspaceShellCapabilityResult;
+    openDetachedChat(sessionId: string, options?: {
+        anchor?: WorkspaceShellAnchorRect;
+        title?: string;
+    }): WorkspaceShellCapabilityResult;
+}
+export declare function WorkspaceShellCapabilitiesProvider({ value, children, }: {
+    value: WorkspaceShellCapabilities;
+    children?: ReactNode;
+}): FunctionComponentElement<ProviderProps<WorkspaceShellCapabilities>>;
+export declare function useWorkspaceShellCapabilities(): WorkspaceShellCapabilities;

package/dist/src/shared/telemetry.d.ts

@@ -0,0 +1,11 @@
+export interface TelemetrySink {
+    capture(event: TelemetryEvent): void | Promise<void>;
+    flush?(): void | Promise<void>;
+}
+export interface TelemetryEvent {
+    name: string;
+    distinctId?: string;
+    properties?: Record<string, unknown>;
+}
+export declare const noopTelemetry: TelemetrySink;
+export declare function safeCapture(telemetry: TelemetrySink, event: TelemetryEvent): void;

package/dist/src/shared/types/agent-tool.d.ts

@@ -0,0 +1,30 @@
+export type JSONSchema = Record<string, unknown>;
+export type ToolReadinessRequirement = 'workspace-fs' | 'sandbox-exec' | 'ui-bridge' | 'runtime-dependencies' | `runtime:${string}`;
+export interface ToolExecContext {
+    abortSignal: AbortSignal;
+    toolCallId: string;
+    onUpdate?: (partial: string) => void;
+    /** Agent chat/session id executing this tool, when known. */
+    sessionId?: string;
+}
+export interface ToolResult {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+    details?: unknown;
+}
+/**
+ * Structural tool contract accepted from workspace plugins and UI tool
+ * factories. Kept agent-runtime-neutral so only the app integration layer
+ * needs to import @hachej/boring-agent.
+ */
+export interface AgentTool {
+    name: string;
+    description: string;
+    promptSnippet?: string;
+    readinessRequirements?: ToolReadinessRequirement[];
+    parameters: JSONSchema;
+    execute(params: Record<string, unknown>, ctx: ToolExecContext): Promise<ToolResult>;
+}

package/dist/src/shared/types/boring-core-front.d.ts

@@ -0,0 +1,2 @@
+// Intentionally empty.
+// Reserved for package-local ambient declarations.

package/dist/src/shared/types/filesystem.d.ts

@@ -0,0 +1,15 @@
+export type FilesystemId = "user" | "company_context" | (string & {});
+export declare const USER_FILESYSTEM_ID = "user";
+export declare const COMPANY_CONTEXT_FILESYSTEM_ID = "company_context";
+export interface UiFileResource {
+    readonly filesystem: FilesystemId;
+    readonly path: string;
+}
+export type UiFileResourceInput = string | {
+    readonly filesystem?: FilesystemId | null;
+    readonly path: string;
+};
+export declare function normalizeUiFilesystem(filesystem: FilesystemId | null | undefined): FilesystemId;
+export declare function normalizeUiFileResource(input: UiFileResourceInput): UiFileResource;
+export declare function uiFileResourceKey(resource: UiFileResourceInput): string;
+export declare function withUiFileResource<T extends Record<string, unknown>>(value: T, fallbackFilesystem?: FilesystemId | null): T & UiFileResource;