@notis_ai/cli 0.2.18 → 0.2.20

package/dist/space-sdk/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@notis/sdk",
+  "version": "0.2.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "node": "./dist/index.js"
+    },
+    "./ui": {
+      "types": "./src/ui/index.d.ts",
+      "node": "./dist/ui.js"
+    },
+    "./words": "./src/words/index.ts",
+    "./config": "./src/config.ts",
+    "./vite": "./src/vite.ts"
+  },
+  "dependencies": {
+    "date-fns": "^4.4.0",
+    "react-day-picker": "^10.0.2",
+    "react-markdown": "^10.1.0",
+    "recharts": "^3.10.1",
+    "remark-gfm": "^4.0.1"
+  },
+  "peerDependencies": {
+    "@vitejs/plugin-react": ">=4.0.0",
+    "react": ">=18.0.0",
+    "react-dom": ">=18.0.0",
+    "vite": ">=5.0.0"
+  },
+  "description": "Notis SDK types for Spaces. The Notis host provides @notis/sdk and @notis/sdk/ui at runtime; dist/ serves Node tests only.",
+  "types": "./src/index.d.ts"
+}

package/dist/space-sdk/src/agentContext.d.ts

@@ -0,0 +1,36 @@
+/** Serializable context shared with the agent. Apps own annotation storage. */
+export interface ContextAttachment {
+    /** Durable HTTPS URL supplied by the app. Sent through the host media pipeline. */
+    url: string;
+    name: string;
+    mimeType: string;
+}
+export interface AgentContextContent {
+    title?: string;
+    /** Emoji, Phosphor icon name, or HTTPS image URL. Never executable markup. */
+    icon?: string;
+    /** An app-defined kind, not a closed list of annotation types. */
+    kind?: string;
+    text?: string;
+    comment?: string;
+    preview?: {
+        format: 'text' | 'markdown';
+        content: string;
+    };
+    /** Any JSON-serializable value: coordinates, chart state, loaded records, etc. */
+    data?: unknown;
+    attachments?: ContextAttachment[];
+}
+export interface AgentContextItem extends AgentContextContent {
+    /** Stable within this app. The host scopes IDs to the originating app. */
+    id: string;
+    resource?: import('./runtime').ContextResource | null;
+}
+/** Host-stamped origin. Apps describe resources; the host identifies the app/view. */
+export interface AgentContextSource {
+    appId: string;
+    appName: string;
+    viewSlug: string;
+    viewName: string;
+    viewUrl?: string | null;
+}

package/dist/space-sdk/src/components/Dialog.d.ts

@@ -0,0 +1,20 @@
+import React, { type ReactNode } from 'react';
+export interface DialogProps {
+    open: boolean;
+    /** Request dismissal. Keep open unchanged to prevent dismissal while saving. */
+    onClose: () => void;
+    title: ReactNode;
+    description?: ReactNode;
+    role?: 'dialog' | 'alertdialog';
+    /**
+     * A confirmation: on phones and tablets the operating system's own dialog asks instead of the card. OK clicks the
+     * button marked `data-dialog-confirm`; Cancel clicks the one marked `data-dialog-cancel`, else calls `onClose`.
+     * Desktop browsers and the Desktop app keep the card.
+     */
+    nativeOnTouch?: boolean;
+    children: ReactNode;
+}
+/** Touch-first devices confirm with the operating system's dialog, as the Portal's AlertDialog does. */
+export declare function prefersNativeConfirm(): boolean;
+/** Native top-layer dialog; content and actions remain app-owned. */
+export declare function Dialog({ open, onClose, title, description, role, nativeOnTouch, children }: DialogProps): React.JSX.Element;

package/dist/space-sdk/src/components/DocumentEditor.d.ts

@@ -0,0 +1,46 @@
+import type { ReactElement } from 'react';
+import type { NotisDocumentEditorProps } from '../runtime';
+/** The words of the read-only document preview, in English and French (C7). */
+export declare const DOCUMENT_EDITOR_WORDS: Readonly<{
+    loading: {
+        en: string;
+        fr: string;
+    };
+    readOnly: {
+        en: string;
+        fr: string;
+    };
+    report: {
+        en: string;
+        fr: string;
+    };
+    html: {
+        en: string;
+        fr: string;
+    };
+    view: {
+        en: string;
+        fr: string;
+    };
+    file: {
+        en: string;
+        fr: string;
+    };
+    anyFile: {
+        en: string;
+        fr: string;
+    };
+}>;
+/**
+ * Embeds the document editor for a document anywhere in an app view. The host
+ * (portal) provides the implementation through `runtime.ui.DocumentEditor` and
+ * dispatches on the document's content type (markdown -> rich text editor,
+ * files -> matching viewer, views -> their trusted native Documents surface).
+ * Outside the portal this falls back to a read-only preview or an explicit
+ * open-in-Space notice for native views.
+ *
+ * ```tsx
+ * <DocumentEditor documentId={entry.id} variant="body" className="min-h-[320px]" />
+ * ```
+ */
+export declare function DocumentEditor(props: NotisDocumentEditorProps): ReactElement;

package/dist/space-sdk/src/components/DocumentPage.d.ts

@@ -0,0 +1,53 @@
+import { type ReactElement } from 'react';
+import type { NotisDocumentPageProps } from '../runtime';
+/** Column widths shared by the host page, its skeleton and the fallback, so nothing moves when the page arrives. */
+export declare const DOCUMENT_PAGE_WIDTHS: {
+    readonly standard: 900;
+    readonly wide: 1200;
+    readonly full: undefined;
+};
+/**
+ * The page's horizontal gutter: 16px, then 48px from 640px wide (the host page's px-4 sm:px-12), and its
+ * toolbar height (56px plus its 1px border, Beta's py-3 toolbar). The skeleton uses the same values.
+ */
+export declare const DOCUMENT_PAGE_GUTTER: {
+    readonly narrow: 16;
+    readonly wide: 48;
+    readonly breakpoint: 640;
+    readonly toolbar: 57;
+};
+/**
+ * Placeholder shaped like the document page (toolbar, icon row, title, meta strip, body lines) at the
+ * same column width and gutter, so the page replaces it without a layout shift. Hosts show it while the
+ * record and the editor load; a Space can show it while its own data decides which record opens.
+ */
+export declare function DocumentPageSkeleton({ width, className, label }: {
+    width?: NotisDocumentPageProps['width'];
+    className?: string;
+    label?: string;
+}): ReactElement;
+/**
+ * The full page of one record that is the main content of a Space view, such as a note: breadcrumb,
+ * Saving or Saved status, '...' menu, cover, icon, title, meta strip, properties that save
+ * automatically, and the collaborative body with presence. The host (Portal) draws it and keeps one
+ * save queue for the whole record. Files open in their viewer under the header; HTML and reports show
+ * only the toolbar (breadcrumb, actions, Share, '...' menu) above their frame, with no header, meta,
+ * properties, aboveBody or belowBody. `viewer: 'html'` opens a record whose one stored `.html` file is
+ * the page (for example a note that keeps a saved HTML report) the same way.
+ *
+ * ```tsx
+ * if (params.note) return <DocumentPage recordKey={params.note}
+ *   breadcrumb={[{ label: 'All notes', onSelect: () => setParams({ note: null }) }]}
+ *   actions={<TrashButton />} onSaved={() => notes.refetch()} />;
+ * ```
+ *
+ * Slots (`breadcrumb`, `actions`, `menuItems`, `aboveBody`, `belowBody`) and toggles (`share`,
+ * `header`, `meta`, `properties`, `width`) adjust it; `layout` rearranges its parts. Hosts without
+ * this component show the record with `DocumentEditor` instead.
+ */
+export declare function DocumentPage(props: NotisDocumentPageProps): ReactElement;
+/**
+ * Starts reading a record before it opens (for example on a list row's hover or focus), so its
+ * DocumentPage shows at once. Does nothing outside a host that supports it.
+ */
+export declare function usePrefetchRecord(): (recordKey: string) => void;

package/dist/space-sdk/src/components/Markdown.d.ts

@@ -0,0 +1,18 @@
+import type { ReactElement } from 'react';
+import { type Components } from 'react-markdown';
+export interface MarkdownProps {
+    /** Markdown source to render. */
+    value: string;
+    /** Typography scale. 'sm' suits dense surfaces (cards, list rows). */
+    size?: 'sm' | 'base';
+    className?: string;
+    /** Per-element overrides, passed through to react-markdown. */
+    components?: Components;
+}
+/**
+ * Renders a markdown value with Notis typography. Markdown is a value type:
+ * use this anywhere markdown appears (document content, database fields,
+ * generated text). Styling comes from `.notis-markdown` rules in the SDK
+ * stylesheet and follows the portal theme variables.
+ */
+export declare function Markdown({ value, size, className, components }: MarkdownProps): ReactElement;

package/dist/space-sdk/src/components/MarkdownEditor.d.ts

@@ -0,0 +1,11 @@
+import type { ReactElement } from 'react';
+import type { NotisMarkdownEditorProps } from '../runtime';
+/** The words of the fallback Markdown editor, in English and French (C9). */
+export declare const MARKDOWN_EDITOR_WORDS: Readonly<{
+    placeholder: {
+        en: string;
+        fr: string;
+    };
+}>;
+/** Use Notis' editor while leaving persistence entirely under app control; outside Notis a plain EN/FR textarea stands in. */
+export declare function MarkdownEditor(props: NotisMarkdownEditorProps): ReactElement;

package/dist/space-sdk/src/components/MultiSelectActionBar.d.ts

@@ -0,0 +1,31 @@
+import { type CSSProperties, type ReactElement } from 'react';
+import type { ResolvedCollectionAction } from '../interactions/actions';
+import type { ShortcutScope } from '../interactions/shortcuts';
+export type MultiSelectAction = ResolvedCollectionAction;
+/** The Portal owns global launcher positioning; app code only reports its own bar. */
+export declare const BULK_ACTION_LAYOUT_EVENT = "notis:bulk-actions-layout";
+export interface BulkActionLayoutDetail {
+    bar: HTMLElement;
+    active: boolean;
+}
+export interface MultiSelectActionBarProps {
+    selectedCount: number;
+    actions: MultiSelectAction[];
+    /** Override the "{count} selected" label units. Default: "selected" with no item word. */
+    itemLabel?: {
+        singular: string;
+        plural: string;
+    };
+    /** Optional extra class on the outer container (composed alongside the inline styles). */
+    className?: string;
+    /** Optional override for the bar's positioning style. Defaults to bottom-center floating. */
+    style?: CSSProperties;
+    /** Disable action key bindings while leaving the visible toolbar mounted. */
+    shortcutsEnabled?: boolean;
+    /** Override the default collection shortcut scope. */
+    shortcutScope?: ShortcutScope;
+    collectionOwnerId?: string;
+    isAvailable?: () => boolean;
+    onClearSelection?: () => void;
+}
+export declare function MultiSelectActionBar({ selectedCount, actions, itemLabel, className, style, shortcutsEnabled, shortcutScope, collectionOwnerId, isAvailable, onClearSelection, }: MultiSelectActionBarProps): ReactElement | null;

package/dist/space-sdk/src/components/MultiSelectCheckbox.d.ts

@@ -0,0 +1,14 @@
+import { type CSSProperties, type MouseEvent as ReactMouseEvent, type ReactElement } from 'react';
+export interface MultiSelectCheckboxProps {
+    isSelected: boolean;
+    onClick: (event: ReactMouseEvent) => void;
+    disabled?: boolean;
+    /** When true, the checkbox is always visible. Default false (hover/focus reveal via the parent's :hover state). */
+    alwaysVisible?: boolean;
+    /** Optional aria-label override. Defaults to "Select item" / "Deselect item". */
+    ariaLabel?: string;
+    className?: string;
+    /** Optional inline-style override merged with the defaults. */
+    style?: CSSProperties;
+}
+export declare function MultiSelectCheckbox({ isSelected, onClick, disabled, alwaysVisible, ariaLabel, className, style, }: MultiSelectCheckboxProps): ReactElement;

package/dist/space-sdk/src/components/MultiSelectDragOverlay.d.ts

@@ -0,0 +1,8 @@
+import { type CSSProperties, type ReactElement } from 'react';
+import type { DragRect } from '../hooks/useMultiSelect';
+export interface MultiSelectDragOverlayProps {
+    rect: DragRect | null;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function MultiSelectDragOverlay({ rect, className, style, }: MultiSelectDragOverlayProps): ReactElement | null;

package/dist/space-sdk/src/components/NotisCommentBoundary.d.ts

@@ -0,0 +1,36 @@
+import React, { type ReactNode } from 'react';
+import type { ContextResource } from '../runtime';
+export interface NotisCommentBoxProps {
+    quote?: string;
+    value: string;
+    onChange(value: string): void;
+    onSubmit(): void;
+    onCancel(): void;
+    pending?: boolean;
+    error?: string;
+    className?: string;
+}
+/** Compact, chrome-themed presentation. Apps retain ownership of comment state. */
+export declare function NotisCommentBox({ quote, value, onChange, onSubmit, onCancel, pending, error, className }: NotisCommentBoxProps): React.JSX.Element;
+export interface NotisCommentBoundaryProps {
+    resource?: ContextResource | null;
+    children: ReactNode;
+    className?: string;
+    commentClassName?: string;
+    /** Replace the optional standard editor while retaining selection/context behavior. */
+    renderComment?: (props: NotisCommentBoxProps) => ReactNode;
+}
+type SelectionRect = Pick<DOMRect, 'left' | 'right' | 'top' | 'bottom'>;
+/** Place the tile after the final selected line, otherwise below (or above near the viewport bottom). */
+export declare function getCommentActionPosition(rects: SelectionRect[], viewport: {
+    width: number;
+    height: number;
+}, rightBoundary?: number, trailing?: SelectionRect[]): {
+    left: number;
+    top: number;
+};
+/** Browser paragraph selection may include an adjacent block's empty starting boundary. */
+export declare function getOwnedCommentRange(selected: Range, content: Element): Range | null;
+/** Selection-to-chat convenience. No annotation database, polling or background attachment. */
+export declare function NotisCommentBoundary({ resource, children, className, commentClassName, renderComment }: NotisCommentBoundaryProps): React.JSX.Element;
+export {};

package/dist/space-sdk/src/components/NotisSelectionBoundary.d.ts

@@ -0,0 +1,16 @@
+import type { CSSProperties, ReactNode } from 'react';
+import React from 'react';
+import type { ContextResource } from '../runtime';
+export declare const NOTIS_CONTEXT_CLIPBOARD_TYPE = "application/x-notis-context+json";
+export interface NotisSelectionBoundaryProps {
+    resource?: ContextResource | null;
+    children: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}
+/**
+ * Adds structured provenance to ordinary copied text. Pasting still works in
+ * every app because `text/plain` is preserved; Notis chat additionally reads
+ * the custom MIME payload and renders a separate quote pill.
+ */
+export declare function NotisSelectionBoundary({ resource, children, className, style, }: NotisSelectionBoundaryProps): React.JSX.Element;

package/dist/space-sdk/src/components/RecordComponents.d.ts

@@ -0,0 +1,64 @@
+import type { ReactElement } from 'react';
+import type { NotisHtmlFrameProps, NotisRecordPropertiesProps, NotisReportFrameProps, NotisShareControlProps, NotisSpacePageFrameProps } from '../runtime';
+/** The words a record component says outside Notis, in English and French. */
+export declare const RECORD_COMPONENT_WORDS: Readonly<{
+    unavailable: {
+        en: string;
+        fr: string;
+    };
+    /** Short enough for a toolbar (C11); the full sentence is its tooltip. */
+    shareUnavailable: {
+        en: string;
+        fr: string;
+    };
+    shareUnavailableHint: {
+        en: string;
+        fr: string;
+    };
+    spacePageTitle: {
+        en: string;
+        fr: string;
+    };
+    spacePagePreview: {
+        en: string;
+        fr: string;
+    };
+    spacePageOpen: {
+        en: string;
+        fr: string;
+    };
+}>;
+/** What a record component shows when the host does not draw it: one sentence, in the Space's language. */
+export declare function RecordComponentUnavailable({ className }: {
+    className?: string;
+}): ReactElement;
+/** The record's properties, drawn by the host. */
+export declare function RecordProperties(props: NotisRecordPropertiesProps): ReactElement;
+/** The host applies its viewer CSP and an opaque-origin sandbox; source cannot relax either. */
+export declare function HtmlFrame(props: NotisHtmlFrameProps): ReactElement;
+/** A saved report's frame, drawn by the host. */
+export declare function ReportFrame(props: NotisReportFrameProps): ReactElement;
+/**
+ * Private/shared state, copy link and revoke, backed by this record's Site. Outside Notis it sits in a toolbar as a
+ * short muted label whose tooltip says where sharing works (C11), never a sentence that fills the bar.
+ */
+export declare function ShareControl(props: NotisShareControlProps): ReactElement;
+/**
+ * The path a Space page link names and the link the fallback card may open: a site-relative path, or an http(s) URL
+ * without credentials. Anything else (script URLs, protocol-relative links) opens nothing.
+ */
+export declare function spacePageLink(href: string): {
+    path: string;
+    openHref: string | null;
+};
+/** What a Space page frame shows when the host does not draw it (previews, verify): its title, its path and Open page. */
+export declare function SpacePageCard({ href, title, className, notice }: Pick<NotisSpacePageFrameProps, 'href' | 'title' | 'className'> & {
+    /** One sentence under the path; default: the page shows live once the Space opens in Notis. */
+    notice?: string;
+}): ReactElement;
+/**
+ * Another Space page shown live inside this view. The host loads only a Space page of its own Notis origin, with the
+ * viewer's own access; any other link (and every host without the frame) shows a card with the title, the path and
+ * Open page. Not interactive by default, so a deck around it keeps its keys and clicks.
+ */
+export declare function SpacePageFrame(props: NotisSpacePageFrameProps): ReactElement;

package/dist/space-sdk/src/components/ShortcutHints.d.ts

@@ -0,0 +1,12 @@
+import { type CSSProperties, type ReactElement } from 'react';
+export interface ShortcutHint {
+    id: string;
+    keys: string;
+    label: string;
+}
+export interface ShortcutHintsProps {
+    shortcuts: ShortcutHint[];
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function ShortcutHints({ shortcuts, className, style }: ShortcutHintsProps): ReactElement | null;

package/dist/space-sdk/src/components/Skeleton.d.ts

@@ -0,0 +1,23 @@
+import type { CSSProperties } from 'react';
+import { type Locale, type Words } from '../words/types';
+/** What a loading placeholder says to screen readers. */
+export declare const SKELETON_WORDS: Readonly<{
+    loading: {
+        en: string;
+        fr: string;
+    };
+}>;
+/** Content-shaped placeholder. Never use it to replace a successful cached result. */
+export declare function Skeleton({ className, style }: {
+    className?: string;
+    style?: CSSProperties;
+}): import("react").JSX.Element;
+/** A whole view loading: a title bar and table, cards, graph or detail placeholders, named for screen readers in the Space's language. */
+export declare function ViewSkeleton({ variant, rows, label, locale }: {
+    variant?: 'table' | 'cards' | 'graph' | 'detail';
+    rows?: number;
+    /** What loads, said to screen readers ("Loading meetings"). Default "Loading content". */
+    label?: Words | string;
+    /** Default the Space's locale. */
+    locale?: Locale;
+}): import("react").JSX.Element;

package/dist/space-sdk/src/config.ts

@@ -0,0 +1,31 @@
+export { defineSpace, defineSpaces } from './space';
+export type { SpaceDefinition, SpacesWorkspace, SpaceActionTemplate, SpaceResourceReference, SpaceDatabaseCreate } from './space';
+export type { SpaceViewParam, SpaceViewParamType, SpaceShows, SpaceMemoryPolicy, SpaceMemorySnapshot, SpaceChrome, SpaceMarkdownInput } from './space';
+
+/**
+ * Configuration utilities for notis.config.ts and Space definitions.
+ *
+ * Usage:
+ * ```ts
+ * // notis.config.ts
+ * import { defineSpaces } from '@notis/sdk/config';
+ *
+ * export default defineSpaces({
+ *   spaces: { notes: { definition: 'spaces/notes/space.config.ts' } },
+ * });
+ * ```
+ *
+ * Each definition file exports `defineSpace({ ... })`. `notis spaces build`
+ * reads only these two shapes.
+ */
+
+/**
+ * Identity helper kept so older sources whose configuration files still import
+ * it keep loading and bundling. It accepts any object and returns it unchanged;
+ * `notis spaces build` never reads that shape.
+ *
+ * @deprecated Use `defineSpaces` for the workspace index and `defineSpace` for each Space.
+ */
+export function defineNotisApp<T extends object>(config: T): T {
+  return config;
+}

package/dist/space-sdk/src/documents.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Document data helpers: normalize raw tool results (Notion-shaped property
+ * values, snake_case fields) into the SDK's `DocumentRecord`/`DatabaseProperty`
+ * shapes, and derive plain-text projections from typed content.
+ *
+ * These are pure functions — safe in any context (portal, dev harness, tests).
+ */
+import type { DatabaseProperty, DocumentRecord, SecretPropertyValue } from './runtime';
+import { type Locale } from './words/types';
+/** The words the document helpers fall back on. */
+export declare const DOCUMENT_WORDS: Readonly<{
+    untitled: {
+        en: string;
+        fr: string;
+    };
+}>;
+/** The locale of the fallback words ("Untitled"). Default English; the SDK hooks pass the Space's locale. */
+export interface DocumentWordsOptions {
+    locale?: Locale;
+}
+export declare function isPresentString(value: unknown): value is string;
+export declare function asRecord(value: unknown): Record<string, unknown> | null;
+export declare function optionalString(value: unknown): string | null;
+/** Flattens a Notion-shaped rich_text array (or plain string) to text. */
+export declare function extractRichText(value: unknown): string;
+/**
+ * Reads a `secret` property value. The platform only ever sends the pointer
+ * ({present, reference, status, metadata}), so this rebuilds it field by field
+ * rather than passing the payload through — an app can never surface secret
+ * material through this helper, whatever the server sent.
+ */
+export declare function getSecretValue(value: unknown): SecretPropertyValue;
+/** Extracts the ids of a normalized relation property value. */
+export declare function getRelationIds(value: unknown): string[];
+/**
+ * Collapses a Notion-shaped property value ({type: 'select', select: {...}})
+ * into a plain JS value (string, string[], number, boolean, ...). Values that
+ * are already plain pass through unchanged.
+ */
+export declare function normalizePropertyValue(value: unknown): unknown;
+/**
+ * Normalizes a raw document from a Notis database tool result
+ * (LOCAL_NOTIS_DATABASE_QUERY / GET_DOCUMENT / UPSERT_*) into a
+ * `DocumentRecord`: camelCases fields and collapses property values. A
+ * document with no title is titled "Untitled" in `options.locale`.
+ */
+export declare function normalizeDocumentRecord(value: unknown, options?: DocumentWordsOptions): DocumentRecord;
+/** Normalizes a raw schema property from LOCAL_NOTIS_DATABASE_GET_DATABASE. */
+export declare function normalizeDatabaseProperty(value: unknown): DatabaseProperty | null;
+/** Strips markdown syntax to readable plain text (previews, search). */
+export declare function markdownToPlainText(markdown: string): string;
+/** Flattens BlockNote block JSON to plain text. */
+export declare function blockNoteToPlainText(blocks: unknown): string;
+/**
+ * Best-available plain-text preview for a document:
+ * plainText -> contentMarkdown -> contentBlocknote -> title, else "Untitled"
+ * in `options.locale`.
+ */
+export declare function getDocumentPreview(document: DocumentRecord, options?: DocumentWordsOptions): string;

package/dist/space-sdk/src/hooks/useAction.d.ts

@@ -0,0 +1,8 @@
+import { type UseQueryOptions, type UseQueryResult } from './useQuery';
+import type { SpaceActionOptions } from '../space';
+export declare function useAction<TInput extends Record<string, unknown> = Record<string, unknown>, TResult = unknown>(actionId: string): {
+    call: (inputs: TInput, options?: SpaceActionOptions) => Promise<TResult>;
+    loading: boolean;
+    error: Error | null;
+};
+export declare function useActionQuery<TResult = unknown>(actionId: string, inputs: Record<string, unknown>, options?: UseQueryOptions): UseQueryResult<TResult>;

package/dist/space-sdk/src/hooks/useActiveResource.d.ts

@@ -0,0 +1,3 @@
+import type { ContextResource } from '../runtime';
+/** Keep Notis aware of the resource currently open inside an app view. */
+export declare function useActiveResource(resource: ContextResource | null): void;

package/dist/space-sdk/src/hooks/useAgentContext.d.ts

@@ -0,0 +1,7 @@
+import type { AgentContextItem } from '../agentContext';
+/** Share context without owning storage, opening a new thread, or sending a message. */
+export declare function useAgentContext(): {
+    add(item: AgentContextItem): Promise<boolean>;
+    update(item: AgentContextItem): Promise<boolean>;
+    remove(id: string): Promise<boolean>;
+};

package/dist/space-sdk/src/hooks/useBackend.d.ts

@@ -0,0 +1,23 @@
+interface UseBackendResult {
+    /**
+     * Make an authenticated request to the Notis backend.
+     * The path should be an absolute backend path (e.g. `/portal_composio/toolkits`).
+     */
+    request: (path: string, options?: {
+        method?: string;
+        headers?: Record<string, string>;
+        body?: unknown;
+    }) => Promise<unknown>;
+}
+/**
+ * Raw backend request proxy. Use this for custom server endpoints or
+ * integration APIs not covered by the typed hooks.
+ * Spaces deny raw requests; use useAction or useActionQuery for declared actions.
+ *
+ * ```tsx
+ * const { request } = useBackend();
+ * const data = await request('/portal_composio/toolkits', { method: 'GET' });
+ * ```
+ */
+export declare function useBackend(): UseBackendResult;
+export {};

package/dist/space-sdk/src/hooks/useCloudComputer.d.ts

@@ -0,0 +1,45 @@
+import type { CloudComputerFacts, NotisRuntime } from '../runtime';
+/** Cache key of the facts read; re-read once the viewer allows a Space to use the cloud computer. */
+export declare const CLOUD_COMPUTER_FACTS_KEY: readonly ['cloud-computer-facts'];
+/** Marks the facts stale in the host cache so every mounted `useCloudComputer()` reads them again. */
+export declare function invalidateCloudComputerFacts(runtime: NotisRuntime | null): void;
+export interface UseCloudComputerResult {
+    /**
+     * The facts, or null while the first read is in flight. `facts.available`
+     * is false when this host cannot answer — render the app's own fallback.
+     */
+    facts: CloudComputerFacts | null;
+    loading: boolean;
+    isFetching: boolean;
+    error: Error | null;
+    /** Re-read the facts. The platform caches them for a few minutes. */
+    refresh: () => Promise<void>;
+    /**
+     * Space only (`cloudComputer: 'read'` or `'shell'`): ask the host to show its approval prompt.
+     * Resolves true once the viewer allowed it (the facts are then read again), false when they did
+     * not, and null on hosts without the prompt (Beta Apps, Sites, previews offline).
+     */
+    requestApproval: () => Promise<boolean | null>;
+}
+/**
+ * Read-only facts about the user's cloud computer.
+ *
+ * ```tsx
+ * const { facts } = useCloudComputer();
+ * const gh = facts?.available ? facts.cli_auth.gh : null;
+ *
+ * return gh?.authenticated
+ *   ? <p>Signed in as {gh.account}</p>
+ *   : <GithubConnect />;
+ * ```
+ *
+ * Requires `cloudComputer: 'read'` (or `'shell'`) in `defineSpace` and the
+ * viewer's approval; until the viewer allows it the facts answer
+ * unavailable, so offer `requestApproval()`. It answers with state the platform already
+ * holds: reading it never creates, resumes or commands a sandbox, and the GitHub
+ * probe only runs when the sandbox is already awake. `authenticated: null`
+ * therefore means *unknown*, not *signed out* — keep the app's own fallback for
+ * that case and for hosts that answer `{ available: false }` (the dev harness,
+ * the vite preview).
+ */
+export declare function useCloudComputer(): UseCloudComputerResult;