@ai4b-team/fsaos-gateway-sdk 1.0.1

package/dist/index.cjs

@@ -0,0 +1,3220 @@
+'use strict';
+
+var supabaseJs = require('@supabase/supabase-js');
+var reactQuery = require('@tanstack/react-query');
+var React = require('react');
+var client = require('react-dom/client');
+var ReactDOM = require('react-dom');
+var JsxRuntime = require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+var ReactDOM__namespace = /*#__PURE__*/_interopNamespace(ReactDOM);
+var JsxRuntime__namespace = /*#__PURE__*/_interopNamespace(JsxRuntime);
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ComponentRenderer: () => ComponentRenderer,
+  EnforcementDeniedError: () => EnforcementDeniedError,
+  KernelProvider: () => KernelProvider,
+  QueryClientProvider: () => reactQuery.QueryClientProvider,
+  auth: () => auth,
+  awaitScopeReady: () => awaitScopeReady,
+  callTool: () => callTool,
+  clearCachedToken: () => clearCachedToken,
+  clearSession: () => clearSession,
+  createItem: () => createItem,
+  disconnectSSE: () => disconnectSSE,
+  disposeVfsRealtimeWs: () => disposeVfsRealtimeWs,
+  emitEvent: () => emitEvent,
+  fetchChannelMessages: () => fetchChannelMessages,
+  fetchChannelMessagesPage: () => fetchChannelMessagesPage,
+  fetchEdgesForItem: () => fetchEdgesForItem,
+  fetchItemHistory: () => fetchItemHistory,
+  fetchItems: () => fetchItems,
+  fetchMemberFocus: () => fetchMemberFocus,
+  fetchOpenEnvelope: () => fetchOpenEnvelope,
+  fetchRecentActivity: () => fetchRecentActivity,
+  fetchTypeDefinitions: () => fetchTypeDefinitions,
+  fetchVfsChildren: () => fetchVfsChildren,
+  fetchVfsChildrenPage: () => fetchVfsChildrenPage,
+  fetchVfsItem: () => fetchVfsItem,
+  fetchVfsItemById: () => fetchVfsItemById,
+  fetchVfsTree: () => fetchVfsTree,
+  gatewayCall: () => gatewayCall,
+  getAccessToken: () => getAccessToken,
+  getAssetUrl: () => getAssetUrl,
+  getDefaultSort: () => getDefaultSort,
+  getRequiredFormFields: () => getRequiredFormFields,
+  getScope: () => getScope,
+  getScopeVersion: () => getScopeVersion,
+  getSessionEntry: () => getSessionEntry,
+  initSession: () => initSession,
+  initVfsRealtimeWs: () => initVfsRealtimeWs,
+  interpretSchema: () => interpretSchema,
+  invalidateAllVfs: () => invalidateAllVfs,
+  invalidateChannelMessages: () => invalidateChannelMessages,
+  invalidateChildren: () => invalidateChildren,
+  invalidateItem: () => invalidateItem,
+  invalidateOpenEnvelope: () => invalidateOpenEnvelope,
+  invalidatePathAndParent: () => invalidatePathAndParent,
+  invalidateSubtree: () => invalidateSubtree,
+  invalidateTypes: () => invalidateTypes,
+  isScopeReady: () => isScopeReady,
+  listChildren: () => listChildren,
+  mount: () => mount,
+  mountRealtimeScope: () => mountRealtimeScope,
+  normalizeItem: () => normalizeItem,
+  ping: () => ping,
+  pushChanges: () => pushChanges,
+  queryClient: () => queryClient,
+  readItem: () => readItem,
+  registerCleanup: () => registerCleanup,
+  resetAllSdkState: () => resetAllSdkState,
+  resolvePrincipalId: () => resolvePrincipalId,
+  setCachedToken: () => setCachedToken,
+  setScope: () => setScope,
+  setupRequireShim: () => setupRequireShim,
+  signal: () => signal,
+  subscribeScope: () => subscribeScope,
+  subscribeToEvents: () => subscribeToEvents,
+  subscribeToPath: () => subscribeToPath,
+  subscribeToScope: () => subscribeToScope,
+  unmountRealtimeScope: () => unmountRealtimeScope,
+  updateItem: () => updateItem,
+  uploadFile: () => uploadFile,
+  useAccounts: () => useAccounts,
+  useAllChannels: () => useAllChannels,
+  useAsset: () => useAsset,
+  useAuth: () => useAuth,
+  useChannelMessages: () => useChannelMessages,
+  useChannels: () => useChannels,
+  useChildren: () => useChildren,
+  useComponent: () => useComponent,
+  useCreate: () => useCreate,
+  useDelete: () => useDelete,
+  useDmChannels: () => useDmChannels,
+  useEdges: () => useEdges,
+  useEventStream: () => useEventStream,
+  useFileUpload: () => useFileUpload,
+  useInfiniteChannelMessages: () => useInfiniteChannelMessages,
+  useInfiniteChildren: () => useInfiniteChildren,
+  useInfiniteItems: () => useInfiniteItems,
+  useItem: () => useItem,
+  useItemById: () => useItemById,
+  useItemHistory: () => useItemHistory,
+  useItems: () => useItems,
+  useLink: () => useLink,
+  useList: () => useList,
+  useMemberFocus: () => useMemberFocus,
+  useMove: () => useMove,
+  useMutation: () => useMutation,
+  useNotifications: () => useNotifications,
+  useOpen: () => useOpen,
+  usePermission: () => usePermission,
+  usePermissions: () => usePermissions,
+  usePrincipal: () => usePrincipal,
+  useRealtimeQuery: () => useRealtimeQuery,
+  useRecentActivity: () => useRecentActivity,
+  useScope: () => useScope,
+  useScopeReady: () => useScopeReady,
+  useSearch: () => useSearch,
+  useTheme: () => useTheme,
+  useTool: () => useTool,
+  useTree: () => useTree,
+  useType: () => useType,
+  useTypeHelpers: () => useTypeHelpers,
+  useTypes: () => useTypes,
+  useUnreadCounts: () => useUnreadCounts,
+  useUpdate: () => useUpdate,
+  vfsKeys: () => vfsKeys
+});
+
+// src/enforcement.ts
+var EnforcementDeniedError = class _EnforcementDeniedError extends Error {
+  name = "EnforcementDeniedError";
+  deniedBy;
+  ruleKey;
+  displayName;
+  constructor(payload) {
+    const message = payload.message || _EnforcementDeniedError.fallbackMessage(payload);
+    super(message);
+    this.deniedBy = payload.denied_by || payload.error_type || payload.error || "unknown";
+    const enforcement = payload.enforcement;
+    this.ruleKey = enforcement?.rule_key ?? void 0;
+    this.displayName = enforcement?.display_name ?? void 0;
+  }
+  static fallbackMessage(payload) {
+    const err = payload.error || "";
+    const deniedBy = payload.denied_by || "";
+    if (deniedBy === "rule" || err === "RULE_DENIED") {
+      return "This feature is not enabled for this workspace.";
+    }
+    if (deniedBy === "entitlement" || err === "ENTITLEMENT_REQUIRED") {
+      return "This feature requires a plan upgrade.";
+    }
+    if (deniedBy === "access" || err === "ACCESS_DENIED" || err === "PERMISSION_DENIED") {
+      return "You don't have permission to do this.";
+    }
+    return "This action is not allowed.";
+  }
+  get isRuleDenial() {
+    return this.deniedBy === "rule" || this.deniedBy === "RULE_DENIED";
+  }
+  get isAccessDenial() {
+    return this.deniedBy === "access" || this.deniedBy === "ACCESS_DENIED";
+  }
+  get isEntitlementDenial() {
+    return this.deniedBy === "entitlement" || this.deniedBy === "ENTITLEMENT_REQUIRED";
+  }
+};
+var CONFIG = typeof window !== "undefined" && window.__FSAOS_CONFIG__ || {};
+var SUPABASE_URL = CONFIG.supabaseUrl || "https://vahbmsslxuustnlvsrkg.supabase.co";
+var SUPABASE_ANON_KEY = CONFIG.supabaseAnonKey || "sb_publishable_ZjosozAjfpZ4InMNElTr6Q_hHB-f5nc";
+var GATEWAY_URL = CONFIG.gatewayUrl || "https://fsaos-mcp-gw-rust.fly.dev";
+var supabase = supabaseJs.createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
+  auth: {
+    persistSession: true,
+    autoRefreshToken: true,
+    detectSessionInUrl: false
+  }
+});
+
+// src/session.ts
+var cachedToken = null;
+var tokenReady;
+var resolveTokenReady;
+var tokenResolved = false;
+tokenReady = new Promise((resolve) => {
+  resolveTokenReady = resolve;
+});
+supabase.auth.onAuthStateChange((_event, session) => {
+  if (session?.access_token) {
+    cachedToken = session.access_token;
+    session.expires_at ?? Math.floor(Date.now() / 1e3) + 3600;
+  } else {
+    cachedToken = null;
+  }
+  if (!tokenResolved) {
+    tokenResolved = true;
+    resolveTokenReady();
+  }
+});
+setTimeout(() => {
+  if (!tokenResolved) {
+    tokenResolved = true;
+    resolveTokenReady();
+  }
+}, 5e3);
+function setCachedToken(token, expiresAt) {
+  cachedToken = token;
+}
+function clearCachedToken() {
+  cachedToken = null;
+}
+async function getAccessToken() {
+  await tokenReady;
+  return cachedToken;
+}
+var currentScopePath = null;
+var scopeVersion = 0;
+var scopeListeners = /* @__PURE__ */ new Set();
+var scopeReady;
+var resolveScopeReady;
+var scopeResolved = false;
+scopeReady = new Promise((resolve) => {
+  resolveScopeReady = resolve;
+});
+function setScope(scopePath) {
+  const changed = currentScopePath !== scopePath;
+  currentScopePath = scopePath;
+  if (!scopeResolved) {
+    scopeResolved = true;
+    resolveScopeReady();
+  }
+  if (changed) {
+    scopeVersion++;
+    scopeListeners.forEach((listener) => {
+      try {
+        listener();
+      } catch (e) {
+        console.warn("[SDK] Scope listener error:", e);
+      }
+    });
+  }
+}
+function getScope() {
+  return currentScopePath;
+}
+function getScopeVersion() {
+  return scopeVersion;
+}
+function subscribeScope(listener) {
+  scopeListeners.add(listener);
+  return () => {
+    scopeListeners.delete(listener);
+  };
+}
+function awaitScopeReady() {
+  return scopeReady;
+}
+function isScopeReady() {
+  return scopeResolved;
+}
+var sessionEntry = null;
+var sessionPromise = null;
+async function initSession() {
+  if (sessionEntry) return sessionEntry;
+  if (sessionPromise) return sessionPromise;
+  sessionPromise = (async () => {
+    const hostname = getHostname();
+    const token = await getAccessToken();
+    const headers = {};
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    const response = await fetch(`${GATEWAY_URL}/d/${hostname}/init`, {
+      method: "GET",
+      headers
+    });
+    if (!response.ok) {
+      throw new Error(`Session init failed: ${response.status} ${response.statusText}`);
+    }
+    const json = await response.json();
+    const entry = json.entry || json;
+    sessionEntry = {
+      scope_id: entry.scope_id,
+      scope_path: entry.scope_path,
+      instance_path: entry.instance_path || "/root",
+      fractal_id: entry.fractal_id || null,
+      instance_name: entry.instance_name || null,
+      display_name: entry.scope_display_name || entry.display_name || null
+    };
+    return sessionEntry;
+  })();
+  return sessionPromise;
+}
+function getSessionEntry() {
+  return sessionEntry;
+}
+function clearSession() {
+  sessionEntry = null;
+  sessionPromise = null;
+  currentScopePath = null;
+}
+var cleanupRegistry = [];
+function registerCleanup(fn) {
+  cleanupRegistry.push(fn);
+}
+function resetAllSdkState() {
+  clearSession();
+  clearCachedToken();
+  scopeResolved = false;
+  scopeReady = new Promise((resolve) => {
+    resolveScopeReady = resolve;
+  });
+  scopeVersion++;
+  scopeListeners.forEach((listener) => {
+    try {
+      listener();
+    } catch (e) {
+      console.warn("[SDK] Scope listener error:", e);
+    }
+  });
+  for (const fn of cleanupRegistry) {
+    try {
+      fn();
+    } catch (e) {
+      console.warn("[SDK] Cleanup function failed:", e);
+    }
+  }
+}
+function getHostname() {
+  if (typeof window !== "undefined") {
+    const cfg = window.__FSAOS_CONFIG__;
+    if (cfg?.hostname) return cfg.hostname;
+    return window.location.hostname;
+  }
+  return "localhost";
+}
+
+// src/client.ts
+var SCOPE_INDEPENDENT_METHODS = /* @__PURE__ */ new Set([
+  "list-memberships",
+  "init"
+]);
+async function gatewayCall(method, params = {}) {
+  const hostname = getHostname();
+  const url = `${GATEWAY_URL}/d/${hostname}`;
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  const token = await getAccessToken();
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (!SCOPE_INDEPENDENT_METHODS.has(method) && !params._scope_path) {
+    await awaitScopeReady();
+  }
+  const enrichedParams = { ...params };
+  const session = getSessionEntry();
+  if (!enrichedParams.domain_scope_id && session?.scope_id) {
+    enrichedParams.domain_scope_id = session.scope_id;
+  }
+  const scopePath = getScope();
+  if (!enrichedParams._scope_path && scopePath) {
+    enrichedParams._scope_path = scopePath;
+  }
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ method, params: enrichedParams })
+  });
+  if (!response.ok) {
+    throw new Error(`Gateway HTTP error: ${response.status} ${response.statusText}`);
+  }
+  const json = await response.json();
+  if (json.success === false) {
+    const err = json.error || "";
+    const deniedBy = json.denied_by || json.error_type || "";
+    if (deniedBy === "rule" || deniedBy === "access" || deniedBy === "entitlement" || err === "RULE_DENIED" || err === "ACCESS_DENIED" || err === "PERMISSION_DENIED" || err === "ENTITLEMENT_REQUIRED") {
+      throw new EnforcementDeniedError(json);
+    }
+    throw new Error(
+      json.message || json.error || `Gateway call ${method} failed`
+    );
+  }
+  return json;
+}
+var queryClient = new reactQuery.QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 1e3 * 60 * 2,
+      // 2 minutes
+      gcTime: 1e3 * 60 * 10,
+      // 10 minutes
+      refetchOnWindowFocus: false,
+      retry: 1
+    }
+  }
+});
+
+// src/vfs-keys.ts
+function sk() {
+  return getScope() ?? "__unscoped__";
+}
+var vfsKeys = {
+  /** Root key for all VFS queries (scope-aware). */
+  all: () => ["vfs", sk()],
+  /** Single item by path (scope-aware — relative paths resolve per-scope). */
+  item: (path) => ["vfs", sk(), "item", path],
+  /** Single item by UUID (scope-independent — UUIDs are globally unique). */
+  itemById: (id) => ["vfs", "item-by-id", id],
+  /** Children of a path (scope-aware). */
+  children: (path) => ["vfs", sk(), "children", path],
+  /** All children queries for current scope (for broad invalidation). */
+  allChildren: () => ["vfs", sk(), "children"],
+  /** Type definitions for a scope (or default). */
+  types: (scopeId) => ["vfs", "types", scopeId ?? "default"],
+  /** Edges for an item (scope-independent — edges are by item UUID). */
+  edges: (itemId) => ["vfs", "edges", itemId],
+  /** Search results (scope-aware — search is scoped). */
+  search: (query, types) => ["vfs", sk(), "search", query, ...types ?? []],
+  /** Items query (type-based listing with filters, scope-aware). */
+  items: (type, filters) => ["vfs", sk(), "items", type, JSON.stringify(filters ?? {})],
+  /** All items queries for current scope (for broad invalidation). */
+  allItems: () => ["vfs", sk(), "items"],
+  /** Recursive tree at a path + depth (scope-aware). */
+  tree: (path, depth) => ["vfs", sk(), "tree", path, depth ?? 1],
+  /** Open envelope for a path (scope-aware). */
+  openEnvelope: (path, strategy) => ["vfs", sk(), "open", path, strategy ?? "__default__"],
+  /** All open-envelope queries for current scope (for broad invalidation). */
+  allOpenEnvelopes: () => ["vfs", sk(), "open"],
+  /** Member focus for a scope. */
+  memberFocus: (scopeId) => ["vfs", "member-focus", scopeId],
+  /** Fractal instances (scope-independent). */
+  fractalInstances: () => ["vfs", "fractal-instances"],
+  /** Recent activity (scope-aware). */
+  recentActivity: (a, b, c) => ["vfs", sk(), "recent-activity", a, b, c],
+  /** Item history (scope-independent — by item UUID). */
+  itemHistory: (a, b, c) => ["vfs", "item-history", a, b, c],
+  /** Channel messages (scope-aware — channels are scoped). */
+  channelMessages: (channelPath, parentMessageId) => ["vfs", sk(), "channel-messages", channelPath, parentMessageId ?? "__top__"],
+  /** All channel-messages queries for current scope (for broad invalidation). */
+  allChannelMessages: () => ["vfs", sk(), "channel-messages"],
+  /** Channels listing (scope-aware). */
+  channels: (filter) => ["vfs", sk(), "channels", filter ?? "all"],
+  /** All channels queries for current scope (for broad invalidation). */
+  allChannels: () => ["vfs", sk(), "channels"],
+  /** Notifications listing (scope-aware). */
+  notifications: (filter, limit) => ["vfs", sk(), "notifications", filter ?? "all", limit ?? 200],
+  /** All notification queries for current scope (for broad invalidation). */
+  allNotifications: () => ["vfs", sk(), "notifications"],
+  /** Unread counts (scope-aware). */
+  unreadCounts: () => ["vfs", sk(), "unread-counts"],
+  /** Membership graph for a principal (scope-independent). */
+  memberships: (principalId) => ["memberships", principalId]
+};
+
+// src/vfs.ts
+function nowISO() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function randomId() {
+  return crypto.randomUUID ? crypto.randomUUID() : `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+}
+function normalizeItem(raw) {
+  const path = raw.path || raw.item_path || "";
+  const segments = path.split("/");
+  segments.pop();
+  const parentPath = segments.join("/");
+  const typeData = raw.type_data || {};
+  if (typeData.allowed_parent_types && !typeData.accepts) {
+    typeData.accepts = typeData.allowed_parent_types;
+  }
+  delete typeData.allowed_parent_types;
+  return {
+    id: raw.id || raw.item_id || "",
+    name: raw.name || raw.item_name || "",
+    item_type: raw.item_type || "unknown",
+    path,
+    parent_path: parentPath,
+    is_active: raw.is_active !== false,
+    has_children: raw.has_children ?? false,
+    created_at: raw.created_at || nowISO(),
+    updated_at: raw.updated_at || nowISO(),
+    visibility: raw.visibility,
+    type_data: typeData,
+    scope_item_id: raw.scope_item_id,
+    fractal_id: raw.fractal_id,
+    parent_instance_id: raw.parent_instance_id,
+    owner_principal_id: raw.owner_principal_id,
+    created_by_principal_id: raw.created_by_principal_id,
+    parent_id: raw.parent_id
+  };
+}
+function extractItems(response) {
+  return (response.content?.items || response.items || []).map(normalizeItem);
+}
+async function fetchVfsItemById(id) {
+  try {
+    const response = await gatewayCall("read", { id });
+    if (response.item_name || response.item_path) {
+      const item2 = normalizeItem(response);
+      if (item2.path) {
+        queryClient.setQueryData(vfsKeys.item(item2.path), item2);
+      }
+      return item2;
+    }
+    const item = response.item;
+    if (item) {
+      const normalized = normalizeItem(item);
+      if (normalized.path) {
+        queryClient.setQueryData(vfsKeys.item(normalized.path), normalized);
+      }
+      return normalized;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function fetchVfsItem(path) {
+  try {
+    const response = await gatewayCall("read", { path });
+    if (response.item_name || response.item_path) {
+      return normalizeItem(response);
+    }
+    const item = response.item;
+    return item ? normalizeItem(item) : null;
+  } catch {
+    return null;
+  }
+}
+async function fetchVfsChildren(path) {
+  try {
+    const response = await gatewayCall("list", { path, limit: 200 });
+    const items = extractItems(response);
+    for (const item of items) {
+      queryClient.setQueryData(vfsKeys.item(item.path), item);
+    }
+    return items;
+  } catch (err) {
+    console.error(`[gateway] Failed to fetch children of ${path}:`, err);
+    return [];
+  }
+}
+async function fetchVfsChildrenPage(path, limit, offset) {
+  try {
+    const response = await gatewayCall("list", { path, limit, offset });
+    const items = extractItems(response);
+    for (const item of items) {
+      queryClient.setQueryData(vfsKeys.item(item.path), item);
+    }
+    return { items, total_hint: response.total ?? response.content?.total ?? items.length };
+  } catch (err) {
+    console.error(`[gateway] Failed to fetch children page of ${path}:`, err);
+    return { items: [], total_hint: 0 };
+  }
+}
+async function fetchTypeDefinitions(scopeId) {
+  const params = scopeId ? { scope_id: scopeId } : {};
+  const response = await gatewayCall("types-list", params);
+  const rawItems = response.content?.items || response.items || [];
+  const types = /* @__PURE__ */ new Map();
+  for (const raw of rawItems) {
+    const name = raw.name;
+    const td = raw.type_data;
+    if (!name || !td) continue;
+    types.set(name, {
+      type_key: name,
+      display_name: td.display_name || name,
+      display_name_plural: td.display_name_plural || name + "s",
+      icon: td.icon || "File",
+      color: td.color || "gray",
+      description: td.description || "",
+      input_schema: td.input_schema || {},
+      system_schema: td.system_schema || {},
+      json_schema: td.input_schema || td.json_schema || {},
+      default_data: td.default_data || {},
+      field_defaults: td.field_defaults || {},
+      renderer_config: td.renderer_config || {},
+      is_system: td.is_system ?? false,
+      is_active: td.is_active ?? true,
+      is_container: td.is_container ?? false,
+      is_scope: td.is_scope ?? false,
+      render_mode: td.render_mode || "none",
+      placement_mode: td.placement_mode,
+      direct_parent_types: td.direct_parent_types,
+      allowed_parent_types: td.allowed_parent_types,
+      governed_create: td.governed_create,
+      create_method: td.create_method,
+      dedup: td.dedup,
+      edges: td.edges,
+      events: td.events
+    });
+  }
+  return types;
+}
+async function fetchEdgesForItem(itemId) {
+  try {
+    const response = await gatewayCall("edges", { item_id: itemId });
+    const outgoing = response.outgoing || [];
+    const incoming = response.incoming || [];
+    const edges = [];
+    for (const edge of outgoing) {
+      edges.push({
+        id: edge.edge_id || randomId(),
+        source_item_id: itemId,
+        target_item_id: edge.target_id || "",
+        edge_type: edge.edge_type || "",
+        weight: edge.weight ?? 1,
+        context: edge.context || {},
+        is_active: true,
+        is_bidirectional: edge.is_bidirectional
+      });
+    }
+    for (const edge of incoming) {
+      edges.push({
+        id: edge.edge_id || randomId(),
+        source_item_id: edge.source_id || "",
+        target_item_id: itemId,
+        edge_type: edge.edge_type || "",
+        weight: edge.weight ?? 1,
+        context: edge.context || {},
+        is_active: true,
+        is_bidirectional: edge.is_bidirectional
+      });
+    }
+    return edges;
+  } catch (err) {
+    console.warn(`[gateway] Failed to fetch edges for ${itemId}:`, err);
+    return [];
+  }
+}
+async function fetchVfsTree(path, maxDepth = 1, itemTypes, limit) {
+  try {
+    const params = {
+      path,
+      max_depth: maxDepth > 0 ? maxDepth : 999
+    };
+    if (itemTypes?.length) params.item_types = itemTypes;
+    if (limit) params.limit = limit;
+    const response = await gatewayCall("tree", params);
+    const items = extractItems(response);
+    for (const item of items) {
+      queryClient.setQueryData(vfsKeys.item(item.path), item);
+    }
+    return items;
+  } catch (err) {
+    console.error(`[gateway] Failed to fetch tree at ${path}:`, err);
+    return [];
+  }
+}
+async function fetchRecentActivity(scopePath, limit = 50, offset = 0) {
+  try {
+    const response = await gatewayCall("recent-activity", {
+      scope_path: scopePath,
+      limit,
+      offset
+    });
+    return response.content?.items || response.items || response.entries || [];
+  } catch (err) {
+    console.error(`[gateway] Failed to fetch recent activity for ${scopePath}:`, err);
+    return [];
+  }
+}
+async function fetchItemHistory(itemId, limit = 50, offset = 0) {
+  try {
+    const response = await gatewayCall("item-history", {
+      item_id: itemId,
+      limit,
+      offset
+    });
+    return {
+      versions: response.content?.items || response.versions || [],
+      total: response.total ?? 0
+    };
+  } catch (err) {
+    console.error(`[gateway] Failed to fetch item history for ${itemId}:`, err);
+    return { versions: [], total: 0 };
+  }
+}
+async function fetchMemberFocus(scopeId, itemTypes, limit) {
+  try {
+    const params = { scope_id: scopeId };
+    if (itemTypes?.length) params.item_types = itemTypes;
+    if (limit) params.limit = limit;
+    const response = await gatewayCall("member-focus", params);
+    const items = extractItems(response);
+    for (const item of items) {
+      queryClient.setQueryData(vfsKeys.item(item.path), item);
+    }
+    return items;
+  } catch (err) {
+    console.error(`[gateway] Failed to fetch member focus for scope ${scopeId}:`, err);
+    return [];
+  }
+}
+async function fetchOpenEnvelope(path, options) {
+  const params = { path };
+  if (options?.mode) params.mode = options.mode;
+  if (options?.strategy) params.strategy = options.strategy;
+  if (options?.arguments) params.arguments = options.arguments;
+  const response = await gatewayCall("open", params);
+  const r = response;
+  return {
+    item_id: r.item_id,
+    item_path: r.item_path,
+    item_name: r.item_name,
+    item_type: r.item_type,
+    render: r.render,
+    compatible_components: r.compatible_components ?? [],
+    content: r.content,
+    metadata: r.metadata,
+    instructions: r.instructions
+  };
+}
+async function fetchItems(filter) {
+  const params = {
+    item_type: filter.type
+  };
+  if (filter.scope) {
+    params.scope_path = filter.scope;
+  }
+  const filters = {};
+  if (filter.name) filters.name = filter.name;
+  if (filter.tag) filters.tag = filter.tag;
+  if (filter.parent_id) filters.parent_id = filter.parent_id;
+  if (filter.sort_by) filters.sort_by = filter.sort_by;
+  if (filter.sort_dir) filters.sort_dir = filter.sort_dir;
+  if (filter.offset != null) filters.offset = filter.offset;
+  if (filter.fields) {
+    for (const [key, value] of Object.entries(filter.fields)) {
+      filters[`field.${key}`] = String(value);
+    }
+  }
+  if (Object.keys(filters).length > 0) {
+    params.filters = filters;
+  }
+  if (filter.limit != null) {
+    params.limit = filter.limit;
+  }
+  try {
+    const response = await gatewayCall("search", params);
+    const items = extractItems(response);
+    for (const item of items) {
+      queryClient.setQueryData(vfsKeys.item(item.path), item);
+    }
+    return { items, total_hint: response.total ?? response.content?.total ?? items.length };
+  } catch (err) {
+    console.error(`[gateway] Failed to fetch items of type ${filter.type}:`, err);
+    return { items: [], total_hint: 0 };
+  }
+}
+function parseChannelMessages(rawItems) {
+  return rawItems.filter((i) => i.item_type === "message").map((i) => {
+    const td = i.type_data || {};
+    let role = "user";
+    if (td.role === "assistant") role = "assistant";
+    else if (td.role === "system") role = "system";
+    const metadata = td.metadata || {};
+    return {
+      id: i.id || "",
+      path: i.path || "",
+      content: td.message || td.content || "",
+      created_at: i.created_at || "",
+      role,
+      seq: td.seq || 0,
+      principal_id: td.principal_id,
+      reply_count: td.reply_count || 0,
+      parent_message_id: td.parent_message_id,
+      intent_card: metadata.intent_card,
+      thread_summary: Array.isArray(td.thread_summary) && td.thread_summary.length > 0 ? td.thread_summary : void 0
+    };
+  }).sort((a, b) => a.seq - b.seq);
+}
+async function fetchChannelMessages(channelPath, parentMessageId) {
+  try {
+    const params = { channel_path: channelPath };
+    if (parentMessageId) params.parent_message_id = parentMessageId;
+    const response = await gatewayCall("get-channel-messages", params);
+    const raw = response;
+    const items = raw.messages || raw.content?.items || raw.items || [];
+    return parseChannelMessages(items);
+  } catch (err) {
+    console.error(
+      `[gateway] Failed to fetch channel messages for ${channelPath}:`,
+      err
+    );
+    return [];
+  }
+}
+async function fetchChannelMessagesPage(channelPath, options) {
+  try {
+    const params = { channel_path: channelPath };
+    if (options?.parentMessageId) params.parent_message_id = options.parentMessageId;
+    if (options?.limit) params.limit = options.limit;
+    if (options?.before_seq != null) params.before_seq = options.before_seq;
+    if (options?.after_seq != null) params.after_seq = options.after_seq;
+    const response = await gatewayCall("get-channel-messages", params);
+    const raw = response;
+    const items = raw.messages || [];
+    return {
+      messages: parseChannelMessages(items),
+      mode: raw.mode || "top_level"
+    };
+  } catch (err) {
+    console.error(
+      `[gateway] Failed to fetch channel messages page for ${channelPath}:`,
+      err
+    );
+    return { messages: [], mode: "top_level" };
+  }
+}
+function invalidateChildren(path) {
+  queryClient.invalidateQueries({ queryKey: vfsKeys.children(path) });
+}
+function invalidateItem(path) {
+  queryClient.invalidateQueries({ queryKey: vfsKeys.item(path) });
+}
+function invalidatePathAndParent(path, fallbackParent) {
+  invalidateItem(path);
+  invalidateChildren(path);
+  const segments = path.split("/");
+  segments.pop();
+  const parentPath = segments.join("/") || fallbackParent;
+  if (parentPath) {
+    invalidateChildren(parentPath);
+  }
+}
+function invalidateSubtree(path) {
+  const prefix = path + "/";
+  queryClient.invalidateQueries({
+    predicate: (query) => {
+      const key = query.queryKey;
+      if (key[0] !== "vfs") return false;
+      return key.some(
+        (segment) => typeof segment === "string" && (segment === path || segment.startsWith(prefix))
+      );
+    }
+  });
+}
+function invalidateAllVfs() {
+  queryClient.invalidateQueries({ queryKey: vfsKeys.all() });
+}
+function invalidateTypes(scopeId) {
+  queryClient.invalidateQueries({ queryKey: vfsKeys.types(scopeId) });
+}
+function invalidateChannelMessages(channelPath, parentMessageId) {
+  if (channelPath) {
+    queryClient.invalidateQueries({ queryKey: vfsKeys.channelMessages(channelPath, parentMessageId) });
+  } else {
+    queryClient.invalidateQueries({ queryKey: vfsKeys.allChannelMessages() });
+  }
+}
+function invalidateOpenEnvelope(path, strategy) {
+  if (path && strategy) {
+    queryClient.invalidateQueries({ queryKey: vfsKeys.openEnvelope(path, strategy) });
+  } else if (path) {
+    queryClient.invalidateQueries({
+      predicate: (query) => {
+        const key = query.queryKey;
+        return key[0] === "vfs" && key[2] === "open" && key[3] === path;
+      }
+    });
+  } else {
+    queryClient.invalidateQueries({ queryKey: vfsKeys.allOpenEnvelopes() });
+  }
+}
+
+// src/ws.ts
+var DEBUG = typeof window !== "undefined" && (window.location?.hostname === "localhost" || window.location?.hostname === "127.0.0.1" || window.__FSAOS_WS_DEBUG__);
+function log(...args) {
+  if (DEBUG) console.log("[WS]", ...args);
+}
+var ws = null;
+var connectionInFlight = null;
+var reconnectTimer = null;
+var reconnectAttempts = 0;
+var MAX_RECONNECT_DELAY = 3e4;
+var CONNECTION_TIMEOUT_MS = 1e4;
+var intentionalClose = false;
+var PING_INTERVAL_MS = 3e4;
+var pingInterval = null;
+var visibilityListenerAttached = false;
+function startPing() {
+  stopPing();
+  pingInterval = setInterval(() => {
+    sendMessage({ type: "ping" });
+  }, PING_INTERVAL_MS);
+}
+function stopPing() {
+  if (pingInterval) {
+    clearInterval(pingInterval);
+    pingInterval = null;
+  }
+}
+function handleVisibilityChange() {
+  if (typeof document === "undefined") return;
+  if (document.hidden) {
+    stopPing();
+  } else {
+    if (hasActiveSubscriptions()) {
+      log("Tab visible, reconnecting...");
+      ensureConnection();
+    }
+  }
+}
+function attachVisibilityListener() {
+  if (visibilityListenerAttached) return;
+  if (typeof document === "undefined") return;
+  document.addEventListener("visibilitychange", handleVisibilityChange);
+  visibilityListenerAttached = true;
+}
+var pathListeners = {};
+var typedListeners = [];
+var activeScopes = /* @__PURE__ */ new Map();
+var activePaths = /* @__PURE__ */ new Map();
+function hasListeners() {
+  const hasPath = Object.keys(pathListeners).some(
+    (k) => pathListeners[k] && pathListeners[k].length > 0
+  );
+  return hasPath || typedListeners.length > 0;
+}
+function hasActiveSubscriptions() {
+  return activeScopes.size > 0 || activePaths.size > 0;
+}
+async function ensureConnection() {
+  if (!hasActiveSubscriptions()) {
+    log("ensureConnection: no active subscriptions, skipping");
+    return;
+  }
+  if (ws && ws.readyState === WebSocket.OPEN) {
+    log("ensureConnection: already open");
+    return;
+  }
+  if (connectionInFlight) {
+    log("ensureConnection: connection already in flight, waiting...");
+    return connectionInFlight;
+  }
+  if (ws) {
+    log("ensureConnection: killing stale WS in state", ws.readyState);
+    try {
+      ws.close();
+    } catch (_e) {
+    }
+    ws = null;
+  }
+  intentionalClose = false;
+  connectionInFlight = (async () => {
+    try {
+      const config = typeof window !== "undefined" && window.__FSAOS_CONFIG__ || {};
+      const gatewayUrl = GATEWAY_URL;
+      const embedToken = config.embedToken || null;
+      let token = embedToken;
+      if (!token) {
+        token = await getAccessToken();
+      }
+      if (!token) {
+        log("ensureConnection: no token available, will retry");
+        scheduleReconnect();
+        return;
+      }
+      const wsProtocol = gatewayUrl.startsWith("https") ? "wss" : "ws";
+      const wsHost = gatewayUrl.replace(/^https?:\/\//, "");
+      let wsUrl = `${wsProtocol}://${wsHost}/ws`;
+      wsUrl += `?token=${encodeURIComponent(token)}`;
+      log("ensureConnection: opening WS to", wsUrl.substring(0, 50) + "...");
+      ws = new WebSocket(wsUrl);
+      await new Promise((resolve, reject) => {
+        if (!ws) return reject(new Error("WebSocket not created"));
+        const timeout = setTimeout(() => {
+          log("ensureConnection: TIMEOUT after", CONNECTION_TIMEOUT_MS, "ms");
+          if (ws && ws.readyState !== WebSocket.OPEN) {
+            try {
+              ws.close();
+            } catch (_e) {
+            }
+            ws = null;
+          }
+          reject(new Error("WebSocket connection timeout"));
+        }, CONNECTION_TIMEOUT_MS);
+        ws.onopen = () => {
+          clearTimeout(timeout);
+          log("ensureConnection: CONNECTED");
+          reconnectAttempts = 0;
+          resubscribeAll();
+          if (typeof document === "undefined" || !document.hidden) {
+            startPing();
+          }
+          attachVisibilityListener();
+          resolve();
+        };
+        ws.onmessage = (event) => {
+          handleMessage(event.data);
+        };
+        ws.onerror = () => {
+          log("ensureConnection: WS error event");
+        };
+        ws.onclose = (event) => {
+          clearTimeout(timeout);
+          log("ensureConnection: WS closed, code:", event.code, "reason:", event.reason);
+          ws = null;
+          stopPing();
+          if (!intentionalClose && hasActiveSubscriptions()) {
+            scheduleReconnect();
+          }
+          reject(new Error(`WebSocket closed: ${event.code}`));
+        };
+      });
+    } catch (e) {
+      log("ensureConnection: failed -", e?.message || e);
+    } finally {
+      connectionInFlight = null;
+    }
+  })();
+  return connectionInFlight;
+}
+function scheduleReconnect() {
+  if (reconnectTimer) return;
+  if (typeof document !== "undefined" && document.hidden) return;
+  const delay = Math.min(
+    1e3 * Math.pow(2, reconnectAttempts) + Math.random() * 1e3,
+    MAX_RECONNECT_DELAY
+  );
+  reconnectAttempts++;
+  log("scheduleReconnect: attempt", reconnectAttempts, "in", Math.round(delay), "ms");
+  reconnectTimer = setTimeout(() => {
+    reconnectTimer = null;
+    if (hasActiveSubscriptions()) {
+      ensureConnection();
+    }
+  }, delay);
+}
+function resubscribeAll() {
+  for (const sub of activeScopes.values()) {
+    log("resubscribeAll: scope", sub.scope_id);
+    sendMessage({ type: "subscribe", scope_id: sub.scope_id, event_types: sub.event_types });
+  }
+  for (const sub of activePaths.values()) {
+    log("resubscribeAll: path", sub.path);
+    sendMessage({ type: "subscribe_path", path: sub.path, event_types: sub.event_types });
+  }
+}
+function sendMessage(msg) {
+  if (ws && ws.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify(msg));
+  }
+}
+function handleMessage(raw) {
+  try {
+    const msg = JSON.parse(raw);
+    if (msg.type === "subscribed" || msg.type === "subscribed_path" || msg.type === "unsubscribed" || msg.type === "unsubscribed_path" || msg.type === "pong") {
+      return;
+    }
+    if (msg.type === "error") {
+      console.warn("[WS] Server error:", msg.message);
+      return;
+    }
+    if (msg.type === "event" || msg.event_type) {
+      const eventType = msg.event_type || "message";
+      const data = msg.data || msg;
+      if (data.path && pathListeners[data.path]) {
+        pathListeners[data.path].forEach((cb) => cb(data));
+      }
+      if (pathListeners["*"]) {
+        pathListeners["*"].forEach((cb) => cb(data));
+      }
+      for (const entry of typedListeners) {
+        if (entry.eventType !== "*" && entry.eventType !== eventType) continue;
+        if (entry.filter && !entry.filter(data)) continue;
+        entry.callback(data);
+      }
+    }
+  } catch (_e) {
+  }
+}
+function maybeDisconnect() {
+  if (!hasListeners() && activeScopes.size === 0 && activePaths.size === 0 && ws) {
+    intentionalClose = true;
+    stopPing();
+    ws.close();
+    ws = null;
+    intentionalClose = false;
+  }
+}
+function subscribeToPath(path, callback) {
+  if (!pathListeners[path]) {
+    pathListeners[path] = [];
+  }
+  pathListeners[path].push(callback);
+  if (!activePaths.has(path)) {
+    activePaths.set(path, { path, event_types: ["token_stream"] });
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      sendMessage({ type: "subscribe_path", path, event_types: ["token_stream"] });
+    }
+  }
+  ensureConnection();
+  return () => {
+    const listeners = pathListeners[path];
+    if (listeners) {
+      const idx = listeners.indexOf(callback);
+      if (idx !== -1) listeners.splice(idx, 1);
+      if (listeners.length === 0) {
+        delete pathListeners[path];
+        activePaths.delete(path);
+        sendMessage({ type: "unsubscribe_path", path });
+      }
+    }
+    maybeDisconnect();
+  };
+}
+function subscribeToEvents(eventType, callback, filter) {
+  const types = Array.isArray(eventType) ? eventType : [eventType];
+  const entries = types.map((t) => ({ eventType: t, callback, filter }));
+  typedListeners.push(...entries);
+  if (hasActiveSubscriptions()) {
+    ensureConnection();
+  }
+  return () => {
+    for (const entry of entries) {
+      const idx = typedListeners.indexOf(entry);
+      if (idx !== -1) typedListeners.splice(idx, 1);
+    }
+    maybeDisconnect();
+  };
+}
+function subscribeToScope(scopeId, eventTypes = ["vfs_change", "ccm_change"]) {
+  log("subscribeToScope:", scopeId, eventTypes);
+  activeScopes.set(scopeId, { scope_id: scopeId, event_types: eventTypes });
+  if (ws && ws.readyState === WebSocket.OPEN) {
+    sendMessage({ type: "subscribe", scope_id: scopeId, event_types: eventTypes });
+  }
+  ensureConnection();
+  return () => {
+    activeScopes.delete(scopeId);
+    sendMessage({ type: "unsubscribe", scope_id: scopeId });
+    maybeDisconnect();
+  };
+}
+function emitEvent(scopeId, eventType, payload = {}) {
+  sendMessage({ type: "emit", scope_id: scopeId, event_type: eventType, payload });
+}
+function disconnectSSE() {
+  log("disconnectSSE: tearing down");
+  intentionalClose = true;
+  stopPing();
+  if (ws) {
+    ws.close();
+    ws = null;
+  }
+  if (reconnectTimer) {
+    clearTimeout(reconnectTimer);
+    reconnectTimer = null;
+  }
+  connectionInFlight = null;
+  intentionalClose = false;
+  reconnectAttempts = 0;
+  for (const key of Object.keys(pathListeners)) {
+    delete pathListeners[key];
+  }
+  typedListeners.length = 0;
+  activeScopes.clear();
+  activePaths.clear();
+}
+function ping() {
+  sendMessage({ type: "ping" });
+}
+registerCleanup(disconnectSSE);
+
+// src/vfs-realtime-ws.ts
+var activeScopeSubs = /* @__PURE__ */ new Map();
+var unsubEvents = null;
+var debounceTimers = /* @__PURE__ */ new Map();
+var DEBOUNCE_MS = 250;
+function initVfsRealtimeWs(accountId) {
+  disposeVfsRealtimeWs();
+  mountRealtimeScope(accountId);
+  unsubEvents = subscribeToEvents(
+    "vfs_change",
+    (data) => handleVfsChange(data)
+  );
+}
+function mountRealtimeScope(scopeId) {
+  if (activeScopeSubs.has(scopeId)) return;
+  const unsub = subscribeToScope(scopeId, ["vfs_change", "ccm_change"]);
+  activeScopeSubs.set(scopeId, unsub);
+}
+function unmountRealtimeScope(scopeId) {
+  const unsub = activeScopeSubs.get(scopeId);
+  if (unsub) {
+    unsub();
+    activeScopeSubs.delete(scopeId);
+  }
+}
+function disposeVfsRealtimeWs() {
+  for (const [, unsub] of activeScopeSubs) {
+    unsub();
+  }
+  activeScopeSubs.clear();
+  if (unsubEvents) {
+    unsubEvents();
+    unsubEvents = null;
+  }
+  debounceTimers.forEach((timer) => clearTimeout(timer));
+  debounceTimers.clear();
+}
+registerCleanup(disposeVfsRealtimeWs);
+function handleVfsChange(data) {
+  const path = data.path;
+  const action = data.action;
+  if (!path) return;
+  const segments = path.split("/");
+  segments.pop();
+  const parentPath = segments.join("/") || "/root";
+  const existing = debounceTimers.get(parentPath);
+  if (existing) clearTimeout(existing);
+  const timer = setTimeout(() => {
+    debounceTimers.delete(parentPath);
+    applyInvalidation(action, path, data, parentPath);
+  }, DEBOUNCE_MS);
+  debounceTimers.set(parentPath, timer);
+}
+function applyInvalidation(action, path, data, parentPath) {
+  const upperAction = (action || "").toUpperCase();
+  if (upperAction === "DELETE") {
+    queryClient.removeQueries({ queryKey: vfsKeys.item(path) });
+    queryClient.removeQueries({ queryKey: vfsKeys.children(path) });
+    queryClient.removeQueries({ queryKey: vfsKeys.tree(path) });
+  } else if (data.item_id) {
+    try {
+      const record = {
+        id: data.item_id,
+        path: data.path,
+        name: data.name,
+        item_type: data.item_type,
+        parent_id: data.parent_id,
+        scope_item_id: data.scope_item_id
+      };
+      const normalized = normalizeItem(record);
+      if (normalized && normalized.id) {
+        queryClient.setQueryData(vfsKeys.item(path), normalized);
+      }
+    } catch (_e) {
+    }
+  }
+  queryClient.invalidateQueries({ queryKey: vfsKeys.children(parentPath) });
+  queryClient.invalidateQueries({
+    predicate: (query) => {
+      const key = query.queryKey;
+      if (key[0] !== "vfs" || key[1] !== "tree") return false;
+      const treePath = key[2];
+      return path.startsWith(treePath + "/") || path === treePath;
+    }
+  });
+  if (data.item_id) {
+    queryClient.invalidateQueries({ queryKey: vfsKeys.itemById(data.item_id) });
+  }
+}
+function readItem(path) {
+  return gatewayCall("read", { path });
+}
+function listChildren(path, options) {
+  return gatewayCall("list", { path, ...options });
+}
+function createItem(params) {
+  return gatewayCall("create", params);
+}
+function updateItem(params) {
+  return gatewayCall("update", params);
+}
+function pushChanges(params) {
+  return gatewayCall("create", params);
+}
+function callTool(toolName, params) {
+  const config = typeof window !== "undefined" && window.__FSAOS_CONFIG__ || {};
+  const scopePath = config.scopePath || "";
+  return gatewayCall("tools/call", {
+    name: toolName,
+    instance_path: scopePath,
+    ...params || {}
+  });
+}
+function signal(targetId, eventName, payload) {
+  return gatewayCall("signal", { target_id: targetId, event_name: eventName, payload: payload || {} });
+}
+function getAssetUrl(path) {
+  const config = typeof window !== "undefined" && window.__FSAOS_CONFIG__ || {};
+  return (config.edgeBaseUrl || "") + path;
+}
+var auth = {
+  signIn: (opts) => {
+    if (opts.provider) {
+      return supabase.auth.signInWithOAuth({
+        provider: opts.provider,
+        options: { redirectTo: opts.redirectTo || window.location.href }
+      });
+    }
+    return supabase.auth.signInWithPassword({
+      email: opts.email,
+      password: opts.password
+    });
+  },
+  signUp: (opts) => {
+    return supabase.auth.signUp({
+      email: opts.email,
+      password: opts.password,
+      options: { data: opts.metadata || {} }
+    });
+  },
+  signOut: async () => {
+    await supabase.auth.signOut();
+    resetAllSdkState();
+    queryClient.clear();
+  },
+  getSession: () => supabase.auth.getSession().then((r) => r.data.session),
+  getUser: () => supabase.auth.getUser().then((r) => r.data.user),
+  onAuthStateChange: (callback) => {
+    const { data: { subscription } } = supabase.auth.onAuthStateChange(
+      (event, session) => {
+        callback({ event, session, user: session?.user ?? null });
+      }
+    );
+    return () => subscription?.unsubscribe();
+  },
+  resetPassword: (email) => supabase.auth.resetPasswordForEmail(email),
+  signInWithMagicLink: (email, redirectTo) => {
+    return supabase.auth.signInWithOtp({
+      email,
+      options: { emailRedirectTo: redirectTo || window.location.href }
+    });
+  }
+};
+function mount() {
+  const rootEl = document.getElementById("root");
+  if (!rootEl) return;
+  try {
+    const comp = window.__FSAOS_COMPONENT__;
+    if (!comp) {
+      rootEl.innerHTML = '<div style="padding:2rem;color:#ef4444;font-family:system-ui"><h2>Component Error</h2><pre>No component found. The bundle may have failed to load.</pre></div>';
+      return;
+    }
+    const RootComponent = comp.default || comp;
+    const itemData = window.__FSAOS_ITEM_DATA__ || null;
+    const props = itemData ? { item: itemData, ...itemData } : {};
+    const root = client.createRoot(rootEl);
+    root.render(
+      React.createElement(
+        reactQuery.QueryClientProvider,
+        { client: queryClient },
+        React.createElement(RootComponent, props)
+      )
+    );
+  } catch (err) {
+    console.error("[FSAOS] Failed to mount root component:", err);
+    rootEl.innerHTML = '<div style="padding:2rem;color:#ef4444;font-family:system-ui"><h2>Component Error</h2><pre>' + (err.message || err) + "</pre></div>";
+  }
+}
+function setupRequireShim() {
+  const R = window.React;
+  const RD = window.ReactDOM;
+  const gateway = window.__FSAOS_GATEWAY__;
+  const ui = window.__FSAOS_UI__;
+  if (!gateway) {
+    console.error("[FSAOS] Cannot set up require shim: __FSAOS_GATEWAY__ not found");
+    return;
+  }
+  const modules = {
+    "react": R,
+    "react-dom": RD,
+    "react-dom/client": RD,
+    "react/jsx-runtime": {
+      jsx: R?.createElement,
+      jsxs: R?.createElement,
+      Fragment: R?.Fragment
+    },
+    "@fsaos/react": gateway,
+    "@fsaos/gateway": gateway,
+    "@fsaos/ui": ui || {}
+  };
+  window.require = function fsaosRequire(name) {
+    if (modules[name]) return modules[name];
+    throw new Error("[FSAOS] Module not found: " + name);
+  };
+  window.__FSAOS_MOUNT__ = gateway.mount;
+}
+function useScopeKey() {
+  return React.useSyncExternalStore(subscribeScope, getScopeVersion, getScopeVersion);
+}
+function useScopeReady() {
+  useScopeKey();
+  return isScopeReady();
+}
+function useItem(path) {
+  useScopeKey();
+  return reactQuery.useQuery({
+    queryKey: vfsKeys.item(path),
+    queryFn: () => fetchVfsItem(path),
+    enabled: !!path
+  });
+}
+function useItemById(id) {
+  useScopeKey();
+  return reactQuery.useQuery({
+    queryKey: vfsKeys.itemById(id),
+    queryFn: () => fetchVfsItemById(id),
+    enabled: !!id
+  });
+}
+function useList(path) {
+  useScopeKey();
+  return reactQuery.useQuery({
+    queryKey: vfsKeys.children(path),
+    queryFn: () => fetchVfsChildren(path),
+    enabled: !!path
+  });
+}
+function useChildren(path) {
+  const query = useList(path);
+  return {
+    ...query,
+    children: query.data ?? []
+  };
+}
+function useTree(path, depth = 1) {
+  useScopeKey();
+  return reactQuery.useQuery({
+    queryKey: vfsKeys.tree(path, depth),
+    queryFn: () => fetchVfsTree(path, depth),
+    enabled: !!path
+  });
+}
+function useSearch(query, itemTypes) {
+  useScopeKey();
+  return reactQuery.useQuery({
+    queryKey: vfsKeys.search(query, itemTypes),
+    queryFn: async () => {
+      const params = { query };
+      if (itemTypes?.length) params.item_types = itemTypes;
+      const response = await gatewayCall("search", params);
+      return (response.content?.items || response.items || []).map(normalizeItem);
+    },
+    enabled: !!query && query.length > 0
+  });
+}
+function useItems(filter) {
+  useScopeKey();
+  const stableFilter = React.useMemo(() => filter, [JSON.stringify(filter)]);
+  return reactQuery.useQuery({
+    queryKey: vfsKeys.items(
+      stableFilter?.type ?? "",
+      stableFilter
+    ),
+    queryFn: () => fetchItems(stableFilter),
+    enabled: !!stableFilter?.type,
+    select: (result) => result.items
+  });
+}
+function useInfiniteItems(filter) {
+  useScopeKey();
+  const PAGE_SIZE = filter?.limit ?? 20;
+  const stableFilter = React.useMemo(() => filter, [JSON.stringify(filter)]);
+  const query = reactQuery.useInfiniteQuery({
+    queryKey: ["vfs", getScope() ?? "__unscoped__", "infinite-items", stableFilter?.type ?? "", JSON.stringify(stableFilter ?? {})],
+    queryFn: async ({ pageParam = 0 }) => {
+      return fetchItems({
+        ...stableFilter,
+        limit: PAGE_SIZE,
+        offset: pageParam
+      });
+    },
+    initialPageParam: 0,
+    getNextPageParam: (lastPage, _allPages, lastPageParam) => {
+      if (lastPage.items.length < PAGE_SIZE) return void 0;
+      return lastPageParam + lastPage.items.length;
+    },
+    enabled: !!stableFilter?.type
+  });
+  const allItems = React.useMemo(() => {
+    if (!query.data?.pages) return [];
+    const seen = /* @__PURE__ */ new Set();
+    const flat = [];
+    for (const page of query.data.pages) {
+      for (const item of page.items) {
+        if (item.id && !seen.has(item.id)) {
+          seen.add(item.id);
+          flat.push(item);
+        }
+      }
+    }
+    return flat;
+  }, [query.data?.pages]);
+  return {
+    allItems,
+    fetchNextPage: query.fetchNextPage,
+    isFetchingNextPage: query.isFetchingNextPage,
+    isExhausted: !query.hasNextPage,
+    isLoading: query.isLoading,
+    isFetching: query.isFetching,
+    error: query.error,
+    totalHint: query.data?.pages?.[0]?.total_hint
+  };
+}
+function useInfiniteChildren(path) {
+  useScopeKey();
+  const PAGE_SIZE = 20;
+  const query = reactQuery.useInfiniteQuery({
+    queryKey: ["vfs", getScope() ?? "__unscoped__", "infinite-children", path ?? ""],
+    queryFn: async ({ pageParam = 0 }) => {
+      return fetchVfsChildrenPage(path, PAGE_SIZE, pageParam);
+    },
+    initialPageParam: 0,
+    getNextPageParam: (lastPage, _allPages, lastPageParam) => {
+      if (lastPage.items.length < PAGE_SIZE) return void 0;
+      return lastPageParam + lastPage.items.length;
+    },
+    enabled: !!path
+  });
+  const allItems = React.useMemo(() => {
+    if (!query.data?.pages) return [];
+    const seen = /* @__PURE__ */ new Set();
+    const flat = [];
+    for (const page of query.data.pages) {
+      for (const item of page.items) {
+        if (item.id && !seen.has(item.id)) {
+          seen.add(item.id);
+          flat.push(item);
+        }
+      }
+    }
+    return flat;
+  }, [query.data?.pages]);
+  return {
+    allItems,
+    fetchNextPage: query.fetchNextPage,
+    isFetchingNextPage: query.isFetchingNextPage,
+    isExhausted: !query.hasNextPage,
+    isLoading: query.isLoading,
+    isFetching: query.isFetching,
+    error: query.error,
+    totalHint: query.data?.pages?.[0]?.total_hint
+  };
+}
+function useEdges(itemId) {
+  useScopeKey();
+  return reactQuery.useQuery({
+    queryKey: vfsKeys.edges(itemId),
+    queryFn: () => fetchEdgesForItem(itemId),
+    enabled: !!itemId
+  });
+}
+function useTypes(scopeId) {
+  useScopeKey();
+  return reactQuery.useQuery({
+    queryKey: vfsKeys.types(scopeId),
+    queryFn: () => fetchTypeDefinitions(scopeId)
+  });
+}
+function useType(typeKey, scopeId) {
+  const typesQuery = useTypes(scopeId);
+  return {
+    ...typesQuery,
+    data: typesQuery.data?.get(typeKey) ?? void 0
+  };
+}
+function useOpen(path, options) {
+  useScopeKey();
+  const stableArgs = React.useMemo(
+    () => options?.arguments,
+    [JSON.stringify(options?.arguments)]
+  );
+  const stableMode = options?.mode;
+  const stableStrategy = options?.strategy;
+  return reactQuery.useQuery({
+    queryKey: vfsKeys.openEnvelope(path, stableStrategy),
+    queryFn: () => fetchOpenEnvelope(path, {
+      mode: stableMode,
+      strategy: stableStrategy,
+      arguments: stableArgs
+    }),
+    enabled: !!path
+  });
+}
+var EDGE_TYPE_LABELS = {
+  related_to: "Related To",
+  depends_on: "Depends On",
+  blocks: "Blocks",
+  parent_of: "Parent Of",
+  child_of: "Child Of",
+  references: "References",
+  implements: "Implements",
+  extends: "Extends",
+  contains: "Contains",
+  belongs_to: "Belongs To",
+  created_by: "Created By",
+  assigned_to: "Assigned To",
+  tagged_with: "Tagged With",
+  linked_to: "Linked To"
+};
+function useTypeHelpers(scopeId) {
+  const typesQuery = useTypes(scopeId);
+  const types = typesQuery.data ?? /* @__PURE__ */ new Map();
+  return React.useMemo(() => {
+    const getTypeDefinition = (typeKey) => types.get(typeKey);
+    const canHaveChildren = (item) => {
+      const td = types.get(item.item_type);
+      return td?.is_container ?? false;
+    };
+    const isScope = (item) => {
+      const td = types.get(item.item_type);
+      return td?.is_scope ?? false;
+    };
+    const isScopeType = (typeKey) => {
+      const td = types.get(typeKey);
+      return td?.is_scope ?? false;
+    };
+    const isContainerType = (typeKey) => {
+      const td = types.get(typeKey);
+      return td?.is_container ?? false;
+    };
+    const getTypeColor = (typeKey) => {
+      const td = types.get(typeKey);
+      return td?.color ?? "gray";
+    };
+    const getTypeIcon = (typeKey) => {
+      const td = types.get(typeKey);
+      return td?.icon ?? "File";
+    };
+    const getTypeDisplayName = (typeKey) => {
+      const td = types.get(typeKey);
+      return td?.display_name ?? typeKey;
+    };
+    const getKnownEdgeTypes = () => Object.entries(EDGE_TYPE_LABELS).map(([key, label]) => ({ key, label }));
+    const getEdgeTypeLabel = (edgeType) => EDGE_TYPE_LABELS[edgeType] ?? edgeType.replace(/_/g, " ");
+    return {
+      canHaveChildren,
+      isScope,
+      isScopeType,
+      isContainerType,
+      getTypeDefinition,
+      getTypeColor,
+      getTypeIcon,
+      getTypeDisplayName,
+      getKnownEdgeTypes,
+      getEdgeTypeLabel,
+      allTypes: types,
+      loading: typesQuery.isLoading
+    };
+  }, [types, typesQuery.isLoading]);
+}
+function useMemberFocus(scopeId, itemTypes, limit) {
+  useScopeKey();
+  return reactQuery.useQuery({
+    queryKey: vfsKeys.memberFocus(scopeId),
+    queryFn: () => fetchMemberFocus(scopeId, itemTypes, limit),
+    enabled: !!scopeId
+  });
+}
+function useItemHistory(itemId, limit = 50, offset = 0) {
+  return reactQuery.useQuery({
+    queryKey: vfsKeys.itemHistory(itemId, String(limit), String(offset)),
+    queryFn: () => fetchItemHistory(itemId, limit, offset),
+    enabled: !!itemId
+  });
+}
+function useRecentActivity(scopePath, limit = 50, offset = 0) {
+  useScopeKey();
+  return reactQuery.useQuery({
+    queryKey: vfsKeys.recentActivity(scopePath, String(limit), String(offset)),
+    queryFn: () => fetchRecentActivity(scopePath, limit, offset),
+    enabled: !!scopePath
+  });
+}
+function useScope() {
+  const [data, setData] = React.useState(null);
+  const [loading, setLoading] = React.useState(true);
+  const [error, setError] = React.useState(null);
+  React.useEffect(() => {
+    let cancelled = false;
+    initSession().then((entry) => {
+      if (!cancelled) {
+        const config = typeof window !== "undefined" && window.__FSAOS_CONFIG__ || {};
+        setData({
+          path: entry.scope_path,
+          scope_id: entry.scope_id,
+          fractal_id: entry.fractal_id,
+          instance_name: entry.instance_name,
+          display_name: entry.display_name,
+          componentPath: config.componentPath || "",
+          isEmbed: !!config.embedToken
+        });
+        setLoading(false);
+      }
+    }).catch((err) => {
+      if (!cancelled) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setLoading(false);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  return { data, loading, error };
+}
+function useAccounts() {
+  const { user } = useAuth();
+  const [currentAccount, setCurrentAccount] = React.useState(null);
+  const [mountedPath, setMountedPath] = React.useState(null);
+  const autoSelectedRef = React.useRef(false);
+  const query = reactQuery.useQuery({
+    queryKey: vfsKeys.memberships(user?.id ?? "anonymous"),
+    queryFn: async () => {
+      const result = await gatewayCall("list-memberships", {});
+      const memberships = result.memberships || [];
+      return memberships.map((m) => ({
+        accountId: m.account_id,
+        path: m.account_path,
+        name: m.account_name,
+        role: m.role || "member",
+        typeData: m.account_type_data || {},
+        joinedAt: m.joined_at,
+        via: m.via,
+        placement: m.placement,
+        subordinateTo: m.subordinate_to ?? null,
+        cascadeAnchorId: m.cascade_anchor_id ?? null,
+        isAccount: m.is_account ?? void 0,
+        isSpace: m.is_space ?? void 0,
+        isOwner: m.is_owner ?? void 0,
+        billingResponsible: m.billing_responsible ?? void 0,
+        grantedVia: m.granted_via ?? null,
+        grantedUnderAccountId: m.granted_under_account_id ?? null,
+        personalSpaceId: m.personal_space_id ?? null,
+        personalSpacePath: m.personal_space_path ?? null
+      }));
+    },
+    enabled: !!user?.id,
+    staleTime: 1e3 * 60 * 2
+  });
+  const allMemberships = query.data ?? [];
+  const switcherAccounts = React.useMemo(() => {
+    return allMemberships.filter((a) => {
+      if (a.placement !== void 0) {
+        return a.placement === "switcher_entry" && a.isAccount === true;
+      }
+      return true;
+    });
+  }, [allMemberships]);
+  React.useEffect(() => {
+    if (!user?.id) {
+      autoSelectedRef.current = false;
+      setCurrentAccount(null);
+      setMountedPath(null);
+      return;
+    }
+    if (autoSelectedRef.current) return;
+    if (switcherAccounts.length === 0) return;
+    if (switcherAccounts.length === 1) {
+      setCurrentAccount(switcherAccounts[0]);
+      setScope(switcherAccounts[0].path);
+      initVfsRealtimeWs(switcherAccounts[0].accountId);
+      autoSelectedRef.current = true;
+    } else if (switcherAccounts.length > 1) {
+      autoSelectedRef.current = true;
+    }
+  }, [user?.id, switcherAccounts]);
+  const switchAccount = React.useCallback((accountPath) => {
+    const account = switcherAccounts.find((a) => a.path === accountPath);
+    if (account) {
+      setCurrentAccount(account);
+      setScope(account.path);
+      initVfsRealtimeWs(account.accountId);
+      setMountedPath(null);
+    }
+  }, [switcherAccounts]);
+  const mountScope = React.useCallback((scopePath) => {
+    if (mountedPath) {
+      unmountRealtimeScope(mountedPath);
+    }
+    setMountedPath(scopePath);
+    mountRealtimeScope(scopePath);
+  }, [mountedPath]);
+  return {
+    accounts: switcherAccounts,
+    allMemberships,
+    currentAccount,
+    mountedScope: mountedPath,
+    switchAccount,
+    mountScope,
+    loading: query.isLoading,
+    error: query.error
+  };
+}
+function useAuth() {
+  const [user, setUser] = React.useState(null);
+  const [session, setSession] = React.useState(null);
+  const [loading, setLoading] = React.useState(true);
+  const subscriptionRef = React.useRef(null);
+  React.useEffect(() => {
+    supabase.auth.getSession().then(({ data, error }) => {
+      if (error) {
+        console.warn("[useAuth] getSession error, clearing stale session:", error.message);
+        supabase.auth.signOut().catch(() => {
+        });
+        setSession(null);
+        setUser(null);
+        setLoading(false);
+        return;
+      }
+      setSession(data?.session ?? null);
+      setUser(data?.session?.user ?? null);
+      setLoading(false);
+    }).catch((err) => {
+      console.warn("[useAuth] getSession threw, clearing stale session:", err?.message);
+      supabase.auth.signOut().catch(() => {
+      });
+      setSession(null);
+      setUser(null);
+      setLoading(false);
+    });
+    const { data: { subscription } } = supabase.auth.onAuthStateChange(
+      (event, newSession) => {
+        if (event === "TOKEN_REFRESHED" && !newSession) {
+          console.warn("[useAuth] TOKEN_REFRESHED with null session \u2014 signing out");
+          supabase.auth.signOut().catch(() => {
+          });
+          setSession(null);
+          setUser(null);
+          setLoading(false);
+          return;
+        }
+        setSession(newSession);
+        setUser(newSession?.user ?? null);
+        setLoading(false);
+      }
+    );
+    subscriptionRef.current = subscription;
+    return () => {
+      subscription?.unsubscribe();
+    };
+  }, []);
+  const signIn = React.useCallback(async (params) => {
+    if (params.provider) {
+      return supabase.auth.signInWithOAuth({
+        provider: params.provider,
+        options: params.redirectTo ? { redirectTo: params.redirectTo } : { redirectTo: window.location.href }
+      });
+    }
+    return supabase.auth.signInWithPassword({
+      email: params.email,
+      password: params.password
+    });
+  }, []);
+  const signUp = React.useCallback(async (params) => {
+    return supabase.auth.signUp({
+      email: params.email,
+      password: params.password,
+      options: { data: params.metadata || {} }
+    });
+  }, []);
+  const signOut = React.useCallback(async () => {
+    await supabase.auth.signOut();
+    resetAllSdkState();
+    queryClient.clear();
+  }, []);
+  const resetPassword = React.useCallback(async (email) => {
+    const { error } = await supabase.auth.resetPasswordForEmail(email);
+    if (error) throw error;
+  }, []);
+  const signInWithMagicLink = React.useCallback(async (email, redirectTo) => {
+    const { error } = await supabase.auth.signInWithOtp({
+      email,
+      options: redirectTo ? { emailRedirectTo: redirectTo } : { emailRedirectTo: window.location.href }
+    });
+    if (error) throw error;
+  }, []);
+  return { user, session, loading, signIn, signUp, signOut, resetPassword, signInWithMagicLink };
+}
+function useAsset(idOrPath) {
+  const [data, setData] = React.useState(null);
+  const [loading, setLoading] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  React.useEffect(() => {
+    if (!idOrPath) {
+      setData(null);
+      setLoading(false);
+      return;
+    }
+    const isUUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(idOrPath);
+    if (isUUID) {
+      setLoading(true);
+      gatewayCall("resolve-asset", { asset_id: idOrPath }).then((result) => {
+        if (result.success && result.public_url) {
+          setData({
+            url: result.public_url,
+            id: result.asset_id,
+            name: result.name,
+            mimeType: result.mime_type,
+            width: result.width,
+            height: result.height,
+            sizeBytes: result.size_bytes
+          });
+        } else {
+          setError(new Error(result.error || "Asset not found"));
+        }
+        setLoading(false);
+      }).catch((e) => {
+        setError(e instanceof Error ? e : new Error(String(e)));
+        setLoading(false);
+      });
+    } else {
+      const config = typeof window !== "undefined" && window.__FSAOS_CONFIG__ || {};
+      const edgeBaseUrl = config.edgeBaseUrl || "";
+      setData({ url: edgeBaseUrl + idOrPath });
+      setLoading(false);
+    }
+  }, [idOrPath]);
+  return { data, loading, error };
+}
+var componentCache = {};
+var componentCssCache = {};
+registerCleanup(() => {
+  for (const key of Object.keys(componentCache)) {
+    delete componentCache[key];
+  }
+});
+var _sdkExports = null;
+function __registerSdkExports(exports) {
+  _sdkExports = exports;
+  if (typeof window !== "undefined" && !window.__FSAOS_GATEWAY__) {
+    window.__FSAOS_GATEWAY__ = exports;
+  }
+}
+function sdkRequireShim(name) {
+  switch (name) {
+    case "react":
+      return typeof window !== "undefined" && window.React || React__default.default;
+    case "react-dom":
+    case "react-dom/client":
+      return typeof window !== "undefined" && window.ReactDOM || ReactDOM__namespace;
+    case "react/jsx-runtime":
+    case "react/jsx-dev-runtime":
+      return typeof window !== "undefined" && window.React ? { jsx: window.React.createElement, jsxs: window.React.createElement, Fragment: window.React.Fragment } : JsxRuntime__namespace;
+    case "@fsaos/gateway":
+    case "@fsaos/react":
+      return typeof window !== "undefined" && window.__FSAOS_GATEWAY__ || _sdkExports || {};
+    case "@fsaos/ui":
+      return typeof window !== "undefined" && window.__FSAOS_UI__ || {};
+    case "@fsaos/theme":
+      return {};
+    default:
+      console.warn(`[useComponent] Unknown module requested: ${name}`);
+      return {};
+  }
+}
+function scopeComponentCss(cssText, scopeClass) {
+  return cssText.replace(
+    /^(\s*)(:root|body)(\s*[{,])/gm,
+    (_match, ws2, _sel, rest) => `${ws2}.${scopeClass}${rest}`
+  );
+}
+async function loadComponentCss(cssUrl, scopeId) {
+  if (componentCssCache[cssUrl]) return;
+  try {
+    const response = await fetch(cssUrl);
+    if (!response.ok) return;
+    let cssText = await response.text();
+    if (!cssText.trim()) return;
+    if (cssText.includes("No CSS bundle for this component")) return;
+    if (scopeId && !cssText.includes(`.fsaos-c-${scopeId}`)) ;
+    const style = document.createElement("style");
+    style.setAttribute("data-fsaos-component-css", cssUrl);
+    if (scopeId) ;
+    style.textContent = cssText;
+    document.head.appendChild(style);
+    componentCssCache[cssUrl] = style;
+  } catch {
+  }
+}
+function evaluateBundle(jsCode) {
+  let registered = null;
+  const previousRegister = window.__FSAOS_REGISTER__;
+  window.__FSAOS_REGISTER__ = (component) => {
+    registered = component;
+  };
+  try {
+    const wrappedCode = [
+      "var require = arguments[0];",
+      jsCode,
+      "return window.__FSAOS_COMPONENT__;"
+    ].join("\n");
+    const fn = new Function(wrappedCode);
+    const fromIife = fn(sdkRequireShim);
+    const exported = registered ?? fromIife;
+    if (!exported) return null;
+    return exported.default || exported;
+  } finally {
+    if (previousRegister !== void 0) {
+      window.__FSAOS_REGISTER__ = previousRegister;
+    } else {
+      delete window.__FSAOS_REGISTER__;
+    }
+  }
+}
+function useComponent(path) {
+  const [Component, setComponent] = React.useState(null);
+  const [loading, setLoading] = React.useState(true);
+  const [error, setError] = React.useState(null);
+  React.useEffect(() => {
+    if (!path) return;
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+    const config = typeof window !== "undefined" && window.__FSAOS_CONFIG__ || {};
+    const edgeBaseUrl = config.edgeBaseUrl || "";
+    (async () => {
+      try {
+        let version = 1;
+        let cacheKey = path + "@v1";
+        let bundleUrl = edgeBaseUrl + path + "/__bundle.js";
+        try {
+          const metaResponse = await fetch(edgeBaseUrl + path + "/__meta", { cache: "no-store" });
+          if (metaResponse.ok) {
+            const meta = await metaResponse.json();
+            version = meta.version || 1;
+            cacheKey = path + "@v" + version;
+            bundleUrl = edgeBaseUrl + path + "/__bundle.v" + version + ".js";
+          }
+        } catch {
+          bundleUrl = edgeBaseUrl + path + "/__bundle.js?v=" + Date.now();
+        }
+        if (cancelled) return;
+        if (componentCache[cacheKey]) {
+          setComponent(() => componentCache[cacheKey]);
+          setLoading(false);
+          return;
+        }
+        const jsResponse = await fetch(bundleUrl);
+        if (!jsResponse.ok) {
+          throw new Error(
+            `Failed to fetch bundle: ${jsResponse.status} ${jsResponse.statusText} (${bundleUrl})`
+          );
+        }
+        const jsCode = await jsResponse.text();
+        if (cancelled) return;
+        const cssUrl = bundleUrl.replace(/__bundle(\.v\d+)?\.js(\?.*)?$/, "__bundle$1.css");
+        loadComponentCss(cssUrl).catch(() => {
+        });
+        const resolved = evaluateBundle(jsCode);
+        if (!resolved) {
+          throw new Error(
+            "Bundle did not export a component. Expected window.__FSAOS_COMPONENT__ (FSAOS build) or a __FSAOS_REGISTER__(Component) call."
+          );
+        }
+        if (typeof resolved !== "function") {
+          throw new Error(`Bundle export is not a React component (got ${typeof resolved})`);
+        }
+        componentCache[cacheKey] = resolved;
+        if (!cancelled) {
+          setComponent(() => resolved);
+          setLoading(false);
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+          setLoading(false);
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [path]);
+  return { Component, loading, error };
+}
+var THEME_PROPERTIES = [
+  "--color-primary",
+  "--color-secondary",
+  "--color-background",
+  "--color-surface",
+  "--color-text",
+  "--color-text-secondary",
+  "--color-border",
+  "--color-accent",
+  "--color-success",
+  "--color-warning",
+  "--color-error",
+  "--font-family-heading",
+  "--font-family-body",
+  "--border-radius",
+  "--spacing-unit"
+];
+function useTheme() {
+  const themeData = React.useMemo(() => {
+    if (typeof document === "undefined") return { tokens: {} };
+    const vars = {};
+    const style = getComputedStyle(document.documentElement);
+    THEME_PROPERTIES.forEach((p) => {
+      vars[p] = style.getPropertyValue(p).trim();
+    });
+    return { tokens: vars };
+  }, []);
+  return { data: themeData, loading: false, error: null };
+}
+function usePermission(_action, _path) {
+  return { data: { allowed: true }, loading: false, error: null };
+}
+function usePermissions(_path, actions) {
+  const perms = {};
+  (actions || []).forEach((a) => {
+    perms[a] = true;
+  });
+  return { data: perms, loading: false, error: null };
+}
+var _principalIdCache = null;
+var _principalIdPromise = null;
+registerCleanup(() => {
+  _principalIdCache = null;
+  _principalIdPromise = null;
+});
+async function resolvePrincipalId(authUserId) {
+  let uid = authUserId;
+  if (!uid) {
+    const { data } = await supabase.auth.getSession();
+    uid = data?.session?.user?.id;
+  }
+  if (!uid) return null;
+  if (_principalIdCache && _principalIdCache.authUserId === uid) {
+    return _principalIdCache.principalId;
+  }
+  if (_principalIdPromise) return _principalIdPromise;
+  _principalIdPromise = (async () => {
+    try {
+      const { data, error } = await supabase.from("os_principals").select("id").eq("auth_user_id", uid).eq("principal_type", "user").maybeSingle();
+      if (error) {
+        console.warn("[SDK] Could not resolve principal_id:", error.message);
+        return null;
+      }
+      const principalId = data?.id ?? null;
+      _principalIdCache = { authUserId: uid, principalId };
+      return principalId;
+    } finally {
+      _principalIdPromise = null;
+    }
+  })();
+  return _principalIdPromise;
+}
+function usePrincipal() {
+  const authResult = useAuth();
+  const user = authResult.user;
+  const [principalId, setPrincipalId] = React.useState(
+    (_principalIdCache?.authUserId === user?.id ? _principalIdCache?.principalId : null) ?? null
+  );
+  const prevUserIdRef = React.useRef(null);
+  React.useEffect(() => {
+    if (!user?.id) {
+      setPrincipalId(null);
+      prevUserIdRef.current = null;
+      return;
+    }
+    if (prevUserIdRef.current === user.id && principalId !== null) return;
+    prevUserIdRef.current = user.id;
+    resolvePrincipalId(user.id).then((id) => {
+      setPrincipalId(id);
+    });
+  }, [user?.id]);
+  if (authResult.loading) {
+    return { data: null, loading: true, error: null };
+  }
+  if (!user) {
+    return {
+      data: { id: "anonymous", principalId: null, role: "viewer", authenticated: false },
+      loading: false,
+      error: null
+    };
+  }
+  return {
+    data: {
+      id: user.id,
+      principalId,
+      email: user.email,
+      role: user.role || user.app_metadata?.role || "user",
+      authenticated: true,
+      metadata: user.user_metadata || {}
+    },
+    loading: false,
+    error: null
+  };
+}
+function useTool() {
+  return { data: null, loading: false, error: null };
+}
+function ComponentRenderer(props) {
+  const { path, ...rest } = props;
+  const result = useComponent(path);
+  const Comp = result.Component;
+  const { loading, error } = result;
+  if (loading) return React.createElement("div", { className: "fsaos-loading" }, "");
+  if (error) return React.createElement("div", { className: "fsaos-error" }, "Failed to load component");
+  if (!Comp) return null;
+  return React.createElement(Comp, rest);
+}
+function KernelProvider(props) {
+  return props.children;
+}
+function useChannelMessages(options) {
+  const scopeKey = useScopeKey();
+  const {
+    channelPath,
+    parentMessageId,
+    realtime = true,
+    enabled: userEnabled
+  } = options;
+  const isEnabled = userEnabled !== void 0 ? userEnabled && !!channelPath : !!channelPath;
+  const stableKey = React.useMemo(
+    () => vfsKeys.channelMessages(channelPath ?? "", parentMessageId),
+    [channelPath, parentMessageId, scopeKey]
+  );
+  const qc = reactQuery.useQueryClient();
+  const debounceRef = React.useRef(null);
+  const query = reactQuery.useQuery({
+    queryKey: stableKey,
+    queryFn: () => fetchChannelMessages(channelPath, parentMessageId),
+    enabled: isEnabled
+  });
+  React.useEffect(() => {
+    if (!realtime || !isEnabled) return;
+    const unsub = subscribeToEvents(
+      "vfs_change",
+      () => {
+        if (debounceRef.current) clearTimeout(debounceRef.current);
+        debounceRef.current = setTimeout(() => {
+          qc.invalidateQueries({ queryKey: stableKey });
+        }, 500);
+      },
+      (data) => {
+        return data.item_type === "message" && typeof data.path === "string" && data.path.startsWith(channelPath);
+      }
+    );
+    return () => {
+      unsub();
+      if (debounceRef.current) clearTimeout(debounceRef.current);
+    };
+  }, [realtime, isEnabled, channelPath, stableKey, qc]);
+  const messages = query.data ?? [];
+  return {
+    messages,
+    threads: React.useMemo(() => messages.filter((m) => m.reply_count > 0), [messages]),
+    isLoading: query.isLoading,
+    isFetching: query.isFetching,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useInfiniteChannelMessages(options) {
+  useScopeKey();
+  const { channelPath, parentMessageId, limit = 50, realtime = true, enabled = true } = options;
+  const isThread = !!parentMessageId;
+  const queryEnabled = enabled && !!channelPath;
+  const query = reactQuery.useInfiniteQuery({
+    queryKey: [...vfsKeys.channelMessages(channelPath || "", parentMessageId), "infinite", limit],
+    queryFn: async ({ pageParam }) => {
+      return fetchChannelMessagesPage(channelPath, {
+        parentMessageId,
+        limit,
+        before_seq: isThread ? void 0 : pageParam,
+        after_seq: isThread ? pageParam : void 0
+      });
+    },
+    initialPageParam: void 0,
+    getNextPageParam: (lastPage) => {
+      if (!isThread) return void 0;
+      if (lastPage.messages.length < limit) return void 0;
+      const maxSeq = lastPage.messages[lastPage.messages.length - 1]?.seq;
+      return maxSeq;
+    },
+    getPreviousPageParam: (firstPage) => {
+      if (isThread) return void 0;
+      if (firstPage.messages.length < limit) return void 0;
+      const minSeq = firstPage.messages[0]?.seq;
+      return minSeq;
+    },
+    enabled: queryEnabled
+  });
+  const messages = React.useMemo(() => {
+    if (!query.data?.pages) return [];
+    const seen = /* @__PURE__ */ new Set();
+    const flat = [];
+    for (const page of query.data.pages) {
+      for (const msg of page.messages) {
+        if (!seen.has(msg.id)) {
+          seen.add(msg.id);
+          flat.push(msg);
+        }
+      }
+    }
+    return flat.sort((a, b) => a.seq - b.seq);
+  }, [query.data?.pages]);
+  React.useEffect(() => {
+    if (!realtime || !channelPath || !queryEnabled) return;
+    const unsub = subscribeToEvents(channelPath, (event) => {
+      if (event.event_type === "vfs_change") {
+        query.refetch();
+      }
+    });
+    return unsub;
+  }, [realtime, channelPath, queryEnabled]);
+  return {
+    messages,
+    threads: messages.filter((m) => m.reply_count > 0),
+    isLoading: query.isLoading,
+    isFetching: query.isFetching,
+    error: query.error,
+    refetch: query.refetch,
+    // Backward pagination (top-level: load older)
+    hasPreviousPage: query.hasPreviousPage ?? false,
+    fetchPreviousPage: query.fetchPreviousPage,
+    isFetchingPreviousPage: query.isFetchingPreviousPage ?? false,
+    // Forward pagination (thread: load newer)
+    hasNextPage: query.hasNextPage ?? false,
+    fetchNextPage: query.fetchNextPage,
+    isFetchingNextPage: query.isFetchingNextPage ?? false
+  };
+}
+function normalizeAiMode(value) {
+  if (value === "on" || value === "auto") return "on";
+  return "off";
+}
+function normalizeChannel(raw) {
+  const td = raw.type_data || {};
+  return {
+    id: raw.channel_id || "",
+    path: raw.channel_path || "",
+    name: raw.channel_name || "",
+    displayName: raw.display_name || raw.channel_name || "",
+    aiMode: normalizeAiMode(raw.ai_mode),
+    isPrivate: raw.is_private || false,
+    isDm: raw.is_dm || false,
+    messageCount: raw.message_count || 0,
+    updatedAt: raw.updated_at || "",
+    chatScopePath: raw.chat_scope_path || "",
+    contextId: raw.context_id || "",
+    contextPath: raw.context_path || "",
+    contextType: raw.context_type || "",
+    contextName: raw.context_name || "",
+    contextDisplayName: raw.context_display_name || "",
+    contextPrincipalId: raw.context_principal_id,
+    accountId: raw.account_id || "",
+    accountPath: raw.account_path || "",
+    accountDisplayName: raw.account_display_name || "",
+    memberRole: raw.member_role || "member",
+    memberPath: raw.member_path || "",
+    modePath: raw.mode_path || "",
+    autoPilot: raw.auto_pilot || td.auto_pilot || false
+  };
+}
+function useAllChannels(options = {}) {
+  const scopeKey = useScopeKey();
+  const { realtime = true, enabled = true } = options;
+  const qc = reactQuery.useQueryClient();
+  const debounceRef = React.useRef(null);
+  const stableKey = React.useMemo(() => vfsKeys.channels("all"), [scopeKey]);
+  const query = reactQuery.useQuery({
+    queryKey: stableKey,
+    queryFn: async () => {
+      const result = await gatewayCall("list-channels", {});
+      const raw = result.channels || [];
+      return raw.map(normalizeChannel);
+    },
+    enabled
+  });
+  React.useEffect(() => {
+    if (!realtime || !enabled) return;
+    const unsub = subscribeToEvents(
+      "vfs_change",
+      () => {
+        if (debounceRef.current) clearTimeout(debounceRef.current);
+        debounceRef.current = setTimeout(() => {
+          qc.invalidateQueries({ queryKey: stableKey });
+        }, 1e3);
+      },
+      (data) => data.item_type === "channel" || data.item_type === "message"
+    );
+    const unsub2 = subscribeToEvents(
+      "ccm_change",
+      () => {
+        if (debounceRef.current) clearTimeout(debounceRef.current);
+        debounceRef.current = setTimeout(() => {
+          qc.invalidateQueries({ queryKey: stableKey });
+        }, 1e3);
+      },
+      (data) => data.item_type === "channel" || data.item_type === "message"
+    );
+    return () => {
+      unsub();
+      unsub2();
+      if (debounceRef.current) clearTimeout(debounceRef.current);
+    };
+  }, [realtime, enabled, stableKey, qc]);
+  const channels = query.data ?? [];
+  return {
+    channels,
+    isLoading: query.isLoading,
+    isFetching: query.isFetching,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useChannels(options = {}) {
+  const result = useAllChannels(options);
+  const filtered = React.useMemo(
+    () => result.channels.filter((c) => !c.isDm),
+    [result.channels]
+  );
+  return { ...result, channels: filtered };
+}
+function useDmChannels(options = {}) {
+  const result = useAllChannels(options);
+  const filtered = React.useMemo(
+    () => result.channels.filter((c) => c.isDm),
+    [result.channels]
+  );
+  return { ...result, channels: filtered };
+}
+function useNotifications(options = {}) {
+  const scopeKey = useScopeKey();
+  const {
+    filter = "all",
+    limit = 200,
+    realtime = true,
+    enabled = true
+  } = options;
+  const qc = reactQuery.useQueryClient();
+  const debounceRef = React.useRef(null);
+  const stableKey = React.useMemo(() => vfsKeys.notifications(filter, limit), [filter, limit, scopeKey]);
+  const query = reactQuery.useQuery({
+    queryKey: stableKey,
+    queryFn: async () => {
+      const params = { limit };
+      if (filter === "unread") params.filter = "unread";
+      const result = await gatewayCall("get-notifications", params);
+      return result.notifications || [];
+    },
+    enabled
+  });
+  React.useEffect(() => {
+    if (!realtime || !enabled) return;
+    const unsubs = ["vfs_change", "ccm_change"].map(
+      (eventType) => subscribeToEvents(
+        eventType,
+        () => {
+          if (debounceRef.current) clearTimeout(debounceRef.current);
+          debounceRef.current = setTimeout(() => {
+            qc.invalidateQueries({ queryKey: stableKey });
+          }, 2e3);
+        },
+        (data) => data.item_type === "notification" || data.item_type === "message"
+      )
+    );
+    return () => {
+      unsubs.forEach((u) => u());
+      if (debounceRef.current) clearTimeout(debounceRef.current);
+    };
+  }, [realtime, enabled, stableKey, qc]);
+  const notifications = query.data ?? [];
+  return {
+    notifications,
+    isLoading: query.isLoading,
+    isFetching: query.isFetching,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useUnreadCounts(options = {}) {
+  const { channels: channelList, realtime = true, enabled = true } = options;
+  const { notifications, isLoading, isFetching, error, refetch } = useNotifications({
+    filter: "unread",
+    limit: 200,
+    realtime,
+    enabled
+  });
+  const unreadByChannel = React.useMemo(() => {
+    const counts = /* @__PURE__ */ new Map();
+    for (const n of notifications) {
+      if (n.is_unread && n.channel_id) {
+        counts.set(n.channel_id, (counts.get(n.channel_id) || 0) + 1);
+      }
+    }
+    return counts;
+  }, [notifications]);
+  const totalUnread = React.useMemo(() => {
+    let total = 0;
+    unreadByChannel.forEach((v) => {
+      total += v;
+    });
+    return total;
+  }, [unreadByChannel]);
+  const { dmUnread, channelUnread } = React.useMemo(() => {
+    if (!channelList) return { dmUnread: 0, channelUnread: 0 };
+    const dmIds = new Set(channelList.filter((c) => c.isDm).map((c) => c.id));
+    let dm = 0;
+    let ch = 0;
+    unreadByChannel.forEach((count, channelId) => {
+      if (dmIds.has(channelId)) dm += count;
+      else ch += count;
+    });
+    return { dmUnread: dm, channelUnread: ch };
+  }, [channelList, unreadByChannel]);
+  return {
+    unreadByChannel,
+    totalUnread,
+    dmUnread,
+    channelUnread,
+    isLoading,
+    isFetching,
+    error,
+    refetch
+  };
+}
+function useCreate() {
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (params) => gatewayCall("create", params),
+    onSuccess: (_data, variables) => {
+      const parentPath = variables.parent_path;
+      if (parentPath) {
+        qc.invalidateQueries({ queryKey: vfsKeys.children(parentPath) });
+      }
+    }
+  });
+}
+function useUpdate() {
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (params) => gatewayCall("update", params),
+    onSuccess: (_data, variables) => {
+      const path = variables.path;
+      if (path) {
+        qc.invalidateQueries({ queryKey: vfsKeys.item(path) });
+        const segments = path.split("/");
+        segments.pop();
+        const parentPath = segments.join("/");
+        if (parentPath) {
+          qc.invalidateQueries({ queryKey: vfsKeys.children(parentPath) });
+        }
+      }
+    }
+  });
+}
+function useDelete() {
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (params) => gatewayCall("delete", params),
+    onSuccess: (_data, variables) => {
+      const path = variables.path;
+      if (path) {
+        qc.removeQueries({ queryKey: vfsKeys.item(path) });
+        const segments = path.split("/");
+        segments.pop();
+        const parentPath = segments.join("/");
+        if (parentPath) {
+          qc.invalidateQueries({ queryKey: vfsKeys.children(parentPath) });
+        }
+      }
+    }
+  });
+}
+function useMove() {
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (params) => gatewayCall("move", params),
+    onSuccess: (_data, variables) => {
+      const path = variables.path;
+      const newParentPath = variables.new_parent_path;
+      if (path) {
+        qc.invalidateQueries({ queryKey: vfsKeys.item(path) });
+        const segments = path.split("/");
+        segments.pop();
+        const oldParentPath = segments.join("/");
+        if (oldParentPath) {
+          qc.invalidateQueries({ queryKey: vfsKeys.children(oldParentPath) });
+        }
+      }
+      if (newParentPath) {
+        qc.invalidateQueries({ queryKey: vfsKeys.children(newParentPath) });
+      }
+    }
+  });
+}
+function useLink() {
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (params) => gatewayCall("link", params),
+    onSuccess: (_data, variables) => {
+      const sourceId = variables.source_id;
+      const targetId = variables.target_id;
+      if (sourceId) {
+        qc.invalidateQueries({ queryKey: vfsKeys.edges(sourceId) });
+      }
+      if (targetId) {
+        qc.invalidateQueries({ queryKey: vfsKeys.edges(targetId) });
+      }
+    }
+  });
+}
+function useMutation(method, options) {
+  const qc = reactQuery.useQueryClient();
+  const { optimistic, ...rest } = options ?? {};
+  return reactQuery.useMutation({
+    mutationFn: (params) => gatewayCall(method, params),
+    onMutate: optimistic ? async (params) => {
+      await qc.cancelQueries({ queryKey: optimistic.queryKey });
+      const previous = qc.getQueryData(optimistic.queryKey);
+      qc.setQueryData(optimistic.queryKey, (old) => optimistic.update(old, params));
+      return { previous };
+    } : void 0,
+    onError: (err, _vars, context) => {
+      if (optimistic && context?.previous !== void 0) {
+        qc.setQueryData(optimistic.queryKey, context.previous);
+      }
+      rest.onError?.(err);
+    },
+    onSuccess: rest.onSuccess,
+    onSettled: optimistic ? () => {
+      qc.invalidateQueries({ queryKey: optimistic.queryKey });
+    } : void 0
+  });
+}
+function useEventStream(handlerOrEventType, handlerOrOptions, filter) {
+  let eventType;
+  let handler;
+  let resolvedFilter;
+  let enabled = true;
+  if (typeof handlerOrEventType === "string") {
+    eventType = handlerOrEventType;
+    handler = handlerOrOptions;
+    resolvedFilter = filter;
+  } else {
+    handler = handlerOrEventType;
+    const opts = handlerOrOptions;
+    eventType = opts.eventType;
+    resolvedFilter = opts.filter;
+    enabled = opts.enabled ?? true;
+  }
+  const handlerRef = React.useRef(handler);
+  const filterRef = React.useRef(resolvedFilter);
+  React.useEffect(() => {
+    handlerRef.current = handler;
+    filterRef.current = resolvedFilter;
+  }, [handler, resolvedFilter]);
+  React.useEffect(() => {
+    if (!enabled) return;
+    const unsub = subscribeToEvents(
+      eventType,
+      (data) => handlerRef.current(data),
+      filterRef.current ? (data) => filterRef.current(data) : void 0
+    );
+    return unsub;
+  }, [eventType, enabled]);
+}
+function useRealtimeQuery(options) {
+  const { queryKey, queryFn, eventType, filter, enabled = true, debounceMs = 500 } = options;
+  const qc = reactQuery.useQueryClient();
+  const debounceRef = React.useRef(null);
+  const query = reactQuery.useQuery({
+    queryKey,
+    queryFn,
+    enabled
+  });
+  React.useEffect(() => {
+    if (!enabled) return;
+    const unsub = subscribeToEvents(
+      eventType,
+      () => {
+        if (debounceRef.current) clearTimeout(debounceRef.current);
+        debounceRef.current = setTimeout(() => {
+          qc.invalidateQueries({ queryKey });
+        }, debounceMs);
+      },
+      filter
+    );
+    return () => {
+      unsub();
+      if (debounceRef.current) clearTimeout(debounceRef.current);
+    };
+  }, [eventType, enabled, debounceMs, qc, JSON.stringify(queryKey)]);
+  return query;
+}
+
+// src/schema-utils.ts
+function keyToLabel(key) {
+  return key.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function inferFilterWidget(type, enumValues) {
+  if (enumValues && enumValues.length > 0) return "select";
+  if (type === "boolean") return "toggle";
+  if (type === "integer" || type === "number") return "range";
+  if (type === "string") return "text";
+  return "none";
+}
+function isFilterable(type, enumValues) {
+  if (type === "object" || type === "array") return false;
+  return true;
+}
+function isSortable(type) {
+  return ["string", "number", "integer", "boolean"].includes(type);
+}
+function isColumnSuitable(type) {
+  return type !== "object" && type !== "array";
+}
+function extractFields(schema, editable, defaults, fieldDefaults) {
+  const properties = schema?.properties;
+  if (!properties || typeof properties !== "object") return [];
+  const fields = [];
+  for (const [key, prop] of Object.entries(properties)) {
+    const type = prop.type || "string";
+    const enumValues = prop.enum;
+    const filterable = isFilterable(type);
+    const sortable = isSortable(type);
+    const filterWidget = inferFilterWidget(type, enumValues);
+    fields.push({
+      key,
+      label: prop.title || keyToLabel(key),
+      type,
+      description: prop.description,
+      enum_values: enumValues,
+      default_value: defaults[key] ?? fieldDefaults[key] ?? prop.default,
+      editable,
+      filterable,
+      sortable,
+      filter_widget: filterWidget
+    });
+  }
+  return fields;
+}
+function interpretSchema(typeDef) {
+  const defaults = typeDef.default_data || {};
+  const fieldDefaults = typeDef.field_defaults || {};
+  const inputFields = extractFields(
+    typeDef.input_schema,
+    true,
+    defaults,
+    fieldDefaults
+  );
+  const systemFields = extractFields(
+    typeDef.system_schema,
+    false,
+    defaults,
+    fieldDefaults
+  );
+  const allFields = [...inputFields, ...systemFields];
+  const columns = allFields.filter((f) => isColumnSuitable(f.type));
+  const filterable = allFields.filter((f) => f.filterable);
+  const sortable = allFields.filter((f) => f.sortable);
+  return {
+    fields: allFields,
+    columns,
+    filterable,
+    sortable,
+    form_fields: inputFields,
+    system_fields: systemFields
+  };
+}
+function getDefaultSort(_typeDef) {
+  return { field: "updated_at", direction: "desc" };
+}
+function getRequiredFormFields(typeDef) {
+  const schema = interpretSchema(typeDef);
+  const required = new Set(typeDef.input_schema?.required || []);
+  return schema.form_fields.filter(
+    (f) => required.has(f.key) || f.default_value === void 0
+  );
+}
+var _idCounter = 0;
+function generateUploadId() {
+  return `upload_${Date.now()}_${++_idCounter}`;
+}
+async function uploadFile(file, options, onProgress, signal2) {
+  const fileName = options.name || (file instanceof File ? file.name : `file-${Date.now()}`);
+  const contentType = file.type || "application/octet-stream";
+  const itemType = options.itemType || "file";
+  const createResult = await gatewayCall("create", {
+    parent_path: options.parentPath,
+    item_type: itemType,
+    name: fileName,
+    type_data: {
+      ...options.typeData || {},
+      file_source: {
+        type: "upload",
+        content_type: contentType
+      }
+    }
+  });
+  const result = createResult;
+  if (!result.id) {
+    throw new Error(result.error || result.message || "Failed to create file item");
+  }
+  const itemId = result.id;
+  const itemPath = result.path;
+  if (result.storage_completed && result.file_ref) {
+    return { itemId, itemPath, fileRef: result.file_ref };
+  }
+  const storageKey = result.storage_key;
+  const uploadToken = result.upload_token;
+  const storageWorkerUrl = result.storage_worker_url || "https://fsaos-storage.radns.workers.dev";
+  if (!storageKey) {
+    throw new Error("Gateway returned no storage_key \u2014 file_source may not be supported for this item type");
+  }
+  await uploadBinaryXHR(storageWorkerUrl, storageKey, uploadToken, file, contentType, onProgress, signal2);
+  const fileRef = await confirmUpload(itemId, storageKey, contentType);
+  return { itemId, itemPath, fileRef };
+}
+function uploadBinaryXHR(storageWorkerUrl, storageKey, uploadToken, body, contentType, onProgress, signal2) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open("PUT", `${storageWorkerUrl}/upload`);
+    xhr.setRequestHeader("X-Storage-Key", storageKey);
+    xhr.setRequestHeader("Content-Type", contentType);
+    if (uploadToken) {
+      xhr.setRequestHeader("X-Upload-Token", uploadToken);
+    }
+    xhr.upload.onprogress = (e) => {
+      if (e.lengthComputable && onProgress) {
+        onProgress(Math.round(e.loaded / e.total * 100));
+      }
+    };
+    xhr.onload = () => {
+      if (xhr.status >= 200 && xhr.status < 300) {
+        resolve();
+      } else {
+        reject(new Error(`Storage upload failed: HTTP ${xhr.status} \u2014 ${xhr.responseText?.slice(0, 300)}`));
+      }
+    };
+    xhr.onerror = () => reject(new Error("Storage upload network error"));
+    xhr.ontimeout = () => reject(new Error("Storage upload timed out"));
+    if (signal2) {
+      if (signal2.aborted) {
+        reject(new Error("Upload cancelled"));
+        return;
+      }
+      signal2.addEventListener("abort", () => {
+        xhr.abort();
+        reject(new Error("Upload cancelled"));
+      });
+    }
+    xhr.send(body);
+  });
+}
+async function confirmUpload(itemId, storageKey, contentType) {
+  const token = await getAccessToken();
+  const response = await fetch(`${GATEWAY_URL}/storage/upload-complete`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...token ? { "Authorization": `Bearer ${token}` } : {}
+    },
+    body: JSON.stringify({
+      item_id: itemId,
+      storage_key: storageKey,
+      content_type: contentType
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Upload confirmation failed: HTTP ${response.status} \u2014 ${text.slice(0, 300)}`);
+  }
+  const result = await response.json();
+  if (!result.success) {
+    throw new Error(result.error || result.message || "Upload confirmation rejected");
+  }
+  return result.file_ref;
+}
+function useFileUpload() {
+  const [uploads, setUploads] = React.useState([]);
+  const qc = reactQuery.useQueryClient();
+  const uploadsRef = React.useRef(uploads);
+  uploadsRef.current = uploads;
+  const updateUpload = React.useCallback((id, patch) => {
+    setUploads((prev) => prev.map((u) => u.id === id ? { ...u, ...patch } : u));
+  }, []);
+  const addUpload = React.useCallback((item) => {
+    setUploads((prev) => [...prev, item]);
+  }, []);
+  const executeUpload = React.useCallback(async (uploadId, file, options, resumeFrom, existingState) => {
+    const fileName = options.name || file.name;
+    const contentType = file.type || "application/octet-stream";
+    const itemType = options.itemType || "file";
+    let itemId = existingState?.itemId || null;
+    let itemPath = existingState?.itemPath || null;
+    let storageKey = existingState?.storageKey || null;
+    let uploadToken = existingState?.uploadToken || null;
+    let storageWorkerUrl = existingState?.storageWorkerUrl || null;
+    try {
+      if (!resumeFrom || resumeFrom === "create") {
+        updateUpload(uploadId, { status: "creating", error: null, _failedAt: null });
+        const createResult = await gatewayCall("create", {
+          parent_path: options.parentPath,
+          item_type: itemType,
+          name: fileName,
+          type_data: {
+            ...options.typeData || {},
+            file_source: {
+              type: "upload",
+              content_type: contentType
+            }
+          }
+        });
+        const result = createResult;
+        if (!result.id) {
+          throw Object.assign(
+            new Error(result.error || result.message || "Failed to create file item"),
+            { _step: "create" }
+          );
+        }
+        itemId = result.id;
+        itemPath = result.path;
+        updateUpload(uploadId, { itemId, itemPath });
+        if (result.storage_completed && result.file_ref) {
+          updateUpload(uploadId, {
+            status: "complete",
+            progress: 100,
+            fileRef: result.file_ref
+          });
+          qc.invalidateQueries({ queryKey: vfsKeys.children(options.parentPath) });
+          return;
+        }
+        storageKey = result.storage_key;
+        uploadToken = result.upload_token || "";
+        storageWorkerUrl = result.storage_worker_url || "https://fsaos-storage.radns.workers.dev";
+        updateUpload(uploadId, {
+          _storageKey: storageKey,
+          _uploadToken: uploadToken,
+          _storageWorkerUrl: storageWorkerUrl
+        });
+        if (!storageKey) {
+          throw Object.assign(
+            new Error("Gateway returned no storage_key"),
+            { _step: "create" }
+          );
+        }
+      }
+      if (!resumeFrom || resumeFrom === "create" || resumeFrom === "upload") {
+        updateUpload(uploadId, { status: "uploading", progress: 0, error: null, _failedAt: null });
+        const xhrPromise = new Promise((resolve, reject) => {
+          const xhr = new XMLHttpRequest();
+          updateUpload(uploadId, { _xhr: xhr });
+          xhr.open("PUT", `${storageWorkerUrl}/upload`);
+          xhr.setRequestHeader("X-Storage-Key", storageKey);
+          xhr.setRequestHeader("Content-Type", contentType);
+          if (uploadToken) {
+            xhr.setRequestHeader("X-Upload-Token", uploadToken);
+          }
+          xhr.upload.onprogress = (e) => {
+            if (e.lengthComputable) {
+              updateUpload(uploadId, { progress: Math.round(e.loaded / e.total * 100) });
+            }
+          };
+          xhr.onload = () => {
+            if (xhr.status >= 200 && xhr.status < 300) {
+              resolve();
+            } else {
+              reject(Object.assign(
+                new Error(`Storage upload failed: HTTP ${xhr.status}`),
+                { _step: "upload" }
+              ));
+            }
+          };
+          xhr.onerror = () => reject(Object.assign(
+            new Error("Storage upload network error"),
+            { _step: "upload" }
+          ));
+          xhr.ontimeout = () => reject(Object.assign(
+            new Error("Storage upload timed out"),
+            { _step: "upload" }
+          ));
+          xhr.send(file);
+        });
+        await xhrPromise;
+        updateUpload(uploadId, { progress: 100, _xhr: null });
+      }
+      updateUpload(uploadId, { status: "confirming", error: null, _failedAt: null });
+      const fileRef = await confirmUpload(itemId, storageKey, contentType);
+      updateUpload(uploadId, {
+        status: "complete",
+        fileRef
+      });
+      qc.invalidateQueries({ queryKey: vfsKeys.children(options.parentPath) });
+    } catch (err) {
+      const message = err?.message || String(err);
+      const failedAt = err?._step || "create";
+      updateUpload(uploadId, {
+        status: "error",
+        error: message,
+        _failedAt: failedAt,
+        _xhr: null
+      });
+    }
+  }, [updateUpload, qc]);
+  const upload = React.useCallback((file, options) => {
+    const id = generateUploadId();
+    const item = {
+      id,
+      file,
+      status: "creating",
+      progress: 0,
+      error: null,
+      itemId: null,
+      itemPath: null,
+      fileRef: null,
+      options,
+      _storageKey: null,
+      _uploadToken: null,
+      _storageWorkerUrl: null,
+      _xhr: null,
+      _failedAt: null
+    };
+    addUpload(item);
+    executeUpload(id, file, options);
+  }, [addUpload, executeUpload]);
+  const uploadMultiple = React.useCallback((files, options) => {
+    for (const file of files) {
+      upload(file, options);
+    }
+  }, [upload]);
+  const retryUpload = React.useCallback((uploadId) => {
+    const item = uploadsRef.current.find((u) => u.id === uploadId);
+    if (!item || item.status !== "error") return;
+    const resumeFrom = item._failedAt || "create";
+    const existingState = item._storageKey && item.itemId ? {
+      storageKey: item._storageKey,
+      uploadToken: item._uploadToken || "",
+      storageWorkerUrl: item._storageWorkerUrl || "https://fsaos-storage.radns.workers.dev",
+      itemId: item.itemId,
+      itemPath: item.itemPath || ""
+    } : void 0;
+    executeUpload(uploadId, item.file, item.options, resumeFrom, existingState);
+  }, [executeUpload]);
+  const cancelUpload = React.useCallback((uploadId) => {
+    const item = uploadsRef.current.find((u) => u.id === uploadId);
+    if (!item) return;
+    if (item._xhr) {
+      item._xhr.abort();
+    }
+    updateUpload(uploadId, {
+      status: "error",
+      error: "Cancelled",
+      _xhr: null,
+      _failedAt: null
+    });
+  }, [updateUpload]);
+  const removeUpload = React.useCallback((uploadId) => {
+    setUploads((prev) => prev.filter((u) => u.id !== uploadId));
+  }, []);
+  const clearCompleted = React.useCallback(() => {
+    setUploads((prev) => prev.filter((u) => u.status !== "complete"));
+  }, []);
+  const isUploading = uploads.some(
+    (u) => u.status === "creating" || u.status === "uploading" || u.status === "confirming"
+  );
+  const publicUploads = uploads.map(({ _storageKey, _uploadToken, _storageWorkerUrl, _xhr, _failedAt, ...rest }) => rest);
+  return {
+    upload,
+    uploadMultiple,
+    uploads: publicUploads,
+    retryUpload,
+    cancelUpload,
+    removeUpload,
+    clearCompleted,
+    isUploading
+  };
+}
+
+// src/index.ts
+__registerSdkExports(src_exports);
+
+Object.defineProperty(exports, "QueryClientProvider", {
+  enumerable: true,
+  get: function () { return reactQuery.QueryClientProvider; }
+});
+exports.ComponentRenderer = ComponentRenderer;
+exports.EnforcementDeniedError = EnforcementDeniedError;
+exports.KernelProvider = KernelProvider;
+exports.auth = auth;
+exports.awaitScopeReady = awaitScopeReady;
+exports.callTool = callTool;
+exports.clearCachedToken = clearCachedToken;
+exports.clearSession = clearSession;
+exports.createItem = createItem;
+exports.disconnectSSE = disconnectSSE;
+exports.disposeVfsRealtimeWs = disposeVfsRealtimeWs;
+exports.emitEvent = emitEvent;
+exports.fetchChannelMessages = fetchChannelMessages;
+exports.fetchChannelMessagesPage = fetchChannelMessagesPage;
+exports.fetchEdgesForItem = fetchEdgesForItem;
+exports.fetchItemHistory = fetchItemHistory;
+exports.fetchItems = fetchItems;
+exports.fetchMemberFocus = fetchMemberFocus;
+exports.fetchOpenEnvelope = fetchOpenEnvelope;
+exports.fetchRecentActivity = fetchRecentActivity;
+exports.fetchTypeDefinitions = fetchTypeDefinitions;
+exports.fetchVfsChildren = fetchVfsChildren;
+exports.fetchVfsChildrenPage = fetchVfsChildrenPage;
+exports.fetchVfsItem = fetchVfsItem;
+exports.fetchVfsItemById = fetchVfsItemById;
+exports.fetchVfsTree = fetchVfsTree;
+exports.gatewayCall = gatewayCall;
+exports.getAccessToken = getAccessToken;
+exports.getAssetUrl = getAssetUrl;
+exports.getDefaultSort = getDefaultSort;
+exports.getRequiredFormFields = getRequiredFormFields;
+exports.getScope = getScope;
+exports.getScopeVersion = getScopeVersion;
+exports.getSessionEntry = getSessionEntry;
+exports.initSession = initSession;
+exports.initVfsRealtimeWs = initVfsRealtimeWs;
+exports.interpretSchema = interpretSchema;
+exports.invalidateAllVfs = invalidateAllVfs;
+exports.invalidateChannelMessages = invalidateChannelMessages;
+exports.invalidateChildren = invalidateChildren;
+exports.invalidateItem = invalidateItem;
+exports.invalidateOpenEnvelope = invalidateOpenEnvelope;
+exports.invalidatePathAndParent = invalidatePathAndParent;
+exports.invalidateSubtree = invalidateSubtree;
+exports.invalidateTypes = invalidateTypes;
+exports.isScopeReady = isScopeReady;
+exports.listChildren = listChildren;
+exports.mount = mount;
+exports.mountRealtimeScope = mountRealtimeScope;
+exports.normalizeItem = normalizeItem;
+exports.ping = ping;
+exports.pushChanges = pushChanges;
+exports.queryClient = queryClient;
+exports.readItem = readItem;
+exports.registerCleanup = registerCleanup;
+exports.resetAllSdkState = resetAllSdkState;
+exports.resolvePrincipalId = resolvePrincipalId;
+exports.setCachedToken = setCachedToken;
+exports.setScope = setScope;
+exports.setupRequireShim = setupRequireShim;
+exports.signal = signal;
+exports.subscribeScope = subscribeScope;
+exports.subscribeToEvents = subscribeToEvents;
+exports.subscribeToPath = subscribeToPath;
+exports.subscribeToScope = subscribeToScope;
+exports.unmountRealtimeScope = unmountRealtimeScope;
+exports.updateItem = updateItem;
+exports.uploadFile = uploadFile;
+exports.useAccounts = useAccounts;
+exports.useAllChannels = useAllChannels;
+exports.useAsset = useAsset;
+exports.useAuth = useAuth;
+exports.useChannelMessages = useChannelMessages;
+exports.useChannels = useChannels;
+exports.useChildren = useChildren;
+exports.useComponent = useComponent;
+exports.useCreate = useCreate;
+exports.useDelete = useDelete;
+exports.useDmChannels = useDmChannels;
+exports.useEdges = useEdges;
+exports.useEventStream = useEventStream;
+exports.useFileUpload = useFileUpload;
+exports.useInfiniteChannelMessages = useInfiniteChannelMessages;
+exports.useInfiniteChildren = useInfiniteChildren;
+exports.useInfiniteItems = useInfiniteItems;
+exports.useItem = useItem;
+exports.useItemById = useItemById;
+exports.useItemHistory = useItemHistory;
+exports.useItems = useItems;
+exports.useLink = useLink;
+exports.useList = useList;
+exports.useMemberFocus = useMemberFocus;
+exports.useMove = useMove;
+exports.useMutation = useMutation;
+exports.useNotifications = useNotifications;
+exports.useOpen = useOpen;
+exports.usePermission = usePermission;
+exports.usePermissions = usePermissions;
+exports.usePrincipal = usePrincipal;
+exports.useRealtimeQuery = useRealtimeQuery;
+exports.useRecentActivity = useRecentActivity;
+exports.useScope = useScope;
+exports.useScopeReady = useScopeReady;
+exports.useSearch = useSearch;
+exports.useTheme = useTheme;
+exports.useTool = useTool;
+exports.useTree = useTree;
+exports.useType = useType;
+exports.useTypeHelpers = useTypeHelpers;
+exports.useTypes = useTypes;
+exports.useUnreadCounts = useUnreadCounts;
+exports.useUpdate = useUpdate;
+exports.vfsKeys = vfsKeys;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map