@belonguniverseai/react-sdk 0.6.21 → 0.6.23

package/dist/embed/goal-proposal-dismissal.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Ruling 5 (spec §7) — "Not now" on the proposal card, persisted per device.
+ * localStorage only for v1: a server-side dismissal marker is a later slice
+ * (spec "Not in this design"), so a reload on ANOTHER device shows the offer
+ * again — documented, acceptable. Every read/write is wrapped in try/catch:
+ * a private window throws on `localStorage` access, and this must never be
+ * the thing that breaks the card.
+ */
+export declare const goalProposalDismissalKey: (sessionId: string) => string;
+export declare const readGoalProposalDismissed: (sessionId: string) => boolean;
+export declare const writeGoalProposalDismissed: (sessionId: string) => void;

package/dist/embed/goal-resume-time.d.ts

@@ -0,0 +1,22 @@
+/**
+ * "resumes 09:00" — the goal pill's one piece of copy built from a time
+ * rather than a status key (`goal-status-label.ts`).
+ *
+ * Formatted in the VIEWER's locale and timezone, client-side, from the
+ * UTC instant the backend sends: the person reading the pill is the person
+ * who has to know whether 09:00 has happened yet, and a server-rendered
+ * time would be in the server's zone. `now` is a parameter rather than a
+ * `new Date()` inside (CLAUDE.md §25 — do not hide time), which is also
+ * what makes the same-day branch testable.
+ *
+ * Same day → the time alone ("09:00"); any other day → date and time
+ * ("Sep 12, 09:00"), because "09:00" on its own reads as *this morning*
+ * and a goal that is asleep until tomorrow is exactly the case where that
+ * misreads. Null for a missing or unparsable instant — the caller falls
+ * back to the plain "scheduled" label rather than rendering "Invalid Date".
+ */
+export declare const formatGoalResumeTime: (input: {
+    readonly resumeAt: string | null | undefined;
+    readonly now: Date;
+    readonly locale: string;
+}) => string | null;

package/dist/embed/goal-row-model.d.ts

@@ -0,0 +1,27 @@
+import { GoalElapsed } from './goal-plain-units.ts';
+import { GoalView } from '../api/goals.ts';
+export type GoalRowTone = "live" | "calm" | "attention";
+export type GoalRowActionKind = "cancel_setup" | "pause" | "resume" | "wake_now" | "details" | "answer" | "review" | "show_me" | "tell_it" | "give_it_more" | "new_goal";
+export type GoalRowAction = {
+    readonly kind: GoalRowActionKind;
+    readonly labelKey: string;
+};
+export type GoalRowCopy = {
+    readonly key: string;
+    readonly vars?: Readonly<Record<string, string | number>>;
+};
+export type GoalRowModel = {
+    readonly tone: GoalRowTone;
+    readonly headline: GoalRowCopy;
+    readonly detail: GoalRowCopy | null;
+    /** Non-null only where the row shows a clock (working, checking, paused).
+     *  The component renders it through `goal.units.*` and passes the result
+     *  into `detail.vars` as `elapsed`. */
+    readonly elapsed: GoalElapsed | null;
+    /** Non-null ONLY for `deferred`. The component formats it in the viewer's
+     *  zone and passes it into `headline.vars` as `time`. */
+    readonly resumeAt: string | null;
+    readonly primary: GoalRowAction | null;
+    readonly secondary: GoalRowAction | null;
+};
+export declare const goalRowModel: (goal: GoalView, now: Date) => GoalRowModel | null;

package/dist/embed/goal-runway.d.ts

@@ -0,0 +1,5 @@
+export type GoalRunwayPreset = "quick" | "normal" | "long";
+export type GoalRunwayLabelKey = "goal.compose.runwayQuick" | "goal.compose.runwayNormal" | "goal.compose.runwayLong";
+export type GoalRunwayDetailKey = "goal.compose.runwayQuickDetail" | "goal.compose.runwayNormalDetail" | "goal.compose.runwayLongDetail";
+export declare const goalRunwayLabelKey: (preset: GoalRunwayPreset) => GoalRunwayLabelKey;
+export declare const goalRunwayDetailKey: (preset: GoalRunwayPreset) => GoalRunwayDetailKey;

package/dist/embed/goal-schedule-handoff.d.ts

@@ -0,0 +1,12 @@
+export declare const goalScheduleCommand: (objective: string) => string;
+/**
+ * The i18n key naming the cadence this objective's own words imply, or null
+ * when they imply none (final review, Low 5: spec §5 asks the ending's button
+ * to say "Run this again {{cadence}}", and the flat "on a schedule" never
+ * named the cadence `goalScheduleCommand` had already guessed).
+ *
+ * A KEY, not the `phrase` above: the phrase is the `/schedule` parser's own
+ * English input and must stay English, while the button is read by a user in
+ * their own language.
+ */
+export declare const goalScheduleCadenceKey: (objective: string) => string | null;

package/dist/embed/goal-status-label.d.ts

@@ -0,0 +1,3 @@
+import { GoalStatus } from '../api/goals.ts';
+export type GoalStatusLabelKey = "goal.statusLabel.clarifying" | "goal.statusLabel.active" | "goal.statusLabel.completionClaimed" | "goal.statusLabel.paused" | "goal.statusLabel.deferred" | "goal.statusLabel.waitingForUser" | "goal.statusLabel.waitingForApproval" | "goal.statusLabel.waitingForUiAction" | "goal.statusLabel.blocked" | "goal.statusLabel.budgetLimited" | "goal.statusLabel.complete" | "goal.statusLabel.cleared";
+export declare const goalStatusLabelKey: (status: GoalStatus) => GoalStatusLabelKey;

package/dist/embed/goal-time-usage.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `GoalBadge`'s time-usage line, pulled out to a pure helper (task-9 review,
+ * finding 4). The prior version always rendered `Math.round(seconds / 60)`
+ * minutes, which read as "130 of 10080 min" for a week-long cap — CLAUDE.md
+ * §11 asks for human units, not a five-digit minute count.
+ *
+ * Rule: minutes when the cap is under 60 minutes, hours when the cap is
+ * under 48 hours, else days — chosen from the CAP so `used`/`max` always
+ * share one unit ("2 of 10 h", never "90 min of 10 h"). Both values round
+ * to integers in that unit; the caller (`GoalBadge.tsx`) applies
+ * `toLocaleString()` for large counts, same as the tokens line.
+ */
+export type GoalTimeUnit = "min" | "h" | "d";
+export type GoalTimeUsage = {
+    readonly used: number;
+    readonly max: number;
+    readonly unit: GoalTimeUnit;
+};
+export declare const formatGoalTimeUsage: (activeSeconds: number, maxActiveSeconds: number) => GoalTimeUsage;

package/dist/embed/issue-report-bus.d.ts

@@ -0,0 +1,14 @@
+import { CapturedScreenshot } from './screen-capture.ts';
+import { IssueReportClientContext } from './issue-report.ts';
+import { ClientErrorEntry } from './client-error-log.ts';
+export type IssueReportRequest = {
+    readonly sessionId: string | null;
+    readonly taskId: string | null;
+    readonly screenshot: CapturedScreenshot | null;
+    readonly context: IssueReportClientContext;
+    readonly clientErrors: readonly ClientErrorEntry[];
+};
+export declare const openIssueReport: (request: IssueReportRequest) => void;
+export declare const closeIssueReport: () => void;
+export declare const peekIssueReport: () => IssueReportRequest | null;
+export declare const subscribeIssueReport: (listener: () => void) => (() => void);

package/dist/embed/issue-report-open.d.ts

@@ -0,0 +1,8 @@
+import { captureScreen } from './screen-capture.ts';
+import { DockView } from './dock-state.ts';
+export declare const requestIssueReport: (input: {
+    readonly dockView: DockView;
+    readonly taskId?: string | null;
+    /** Injected in tests. */
+    readonly capture?: typeof captureScreen;
+}) => Promise<void>;

package/dist/embed/issue-report.d.ts

@@ -0,0 +1,41 @@
+import { DockView } from './dock-state.ts';
+/**
+ * The server's own caps (`apps/belong-cloud/src/features/issue-reports/issue-report.schemas.ts`,
+ * `hostUrl`/`userAgent`), mirrored here so a page with a long URL or an
+ * unusual user agent string never produces a report the route refuses with
+ * `invalid_meta`. Without this, the ONE feature whose job is catching the
+ * unreportable becomes the thing that cannot be reported: the SDK collapses
+ * that 400 to `request_failed` and the dialog says "Try again," which never
+ * succeeds for that user.
+ */
+export declare const MAX_HOST_URL_CHARS = 2000;
+export declare const MAX_USER_AGENT_CHARS = 500;
+export type IssueReportViewport = {
+    readonly widthPx: number;
+    readonly heightPx: number;
+    /** Device pixel ratio x100 — an integer, per §11. */
+    readonly dprX100: number;
+};
+export type IssueReportClientContext = {
+    readonly hostUrl: string;
+    readonly dockView: DockView;
+    readonly sdkVersion: string;
+    readonly sdkBuiltAt: string | null;
+    readonly viewport: IssueReportViewport;
+    readonly locale: string;
+    readonly userAgent: string;
+    readonly capturedAt: string;
+};
+export declare const readViewport: (win: {
+    readonly innerWidth: number;
+    readonly innerHeight: number;
+    readonly devicePixelRatio: number;
+}) => IssueReportViewport;
+export declare const buildIssueReportContext: (input: {
+    readonly dockView: DockView;
+    readonly hostUrl: string;
+    readonly locale: string;
+    readonly userAgent: string;
+    readonly viewport: IssueReportViewport;
+    readonly capturedAt: string;
+}) => IssueReportClientContext;

package/dist/embed/legal-disclaimer.d.ts

@@ -23,7 +23,11 @@ export type DisclaimerCopy = {
      *  the product and the user's next move — never the transport. */
     readonly acceptError: string;
     readonly languageHint: string;
-    /** The permanent one-liner under the chat box. */
+    /** Accuracy reminder beside the tenant's beta status in the footer. */
+    readonly shortReminder: string;
+    /** Simetrik legal's caveat, first in the footer's info popover: the AI may
+     *  err, and the beta may carry a later cost. It names no trial length —
+     *  Simetrik runs the beta and sets its duration per client. */
     readonly shortLine: string;
 };
 export declare const DISCLAIMER_COPY: Record<Locale, DisclaimerCopy>;

package/dist/embed/library-composer.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from 'react';
+export type LibraryComposerRequest = {
+    readonly kind: "prompt";
+    readonly prePromptId: string;
+} | {
+    readonly kind: "skill";
+    readonly name: string;
+};
+type Composer = {
+    readonly insert: (request: LibraryComposerRequest) => boolean;
+    readonly focus: () => void;
+};
+/** Each dock owns its handoff. Requests are synchronous and never queued. */
+export declare function LibraryComposerProvider({ children, scopeKey, chatVisible, onAccepted, }: {
+    readonly children: ReactNode;
+    readonly scopeKey: string;
+    readonly chatVisible: boolean;
+    readonly onAccepted: () => void;
+}): import("react").JSX.Element;
+/** False means no current, enabled composer accepted this library item. */
+export declare const useLibraryComposer: () => Composer["insert"];
+/** Register the current keep-alive composer without adding API/query dependencies. */
+export declare function useRegisterLibraryComposer(composer: Composer): void;
+export {};

package/dist/embed/library-navigation.d.ts

@@ -0,0 +1,6 @@
+import { DockView } from './dock-state.ts';
+export declare const isLibraryView: (view: DockView) => view is "skills" | "prompts";
+/** Preserve the selected library section; otherwise prefer available skills. */
+export declare const libraryEntryView: (view: DockView, skillsUnavailable: boolean) => "skills" | "prompts";
+/** Company Discover does not depend on the personal-upload capability. */
+export declare const useLibrarySkillsUnavailable: () => boolean;

package/dist/embed/portal-container.d.ts

@@ -1,19 +1,4 @@
-/**
- * Portal container context.
- *
- * Radix overlays (DropdownMenu, Tooltip, Popover, …) portal to
- * `document.body` by default. When the dock is mounted inside a Shadow DOM for
- * style isolation (the production embed — see `embed/bootstrap.ts`), that
- * default would drop the overlay into the host's light DOM, OUTSIDE the shadow
- * root, where none of our injected CSS reaches — so it would render unstyled.
- *
- * This context carries the element those portals should mount into instead: a
- * node that lives INSIDE the shadow root, so overlays inherit the dock's
- * isolated styles. The default is `null`, which means "no override" — Radix
- * falls back to `document.body`. That's exactly right for the dev SPA and
- * Storybook, where there is no shadow root and the styles live in the document
- * head.
- */
+import { CSSProperties } from 'react';
 export declare const PortalContainerContext: import('react').Context<HTMLElement | null>;
 /**
  * The element Radix portals should mount into, or `null` to use Radix's
@@ -21,3 +6,19 @@ export declare const PortalContainerContext: import('react').Context<HTMLElement
  * `container` prop — Radix treats `null`/`undefined` as "use the default".
  */
 export declare const usePortalContainer: () => HTMLElement | null;
+/** Settings follows the agent's footprint even though it portals outside the dock. */
+export type DockSurface = {
+    readonly layout: "docked" | "fullscreen" | "mobile";
+    readonly widthPx: number;
+    readonly side: "left" | "right";
+    readonly settingsOpen: boolean;
+    readonly onSettingsOpenChange: (open: boolean) => void;
+};
+export declare const DockSurfaceContext: import('react').Context<DockSurface | null>;
+export declare const useDockSurface: () => DockSurface | null;
+/** Portal roots are siblings of the dock, so they need the same tenant tokens. */
+export type PortalTheme = {
+    readonly style: CSSProperties;
+    readonly className: string | undefined;
+};
+export declare const usePortalTheme: () => PortalTheme;

package/dist/embed/presets.d.ts

@@ -9,8 +9,8 @@ export declare const PRESET_NAME_SCHEMA: z.ZodEnum<{
 }>;
 export declare const BELONG_LIGHT_PALETTE: BelongThemePalette;
 export declare const BELONG_DARK_PALETTE: BelongThemePalette;
-export declare const BELONG_FONT_FAMILY = "\"Inter\", -apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, Oxygen, Ubuntu, Cantarell, sans-serif";
-export declare const BELONG_RADIUS = "12px";
+export declare const BELONG_FONT_FAMILY = "-apple-system, BlinkMacSystemFont, \"Segoe UI\", sans-serif";
+export declare const BELONG_RADIUS = "16px";
 export declare const BELONG_BRAND: BelongThemeBrand;
 export declare const SIMETRIK_BRAND: BelongThemeBrand;
 export declare const SIMETRIK_LIGHT_PALETTE: BelongThemePalette;

package/dist/embed/schedule-invitation.d.ts

@@ -0,0 +1,5 @@
+/** Fragments stay out of HTTP request logs and referrers. */
+export declare const scheduleInvitationLink: (pageUrl: string, token: string) => string;
+export declare const scheduleInvitationToken: (input: string) => string | null;
+export declare const consumeScheduleInvitation: () => string | null;
+export declare const clearScheduleInvitation: () => void;

package/dist/embed/screen-capture.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Rasterize the host page for an issue report.
+ *
+ * snapdom clones the DOM into an SVG foreignObject with styles inlined, then
+ * paints it to a canvas. It is the one such library that walks SHADOW ROOTS,
+ * which is not optional here: the dock itself lives in one, so anything else
+ * (html2canvas, notably) would photograph the host app with a hole where
+ * Belong is.
+ *
+ * KNOWN LIMITS — say them here so they are not re-discovered from a confusing
+ * report:
+ *   • cross-origin images and cross-origin iframes come out blank;
+ *   • this is a re-render of the DOM, not a photograph of pixels — a canvas
+ *     element or an unusual CSS feature can differ from what the user saw;
+ *   • it costs a beat on a large page, which is why capture runs on the click
+ *     and the dialog opens after it.
+ *
+ * DEVICE PIXEL RATIO: snapdom's `toCanvas` defaults `dpr` to
+ * `window.devicePixelRatio || 1` and multiplies the OUTPUT canvas dimensions
+ * by it, on top of `scale`. `captureScale`/`MAX_SCREENSHOT_WIDTH_PX` below
+ * only account for `scale` — so left at its default, a capture on a 2x
+ * display would produce a canvas 2x wider than the documented 1600px cap
+ * promises, inflating bytes and pushing more captures into the
+ * `MAX_SCREENSHOT_BYTES` refusal. `dpr: 1` is passed explicitly so the
+ * output is in CSS pixels and `MAX_SCREENSHOT_WIDTH_PX` means what it says
+ * regardless of the display's pixel ratio.
+ *
+ * WEBP-WITH-PNG-FALLBACK: `defaultEncode` always *requests* "image/webp". The
+ * PNG fallback is not a second encode call in this file — it is the browser's
+ * own behavior. Per the HTML spec, `HTMLCanvasElement.toBlob` given a type it
+ * cannot encode must produce `image/png` instead. So on a UA without a WebP
+ * encoder, the very same call already yields a PNG blob, and `blob.type`
+ * carries the truth of which one it got. A later task propagates `blob.type`
+ * into the upload, and the route accepts both `image/webp` and `image/png` —
+ * that is exactly why it accepts two. One consequence: PNG ignores the
+ * `quality` argument entirely, so the low-quality retry below can be a no-op
+ * on those browsers (same bytes both times) — the designed outcome there is
+ * still a report with no picture rather than an oversized upload, never a
+ * silently-too-big send.
+ *
+ * Never throws: every failure is `null`, and the dialog then offers to send the
+ * report without a picture. A capture failure must not cost us the report.
+ *
+ * A THROWN failure (as opposed to the "over the cap even at low quality"
+ * refusal above, which is not a failure) is also recorded into the client-
+ * error ring buffer (`client-error-log.ts`), so the answer to "why is there
+ * no image" travels INSIDE the report itself — the one place an operator is
+ * already looking — rather than being indistinguishable from a user who
+ * removed the screenshot or an object-store put that failed server-side.
+ * Recording is wrapped in its own try/catch: it must not be able to violate
+ * the never-throws contract above, even if the recorder itself somehow threw.
+ *
+ * The library is imported lazily so it stays out of the dock's main chunk —
+ * most sessions never open this dialog.
+ */
+export declare const MAX_SCREENSHOT_WIDTH_PX = 1600;
+export declare const MAX_SCREENSHOT_BYTES = 2000000;
+export type CapturedScreenshot = {
+    readonly blob: Blob;
+    readonly widthPx: number;
+    readonly heightPx: number;
+};
+export type Rasterizer = (element: Element, options: {
+    readonly scale: number;
+    readonly dpr: number;
+}) => Promise<HTMLCanvasElement>;
+export type Encoder = (canvas: HTMLCanvasElement, quality: number) => Promise<Blob | null>;
+/** Shrink only what is wider than the cap; never upscale. */
+export declare const captureScale: (elementWidthPx: number) => number;
+export declare const captureScreen: (input: {
+    readonly element: Element;
+    readonly rasterize?: Rasterizer;
+    readonly encode?: Encoder;
+}) => Promise<CapturedScreenshot | null>;

package/dist/embed/slash-commands.d.ts

@@ -43,6 +43,30 @@ export type BuiltinCommand = {
     readonly type: "unschedule";
 } | {
     readonly type: "unschedule_invalid";
+} | {
+    readonly type: "goal";
+    readonly action: "create";
+    readonly objective: string;
+} | {
+    readonly type: "goal";
+    readonly action: "open_sheet";
+} | {
+    readonly type: "goal";
+    readonly action: "status" | "pause" | "resume" | "clear";
+} | {
+    readonly type: "goal";
+    readonly action: "edit";
+    readonly objective: string;
+} | {
+    readonly type: "goal";
+    readonly action: "turns";
+    readonly maxTurns: number;
+} | {
+    readonly type: "goal";
+    readonly action: "budget";
+    readonly tokenBudget: number;
+} | {
+    readonly type: "goal_invalid";
 };
 /**
  * Recognize a submitted draft as a built-in command. `/compact` remains an

package/dist/embed/task-schedule-command.d.ts

@@ -24,6 +24,13 @@ export declare const partsInTimezone: (instant: Date, timezone: string) => WallC
  *  by the gap. Exported for the Scheduled dialog's date+time+timezone →
  *  instant conversion (the server ports the same algorithm). */
 export declare const instantInTimezone: (wall: WallClock, timezone: string) => Date;
+/** The Scheduled dialog's "next run" reading, localized to the VIEWER's
+ *  locale but the SCHEDULE's own timezone (chat.tsx decomposition campaign —
+ *  extracted out of `ChatRoute` as a pure helper, no behavior change). */
+export declare const scheduleLocalTime: (locale: Locale, schedule: {
+    readonly scheduledFor: string;
+    readonly timezone: string;
+}) => string;
 export declare const parseTaskScheduleCommand: (input: {
     readonly argumentsText: string;
     readonly locale: Locale;

package/dist/embed/use-session-draft.d.ts

@@ -0,0 +1,11 @@
+import { SetStateAction } from 'react';
+import { WorkspaceScope } from './workspace-scope.ts';
+type DraftScope = {
+    readonly apiBaseUrl: string;
+    readonly workspace: WorkspaceScope;
+};
+/** Explicit New chat discards the unbound main draft; switching sessions does not. */
+export declare function discardSessionDraft(sessionId: string, scope: DraftScope): void;
+/** Text drafts survive session remounts/reloads in this tab; nothing is sent to the server. */
+export declare function useSessionDraft(initialSessionId: string, transportSessionId: string | null, scope: DraftScope): readonly [string, (next: SetStateAction<string>) => void];
+export {};