@palettelab/sdk 0.1.14 → 0.1.16

package/dist/index.mjs

@@ -171,6 +171,7 @@ function createMockPlatformContext(overrides = {}) {
     apiFetch: async () => new Response(JSON.stringify({}), { status: 200 }),
     navigate: () => {
     },
+    routePath: "/",
     showToast: () => {
     },
     ...overrides
@@ -302,6 +303,8 @@ function hasAllPermissions(ctx, permissions) {
 }
 
 // src/storage.ts
+var DEFAULT_CHUNK_SIZE = 8 * 1024 * 1024;
+var MIN_CHUNK_SIZE = 256 * 1024;
 async function uploadToSignedUrl(uploadUrl, file, contentType = "application/octet-stream") {
   const res = await fetch(uploadUrl, {
     method: "PUT",
@@ -310,10 +313,178 @@ async function uploadToSignedUrl(uploadUrl, file, contentType = "application/oct
   });
   if (!res.ok) throw new Error(`Upload failed: ${res.statusText}`);
 }
+function normalizeChunkSize(value) {
+  const raw = Math.max(value || DEFAULT_CHUNK_SIZE, MIN_CHUNK_SIZE);
+  return Math.ceil(raw / MIN_CHUNK_SIZE) * MIN_CHUNK_SIZE;
+}
+function defaultPluginId() {
+  if (typeof window === "undefined") return "";
+  const match = window.location.pathname.match(/\/apps\/([^/?#]+)/);
+  return match ? decodeURIComponent(match[1]) : "";
+}
+function fileFingerprint(pluginId, file, key) {
+  return [pluginId, key || file.name, file.size, file.lastModified].join(":");
+}
+function sessionStorageKey(pluginId, fingerprint) {
+  return `palette:storage-upload:${pluginId}:${fingerprint}`;
+}
+function readStoredSession(pluginId, fingerprint) {
+  if (typeof window === "undefined") return null;
+  try {
+    const raw = window.localStorage.getItem(sessionStorageKey(pluginId, fingerprint));
+    if (!raw) return null;
+    const session = JSON.parse(raw);
+    return session.plugin_id === pluginId && session.fingerprint === fingerprint ? session : null;
+  } catch {
+    return null;
+  }
+}
+function writeStoredSession(pluginId, fingerprint, session) {
+  if (typeof window === "undefined") return;
+  const stored = { ...session, plugin_id: pluginId, fingerprint, updated_at: Date.now() };
+  window.localStorage.setItem(sessionStorageKey(pluginId, fingerprint), JSON.stringify(stored));
+}
+function clearStoredSession(pluginId, fingerprint) {
+  if (typeof window === "undefined") return;
+  window.localStorage.removeItem(sessionStorageKey(pluginId, fingerprint));
+}
+function absoluteApiUrl(pathOrUrl) {
+  return /^https?:\/\//i.test(pathOrUrl) ? pathOrUrl : `${getBaseUrl()}${pathOrUrl}`;
+}
+function isPaletteApiUpload(url) {
+  return url.startsWith(getBaseUrl()) || url.startsWith("/");
+}
+function report(loaded, total, chunkIndex, chunkCount, state, onProgress) {
+  onProgress?.({
+    loaded,
+    total,
+    percentage: total > 0 ? Math.min(100, Math.round(loaded / total * 1e4) / 100) : 100,
+    chunkIndex,
+    chunkCount,
+    state
+  });
+}
+function xhrPut(url, body, headers, signal, onUploadProgress) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open("PUT", absoluteApiUrl(url), true);
+    xhr.withCredentials = isPaletteApiUpload(url);
+    for (const [key, value] of Object.entries(headers)) xhr.setRequestHeader(key, value);
+    xhr.upload.onprogress = (event) => {
+      if (event.lengthComputable) onUploadProgress?.(event.loaded);
+    };
+    xhr.onload = () => {
+      const ok = [200, 201, 204, 308].includes(xhr.status);
+      if (!ok) reject(new Error(`Upload failed: ${xhr.status} ${xhr.statusText}`));
+      else resolve({ status: xhr.status, range: xhr.getResponseHeader("Range") });
+    };
+    xhr.onerror = () => reject(new Error("Upload failed"));
+    xhr.onabort = () => reject(new DOMException("Upload aborted", "AbortError"));
+    if (signal) {
+      if (signal.aborted) {
+        xhr.abort();
+        return;
+      }
+      signal.addEventListener("abort", () => xhr.abort(), { once: true });
+    }
+    xhr.send(body);
+  });
+}
+function uploadedFromRange(range) {
+  if (!range) return 0;
+  const match = range.match(/bytes=0-(\d+)/);
+  return match ? Number(match[1]) + 1 : 0;
+}
+async function queryGcsOffset(session) {
+  try {
+    const result = await xhrPut(session.upload_url, new Blob([]), {
+      "Content-Range": `bytes */${session.size}`
+    });
+    if ([200, 201, 204].includes(result.status)) return session.size;
+    return uploadedFromRange(result.range);
+  } catch {
+    return 0;
+  }
+}
+async function queryLocalOffset(session) {
+  const res = await fetch(absoluteApiUrl(session.status_url), { credentials: "include" });
+  if (!res.ok) return 0;
+  const body = await res.json();
+  return Number(body.uploaded_bytes || 0);
+}
+async function queryOffset(session) {
+  if (session.mode === "local_resumable") return queryLocalOffset(session);
+  return queryGcsOffset(session);
+}
 var StorageClient = class {
-  constructor() {
+  constructor(ctx) {
+    this.ctx = ctx;
     this.uploadToSignedUrl = uploadToSignedUrl;
   }
+  pluginId(explicit) {
+    const resolved = explicit || this.ctx?.pluginId || defaultPluginId();
+    if (!resolved) throw new Error("pluginId is required for app storage uploads");
+    return resolved;
+  }
+  async createSession(pluginId, file, options) {
+    const res = await (this.ctx?.apiFetch || apiFetch)(`/api/v1/app-storage/${encodeURIComponent(pluginId)}/uploads`, {
+      method: "POST",
+      body: JSON.stringify({
+        filename: file.name,
+        content_type: options.contentType || file.type || "application/octet-stream",
+        size: file.size,
+        key: options.key || null,
+        resumable: options.resumable ?? true,
+        chunk_size: normalizeChunkSize(options.chunkSize)
+      })
+    });
+    return res.json();
+  }
+  async upload(file, options = {}) {
+    const pluginId = this.pluginId(options.pluginId);
+    const fingerprint = fileFingerprint(pluginId, file, options.key);
+    const stored = options.resumable === false ? null : readStoredSession(pluginId, fingerprint);
+    const session = stored || await this.createSession(pluginId, file, options);
+    writeStoredSession(pluginId, fingerprint, session);
+    const chunkSize = normalizeChunkSize(options.chunkSize || session.chunk_size);
+    const chunkCount = Math.max(1, Math.ceil(file.size / chunkSize));
+    let offset = stored ? await queryOffset(session) : 0;
+    report(offset, file.size, Math.floor(offset / chunkSize), chunkCount, "starting", options.onProgress);
+    while (offset < file.size) {
+      if (options.signal?.aborted) throw new DOMException("Upload aborted", "AbortError");
+      const start = offset;
+      const end = Math.min(file.size, start + chunkSize) - 1;
+      const chunk = file.slice(start, end + 1);
+      const chunkIndex = Math.floor(start / chunkSize) + 1;
+      const lastReportedBase = start;
+      await xhrPut(
+        session.upload_url,
+        chunk,
+        {
+          "Content-Type": session.content_type,
+          "Content-Range": `bytes ${start}-${end}/${file.size}`
+        },
+        options.signal,
+        (loaded) => report(lastReportedBase + loaded, file.size, chunkIndex, chunkCount, "uploading", options.onProgress)
+      );
+      offset = end + 1;
+      report(offset, file.size, chunkIndex, chunkCount, offset >= file.size ? "complete" : "uploading", options.onProgress);
+      writeStoredSession(pluginId, fingerprint, session);
+    }
+    clearStoredSession(pluginId, fingerprint);
+    return {
+      uploadId: session.upload_id,
+      mode: session.mode,
+      bucket: session.bucket,
+      objectPath: session.object_path,
+      fileUrl: session.file_url,
+      contentType: session.content_type,
+      size: session.size
+    };
+  }
+  async resume(file, options = {}) {
+    return this.upload(file, { ...options, resumable: true });
+  }
 };
 
 // src/user-org.ts
@@ -391,7 +562,7 @@ var OrganizationClient = class {
 
 // src/palette-client.ts
 function createPaletteClient(ctx) {
-  const defaultPluginId = () => {
+  const defaultPluginId2 = () => {
     if (ctx?.pluginId) return ctx.pluginId;
     if (typeof window === "undefined") return "";
     const match = window.location.pathname.match(/\/apps\/([^/?#]+)/);
@@ -401,15 +572,15 @@ function createPaletteClient(ctx) {
     user: new UserClient(ctx),
     organization: new OrganizationClient(ctx),
     dataRooms: new DataRoomClient(),
-    storage: new StorageClient(),
+    storage: new StorageClient(ctx),
     config: {
       get: (pluginId = ctx?.pluginId ?? "") => {
-        const resolved = pluginId || defaultPluginId();
+        const resolved = pluginId || defaultPluginId2();
         if (!resolved) throw new Error("pluginId is required to read install config");
         return getInstallConfig(resolved);
       },
       update: (values, pluginId = ctx?.pluginId ?? "") => {
-        const resolved = pluginId || defaultPluginId();
+        const resolved = pluginId || defaultPluginId2();
         if (!resolved) throw new Error("pluginId is required to update install config");
         return updateInstallConfig(resolved, values);
       }
@@ -490,14 +661,216 @@ function usePluginTranslations(resources, options = {}) {
   };
 }
 
+// src/router.tsx
+import {
+  Component,
+  createContext as createContext2,
+  createElement as createElement2,
+  useCallback as useCallback2,
+  useContext as useContext2,
+  useEffect,
+  useMemo,
+  useState
+} from "react";
+var RouterCtx = createContext2(null);
+var NOT_FOUND = /* @__PURE__ */ Symbol.for("palette.router.not-found");
+function notFound() {
+  throw Object.assign(new Error("Palette route not found"), { code: NOT_FOUND });
+}
+function normalizePath(path) {
+  const clean = String(path || "/").split("#")[0].split("?")[0] || "/";
+  return `/${clean.replace(/^\/+/, "").replace(/\/+$/, "")}`.replace(/^\/$/, "/");
+}
+function splitPath(path) {
+  return normalizePath(path).split("/").filter(Boolean).map(decodeURIComponent);
+}
+function routeScore(route) {
+  if (typeof route.score === "number") return route.score;
+  return route.segments.reduce((score, segment) => {
+    if (segment.kind === "static") return score + 10;
+    if (segment.kind === "dynamic") return score + 5;
+    return score + (segment.optional ? 1 : 2);
+  }, route.segments.length);
+}
+function matchRoute(route, path) {
+  const parts = splitPath(path);
+  const params = {};
+  let index = 0;
+  for (const segment of route.segments) {
+    if (segment.kind === "catchAll") {
+      const rest = parts.slice(index);
+      if (!segment.optional && rest.length === 0) return null;
+      params[segment.name] = rest;
+      index = parts.length;
+      break;
+    }
+    const value = parts[index];
+    if (value === void 0) return null;
+    if (segment.kind === "static") {
+      if (value !== segment.value) return null;
+    } else {
+      params[segment.name] = value;
+    }
+    index += 1;
+  }
+  return index === parts.length ? params : null;
+}
+function currentPluginPath(pluginId, routePath) {
+  if (routePath) return normalizePath(routePath);
+  if (typeof window === "undefined") return "/";
+  const path = window.location.pathname;
+  if (pluginId) {
+    const prefix = `/apps/${pluginId}`;
+    if (path === prefix) return "/";
+    if (path.startsWith(`${prefix}/`)) return normalizePath(path.slice(prefix.length));
+  }
+  return normalizePath(path);
+}
+function currentSearchParams() {
+  if (typeof window === "undefined") return new URLSearchParams();
+  return new URLSearchParams(window.location.search);
+}
+var PaletteRouteErrorBoundary = class extends Component {
+  constructor() {
+    super(...arguments);
+    this.state = { error: null };
+    this.reset = () => this.setState({ error: null });
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(_error, _info) {
+  }
+  render() {
+    const error = this.state.error;
+    if (!error) return this.props.children;
+    if (error.code === NOT_FOUND && this.props.notFound) {
+      return createElement2(this.props.notFound);
+    }
+    if (this.props.fallback) {
+      return createElement2(this.props.fallback, { error, reset: this.reset });
+    }
+    throw error;
+  }
+};
+function renderRoute(route) {
+  const page = createElement2(route.page);
+  const wrapped = (route.layouts || []).reduceRight(
+    (children, Layout) => createElement2(Layout, null, children),
+    page
+  );
+  return createElement2(
+    PaletteRouteErrorBoundary,
+    { fallback: route.error, notFound: route.notFound },
+    wrapped
+  );
+}
+function PaletteAppRouter({
+  routes,
+  notFound: NotFound
+}) {
+  const platform = usePlatform();
+  const [location, setLocation] = useState(() => ({
+    pathname: currentPluginPath(platform.pluginId, platform.routePath),
+    searchParams: currentSearchParams()
+  }));
+  useEffect(() => {
+    setLocation({
+      pathname: currentPluginPath(platform.pluginId, platform.routePath),
+      searchParams: currentSearchParams()
+    });
+  }, [platform.pluginId, platform.routePath]);
+  useEffect(() => {
+    const sync = () => setLocation({
+      pathname: currentPluginPath(platform.pluginId, platform.routePath),
+      searchParams: currentSearchParams()
+    });
+    window.addEventListener("popstate", sync);
+    return () => window.removeEventListener("popstate", sync);
+  }, [platform.pluginId, platform.routePath]);
+  const sortedRoutes = useMemo(
+    () => [...routes].sort((a, b) => routeScore(b) - routeScore(a)),
+    [routes]
+  );
+  const matched = useMemo(() => {
+    for (const route of sortedRoutes) {
+      const params = matchRoute(route, location.pathname);
+      if (params) return { route, params };
+    }
+    return null;
+  }, [location.pathname, sortedRoutes]);
+  const navigate = useCallback2((target, replace = false) => {
+    const [pathPart, queryPart = ""] = String(target || "/").split("?");
+    const pathname = normalizePath(pathPart);
+    const next = `${pathname}${queryPart ? `?${queryPart}` : ""}`;
+    setLocation({ pathname, searchParams: new URLSearchParams(queryPart) });
+    const currentPath = typeof window === "undefined" ? "" : window.location.pathname;
+    const inPalettePath = platform.pluginId && (currentPath.startsWith(`/apps/${platform.pluginId}`) || platform.routePath !== void 0);
+    const osPath = inPalettePath && platform.pluginId ? `/apps/${platform.pluginId}${pathname === "/" ? "" : pathname}${queryPart ? `?${queryPart}` : ""}` : next;
+    if (replace && typeof window !== "undefined") window.history.replaceState(null, "", osPath);
+    else platform.navigate(osPath);
+  }, [platform]);
+  const state = useMemo(() => ({
+    pathname: location.pathname,
+    searchParams: location.searchParams,
+    params: matched?.params || {},
+    push: (path) => navigate(path, false),
+    replace: (path) => navigate(path, true)
+  }), [location.pathname, location.searchParams, matched?.params, navigate]);
+  const content = matched ? renderRoute(matched.route) : NotFound ? createElement2(NotFound) : createElement2("div", null, "Page not found");
+  return createElement2(RouterCtx.Provider, { value: state }, content);
+}
+function useRouterState() {
+  const value = useContext2(RouterCtx);
+  if (!value) throw new Error("Palette app router hooks must be used inside PaletteAppRouter");
+  return value;
+}
+function useRouter() {
+  const { push, replace } = useRouterState();
+  return { push, replace, back: () => window.history.back(), forward: () => window.history.forward() };
+}
+function usePathname() {
+  return useRouterState().pathname;
+}
+function useSearchParams() {
+  return useRouterState().searchParams;
+}
+function useParams() {
+  return useRouterState().params;
+}
+function Link({
+  href,
+  replace,
+  onClick,
+  children,
+  ...props
+}) {
+  const router = useRouter();
+  return createElement2(
+    "a",
+    {
+      ...props,
+      href,
+      onClick: (event) => {
+        onClick?.(event);
+        if (event.defaultPrevented || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
+        event.preventDefault();
+        if (replace) router.replace(href);
+        else router.push(href);
+      }
+    },
+    children
+  );
+}
+
 // src/hooks/use-plugin-tasks.ts
-import { useCallback as useCallback2, useEffect, useState } from "react";
+import { useCallback as useCallback3, useEffect as useEffect2, useState as useState2 } from "react";
 function usePluginTasks(agentId) {
   const { apiFetch: apiFetch2 } = usePlatform();
-  const [tasks, setTasks] = useState([]);
-  const [stats, setStats] = useState(null);
-  const [loading, setLoading] = useState(true);
-  const fetchTasks = useCallback2(async () => {
+  const [tasks, setTasks] = useState2([]);
+  const [stats, setStats] = useState2(null);
+  const [loading, setLoading] = useState2(true);
+  const fetchTasks = useCallback3(async () => {
     try {
       const params = new URLSearchParams();
       if (agentId) params.set("agent_id", String(agentId));
@@ -506,18 +879,18 @@ function usePluginTasks(agentId) {
     } catch {
     }
   }, [apiFetch2, agentId]);
-  const fetchStats = useCallback2(async () => {
+  const fetchStats = useCallback3(async () => {
     try {
       const res = await apiFetch2("/api/v1/tasks/stats");
       setStats(await res.json());
     } catch {
     }
   }, [apiFetch2]);
-  useEffect(() => {
+  useEffect2(() => {
     setLoading(true);
     Promise.all([fetchTasks(), fetchStats()]).finally(() => setLoading(false));
   }, [fetchTasks, fetchStats]);
-  const createTask = useCallback2(async (payload) => {
+  const createTask = useCallback3(async (payload) => {
     const res = await apiFetch2("/api/v1/tasks", {
       method: "POST",
       body: JSON.stringify(payload)
@@ -526,7 +899,7 @@ function usePluginTasks(agentId) {
     await Promise.all([fetchTasks(), fetchStats()]);
     return task;
   }, [apiFetch2, fetchTasks, fetchStats]);
-  const updateTask = useCallback2(async (taskId, payload) => {
+  const updateTask = useCallback3(async (taskId, payload) => {
     const res = await apiFetch2(`/api/v1/tasks/${taskId}`, {
       method: "PATCH",
       body: JSON.stringify(payload)
@@ -535,7 +908,7 @@ function usePluginTasks(agentId) {
     await Promise.all([fetchTasks(), fetchStats()]);
     return task;
   }, [apiFetch2, fetchTasks, fetchStats]);
-  const deleteTask = useCallback2(async (taskId) => {
+  const deleteTask = useCallback3(async (taskId) => {
     await apiFetch2(`/api/v1/tasks/${taskId}`, { method: "DELETE" });
     await Promise.all([fetchTasks(), fetchStats()]);
   }, [apiFetch2, fetchTasks, fetchStats]);
@@ -543,23 +916,23 @@ function usePluginTasks(agentId) {
 }
 
 // src/hooks/use-plugin-data-rooms.ts
-import { useCallback as useCallback3, useEffect as useEffect2, useState as useState2 } from "react";
+import { useCallback as useCallback4, useEffect as useEffect3, useState as useState3 } from "react";
 function usePluginDataRooms() {
   const { apiFetch: apiFetch2 } = usePlatform();
-  const [rooms, setRooms] = useState2([]);
-  const [loading, setLoading] = useState2(true);
-  const fetchRooms = useCallback3(async () => {
+  const [rooms, setRooms] = useState3([]);
+  const [loading, setLoading] = useState3(true);
+  const fetchRooms = useCallback4(async () => {
     try {
       const res = await apiFetch2("/api/v1/data-rooms");
       setRooms(await res.json());
     } catch {
     }
   }, [apiFetch2]);
-  useEffect2(() => {
+  useEffect3(() => {
     setLoading(true);
     fetchRooms().finally(() => setLoading(false));
   }, [fetchRooms]);
-  const fetchFolder = useCallback3(async (roomId, folderId) => {
+  const fetchFolder = useCallback4(async (roomId, folderId) => {
     const path = folderId ? `/api/v1/data-rooms/${roomId}/folders/${folderId}` : `/api/v1/data-rooms/${roomId}`;
     const res = await apiFetch2(path);
     return res.json();
@@ -568,19 +941,19 @@ function usePluginDataRooms() {
 }
 
 // src/hooks/use-plugin-chat.ts
-import { useCallback as useCallback4, useRef, useState as useState3 } from "react";
+import { useCallback as useCallback5, useRef, useState as useState4 } from "react";
 function usePluginChat(agentId) {
   const { apiFetch: apiFetch2 } = usePlatform();
-  const [threads, setThreads] = useState3([]);
-  const [messages, setMessages] = useState3([]);
-  const [streaming, setStreaming] = useState3(false);
-  const [activeThreadId, setActiveThreadId] = useState3(null);
+  const [threads, setThreads] = useState4([]);
+  const [messages, setMessages] = useState4([]);
+  const [streaming, setStreaming] = useState4(false);
+  const [activeThreadId, setActiveThreadId] = useState4(null);
   const abortRef = useRef(null);
-  const fetchThreads = useCallback4(async () => {
+  const fetchThreads = useCallback5(async () => {
     const res = await apiFetch2(`/api/v1/chat/${agentId}/threads`);
     setThreads(await res.json());
   }, [apiFetch2, agentId]);
-  const createThread = useCallback4(async () => {
+  const createThread = useCallback5(async () => {
     const res = await apiFetch2(`/api/v1/chat/${agentId}/threads`, { method: "POST" });
     const thread = await res.json();
     setActiveThreadId(thread.id);
@@ -588,13 +961,13 @@ function usePluginChat(agentId) {
     await fetchThreads();
     return thread;
   }, [apiFetch2, agentId, fetchThreads]);
-  const fetchMessages = useCallback4(async (threadId) => {
+  const fetchMessages = useCallback5(async (threadId) => {
     const res = await apiFetch2(`/api/v1/chat/threads/${threadId}/messages`);
     const msgs = await res.json();
     setMessages(msgs);
     setActiveThreadId(threadId);
   }, [apiFetch2]);
-  const sendMessage = useCallback4(async (threadId, content) => {
+  const sendMessage = useCallback5(async (threadId, content) => {
     setStreaming(true);
     abortRef.current = new AbortController();
     const userMsg = {
@@ -662,7 +1035,7 @@ function usePluginChat(agentId) {
       abortRef.current = null;
     }
   }, []);
-  const stopStreaming = useCallback4(() => {
+  const stopStreaming = useCallback5(() => {
     abortRef.current?.abort();
   }, []);
   return {
@@ -679,8 +1052,10 @@ function usePluginChat(agentId) {
 }
 export {
   DataRoomClient,
+  Link,
   OrganizationClient,
   PaletteApiError,
+  PaletteAppRouter,
   PlatformCtx,
   PluginProvider,
   StorageClient,
@@ -700,14 +1075,19 @@ export {
   isPaletteApiError,
   isSandboxRuntime,
   normalizePaletteLanguage,
+  notFound,
   setBaseUrl,
   translate,
   updateInstallConfig,
   uploadToSignedUrl,
+  useParams,
+  usePathname,
   usePlatform,
   usePluginChat,
   usePluginDataRooms,
   usePluginTasks,
   usePluginTranslations,
+  useRouter,
+  useSearchParams,
   withPluginProvider
 };

package/dist/{plugin-UV46q1mU.d.mts → plugin-CG6spHKI.d.mts}

@@ -106,7 +106,7 @@ interface PluginManifest {
     frontend?: {
         entry: string;
         sandbox?: boolean;
-        framework?: "react" | "next";
+        framework?: "react" | "next" | "palette-app";
         config?: string;
     };
     backend?: {
@@ -165,6 +165,8 @@ interface PlatformContext {
     apiFetch: (path: string, init?: RequestInit) => Promise<Response>;
     /** Navigate to a platform route */
     navigate: (path: string) => void;
+    /** Current route path within the plugin app, when mounted by Palette OS */
+    routePath?: string;
     /** Show a toast notification */
     showToast: (message: string, type?: "success" | "error" | "info") => void;
     /** Permissions declared for the current plugin install/runtime */

package/dist/{plugin-UV46q1mU.d.ts → plugin-CG6spHKI.d.ts}

@@ -106,7 +106,7 @@ interface PluginManifest {
     frontend?: {
         entry: string;
         sandbox?: boolean;
-        framework?: "react" | "next";
+        framework?: "react" | "next" | "palette-app";
         config?: string;
     };
     backend?: {
@@ -165,6 +165,8 @@ interface PlatformContext {
     apiFetch: (path: string, init?: RequestInit) => Promise<Response>;
     /** Navigate to a platform route */
     navigate: (path: string) => void;
+    /** Current route path within the plugin app, when mounted by Palette OS */
+    routePath?: string;
     /** Show a toast notification */
     showToast: (message: string, type?: "success" | "error" | "info") => void;
     /** Permissions declared for the current plugin install/runtime */