@camerontaylor/paseo-plugin 0.8.0-fork.1

package/dist/attachments.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import type { PluginAttachmentSourceContribution } from "./contracts.js";
+export declare function defineAttachmentSource<Definition extends PluginAttachmentSourceContribution>(definition: Definition): Definition;
+export declare const PluginAttachmentItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    identifier: z.ZodString;
+    title: z.ZodString;
+    subtitle: z.ZodOptional<z.ZodString>;
+    url: z.ZodURL;
+    text: z.ZodString;
+    resourceType: z.ZodString;
+}, z.core.$strip>;
+export declare const PluginAttachmentSearchPayloadSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        identifier: z.ZodString;
+        title: z.ZodString;
+        subtitle: z.ZodOptional<z.ZodString>;
+        url: z.ZodURL;
+        text: z.ZodString;
+        resourceType: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PluginAttachmentItem = z.infer<typeof PluginAttachmentItemSchema>;
+export type PluginAttachmentSearchPayload = z.infer<typeof PluginAttachmentSearchPayloadSchema>;
+//# sourceMappingURL=attachments.d.ts.map

package/dist/attachments.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export function defineAttachmentSource(definition) {
+    return definition;
+}
+export const PluginAttachmentItemSchema = z.object({
+    id: z.string(),
+    identifier: z.string(),
+    title: z.string(),
+    subtitle: z.string().optional(),
+    url: z.url(),
+    text: z.string(),
+    resourceType: z.string(),
+});
+export const PluginAttachmentSearchPayloadSchema = z.object({
+    items: z.array(PluginAttachmentItemSchema),
+});
+//# sourceMappingURL=attachments.js.map

package/dist/client/buttons.d.ts

@@ -0,0 +1,64 @@
+import type { ComponentType } from "react";
+import type { PluginHostProps } from "./contracts.js";
+export type PluginButtonContext = {
+    context: "workspace";
+    workspaceId: string;
+} | {
+    context: "agent";
+    workspaceId: string;
+    agentId: string;
+};
+export type PluginButtonIconProps = PluginHostProps & PluginButtonContext & {
+    size: number;
+    color: string;
+};
+export type PluginButtonContentProps = PluginHostProps & PluginButtonContext & {
+    close(): void;
+};
+export type PluginButtonIcon = string | ComponentType<PluginButtonIconProps>;
+export type PluginButtonBehavior = {
+    kind: "action";
+    onPress(): void | Promise<void>;
+} | {
+    kind: "menu";
+    items: readonly PluginButtonMenuEntry[];
+} | {
+    kind: "popover";
+    Content: ComponentType<PluginButtonContentProps>;
+};
+export type PluginButtonMenuEntry = {
+    kind: "separator";
+    id: string;
+} | {
+    kind: "item";
+    id: string;
+    title: string;
+    icon?: PluginButtonIcon;
+    visible?: boolean;
+    disabled?: boolean;
+    behavior: PluginButtonBehavior;
+};
+export interface PluginButton {
+    title: string;
+    icon: PluginButtonIcon;
+    /** Omit for an icon-only header button. Composer pills use title when omitted. */
+    label?: string;
+    visible?: boolean;
+    disabled?: boolean;
+    behavior: PluginButtonBehavior;
+}
+export interface PluginButtonRegistration {
+    /** Updates presentation in place. Supply a complete behavior to replace it. */
+    update(patch: Partial<PluginButton>): void;
+    /** Idempotent. Updates after removal do nothing. */
+    remove(): void;
+}
+export interface PluginHeaderButtonContribution {
+    id: string;
+    workspaceId: string;
+    button: PluginButton;
+}
+export interface PluginComposerPillContribution extends PluginHeaderButtonContribution {
+    agentId: string;
+}
+//# sourceMappingURL=buttons.d.ts.map

package/dist/client/buttons.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=buttons.js.map

package/dist/client/client-state.d.ts

@@ -0,0 +1,15 @@
+import { type ReactNode } from "react";
+import type { PluginAgentSnapshot, PluginWorkspaceSnapshot } from "../contracts.js";
+export interface PluginClientStateSource {
+    subscribe(listener: () => void): () => void;
+    getWorkspace(id: string): PluginWorkspaceSnapshot | null;
+    getAgent(id: string): PluginAgentSnapshot | null;
+}
+export declare function usePluginClientStateSource(): PluginClientStateSource | null;
+export declare function useWorkspace<Selection>(workspaceId: string, selector: (workspace: PluginWorkspaceSnapshot) => Selection): Selection | null;
+export declare function useAgent<Selection>(agentId: string, selector: (agent: PluginAgentSnapshot) => Selection): Selection | null;
+export declare function PluginClientStateProvider({ children, source, }: {
+    children: ReactNode;
+    source: PluginClientStateSource;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=client-state.d.ts.map

package/dist/client/client-state.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+import { useSyncExternalStoreWithSelector } from "use-sync-external-store/shim/with-selector";
+import { shallowEqual } from "./shallow.js";
+const PluginClientStateContext = createContext(null);
+export function usePluginClientStateSource() {
+    return useContext(PluginClientStateContext);
+}
+function usePluginEntity(input) {
+    const source = usePluginClientStateSource();
+    if (!source)
+        throw new Error("Plugin state hooks must run inside a workspace panel");
+    return useSyncExternalStoreWithSelector(source.subscribe, () => input.read(source, input.id), () => input.read(source, input.id), (entity) => (entity ? input.selector(entity) : null), shallowEqual);
+}
+export function useWorkspace(workspaceId, selector) {
+    return usePluginEntity({
+        id: workspaceId,
+        read: (source, id) => source.getWorkspace(id),
+        selector,
+    });
+}
+export function useAgent(agentId, selector) {
+    return usePluginEntity({
+        id: agentId,
+        read: (source, id) => source.getAgent(id),
+        selector,
+    });
+}
+export function PluginClientStateProvider({ children, source, }) {
+    return (_jsx(PluginClientStateContext.Provider, { value: source, children: children }));
+}
+//# sourceMappingURL=client-state.js.map

package/dist/client/contracts.d.ts

@@ -0,0 +1,201 @@
+import type { ComponentType } from "react";
+import type { PaseoApi } from "@camerontaylor/paseo-client";
+import type { AgentTimelineItem } from "@camerontaylor/paseo-protocol/agent-types";
+import type { ZodType, input as ZodInput, output as ZodOutput } from "zod";
+import type { PluginRpcContract } from "../rpc.js";
+import type { PluginButtonRegistration, PluginHeaderButtonContribution, PluginComposerPillContribution } from "./buttons.js";
+import type { PluginTheme, PluginWorkspaceSnapshot, PluginAgentSnapshot, PluginThemeContribution, PluginAttachmentSourceContribution, PluginTimelineTransformResult, PluginCleanup } from "../contracts.js";
+export interface PluginHostProps {
+    theme: PluginTheme;
+    host: {
+        id: string;
+        label: string;
+    };
+    layout: {
+        compact: boolean;
+        platform: "ios" | "android" | "web";
+    };
+}
+interface PluginNavigableHostProps extends PluginHostProps {
+    /** Client-owned navigation. Undefined on older hosts; hide dependent affordances when absent. */
+    readonly navigation?: {
+        readonly openAgent: (input: {
+            readonly agentId: string;
+        }) => void;
+        readonly openWorkspace: (input: {
+            readonly workspaceId: string;
+        }) => void;
+    };
+}
+export interface PluginSurfaceProps extends PluginNavigableHostProps {
+}
+export interface PluginIconProps {
+    name: string;
+    size?: number;
+    color?: string;
+}
+export type PluginPanelLocation = "workspace" | "explorer";
+export interface PluginOpenPanelOptions {
+    location?: PluginPanelLocation;
+}
+interface PluginWorkspacePanelBase {
+    id: string;
+    title: string;
+    icon: string;
+    locations?: readonly PluginPanelLocation[];
+}
+export interface PluginWorkspacePanelProps extends PluginNavigableHostProps {
+    context: "workspace";
+    workspaceId: string;
+}
+export interface PluginAgentPanelProps extends PluginNavigableHostProps {
+    context: "agent";
+    workspaceId: string;
+    agentId: string;
+}
+export interface PluginClientOpenPanelOptions extends PluginOpenPanelOptions {
+    workspaceId: string;
+    agentId?: string;
+}
+export interface PluginClientContext extends PluginCommandCapabilities {
+    addSettingsScreen(contribution: PluginSettingsScreenContribution): PluginCleanup;
+    addSurface(id: string, Component: ComponentType<PluginSurfaceProps>): PluginCleanup;
+    addSidebarItem(contribution: PluginSidebarContribution): PluginCleanup;
+    addWorkspacePanel(contribution: PluginWorkspacePanelContribution): PluginCleanup;
+    addCommandCenterItem(contribution: PluginCommandCenterItemContribution): PluginCleanup;
+    addSlashCommand(contribution: PluginClientSlashCommandContribution): PluginCleanup;
+    addHeaderButton(contribution: PluginHeaderButtonContribution): PluginButtonRegistration;
+    addComposerPill(contribution: PluginComposerPillContribution): PluginButtonRegistration;
+    addAttachmentSource(contribution: PluginAttachmentSourceContribution): PluginCleanup;
+    addTheme(contribution: PluginThemeContribution): PluginCleanup;
+    addTimelineTransformer<ItemType extends AgentTimelineItem["type"]>(contribution: PluginTimelineTransformerContribution<ItemType>): PluginCleanup;
+    addTimelineRenderer<Schema extends ZodType>(contribution: PluginTimelineRendererContribution<Schema>): PluginCleanup;
+    openPanel(id: string, options: PluginClientOpenPanelOptions): void;
+}
+export type PluginClientContribution = (client: PluginClientContext) => PluginCleanup;
+export type PluginWorkspacePanelContribution = (PluginWorkspacePanelBase & {
+    context: "workspace";
+    Component: ComponentType<PluginWorkspacePanelProps>;
+}) | (PluginWorkspacePanelBase & {
+    context: "agent";
+    Component: ComponentType<PluginAgentPanelProps>;
+});
+export interface PluginSettingsScreenContribution {
+    id: string;
+    title: string;
+    icon: string;
+    Component: ComponentType<PluginSurfaceProps>;
+}
+export interface PluginSurfaceContribution {
+    id: string;
+    Component: ComponentType<PluginSurfaceProps>;
+}
+export interface PluginSidebarContribution {
+    id: string;
+    title: string;
+    icon: string;
+    surface: string;
+}
+export type PluginTimelineTransformerContribution<ItemType extends AgentTimelineItem["type"] = AgentTimelineItem["type"]> = ItemType extends AgentTimelineItem["type"] ? {
+    id: string;
+    query: {
+        itemType: ItemType;
+    };
+    transform(input: {
+        item: Extract<AgentTimelineItem, {
+            type: ItemType;
+        }>;
+        phase: "streaming" | "complete";
+    }): PluginTimelineTransformResult | undefined;
+} : never;
+export interface PluginTimelineItemProps<Data = unknown> extends PluginHostProps {
+    agentId: string;
+    item: {
+        type: "plugin";
+        kind: string;
+        version: number;
+        data: Data;
+    };
+    timestamp: Date;
+}
+export interface PluginTimelineRendererContribution<Schema extends ZodType = ZodType> {
+    kind: string;
+    version: number;
+    schema: Schema;
+    Component: ComponentType<PluginTimelineItemProps<ZodOutput<Schema>>>;
+}
+export interface PluginCommandCapabilities {
+    paseo: PaseoApi;
+    rpc<InputSchema extends ZodType, OutputSchema extends ZodType>(contract: PluginRpcContract<InputSchema, OutputSchema>, input: ZodInput<InputSchema>): Promise<ZodOutput<OutputSchema>>;
+    openSurface(id: string): void;
+    openSettings(id: string): void;
+}
+export interface PluginGlobalCommandContext extends PluginCommandCapabilities {
+    context: "global";
+}
+export interface PluginWorkspaceCommandContext extends PluginCommandCapabilities {
+    context: "workspace";
+    workspace: PluginWorkspaceSnapshot;
+    openPanel(id: string, options?: PluginOpenPanelOptions): void;
+}
+export interface PluginAgentCommandContext extends PluginCommandCapabilities {
+    context: "agent";
+    workspace: PluginWorkspaceSnapshot;
+    agent: PluginAgentSnapshot;
+    openPanel(id: string, options?: PluginOpenPanelOptions): void;
+}
+interface PluginCommandCenterItemBase {
+    id: string;
+    title: string;
+    icon: string;
+    keywords?: readonly string[];
+}
+export type PluginCommandCenterItemContribution = (PluginCommandCenterItemBase & {
+    context: "global";
+    onSelect(context: PluginGlobalCommandContext): void | Promise<void>;
+}) | (PluginCommandCenterItemBase & {
+    context: "workspace";
+    onSelect(context: PluginWorkspaceCommandContext): void | Promise<void>;
+}) | (PluginCommandCenterItemBase & {
+    context: "agent";
+    onSelect(context: PluginAgentCommandContext): void | Promise<void>;
+});
+interface PluginClientSlashCommandBase {
+    name: string;
+    description: string;
+    argumentHint: string;
+}
+export type PluginClientSlashCommandContribution = (PluginClientSlashCommandBase & {
+    context: "workspace";
+    onSubmit(context: PluginWorkspaceCommandContext & {
+        args: string;
+    }): void | Promise<void>;
+}) | (PluginClientSlashCommandBase & {
+    context: "agent";
+    onSubmit(context: PluginAgentCommandContext & {
+        args: string;
+    }): void | Promise<void>;
+});
+export type SettingsState<Schema extends ZodType> = ({
+    status: "loading";
+} | {
+    status: "error";
+    error: string;
+} | {
+    status: "invalid";
+    error: string;
+    revision: string;
+} | {
+    status: "ready";
+    values: ZodOutput<Schema>;
+    revision: string;
+}) & {
+    saving: boolean;
+    saveError: string | null;
+    /** Save an entire document against the revision currently displayed. Never throws. */
+    save(values: ZodOutput<Schema>, revision: string): Promise<boolean>;
+    reset(): Promise<boolean>;
+    reload(): Promise<void>;
+};
+export {};
+//# sourceMappingURL=contracts.d.ts.map

package/dist/client/contracts.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=contracts.js.map

package/dist/client/host.d.ts

@@ -0,0 +1,19 @@
+export { PluginClientStateProvider, type PluginClientStateSource } from "./client-state.js";
+export { usePluginRuntimeContextBridge, type PluginRuntimeContextBridge, } from "./runtime-context-bridge.js";
+import type { PluginAttachmentSourceContribution } from "../contracts.js";
+import { PluginRpcProvider } from "./rpc-context.js";
+import { PaseoApiProvider } from "./paseo-context.js";
+import { callPluginRpc } from "../rpc.js";
+export declare function searchPluginAttachments(source: PluginAttachmentSourceContribution, invoke: (method: string, input: unknown) => Promise<unknown>, query: string): Promise<{
+    items: {
+        id: string;
+        identifier: string;
+        title: string;
+        url: string;
+        text: string;
+        resourceType: string;
+        subtitle?: string | undefined;
+    }[];
+}>;
+export { callPluginRpc, PaseoApiProvider, PluginRpcProvider };
+//# sourceMappingURL=host.d.ts.map

package/dist/client/host.js

@@ -0,0 +1,12 @@
+import { PluginAttachmentSearchPayloadSchema } from "../attachments.js";
+export { PluginClientStateProvider } from "./client-state.js";
+export { usePluginRuntimeContextBridge, } from "./runtime-context-bridge.js";
+import { PluginRpcProvider } from "./rpc-context.js";
+import { PaseoApiProvider } from "./paseo-context.js";
+import { callPluginRpc } from "../rpc.js";
+export async function searchPluginAttachments(source, invoke, query) {
+    const output = await callPluginRpc(source.search, invoke, { query });
+    return PluginAttachmentSearchPayloadSchema.parseAsync(output);
+}
+export { callPluginRpc, PaseoApiProvider, PluginRpcProvider };
+//# sourceMappingURL=host.js.map

package/dist/client/index.d.ts

@@ -0,0 +1,10 @@
+export type { PluginHostProps, PluginSurfaceProps, PluginIconProps, PluginPanelLocation, PluginOpenPanelOptions, PluginWorkspacePanelProps, PluginAgentPanelProps, PluginClientOpenPanelOptions, PluginClientContext, PluginClientContribution, PluginWorkspacePanelContribution, PluginSettingsScreenContribution, PluginSurfaceContribution, PluginSidebarContribution, PluginTimelineTransformerContribution, PluginTimelineItemProps, PluginTimelineRendererContribution, PluginCommandCapabilities, PluginGlobalCommandContext, PluginWorkspaceCommandContext, PluginAgentCommandContext, PluginCommandCenterItemContribution, PluginClientSlashCommandContribution, SettingsState, } from "./contracts.js";
+export type { PluginButton, PluginButtonBehavior, PluginButtonContentProps, PluginButtonContext, PluginButtonIcon, PluginButtonIconProps, PluginButtonMenuEntry, PluginButtonRegistration, PluginComposerPillContribution, PluginHeaderButtonContribution, } from "./buttons.js";
+export { usePaseo } from "./paseo-context.js";
+export { useAgent, useWorkspace } from "./client-state.js";
+export { useRpc } from "./rpc-context.js";
+import type { SettingsDefinition } from "../settings.js";
+import type { SettingsState } from "./contracts.js";
+import type { ZodType } from "zod";
+export declare function useSettings<Schema extends ZodType>(definition: SettingsDefinition<Schema>): SettingsState<Schema>;
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.js

@@ -0,0 +1,4 @@
+export { usePaseo } from "./paseo-context.js";
+export { useAgent, useWorkspace } from "./client-state.js";
+export { useRpc } from "./rpc-context.js";
+//# sourceMappingURL=index.js.map

package/dist/client/paseo-context.d.ts

@@ -0,0 +1,9 @@
+import type { PaseoApi } from "@camerontaylor/paseo-client";
+import { type ReactNode } from "react";
+export declare function usePaseoContextValue(): PaseoApi | null;
+export declare function PaseoApiProvider({ children, paseo }: {
+    children: ReactNode;
+    paseo: PaseoApi;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function usePaseo(): PaseoApi;
+//# sourceMappingURL=paseo-context.d.ts.map

package/dist/client/paseo-context.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+const PaseoApiContext = createContext(null);
+export function usePaseoContextValue() {
+    return useContext(PaseoApiContext);
+}
+export function PaseoApiProvider({ children, paseo }) {
+    return _jsx(PaseoApiContext.Provider, { value: paseo, children: children });
+}
+export function usePaseo() {
+    const paseo = usePaseoContextValue();
+    if (!paseo)
+        throw new Error("usePaseo must run inside a contributed plugin surface");
+    return paseo;
+}
+//# sourceMappingURL=paseo-context.js.map

package/dist/client/react-native.d.ts

@@ -0,0 +1,46 @@
+import type { ComponentType, FunctionComponent, ReactNode, ForwardRefExoticComponent, RefAttributes, ReactElement, Ref } from "react";
+import type { StyleProp, ViewStyle, ScrollView as NativeScrollView, ScrollViewProps, FlatList as NativeFlatList, FlatListProps, TextInput as NativeTextInput, TextInputProps } from "react-native";
+import type { PluginIconProps } from "./contracts.js";
+export interface ModalProps {
+    title: string;
+    icon?: ReactNode;
+    open: boolean;
+    onOpenChange(open: boolean): void;
+    children: ReactNode;
+}
+export interface ModalContentProps {
+    children: ReactNode;
+    /** Paint the full body below the header. */
+    style?: StyleProp<ViewStyle>;
+    /** Overrides the default 24px padding and 16px gap. Safe-area clearance stays host-owned. */
+    contentContainerStyle?: StyleProp<ViewStyle>;
+    /** Default true. Set false for a bounded body with your own ScrollView or FlatList. */
+    scrollable?: boolean;
+}
+export interface ModalComponent extends FunctionComponent<ModalProps> {
+    Content: ComponentType<ModalContentProps>;
+}
+export type ToastVariant = "default" | "info" | "success" | "warning" | "error";
+export interface ToastOptions {
+    variant?: ToastVariant;
+    durationMs?: number;
+}
+export interface ToastApi {
+    show(message: string, options?: ToastOptions): void;
+    error(message: string): void;
+}
+export declare const Icon: ComponentType<PluginIconProps>;
+export declare const Modal: ModalComponent;
+export declare function useToast(): ToastApi;
+export declare function useRevealedText(text: string, phase: "streaming" | "complete"): string;
+export type { PluginIconProps } from "./contracts.js";
+/** React Native scrolling with the host's sheet gestures when rendered inside a sheet. */
+export declare const ScrollView: ForwardRefExoticComponent<ScrollViewProps & RefAttributes<NativeScrollView>>;
+export declare function FlatList<Item>(props: FlatListProps<Item> & {
+    ref?: Ref<NativeFlatList<Item>>;
+}): ReactElement;
+/** Copies text to this client's clipboard. Rejects when copying is unavailable or denied. */
+export declare function copyText(text: string): Promise<void>;
+/** Native input focus integrated with modal keyboard positioning. */
+export declare const TextInput: ForwardRefExoticComponent<TextInputProps & RefAttributes<NativeTextInput>>;
+//# sourceMappingURL=react-native.d.ts.map

package/dist/client/react-native.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=react-native.js.map

package/dist/client/rpc-context.d.ts

@@ -0,0 +1,13 @@
+import { type ReactNode } from "react";
+import type { ZodType, input as ZodInput, output as ZodOutput } from "zod";
+import { type PluginRpcContract } from "../rpc.js";
+export interface PluginRpcContextValue {
+    invoke(method: string, input: unknown): Promise<unknown>;
+}
+export declare function usePluginRpcContextValue(): PluginRpcContextValue | null;
+export declare function PluginRpcProvider({ children, invoke, }: {
+    children: ReactNode;
+    invoke(method: string, input: unknown): Promise<unknown>;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useRpc<InputSchema extends ZodType, OutputSchema extends ZodType>(contract: PluginRpcContract<InputSchema, OutputSchema>): (input: ZodInput<InputSchema>) => Promise<ZodOutput<OutputSchema>>;
+//# sourceMappingURL=rpc-context.d.ts.map

package/dist/client/rpc-context.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useMemo } from "react";
+import { callPluginRpc } from "../rpc.js";
+const PluginRpcContext = createContext(null);
+export function usePluginRpcContextValue() {
+    return useContext(PluginRpcContext);
+}
+export function PluginRpcProvider({ children, invoke, }) {
+    const value = useMemo(() => ({ invoke }), [invoke]);
+    return _jsx(PluginRpcContext.Provider, { value: value, children: children });
+}
+export function useRpc(contract) {
+    const context = usePluginRpcContextValue();
+    if (!context)
+        throw new Error("useRpc must run inside a contributed plugin surface");
+    return useCallback((input) => callPluginRpc(contract, context.invoke, input), [context, contract]);
+}
+//# sourceMappingURL=rpc-context.js.map

package/dist/client/runtime-context-bridge.d.ts

@@ -0,0 +1,5 @@
+import { type ReactNode } from "react";
+export type PluginRuntimeContextBridge = (children: ReactNode) => ReactNode;
+/** Rebuilds plugin runtime contexts inside React Native portal hosts. */
+export declare function usePluginRuntimeContextBridge(): PluginRuntimeContextBridge;
+//# sourceMappingURL=runtime-context-bridge.d.ts.map

package/dist/client/runtime-context-bridge.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback } from "react";
+import { PluginClientStateProvider, usePluginClientStateSource } from "./client-state.js";
+import { PaseoApiProvider, usePaseoContextValue } from "./paseo-context.js";
+import { PluginRpcProvider, usePluginRpcContextValue } from "./rpc-context.js";
+/** Rebuilds plugin runtime contexts inside React Native portal hosts. */
+export function usePluginRuntimeContextBridge() {
+    const paseo = usePaseoContextValue();
+    const rpc = usePluginRpcContextValue();
+    const state = usePluginClientStateSource();
+    if (!paseo || !rpc) {
+        throw new Error("Plugin UI must run inside a contributed plugin surface");
+    }
+    return useCallback((children) => {
+        const content = state ? (_jsx(PluginClientStateProvider, { source: state, children: children })) : (children);
+        return (_jsx(PaseoApiProvider, { paseo: paseo, children: _jsx(PluginRpcProvider, { invoke: rpc.invoke, children: content }) }));
+    }, [paseo, rpc, state]);
+}
+//# sourceMappingURL=runtime-context-bridge.js.map

package/dist/client/shallow.d.ts

@@ -0,0 +1,2 @@
+export declare function shallowEqual(left: unknown, right: unknown): boolean;
+//# sourceMappingURL=shallow.d.ts.map

package/dist/client/shallow.js

@@ -0,0 +1,45 @@
+function isIterable(value) {
+    return Symbol.iterator in value;
+}
+function hasEntries(value) {
+    return "entries" in value;
+}
+function compareEntries(left, right) {
+    const leftEntries = left instanceof Map ? left : new Map(left.entries());
+    const rightEntries = right instanceof Map ? right : new Map(right.entries());
+    if (leftEntries.size !== rightEntries.size)
+        return false;
+    for (const [key, value] of leftEntries) {
+        if (!rightEntries.has(key) || !Object.is(value, rightEntries.get(key)))
+            return false;
+    }
+    return true;
+}
+function compareIterables(left, right) {
+    const leftIterator = left[Symbol.iterator]();
+    const rightIterator = right[Symbol.iterator]();
+    let leftValue = leftIterator.next();
+    let rightValue = rightIterator.next();
+    while (!leftValue.done && !rightValue.done) {
+        if (!Object.is(leftValue.value, rightValue.value))
+            return false;
+        leftValue = leftIterator.next();
+        rightValue = rightIterator.next();
+    }
+    return Boolean(leftValue.done && rightValue.done);
+}
+export function shallowEqual(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (!left || !right || typeof left !== "object" || typeof right !== "object")
+        return false;
+    if (Object.getPrototypeOf(left) !== Object.getPrototypeOf(right))
+        return false;
+    if (isIterable(left) && isIterable(right)) {
+        if (hasEntries(left) && hasEntries(right))
+            return compareEntries(left, right);
+        return compareIterables(left, right);
+    }
+    return compareEntries({ entries: () => Object.entries(left) }, { entries: () => Object.entries(right) });
+}
+//# sourceMappingURL=shallow.js.map