@datalayer/core 1.1.60 → 1.2.10

package/lib/hooks/useCache.js

@@ -37,14 +37,15 @@
  * ```
  */
 import { useQuery, useQueries, useMutation, useQueryClient, } from '@tanstack/react-query';
-import { BOOTSTRAP_USER_ONBOARDING, asContact, asDatasource, asInvite, asOrganization, asSecret, asTeam, asToken, asUser, } from '../models/index.js';
-import { asPage, asSpace } from './cacheConverters.js';
+import { BOOTSTRAP_USER_ONBOARDING, asContact, asInvite, asOrganization, asSecret, asTeam, asToken, asUser, } from '../models/index.js';
+import { asSpace } from './cacheConverters.js';
 import { useCoreStore, useIAMStore, profileStore } from '../state/index.js';
 import { asDisplayName, namesAsInitials, asArray } from '../utils/index.js';
 import { useDatalayer } from './useDatalayer.js';
 import { useAuthorization } from './useAuthorization.js';
 import { useUploadForm } from './useUpload.js';
 import { OUTPUTSHOT_PLACEHOLDER_DEFAULT_SVG } from './assets/index.js';
+import { forgetSessionState } from '../state/sessionEnd.js';
 // Kept for potential future use
 // Default query options for all queries
 const DEFAULT_QUERY_OPTIONS = {
@@ -57,6 +58,53 @@ const DEFAULT_QUERY_OPTIONS = {
     // Ensure queries prioritize cache over network when data is fresh
     networkMode: 'online',
 };
+/**
+ * Refresh what a visitor sees, not just what the editor is looking at.
+ *
+ * `invalidateQueries` marks queries stale and refetches the **active** ones —
+ * the ones some mounted component is watching. Everything else is left to
+ * refetch when it is next mounted, which is the usual and correct behaviour
+ * and does not work here.
+ *
+ * It does not work because the app's `QueryClient` is built with
+ * `refetchOnMount: false`. A query that mounts holding stale data renders it
+ * and asks for nothing. So an administrator on `/admin/library/featured`
+ * would reorder the ribbon, watch the admin list reorder itself correctly —
+ * that query is active — and then find the home page still showing the old
+ * order, because the ribbon was not mounted when the invalidation happened
+ * and would not ask again when it was. Only a full page reload, which throws
+ * the whole cache away, put it right.
+ *
+ * `refetchType: 'all'` fetches the inactive ones too, there and then. It
+ * belongs on the handful of mutations that change what somebody *else's*
+ * screen shows, and nowhere else: for an ordinary edit, refetching every
+ * dormant query in the cache is a burst of requests for pages nobody is on.
+ */
+const invalidateEverywhere = (client, queryKey) => {
+    void client.invalidateQueries({ queryKey, refetchType: 'all' });
+};
+/**
+ * Forget everything a session was told, without orphaning what is on screen.
+ *
+ * `queryClient.clear()` is the obvious way to end a session and the wrong
+ * one. It destroys the query objects themselves, and an observer whose query
+ * is destroyed while its fetch is in flight is never answered and never asks
+ * again: it sits at `isLoading` for as long as the page stays open.
+ *
+ * Signing out is exactly that race. Ending the session swaps the whole tree
+ * for the anonymous one, which mounts the home page and starts fetching the
+ * featured ribbon; the logout response then lands on top of that fetch. The
+ * ribbon stayed a row of empty placeholders until the reader reloaded.
+ *
+ * So: drop what nobody is looking at, and reset what is on screen. A reset
+ * forgets the answer the person who has left was given and asks the question
+ * again as whoever is here now, which is what signing out means for a page
+ * that is still open.
+ */
+export const forgetSession = (client) => {
+    client.removeQueries({ type: 'inactive' });
+    client.resetQueries({ type: 'active' });
+};
 // ============================================================================
 // Query Key Factories
 // ============================================================================
@@ -66,6 +114,155 @@ const DEFAULT_QUERY_OPTIONS = {
  * @see https://tanstack.com/query/latest/docs/framework/react/guides/query-keys
  */
 export const queryKeys = {
+    // Contents catalog
+    contents: {
+        all: () => ['contents'],
+        sources: () => [...queryKeys.contents.all(), 'sources'],
+        capabilities: () => [...queryKeys.contents.all(), 'capabilities'],
+        sourceList: (filters) => [...queryKeys.contents.sources(), 'list', filters ?? {}],
+        source: (sourceUid) => [...queryKeys.contents.sources(), 'detail', sourceUid],
+        sourceSharing: (sourceUid) => [...queryKeys.contents.source(sourceUid), 'sharing'],
+        datasetRevisions: (sourceUid) => [...queryKeys.contents.source(sourceUid), 'revisions'],
+        datasetRevision: (sourceUid, revisionUid) => [...queryKeys.contents.datasetRevisions(sourceUid), revisionUid],
+        datasetPublications: (sourceUid) => [...queryKeys.contents.source(sourceUid), 'publications'],
+        publishedDatasets: () => [...queryKeys.contents.all(), 'publications', 'datasets'],
+        cloudObjects: (sourceUid, prefix, cursor) => [
+            ...queryKeys.contents.source(sourceUid),
+            'cloud',
+            'objects',
+            prefix ?? '',
+            cursor ?? '',
+        ],
+        credentialDiagnostics: (sourceUid) => [...queryKeys.contents.source(sourceUid), 'diagnostics'],
+        homeFolder: () => [...queryKeys.contents.sources(), 'user-folder'],
+        homeFolderQuota: () => [...queryKeys.contents.homeFolder(), 'quota'],
+        homeFolderObjects: (filters) => [
+            ...queryKeys.contents.homeFolder(),
+            'objects',
+            'list',
+            filters ?? {},
+        ],
+        homeFolderObject: (path) => [...queryKeys.contents.homeFolder(), 'objects', 'stat', path],
+        homeFolderObjectVersions: (objectUid, cursor) => [
+            ...queryKeys.contents.homeFolder(),
+            'objects',
+            objectUid,
+            'versions',
+            cursor ?? '',
+        ],
+        operations: () => [...queryKeys.contents.all(), 'operations'],
+        operation: (operationUid) => [...queryKeys.contents.operations(), operationUid],
+        transfers: () => [...queryKeys.contents.all(), 'transfers'],
+        transferList: (filters) => [...queryKeys.contents.transfers(), 'list', filters ?? {}],
+        transfer: (transferUid) => [...queryKeys.contents.transfers(), transferUid],
+        syncSessions: () => [...queryKeys.contents.all(), 'sync'],
+        syncSessionList: (filters) => [...queryKeys.contents.syncSessions(), 'list', filters ?? {}],
+        syncSession: (sessionUid) => [...queryKeys.contents.syncSessions(), sessionUid],
+        syncConflicts: (sessionUid) => [...queryKeys.contents.syncSession(sessionUid), 'conflicts'],
+        attachments: () => [...queryKeys.contents.all(), 'attachments'],
+        attachmentList: (filters) => [...queryKeys.contents.attachments(), 'list', filters ?? {}],
+        attachmentManifest: (sandboxUid) => [...queryKeys.contents.attachments(), 'manifest', sandboxUid],
+        // The session of one attachment lives under the attachments key on
+        // purpose: revoking or refreshing an attachment refreshes its bridge.
+        bridgeSession: (attachmentUid) => [...queryKeys.contents.attachments(), 'bridge', attachmentUid],
+        bridges: () => [...queryKeys.contents.all(), 'bridges'],
+        bridgeList: (filters) => [...queryKeys.contents.bridges(), 'list', filters ?? {}],
+        bridge: (bridgeUid) => [...queryKeys.contents.bridges(), bridgeUid],
+        // What a running Runtime has mounted. Under the Contents key rather than
+        // a Runtimes one because attaching and detaching a source is what changes
+        // it, and those invalidate from here.
+        runtimeMounts: (runtimeName) => [...queryKeys.contents.all(), 'runtime-mounts', runtimeName],
+        mcpTools: (sourceUid) => [...queryKeys.contents.source(sourceUid), 'mcp', 'tools'],
+        mcpSessions: () => [...queryKeys.contents.all(), 'mcp-sessions'],
+        mcpSessionList: (filters) => [...queryKeys.contents.mcpSessions(), 'list', filters ?? {}],
+        mcpSession: (sessionUid) => [...queryKeys.contents.mcpSessions(), sessionUid],
+        mcpCalls: (sessionUid) => [...queryKeys.contents.mcpSession(sessionUid), 'calls'],
+        mcpCall: (sessionUid, callUid) => [...queryKeys.contents.mcpCalls(sessionUid), callUid],
+        mcpApprovals: () => [...queryKeys.contents.all(), 'mcp-approvals'],
+        mcpApprovalList: (filters) => [...queryKeys.contents.mcpApprovals(), 'list', filters ?? {}],
+        datasourceSchema: (sourceUid) => [
+            ...queryKeys.contents.source(sourceUid),
+            'datasource',
+            'schema',
+        ],
+        datasourceCapabilities: (sourceUid) => [
+            ...queryKeys.contents.source(sourceUid),
+            'datasource',
+            'capabilities',
+        ],
+        datasourceQueries: (sourceUid) => [...queryKeys.contents.source(sourceUid), 'queries'],
+        // A query is addressed by its own uid, not under its source: a
+        // notebook reconnects to one by uid alone.
+        queries: () => [...queryKeys.contents.all(), 'queries'],
+        query: (queryUid) => [...queryKeys.contents.queries(), queryUid],
+        dataserverStatus: (sourceUid) => [
+            ...queryKeys.contents.source(sourceUid),
+            'dataserver',
+            'status',
+        ],
+    },
+    // The Jupyter MCP Server: what the agents did, and what they may do
+    mcp: {
+        all: () => ['mcp'],
+        tasks: () => [...queryKeys.mcp.all(), 'tasks'],
+        taskList: (filters) => [...queryKeys.mcp.tasks(), 'list', filters ?? {}],
+        task: (taskUid) => [...queryKeys.mcp.tasks(), taskUid],
+        notebookTasks: (notebookUid, filters) => [
+            ...queryKeys.mcp.tasks(),
+            'notebook',
+            notebookUid,
+            filters ?? {},
+        ],
+        bindings: () => [...queryKeys.mcp.all(), 'bindings'],
+        bindingList: (filters) => [...queryKeys.mcp.bindings(), 'list', filters ?? {}],
+        activity: (filters) => [...queryKeys.mcp.all(), 'activity', filters ?? {}],
+        audit: () => [...queryKeys.mcp.all(), 'audit'],
+        auditList: (filters) => [...queryKeys.mcp.audit(), 'list', filters ?? {}],
+        policy: (filters) => [...queryKeys.mcp.all(), 'policy', filters ?? {}],
+        connectedAgents: () => [...queryKeys.mcp.all(), 'connected-agents'],
+        // Service agents are an organization's, never an account's: two
+        // organizations' lists must not share a cache entry.
+        serviceAgents: (orgUid) => [...queryKeys.mcp.all(), 'service-agents', orgUid],
+        // The layer IAM stores, keyed by the scope *and* the subject: an
+        // organization's policy and a team's are different documents, and a
+        // shared entry would show one under the other's name.
+        policyLayer: (scope, subjectUid) => [...queryKeys.mcp.all(), 'policy-layer', scope, subjectUid],
+        alertRules: (orgUid) => [...queryKeys.mcp.all(), 'alert-rules', orgUid],
+        identityProviders: (orgUid) => [...queryKeys.mcp.all(), 'identity-providers', orgUid],
+        scimTokens: (orgUid) => [...queryKeys.mcp.all(), 'scim-tokens', orgUid],
+        // Keyed by scope *and* subject, like `policyLayer`: an organization's
+        // admitted clients and a team's are different lists, and a shared entry
+        // would show one under the other's name.
+        admittedClients: (scope, subjectUid) => [...queryKeys.mcp.all(), 'admitted-clients', scope, subjectUid],
+        forwarding: (orgUid) => [...queryKeys.mcp.all(), 'audit-forwarding', orgUid],
+        auditSettings: (orgUid) => [...queryKeys.mcp.all(), 'audit-settings', orgUid],
+        organizationTeams: (orgUid) => [...queryKeys.mcp.all(), 'organization-teams', orgUid],
+        // Observability, over the OTEL service, keyed by the task it describes.
+        trace: (taskUid) => [...queryKeys.mcp.task(taskUid), 'trace'],
+        // A trace named directly: a synchronous call has one and no task.
+        traceById: (traceId) => [...queryKeys.mcp.all(), 'traces', traceId],
+        logs: (taskUid) => [...queryKeys.mcp.task(taskUid), 'logs'],
+        metrics: (filters) => [...queryKeys.mcp.all(), 'metrics', filters ?? {}],
+        operations: () => [...queryKeys.mcp.all(), 'operations'],
+        workers: () => [...queryKeys.mcp.operations(), 'workers'],
+        workflows: () => [...queryKeys.mcp.operations(), 'workflows'],
+        gatewayVersion: () => [...queryKeys.mcp.all(), 'version'],
+        // The Enterprise console: one answer per organization, narrowed by team.
+        orgOverview: (orgUid, filters) => [
+            ...queryKeys.mcp.all(),
+            'organizations',
+            orgUid,
+            'overview',
+            filters ?? {},
+        ],
+        orgUsage: (orgUid, filters) => [
+            ...queryKeys.mcp.all(),
+            'organizations',
+            orgUid,
+            'usage',
+            filters ?? {},
+        ],
+    },
     // Authentication & Profile
     auth: {
         me: () => ['auth', 'me'],
@@ -148,6 +345,14 @@ export const queryKeys = {
         bySpace: (spaceId) => [...queryKeys.documents.all(), 'space', spaceId],
         model: (documentId) => [...queryKeys.documents.detail(documentId), 'model'],
     },
+    // Decks
+    decks: {
+        all: () => ['decks'],
+        details: () => [...queryKeys.decks.all(), 'detail'],
+        detail: (id) => [...queryKeys.decks.details(), id],
+        bySpace: (spaceId) => [...queryKeys.decks.all(), 'space', spaceId],
+        model: (deckId) => [...queryKeys.decks.detail(deckId), 'model'],
+    },
     // Cells
     cells: {
         all: () => ['cells'],
@@ -155,13 +360,6 @@ export const queryKeys = {
         detail: (id) => [...queryKeys.cells.details(), id],
         bySpace: (spaceId) => [...queryKeys.cells.all(), 'space', spaceId],
     },
-    // Datasets
-    datasets: {
-        all: () => ['datasets'],
-        details: () => [...queryKeys.datasets.all(), 'detail'],
-        detail: (id) => [...queryKeys.datasets.details(), id],
-        bySpace: (spaceId) => [...queryKeys.datasets.all(), 'space', spaceId],
-    },
     // Lessons
     lessons: {
         all: () => ['lessons'],
@@ -201,18 +399,6 @@ export const queryKeys = {
         detail: (id) => [...queryKeys.environments.details(), id],
         bySpace: (spaceId) => [...queryKeys.environments.all(), 'space', spaceId],
     },
-    // Pages
-    pages: {
-        all: () => ['pages'],
-        details: () => [...queryKeys.pages.all(), 'detail'],
-        detail: (id) => [...queryKeys.pages.details(), id],
-    },
-    // Datasources
-    datasources: {
-        all: () => ['datasources'],
-        details: () => [...queryKeys.datasources.all(), 'detail'],
-        detail: (id) => [...queryKeys.datasources.details(), id],
-    },
     // Secrets
     secrets: {
         all: () => ['secrets'],
@@ -270,8 +456,16 @@ export const queryKeys = {
     items: {
         all: () => ['items'],
         public: () => [...queryKeys.items.all(), 'public'],
+        publicItem: (uid) => [...queryKeys.items.all(), 'public', uid],
         bySpace: (spaceId) => [...queryKeys.items.all(), 'space', spaceId],
         search: (opts) => [...queryKeys.items.all(), 'search', opts],
+        // The library: what the home page, the profile pages and "my orbits"
+        // read, each invalidated by the mutation that changes it.
+        featured: () => [...queryKeys.items.all(), 'featured'],
+        orbits: () => [...queryKeys.items.all(), 'orbits'],
+        orbiters: (uid) => [...queryKeys.items.all(), 'orbiters', uid],
+        derivations: (uid) => [...queryKeys.items.all(), 'derivations', uid],
+        byOwner: (handle) => [...queryKeys.items.all(), 'owner', handle],
     },
     // Layout
     layout: {
@@ -352,6 +546,8 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
     const { isLoading: notebookUploadLoading, uploadAndSubmit: uploadNotebook, progress: notebookUploadProgress, reset: resetNotebookUpload, } = useUploadForm(`${coreStore.configuration.spacerUrl}/api/spacer/v1/notebooks`);
     // Hook for document upload/creation
     const { isLoading: documentUploadLoading, uploadAndSubmit: uploadDocument, progress: documentUploadProgress, reset: resetDocumentUpload, } = useUploadForm(`${coreStore.configuration.spacerUrl}/api/spacer/v1/lexicals`);
+    // Hook for deck upload/creation
+    const { isLoading: deckUploadLoading, uploadAndSubmit: uploadDeck, progress: deckUploadProgress, reset: resetDeckUpload, } = useUploadForm(`${coreStore.configuration.spacerUrl}/api/spacer/v1/decks`);
     // ============================================================================
     // Transformation Functions (kept from original useCache)
     // Note: These functions use 'any' because they handle dynamic API responses
@@ -451,16 +647,6 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
     const toSpace = (spc) => {
         return asSpace(spc);
     };
-    const toPage = (s) => {
-        if (s) {
-            return asPage(s);
-        }
-    };
-    const toDatasource = (s) => {
-        if (s) {
-            return asDatasource(s);
-        }
-    };
     const toSecret = (s) => {
         if (s) {
             return asSecret(s);
@@ -486,6 +672,228 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
      * is available so the UI hydration hooks (e.g. `useUsersByUids`) can
      * still fill in display data downstream.
      */
+    /**
+     * What the library knows about an artifact, on top of what its own service
+     * stores: how many people orbit it, whether this visitor does, how often it
+     * has been reused, whether it is featured, and what it looks like.
+     *
+     * Applied in one place — `toItem`, the library and search path — rather than
+     * in each mapper: a notebook read from its space has none of this, and
+     * inventing zeros there would say "nobody orbits it" where the truth is
+     * "this was not the library answering".
+     */
+    const withLibraryMeta = (raw) => {
+        if (!raw || typeof raw !== 'object') {
+            return {};
+        }
+        const meta = {};
+        if (raw.orbits !== undefined)
+            meta.orbits = Number(raw.orbits) || 0;
+        if (raw.orbited !== undefined)
+            meta.orbited = Boolean(raw.orbited);
+        if (raw.clones !== undefined)
+            meta.clones = Number(raw.clones) || 0;
+        if (raw.instantiations !== undefined)
+            meta.instantiations = Number(raw.instantiations) || 0;
+        if (raw.featured !== undefined)
+            meta.featured = Boolean(raw.featured);
+        if (raw.featuredRank !== undefined)
+            meta.featuredRank = Number(raw.featuredRank);
+        if (raw.reuse !== undefined)
+            meta.reuse = raw.reuse;
+        if (raw.publisher !== undefined)
+            meta.publisher = raw.publisher;
+        if (raw.image !== undefined)
+            meta.image = raw.image;
+        /*
+         * Where the artifact can be opened for editing.
+         *
+         * An item is a nested child of its space and carries no handle of its
+         * own, so the library resolves the space when it projects one. Without
+         * these two a page can link to the public reading of an artifact and has
+         * no way to offer the editable one.
+         */
+        if (raw.space_handle_s)
+            meta.spaceHandle = raw.space_handle_s;
+        if (raw.space_owner_handle_s)
+            meta.spaceOwnerHandle = raw.space_owner_handle_s;
+        /*
+         * The absolute address anyone can read it at.
+         *
+         * Built by the library, not here, because it needs the host the site is
+         * served from and the browser only knows the host it happens to be on —
+         * which on a development server is `localhost:3063`, the one address that
+         * is no use to whoever the link is being copied for.
+         */
+        if (raw.publicUrl)
+            meta.publicUrl = raw.publicUrl;
+        return meta;
+    };
+    /**
+     * A published dataset. Keyed on the dataset it is a publication of, not on
+     * the publication: republishing mints a new immutable revision, and the
+     * library entry — with the orbits it has collected — is the dataset's.
+     */
+    const toDataset = (raw) => {
+        const owner = toItemOwner(raw);
+        return {
+            id: raw.uid,
+            type: 'dataset',
+            name: raw.name_t,
+            description: raw.description_t,
+            tags: Array.isArray(raw.tags_ss) ? raw.tags_ss : [],
+            public: raw.is_public_b ?? true,
+            license: raw.license_s,
+            fileCount: raw.file_count_i,
+            totalSize: raw.total_size_l,
+            publicationId: raw.latest_publication_uid_s,
+            revisionId: raw.revision_uid_s,
+            creationDate: raw.creation_ts_dt
+                ? new Date(raw.creation_ts_dt)
+                : undefined,
+            owner,
+        };
+    };
+    /**
+     * An agent as a library artifact: published by Datalayer rather than by a
+     * user, and reused by instantiating a runtime from its specification rather
+     * than by cloning a document. The specification itself lives in the
+     * application's own build; this is only what the library shows of it.
+     */
+    /**
+     * A published Data Server: its catalog, never its address.
+     *
+     * What the library holds is what it answers for — the connector kinds and
+     * the relations they name. Reusing one attaches it as a Datasource; there
+     * is nothing to copy, because a Data Server is a process somebody runs.
+     */
+    const toDataserver = (raw) => {
+        const owner = toItemOwner(raw);
+        return {
+            id: raw.uid,
+            type: 'dataserver',
+            name: raw.name_t,
+            description: raw.description_t,
+            tags: Array.isArray(raw.tags_ss) ? raw.tags_ss : [],
+            public: raw.is_public_b ?? true,
+            connectors: Array.isArray(raw.connectors_ss) ? raw.connectors_ss : [],
+            relations: Array.isArray(raw.relations_ss) ? raw.relations_ss : [],
+            publicationId: raw.latest_publication_uid_s,
+            creationDate: raw.creation_ts_dt
+                ? new Date(raw.creation_ts_dt)
+                : undefined,
+            owner,
+        };
+    };
+    const toAgent = (raw) => {
+        return {
+            id: raw.uid,
+            type: 'agent',
+            name: raw.name_t,
+            description: raw.description_t,
+            tags: Array.isArray(raw.tags_ss) ? raw.tags_ss : [],
+            public: raw.is_public_b ?? true,
+            domain: raw.domain_s,
+            icon: raw.icon_s,
+            emoji: raw.emoji_s,
+            model: raw.model_s,
+            specId: String(raw.uid || '').replace(/^agent:/, ''),
+            specVersion: raw.spec_version_s,
+            publisher: raw.publisher_s || 'datalayer',
+            creationDate: raw.creation_ts_dt
+                ? new Date(raw.creation_ts_dt)
+                : undefined,
+        };
+    };
+    /**
+     * A published benchmark report (B5-01): what it is about and where it
+     * stands, and the document it is written in, which the library reads for it
+     * and hands over as `model_s` — the field a document's reader looks for.
+     */
+    const toReport = (raw) => {
+        return {
+            id: raw.uid,
+            type: 'report',
+            name: raw.name_t,
+            description: raw.description_t,
+            tags: Array.isArray(raw.tags_ss) ? raw.tags_ss : [],
+            public: raw.is_public_b ?? true,
+            state: raw.state_s,
+            version: raw.version_i,
+            runCount: raw.run_count_i,
+            evalsetId: raw.evalset_uid_s,
+            report: raw.report,
+            model_s: raw.model_s,
+            creationDate: raw.creation_ts_dt
+                ? new Date(raw.creation_ts_dt)
+                : undefined,
+            lastPublicationDate: raw.published_ts_dt
+                ? new Date(raw.published_ts_dt)
+                : undefined,
+            owner: toItemOwner(raw),
+        };
+    };
+    /**
+     * A published investigation (B5-01): its scope, where it stands and what was
+     * decided, and the document it is written in, as a report's is.
+     */
+    const toInvestigation = (raw) => {
+        return {
+            id: raw.uid,
+            type: 'investigation',
+            name: raw.name_t,
+            description: raw.description_t,
+            tags: Array.isArray(raw.tags_ss) ? raw.tags_ss : [],
+            public: raw.is_public_b ?? true,
+            scope: raw.scope_s,
+            status: raw.status_s,
+            evalsetId: raw.evalset_uid_s,
+            investigation: raw.investigation,
+            model_s: raw.model_s,
+            creationDate: raw.creation_ts_dt
+                ? new Date(raw.creation_ts_dt)
+                : undefined,
+            lastPublicationDate: raw.published_ts_dt
+                ? new Date(raw.published_ts_dt)
+                : undefined,
+            owner: toItemOwner(raw),
+        };
+    };
+    /** An evaluator of the platform's catalogue (B5-01), published as an agent is. */
+    const toEvaluator = (raw) => {
+        return {
+            id: raw.uid,
+            type: 'evaluator',
+            name: raw.name_t,
+            description: raw.description_t,
+            tags: Array.isArray(raw.tags_ss) ? raw.tags_ss : [],
+            public: raw.is_public_b ?? true,
+            specId: String(raw.uid || '').replace(/^evaluator:/, ''),
+            specVersion: raw.spec_version_s,
+            publisher: raw.publisher_s || 'datalayer',
+            creationDate: raw.creation_ts_dt
+                ? new Date(raw.creation_ts_dt)
+                : undefined,
+        };
+    };
+    /**
+     * A card of the site's own in the featured ribbon — the run the home page is
+     * written about, say. The library knows its name and whether it is
+     * featured; what it draws and where it leads are in the application's build,
+     * keyed by `cardId`.
+     */
+    const toSiteCard = (raw) => {
+        return {
+            id: raw.uid,
+            type: 'sitecard',
+            name: raw.name_t,
+            description: raw.description_t,
+            tags: Array.isArray(raw.tags_ss) ? raw.tags_ss : [],
+            public: raw.is_public_b ?? true,
+            cardId: String(raw.uid || '').replace(/^sitecard:/, ''),
+            publisher: raw.publisher_s || 'datalayer',
+        };
+    };
     const toItemOwner = (raw) => {
         const uid = String(raw?.creator_uid_s ??
             raw?.creator_uid ??
@@ -497,6 +905,15 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
         const lastName = String(raw?.creator_last_name_t ?? raw?.last_name_t ?? '').trim();
         const email = String(raw?.creator_email_s ?? raw?.email_s ?? '').trim();
         const displayName = firstName || lastName ? asDisplayName(firstName, lastName) : handle;
+        /*
+         * The face, which the library has been projecting all along and nothing
+         * was reading. Without it every published artifact was attributed to a
+         * pair of initials, on its own public page as much as anywhere else —
+         * the owner is right there in the projection, and this is the one place
+         * it was being dropped.
+         */
+        const avatarUrl = String(raw?.creator_avatar_url_s ?? raw?.avatar_url_s ?? '').trim();
+        const avatarIcon = String(raw?.creator_avatar_icon_s ?? raw?.avatar_icon_s ?? '').trim();
         return {
             id: uid,
             handle,
@@ -505,6 +922,8 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             lastName,
             initials: namesAsInitials(firstName, lastName),
             displayName,
+            avatarUrl: avatarUrl || undefined,
+            avatarIcon: avatarIcon || undefined,
             roles: [],
             iamProviders: [],
             setRoles: () => { },
@@ -516,35 +935,6 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
     };
     // Kept for potential future use
     // Kept for potential future use
-    const toDataset = (raw_dataset) => {
-        const owner = toItemOwner(raw_dataset);
-        return {
-            id: raw_dataset.uid,
-            type: 'dataset',
-            name: raw_dataset.name_t,
-            description: raw_dataset.description_t,
-            fileName: raw_dataset.file_name_s,
-            datasetExtension: raw_dataset.dataset_extension_s,
-            contentLength: raw_dataset.content_length_i,
-            contentType: raw_dataset.content_type_s,
-            mimeType: raw_dataset.mimetype_s,
-            path: raw_dataset.s3_path_s,
-            cdnUrl: raw_dataset.cdn_url_s,
-            creationDate: new Date(raw_dataset.creation_ts_dt),
-            public: raw_dataset.is_public_b ?? false,
-            lastPublicationDate: raw_dataset.creation_ts_dt
-                ? new Date(raw_dataset.creation_ts_dt)
-                : undefined,
-            owner,
-            space: {
-                handle: raw_dataset.handle_s,
-            },
-            organization: {
-                id: raw_dataset.organization_uid_s,
-                handle: raw_dataset.organization_handle_s,
-            },
-        };
-    };
     const toCell = (cl) => {
         const owner = toItemOwner(cl);
         return {
@@ -552,6 +942,17 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             type: 'cell',
             name: cl.name_t,
             description: cl.description_t,
+            /*
+             * The words its owner filed it under.
+             *
+             * Every artifact type the library holds carries `tags_ss`, and the six
+             * space items — notebook, document, cell, lesson, exercise, assignment
+             * — were the six that never read it. So a notebook could be published
+             * under tags, be found by them in a search, and arrive at the card that
+             * shows them with none: the field was dropped here, one layer below
+             * anything that could notice.
+             */
+            tags: Array.isArray(cl.tags_ss) ? cl.tags_ss : [],
             source: cl.source_t,
             creationDate: new Date(cl.creation_ts_dt),
             public: cl.is_public_b ?? false,
@@ -577,6 +978,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             type: 'notebook',
             name: raw_notebook.name_t,
             description: raw_notebook.description_t,
+            tags: Array.isArray(raw_notebook.tags_ss) ? raw_notebook.tags_ss : [],
             nbformat: raw_notebook.model_s
                 ? JSON.parse(raw_notebook.model_s)
                 : undefined,
@@ -599,6 +1001,49 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             },
         };
     };
+    /**
+     * Put a deck in the detail cache — but only a whole one.
+     *
+     * A listing answers with the space's items, and an item carries no
+     * `model_s`: the specification lives in S3 and only `GET /decks/{uid}`
+     * inlines it. Seeding the detail cache from such a row left `useDeck`
+     * answering instantly with a deck whose `spec` is undefined — and since
+     * these queries stay fresh for five minutes and do not refetch on mount,
+     * an editor opened from the table drew nothing until the tab was reloaded.
+     * A deck without its specification is not the deck this cache promises.
+     */
+    const seedDeckDetail = (deck) => {
+        if (deck?.spec) {
+            queryClient.setQueryData(queryKeys.decks.detail(deck.id), deck);
+        }
+    };
+    const toDeck = (raw) => {
+        const owner = toItemOwner(raw);
+        return {
+            id: raw.uid,
+            type: 'deck',
+            name: raw.name_t,
+            description: raw.description_t,
+            tags: Array.isArray(raw.tags_ss) ? raw.tags_ss : [],
+            spec: raw.model_s ? JSON.parse(raw.model_s) : undefined,
+            public: raw.is_public_b ?? false,
+            creationDate: new Date(raw.creation_ts_dt),
+            lastUpdateDate: raw.last_update_ts_dt
+                ? new Date(raw.last_update_ts_dt)
+                : undefined,
+            lastPublicationDate: raw.creation_ts_dt
+                ? new Date(raw.creation_ts_dt)
+                : undefined,
+            owner,
+            space: {
+                handle: raw.handle_s,
+            },
+            organization: {
+                id: raw.organization_uid_s,
+                handle: raw.organization_handle_s,
+            },
+        };
+    };
     const toDocument = (doc) => {
         const owner = toItemOwner(doc);
         return {
@@ -606,6 +1051,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             type: 'document',
             name: doc.name_t,
             description: doc.description_t,
+            tags: Array.isArray(doc.tags_ss) ? doc.tags_ss : [],
             model: doc.model_s ? JSON.parse(doc.model_s) : undefined,
             public: doc.is_public_b ?? false,
             creationDate: new Date(doc.creation_ts_dt),
@@ -632,6 +1078,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             type: 'lesson',
             name: raw_lesson.name_t,
             description: raw_lesson.description_t,
+            tags: Array.isArray(raw_lesson.tags_ss) ? raw_lesson.tags_ss : [],
             nbformat: raw_lesson.model_s ? JSON.parse(raw_lesson.model_s) : undefined,
             public: raw_lesson.is_public_b ?? false,
             creationDate: new Date(raw_lesson.creation_ts_dt),
@@ -659,6 +1106,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             type: 'exercise',
             name: ex.name_t,
             description: ex.description_t,
+            tags: Array.isArray(ex.tags_ss) ? ex.tags_ss : [],
             help: ex.help_t,
             codePre: ex.code_pre_t,
             codeQuestion: ex.code_question_t,
@@ -704,6 +1152,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             type: 'assignment',
             name: raw_assignment.name_t,
             description: raw_assignment.description_t,
+            tags: Array.isArray(raw_assignment.tags_ss) ? raw_assignment.tags_ss : [],
             nbformat: raw_assignment.model_s
                 ? JSON.parse(raw_assignment.model_s)
                 : undefined,
@@ -751,6 +1200,13 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
     };
     const toEvalset = (raw_evalset) => {
         const owner = toItemOwner(raw_evalset);
+        const numberOrUndefined = (value) => {
+            if (value === null || value === undefined || value === '') {
+                return undefined;
+            }
+            const parsed = Number(value);
+            return Number.isFinite(parsed) ? parsed : undefined;
+        };
         return {
             id: raw_evalset.uid,
             type: 'evalset',
@@ -764,6 +1220,70 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 ? new Date(raw_evalset.last_update_ts_dt)
                 : undefined,
             tags: Array.isArray(raw_evalset.tags_ss) ? raw_evalset.tags_ss : [],
+            /*
+             * What the runs of a benchmark say about it, projected onto its
+             * library card whenever a run moves (BENCHMARK.md, B2-10 and B1-09).
+             *
+             * These were dropped here, so a card in the Library or on the home
+             * page could show a name and a description and nothing that would
+             * help anybody choose between two benchmarks — how big it is, what it
+             * has been run on, how well anyone has done, what a run tends to
+             * cost. The projection has been writing them all along.
+             */
+            category: raw_evalset.category_s || undefined,
+            caseCount: numberOrUndefined(raw_evalset.case_count_i),
+            runCount: numberOrUndefined(raw_evalset.run_count_i),
+            latestPassRate: numberOrUndefined(raw_evalset.latest_pass_rate_f),
+            bestPassRate: numberOrUndefined(raw_evalset.best_pass_rate_f),
+            lastRunStatus: raw_evalset.last_run_status_s || undefined,
+            lastRunAt: raw_evalset.last_run_at_dt
+                ? new Date(raw_evalset.last_run_at_dt)
+                : undefined,
+            estimatedCost: numberOrUndefined(raw_evalset.estimated_cost_f),
+            environment: raw_evalset.environment_s || undefined,
+            subjectRefs: Array.isArray(raw_evalset.subject_refs_ss)
+                ? raw_evalset.subject_refs_ss
+                : [],
+            owner,
+        };
+    };
+    /**
+     * A published environment version as a library artifact (PLAN_ENV E2-16).
+     *
+     * Keyed on the version uid, so one published version is one card, and read
+     * from the publication's immutable snapshot: its name, title, README (the
+     * description), the licenses its SBOM names (the tags), its size class and
+     * the variants it was built for. Republishing mints a new version — and a
+     * new card — rather than moving this one.
+     */
+    const toEnvironmentArtifact = (raw) => {
+        const owner = toItemOwner(raw);
+        const numberOrUndefined = (value) => {
+            if (value === null || value === undefined || value === '') {
+                return undefined;
+            }
+            const parsed = Number(value);
+            return Number.isFinite(parsed) ? parsed : undefined;
+        };
+        return {
+            id: raw.uid,
+            type: 'environment',
+            name: raw.name_t,
+            title: raw.title_t || undefined,
+            description: raw.description_t,
+            tags: Array.isArray(raw.tags_ss) ? raw.tags_ss : [],
+            licenses: Array.isArray(raw.tags_ss) ? raw.tags_ss : [],
+            public: raw.is_public_b ?? true,
+            environmentUid: raw.environment_uid_s || undefined,
+            sizeClass: raw.size_class_s || undefined,
+            variants: Array.isArray(raw.variants_ss) ? raw.variants_ss : [],
+            versionNumber: numberOrUndefined(raw.version_number_i),
+            creationDate: raw.creation_ts_dt
+                ? new Date(raw.creation_ts_dt)
+                : undefined,
+            lastUpdateDate: raw.source_update_ts_dt
+                ? new Date(raw.source_update_ts_dt)
+                : undefined,
             owner,
         };
     };
@@ -772,6 +1292,13 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             console.error('No type_s found on item', item);
             return {};
         }
+        // The library answers with the same field names a space item has, plus
+        // what only it knows; the type mapper reads the former and
+        // `withLibraryMeta` adds the latter, so one artifact has one shape
+        // wherever it was searched.
+        return { ...toTypedItem(item), ...withLibraryMeta(item) };
+    };
+    const toTypedItem = (item) => {
         switch (item.type_s) {
             case 'assignment':
                 return toAssignment(item);
@@ -816,8 +1343,10 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                     },
                 };
             }
-            case 'dataset':
-                return toDataset(item);
+            // Without this the mapper answered `{}` for a deck: the card then
+            // read no type and no name, and drew itself as a nameless notebook.
+            case 'deck':
+                return toDeck(item);
             case 'document':
                 return toDocument(item);
             case 'exercise':
@@ -826,10 +1355,24 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 return toLesson(item);
             case 'notebook':
                 return toNotebook(item);
-            case 'page':
-                return toPage(item);
             case 'evalset':
                 return toEvalset(item);
+            case 'environment':
+                return toEnvironmentArtifact(item);
+            case 'dataset':
+                return toDataset(item);
+            case 'agent':
+                return toAgent(item);
+            case 'dataserver':
+                return toDataserver(item);
+            case 'report':
+                return toReport(item);
+            case 'investigation':
+                return toInvestigation(item);
+            case 'evaluator':
+                return toEvaluator(item);
+            case 'sitecard':
+                return toSiteCard(item);
             default:
                 return {};
         }
@@ -955,8 +1498,8 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 });
             },
             onSuccess: () => {
-                // Clear all queries on logout
-                queryClient.clear();
+                forgetSession(queryClient);
+                forgetSessionState();
             },
         });
     };
@@ -993,11 +1536,11 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
      */
     const useUpdateMe = () => {
         return useMutation({
-            mutationFn: async ({ email, firstName, lastName, avatarIcon, banner, }) => {
+            mutationFn: async ({ email, firstName, lastName, avatarIcon, banner, showOrbits, }) => {
                 return requestDatalayer({
                     url: `${configuration.iamUrl}/api/iam/v1/me`,
                     method: 'PUT',
-                    body: { email, firstName, lastName, avatarIcon, banner },
+                    body: { email, firstName, lastName, avatarIcon, banner, showOrbits },
                 });
             },
             onSuccess: () => {
@@ -1231,19 +1774,33 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
     const useUpdateUserSettings = () => {
         return useMutation({
             mutationFn: async ({ userId, settings, }) => {
+                // Only the keys the caller actually set. IAM merges what it
+                // receives into the settings document, so sending a key means
+                // changing it — an undefined one is dropped by `JSON.stringify`
+                // and leaves the stored value alone.
+                const body = {};
+                if (settings.aiAgentsUrl !== undefined) {
+                    body.aiAgents_url_s = settings.aiAgentsUrl;
+                }
+                if (settings.canInvite !== undefined) {
+                    body.can_invite_b = settings.canInvite;
+                }
+                if (settings.docsInPlace !== undefined) {
+                    body.docs_in_place_b = settings.docsInPlace;
+                }
                 return requestDatalayer({
                     url: `${configuration.iamUrl}/api/iam/v1/users/${userId}/settings`,
                     method: 'PUT',
-                    body: {
-                        aiAgents_url_s: settings.aiAgentsUrl,
-                        can_invite_b: settings.canInvite || false,
-                    },
+                    body,
                 });
             },
             onSuccess: (_, variables) => {
                 queryClient.invalidateQueries({
                     queryKey: queryKeys.users.detail(variables.userId),
                 });
+                // The signed-in user carries these settings, and the application
+                // shell reads them from there.
+                queryClient.invalidateQueries({ queryKey: queryKeys.auth.me() });
             },
         });
     };
@@ -1682,7 +2239,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
     };
     /**
      * Update space with optimistic update.
-     * Any extra fields (e.g. attached_agent_pod_name_s) are forwarded to the backend.
+     * Any extra fields (e.g. attached_agent_runtime_name_s) are forwarded to the backend.
      */
     const useUpdateSpace = () => {
         return useMutation({
@@ -1873,6 +2430,148 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             },
         });
     };
+    /**
+     * Get a deck by id, its specification inlined as `spec`.
+     */
+    const useDeck = (deckId) => {
+        return useQuery({
+            queryKey: queryKeys.decks.detail(deckId),
+            queryFn: async () => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.spacerUrl}/api/spacer/v1/decks/${deckId}`,
+                    method: 'GET',
+                });
+                if (resp.success && resp.deck) {
+                    return toDeck(resp.deck);
+                }
+                if (resp?.code === 'FORBIDDEN') {
+                    throw new Error(resp.message || 'Not authorized to access this deck');
+                }
+                throw new Error(resp.message || 'Failed to fetch deck');
+            },
+            ...DEFAULT_QUERY_OPTIONS,
+            enabled: !!deckId,
+        });
+    };
+    /**
+     * Get decks by space
+     */
+    const useDecksBySpace = (spaceId) => {
+        return useQuery({
+            queryKey: queryKeys.decks.bySpace(spaceId),
+            queryFn: async () => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.spacerUrl}/api/spacer/v1/spaces/${spaceId}/items/types/deck`,
+                    method: 'GET',
+                });
+                if (resp.success && resp.items) {
+                    return resp.items.map((raw) => {
+                        const deck = toDeck(raw);
+                        seedDeckDetail(deck);
+                        return deck;
+                    });
+                }
+                return [];
+            },
+            ...DEFAULT_QUERY_OPTIONS,
+            enabled: !!spaceId,
+        });
+    };
+    /**
+     * Create a deck — from an uploaded specification, or the starter one.
+     */
+    const useCreateDeck = () => {
+        return useMutation({
+            mutationFn: async ({ spaceId, name, description, deckType = 'deck', file, }) => {
+                const formData = new FormData();
+                formData.append('space_id', spaceId);
+                // Backward compatibility for endpoints still expecting camelCase.
+                formData.append('spaceId', spaceId);
+                formData.append('deckType', deckType);
+                formData.append('name', name);
+                formData.append('description', description || '');
+                if (file) {
+                    formData.append('file', file);
+                }
+                return uploadDeck(formData);
+            },
+            onSuccess: resp => {
+                if (resp.success && resp.deck) {
+                    const deck = toDeck(resp.deck);
+                    seedDeckDetail(deck);
+                    queryClient.refetchQueries({ queryKey: queryKeys.decks.all() });
+                    queryClient.refetchQueries({ queryKey: queryKeys.items.all() });
+                }
+            },
+        });
+    };
+    /**
+     * Update a deck's name and description
+     */
+    const useUpdateDeck = () => {
+        return useMutation({
+            mutationFn: async ({ id, name, description, }) => {
+                return requestDatalayer({
+                    url: `${configuration.spacerUrl}/api/spacer/v1/decks/${id}`,
+                    method: 'PUT',
+                    body: { name, description },
+                });
+            },
+            onSuccess: (resp, deck) => {
+                if (resp.success) {
+                    queryClient.invalidateQueries({
+                        queryKey: queryKeys.decks.detail(deck.id),
+                    });
+                    queryClient.invalidateQueries({ queryKey: queryKeys.decks.all() });
+                }
+            },
+        });
+    };
+    /**
+     * Replace a deck's specification, whole.
+     */
+    const useUpdateDeckModel = () => {
+        return useMutation({
+            mutationFn: async ({ deckId, spec, }) => {
+                return requestDatalayer({
+                    url: `${configuration.spacerUrl}/api/spacer/v1/decks/${deckId}/model`,
+                    method: 'PUT',
+                    body: { spec },
+                });
+            },
+            onSuccess: (_, variables) => {
+                queryClient.invalidateQueries({
+                    queryKey: queryKeys.decks.detail(variables.deckId),
+                });
+                queryClient.invalidateQueries({
+                    queryKey: queryKeys.decks.model(variables.deckId),
+                });
+                queryClient.invalidateQueries({ queryKey: queryKeys.decks.all() });
+            },
+        });
+    };
+    /**
+     * Clone a deck into the caller's library (or a space they may change).
+     * The spacer writes the specification again under the new uid.
+     */
+    const useCloneDeck = () => {
+        return useMutation({
+            mutationFn: async (deckId) => {
+                return requestDatalayer({
+                    url: `${configuration.spacerUrl}/api/spacer/v1/decks/${deckId}/clone`,
+                    method: 'POST',
+                });
+            },
+            onSuccess: resp => {
+                if (resp.success && resp.deck) {
+                    const deck = toDeck(resp.deck);
+                    seedDeckDetail(deck);
+                    queryClient.refetchQueries({ queryKey: queryKeys.decks.all() });
+                    queryClient.refetchQueries({ queryKey: queryKeys.items.all() });
+                }
+            },
+        });
+    };
     /**
      * Clone notebook
      */
@@ -2068,242 +2767,41 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             },
         });
     };
-    // ============================================================================
-    // Page Hooks
-    // ============================================================================
     /**
-     * Get page by ID
+     * Get all secrets
      */
-    const usePage = (pageId) => {
+    // TODO: Previously this hook pre-populated individual secret caches with setQueryData,
+    // but this prevented useSecret from fetching fresh data (e.g., the value field).
+    // Consider re-adding cache pre-population if the list endpoint returns full secret data,
+    // or use a different query key pattern for partial vs full secret data.
+    const useSecrets = (options) => {
+        const principalUid = options?.principalUid;
+        const principalKind = options?.principalKind;
         return useQuery({
-            queryKey: queryKeys.pages.detail(pageId),
+            queryKey: [
+                ...queryKeys.secrets.all(),
+                principalUid || 'self',
+                principalKind || '',
+            ],
             queryFn: async () => {
                 const resp = await requestDatalayer({
-                    url: `${configuration.libraryUrl}/api/library/v1/pages/${pageId}`,
+                    url: withAccountUidQuery(`${configuration.iamUrl}/api/iam/v1/secrets`, principalUid, principalKind),
                     method: 'GET',
                 });
-                if (resp.success && resp.page) {
-                    return toPage(resp.page);
+                if (resp.success && resp.secrets) {
+                    const secrets = resp.secrets
+                        .map((s) => toSecret(s))
+                        .filter(Boolean);
+                    return secrets;
                 }
-                throw new Error(resp.message || 'Failed to fetch page');
+                return [];
             },
             ...DEFAULT_QUERY_OPTIONS,
-            enabled: !!pageId,
+            refetchOnMount: true, // Override to refetch when stale after invalidation
         });
     };
     /**
-     * Get all pages
-     */
-    const usePages = (scope) => {
-        return useQuery({
-            queryKey: [
-                ...queryKeys.pages.all(),
-                scope?.selectedPrincipalUid || '',
-                scope?.selectedPrincipalKind || '',
-            ],
-            queryFn: async () => {
-                const params = new URLSearchParams();
-                if (scope?.selectedPrincipalUid) {
-                    params.set('selected_principal_uid', scope.selectedPrincipalUid);
-                }
-                if (scope?.selectedPrincipalKind) {
-                    params.set('selected_principal_kind', scope.selectedPrincipalKind);
-                }
-                const query = params.toString();
-                const resp = await requestDatalayer({
-                    url: `${configuration.libraryUrl}/api/library/v1/pages${query ? `?${query}` : ''}`,
-                    method: 'GET',
-                });
-                if (resp.success && resp.pages) {
-                    const pages = resp.pages
-                        .map((p) => {
-                        const page = toPage(p);
-                        if (page) {
-                            queryClient.setQueryData(queryKeys.pages.detail(page.id), page);
-                        }
-                        return page;
-                    })
-                        .filter(Boolean);
-                    return pages;
-                }
-                return [];
-            },
-            ...DEFAULT_QUERY_OPTIONS,
-        });
-    };
-    /**
-     * Create page
-     */
-    const useCreatePage = () => {
-        return useMutation({
-            mutationFn: async (page) => {
-                return requestDatalayer({
-                    url: `${configuration.libraryUrl}/api/library/v1/pages`,
-                    method: 'POST',
-                    body: { ...page },
-                });
-            },
-            onSuccess: resp => {
-                if (resp.success && resp.page) {
-                    const page = toPage(resp.page);
-                    if (page) {
-                        // Set detail cache
-                        queryClient.setQueryData(queryKeys.pages.detail(page.id), page);
-                        // Invalidate list to refetch
-                        queryClient.invalidateQueries({
-                            queryKey: queryKeys.pages.all(),
-                        });
-                    }
-                }
-            },
-        });
-    };
-    /**
-     * Update page
-     */
-    const useUpdatePage = () => {
-        return useMutation({
-            mutationFn: async (page) => {
-                return requestDatalayer({
-                    url: `${configuration.libraryUrl}/api/library/v1/pages/${page.id}`,
-                    method: 'PUT',
-                    body: {
-                        name: page.name,
-                        description: page.description,
-                        tags: page.tags,
-                    },
-                });
-            },
-            onSuccess: (resp, page) => {
-                if (resp.success) {
-                    // Invalidate detail and list queries
-                    queryClient.invalidateQueries({
-                        queryKey: queryKeys.pages.detail(page.id),
-                    });
-                    queryClient.invalidateQueries({
-                        queryKey: queryKeys.pages.all(),
-                    });
-                }
-            },
-        });
-    };
-    /**
-     * Delete page
-     */
-    const useDeletePage = () => {
-        return useMutation({
-            mutationFn: async (pageId) => {
-                return requestDatalayer({
-                    url: `${configuration.libraryUrl}/api/library/v1/pages/${pageId}`,
-                    method: 'DELETE',
-                });
-            },
-            onSuccess: (_, pageId) => {
-                // Remove from detail cache
-                queryClient.removeQueries({ queryKey: queryKeys.pages.detail(pageId) });
-                // Invalidate list to refetch
-                queryClient.invalidateQueries({
-                    queryKey: queryKeys.pages.all(),
-                });
-            },
-        });
-    };
-    /**
-     * Get all datasources
-     */
-    const useDatasources = (options) => {
-        const principalUid = options?.principalUid;
-        const principalKind = options?.principalKind;
-        return useQuery({
-            queryKey: [
-                ...queryKeys.datasources.all(),
-                principalUid || 'self',
-                principalKind || '',
-            ],
-            queryFn: async () => {
-                const resp = await requestDatalayer({
-                    url: withAccountUidQuery(`${configuration.iamUrl}/api/iam/v1/datasources`, principalUid, principalKind),
-                    method: 'GET',
-                });
-                if (resp.success && resp.datasources) {
-                    const datasources = resp.datasources
-                        .map((d) => {
-                        const datasource = toDatasource(d);
-                        if (datasource) {
-                            queryClient.setQueryData(queryKeys.datasources.detail(datasource.id), datasource);
-                        }
-                        return datasource;
-                    })
-                        .filter(Boolean);
-                    return datasources;
-                }
-                return [];
-            },
-            ...DEFAULT_QUERY_OPTIONS,
-        });
-    };
-    /**
-     * Create datasource
-     */
-    const useCreateDatasource = (options) => {
-        const principalUid = options?.principalUid;
-        const principalKind = options?.principalKind;
-        return useMutation({
-            mutationFn: async (datasource) => {
-                return requestDatalayer({
-                    url: withAccountUidQuery(`${configuration.iamUrl}/api/iam/v1/datasources`, principalUid, principalKind),
-                    method: 'POST',
-                    body: { ...datasource },
-                });
-            },
-            onSuccess: resp => {
-                if (resp.success && resp.datasource) {
-                    const ds = toDatasource(resp.datasource);
-                    if (ds) {
-                        queryClient.setQueryData(queryKeys.datasources.detail(ds.id), ds);
-                    }
-                }
-                queryClient.invalidateQueries({
-                    queryKey: queryKeys.datasources.all(),
-                });
-            },
-        });
-    };
-    /**
-     * Get all secrets
-     */
-    // TODO: Previously this hook pre-populated individual secret caches with setQueryData,
-    // but this prevented useSecret from fetching fresh data (e.g., the value field).
-    // Consider re-adding cache pre-population if the list endpoint returns full secret data,
-    // or use a different query key pattern for partial vs full secret data.
-    const useSecrets = (options) => {
-        const principalUid = options?.principalUid;
-        const principalKind = options?.principalKind;
-        return useQuery({
-            queryKey: [
-                ...queryKeys.secrets.all(),
-                principalUid || 'self',
-                principalKind || '',
-            ],
-            queryFn: async () => {
-                const resp = await requestDatalayer({
-                    url: withAccountUidQuery(`${configuration.iamUrl}/api/iam/v1/secrets`, principalUid, principalKind),
-                    method: 'GET',
-                });
-                if (resp.success && resp.secrets) {
-                    const secrets = resp.secrets
-                        .map((s) => toSecret(s))
-                        .filter(Boolean);
-                    return secrets;
-                }
-                return [];
-            },
-            ...DEFAULT_QUERY_OPTIONS,
-            refetchOnMount: true, // Override to refetch when stale after invalidation
-        });
-    };
-    /**
-     * Create secret
+     * Create secret
      */
     const useCreateSecret = (options) => {
         const principalUid = options?.principalUid;
@@ -2561,10 +3059,8 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 queryClient.removeQueries({
                     queryKey: queryKeys.documents.detail(itemId),
                 });
+                queryClient.removeQueries({ queryKey: queryKeys.decks.detail(itemId) });
                 queryClient.removeQueries({ queryKey: queryKeys.cells.detail(itemId) });
-                queryClient.removeQueries({
-                    queryKey: queryKeys.datasets.detail(itemId),
-                });
                 queryClient.removeQueries({
                     queryKey: queryKeys.lessons.detail(itemId),
                 });
@@ -2577,8 +3073,8 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 // Invalidate all artifact type queries
                 queryClient.invalidateQueries({ queryKey: queryKeys.notebooks.all() });
                 queryClient.invalidateQueries({ queryKey: queryKeys.documents.all() });
+                queryClient.invalidateQueries({ queryKey: queryKeys.decks.all() });
                 queryClient.invalidateQueries({ queryKey: queryKeys.cells.all() });
-                queryClient.invalidateQueries({ queryKey: queryKeys.datasets.all() });
                 queryClient.invalidateQueries({ queryKey: queryKeys.lessons.all() });
                 queryClient.invalidateQueries({ queryKey: queryKeys.exercises.all() });
                 queryClient.invalidateQueries({
@@ -2592,59 +3088,6 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
     // ============================================================================
     // Core CRUD Operations - Refresh & Get Methods
     // ============================================================================
-    /**
-     * Get single datasource by ID
-     */
-    const useDatasource = (datasourceId, options) => {
-        const principalUid = options?.principalUid;
-        const principalKind = options?.principalKind;
-        return useQuery({
-            queryKey: [
-                ...queryKeys.datasources.detail(datasourceId),
-                principalUid || 'self',
-                principalKind || '',
-            ],
-            queryFn: async () => {
-                const resp = await requestDatalayer({
-                    url: withAccountUidQuery(`${configuration.iamUrl}/api/iam/v1/datasources/${datasourceId}`, principalUid, principalKind),
-                    method: 'GET',
-                });
-                if (resp.success && resp.datasource) {
-                    return toDatasource(resp.datasource);
-                }
-                return null;
-            },
-            ...DEFAULT_QUERY_OPTIONS,
-            enabled: !!datasourceId,
-        });
-    };
-    /**
-     * Update datasource
-     */
-    const useUpdateDatasource = (options) => {
-        const principalUid = options?.principalUid;
-        const principalKind = options?.principalKind;
-        return useMutation({
-            mutationFn: async (datasource) => {
-                return requestDatalayer({
-                    url: withAccountUidQuery(`${configuration.iamUrl}/api/iam/v1/datasources/${datasource.id}`, principalUid, principalKind),
-                    method: 'PUT',
-                    body: { ...datasource },
-                });
-            },
-            onSuccess: resp => {
-                if (resp.success && resp.datasource) {
-                    const ds = toDatasource(resp.datasource);
-                    if (ds) {
-                        queryClient.setQueryData(queryKeys.datasources.detail(ds.id), ds);
-                    }
-                }
-                queryClient.invalidateQueries({
-                    queryKey: queryKeys.datasources.all(),
-                });
-            },
-        });
-    };
     /**
      * Get single secret by ID
      */
@@ -3578,25 +4021,6 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             },
         });
     };
-    /**
-     * Get public courses
-     */
-    const usePublicCourses = () => {
-        return useQuery({
-            queryKey: ['courses', 'public'],
-            queryFn: async () => {
-                const resp = await requestDatalayer({
-                    url: `${configuration.libraryUrl}/api/library/v1/courses/public`,
-                    method: 'GET',
-                });
-                if (resp.success && resp.courses) {
-                    return resp.courses.map((course) => toCourse(course));
-                }
-                return [];
-            },
-            ...DEFAULT_QUERY_OPTIONS,
-        });
-    };
     /**
      * Get instructor courses
      */
@@ -3974,62 +4398,38 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
         });
     };
     /**
-     * Get dataset by ID
+     * Get environment by ID
      */
-    const useDataset = (datasetId, scope) => {
+    const useEnvironment = (environmentId) => {
         return useQuery({
-            queryKey: [
-                ...queryKeys.datasets.detail(datasetId),
-                scope?.selectedPrincipalUid || '',
-                scope?.selectedPrincipalKind || '',
-            ],
+            queryKey: queryKeys.environments.detail(environmentId),
             queryFn: async () => {
-                const params = new URLSearchParams();
-                if (scope?.selectedPrincipalUid) {
-                    params.set('selected_principal_uid', scope.selectedPrincipalUid);
-                }
-                if (scope?.selectedPrincipalKind) {
-                    params.set('selected_principal_kind', scope.selectedPrincipalKind);
-                }
-                const query = params.toString();
                 const resp = await requestDatalayer({
-                    url: `${configuration.runtimesUrl}/api/runtimes/v1/spaces/items/${datasetId}${query ? `?${query}` : ''}`,
+                    url: `${configuration.spacerUrl}/api/spacer/v1/spaces/items/${environmentId}`,
                     method: 'GET',
                 });
                 if (resp.success && resp.item) {
-                    return toDataset(resp.item);
+                    return toEnvironment(resp.item);
                 }
                 return undefined;
             },
-            enabled: !!datasetId,
+            enabled: !!environmentId,
             ...DEFAULT_QUERY_OPTIONS,
         });
     };
     /**
-     * Get datasets by space
+     * Get environments by space
      */
-    const useDatasetsBySpace = (spaceId, scope) => {
+    const useEnvironmentsBySpace = (spaceId) => {
         return useQuery({
-            queryKey: [
-                ...queryKeys.datasets.bySpace(spaceId),
-                scope?.selectedPrincipalUid || '',
-                scope?.selectedPrincipalKind || '',
-            ],
+            queryKey: queryKeys.environments.bySpace(spaceId),
             queryFn: async () => {
-                const params = new URLSearchParams();
-                if (scope?.selectedPrincipalUid) {
-                    params.set('selected_principal_uid', scope.selectedPrincipalUid);
-                }
-                if (scope?.selectedPrincipalKind) {
-                    params.set('selected_principal_kind', scope.selectedPrincipalKind);
-                }
-                const query = params.toString();
                 const resp = await requestDatalayer({
-                    url: `${configuration.runtimesUrl}/api/runtimes/v1/spaces/${spaceId}/items/types/dataset${query ? `?${query}` : ''}`,
+                    url: `${configuration.spacerUrl}/api/spacer/v1/spaces/${spaceId}/items/types/environment`,
                     method: 'GET',
                 });
                 if (resp.success && resp.items) {
-                    return resp.items.map((item) => toDataset(item));
+                    return resp.items.map((item) => toEnvironment(item));
                 }
                 return [];
             },
@@ -4038,95 +4438,20 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
         });
     };
     /**
-     * Update dataset
+     * Get lesson by ID
      */
-    const useUpdateDataset = () => {
-        return useMutation({
-            mutationFn: async ({ id, name, description, selectedPrincipalUid, selectedPrincipalKind, }) => {
-                const params = new URLSearchParams();
-                if (selectedPrincipalUid) {
-                    params.set('selected_principal_uid', selectedPrincipalUid);
-                }
-                if (selectedPrincipalKind) {
-                    params.set('selected_principal_kind', selectedPrincipalKind);
-                }
-                const query = params.toString();
-                return requestDatalayer({
-                    url: `${configuration.runtimesUrl}/api/runtimes/v1/datasets/${id}${query ? `?${query}` : ''}`,
-                    method: 'PUT',
-                    body: { name, description },
+    const useLesson = (lessonId) => {
+        return useQuery({
+            queryKey: queryKeys.lessons.detail(lessonId),
+            queryFn: async () => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.spacerUrl}/api/spacer/v1/lessons/${lessonId}`,
+                    method: 'GET',
                 });
-            },
-            onSuccess: (resp, { id, spaceId }) => {
-                if (resp.success) {
-                    // Invalidate detail and list queries
-                    queryClient.invalidateQueries({
-                        queryKey: queryKeys.datasets.detail(id),
-                    });
-                    if (spaceId) {
-                        queryClient.invalidateQueries({
-                            queryKey: queryKeys.datasets.bySpace(spaceId),
-                        });
-                    }
+                if (resp.success && resp.lesson) {
+                    return toLesson(resp.lesson);
                 }
-            },
-        });
-    };
-    /**
-     * Get environment by ID
-     */
-    const useEnvironment = (environmentId) => {
-        return useQuery({
-            queryKey: queryKeys.environments.detail(environmentId),
-            queryFn: async () => {
-                const resp = await requestDatalayer({
-                    url: `${configuration.spacerUrl}/api/spacer/v1/spaces/items/${environmentId}`,
-                    method: 'GET',
-                });
-                if (resp.success && resp.item) {
-                    return toEnvironment(resp.item);
-                }
-                return undefined;
-            },
-            enabled: !!environmentId,
-            ...DEFAULT_QUERY_OPTIONS,
-        });
-    };
-    /**
-     * Get environments by space
-     */
-    const useEnvironmentsBySpace = (spaceId) => {
-        return useQuery({
-            queryKey: queryKeys.environments.bySpace(spaceId),
-            queryFn: async () => {
-                const resp = await requestDatalayer({
-                    url: `${configuration.spacerUrl}/api/spacer/v1/spaces/${spaceId}/items/types/environment`,
-                    method: 'GET',
-                });
-                if (resp.success && resp.items) {
-                    return resp.items.map((item) => toEnvironment(item));
-                }
-                return [];
-            },
-            enabled: !!spaceId,
-            ...DEFAULT_QUERY_OPTIONS,
-        });
-    };
-    /**
-     * Get lesson by ID
-     */
-    const useLesson = (lessonId) => {
-        return useQuery({
-            queryKey: queryKeys.lessons.detail(lessonId),
-            queryFn: async () => {
-                const resp = await requestDatalayer({
-                    url: `${configuration.spacerUrl}/api/spacer/v1/lessons/${lessonId}`,
-                    method: 'GET',
-                });
-                if (resp.success && resp.lesson) {
-                    return toLesson(resp.lesson);
-                }
-                return undefined;
+                return undefined;
             },
             enabled: !!lessonId,
             ...DEFAULT_QUERY_OPTIONS,
@@ -4730,6 +5055,31 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
     /**
      * Launch bulk emails for outbound campaign (production mode)
      */
+    /**
+     * Mark an outbound as launched without sending — for launches that
+     * happened outside the browser (curl, the CLI).
+     */
+    const useMarkOutboundLaunched = () => {
+        const queryClient = useQueryClient();
+        return useMutation({
+            mutationFn: async (outboundId) => {
+                return requestDatalayer({
+                    url: `${configuration.growthUrl}/api/growth/v1/outbounds/${outboundId}/mark-launched`,
+                    method: 'POST',
+                    body: {},
+                });
+            },
+            onSuccess: (_, outboundId) => {
+                queryClient.removeQueries({
+                    queryKey: ['outbounds', outboundId],
+                });
+                queryClient.invalidateQueries({
+                    queryKey: ['outbounds'],
+                    refetchType: 'inactive',
+                });
+            },
+        });
+    };
     const useLaunchBulkEmailsOutbounds = () => {
         const queryClient = useQueryClient();
         return useMutation({
@@ -5957,35 +6307,721 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
     /**
      * Search public items (notebooks, documents, etc.)
      */
+    /**
+     * Every artifact type a library card is drawn for. One list, so a caller
+     * that wants "everything" cannot accidentally ask for the six types someone
+     * wrote out by hand two releases ago.
+     *
+     * `deck` is here because the administration page's "not in the ribbon" list
+     * asks for this default: without it a published deck was in the library and
+     * could be found by searching, but was never offered to be featured.
+     */
+    const LIBRARY_ARTIFACT_TYPES = [
+        'notebook',
+        'document',
+        'deck',
+        'cell',
+        'lesson',
+        'exercise',
+        'assignment',
+        'course',
+        'evalset',
+        'dataset',
+        'agent',
+    ];
+    const librarySearchQueryString = ({ q, types, max = 20, offset = 0, sort = 'relevance', featured = false, owner, }) => {
+        const normalizedTypes = Array.from(new Set((types || [])
+            .map(type => String(type || '')
+            .trim()
+            .toLowerCase())
+            .filter(Boolean)
+            .map(type => (type === 'eval' ? 'evalset' : type))));
+        const params = {
+            q: q || '*',
+            types: (normalizedTypes.length > 0
+                ? normalizedTypes
+                : LIBRARY_ARTIFACT_TYPES).join(' '),
+            max: String(max),
+            offset: String(offset),
+            sort,
+        };
+        if (featured) {
+            params.featured = 'true';
+        }
+        if (owner) {
+            params.owner = owner;
+        }
+        return Object.entries(params)
+            .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
+            .join('&');
+    };
+    const searchLibrary = async (args) => {
+        const resp = await requestDatalayer({
+            url: `${configuration.libraryUrl}/api/library/v1/search?${librarySearchQueryString(args)}`,
+            method: 'GET',
+        });
+        if (!resp.success) {
+            throw new Error(resp.message || 'Failed to search the library');
+        }
+        return {
+            items: (resp.items || [])
+                .map((item) => toItem(item))
+                .filter(Boolean),
+            total: Number(resp.total ?? 0),
+            offset: Number(resp.offset ?? args.offset ?? 0),
+        };
+    };
+    /**
+     * Search the library: one request, whatever mix of artifact types is asked
+     * for, with the total so a caller can page without asking twice.
+     *
+     * Answers `{ items, total, offset }` rather than a bare array — a result
+     * page without its total cannot be paged, and every caller was inventing
+     * "there is probably more" from the length it got.
+     */
     const useSearchPublicItems = () => {
         return useMutation({
-            mutationFn: async ({ q, types = ['notebook', 'document', 'cell', 'lesson', 'evalset', 'course'], max = 100, }) => {
-                const normalizedTypes = Array.from(new Set((types || [])
-                    .map(type => String(type || '')
-                    .trim()
-                    .toLowerCase())
-                    .filter(Boolean)
-                    .map(type => (type === 'eval' ? 'evalset' : type))));
-                const queryString = Object.entries({
-                    q: q || '*',
-                    types: (normalizedTypes.length > 0
-                        ? normalizedTypes
-                        : ['notebook', 'document', 'cell', 'lesson', 'evalset', 'course']).join(' '),
-                    max: max.toString(),
-                })
-                    .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
-                    .join('&');
+            mutationFn: async (args) => searchLibrary(args),
+        });
+    };
+    /**
+     * Everything the library holds, as a query rather than a mutation.
+     *
+     * For the administration page, which has to show what *could* be featured
+     * as well as what is. Publishing the agent catalogue puts artifacts in the
+     * library; without this the page reported "6 agents published" and then
+     * listed none of them, because the only list it had was the featured one.
+     */
+    const useLibraryArtifacts = (max = 100, options) => {
+        return useQuery({
+            queryKey: [...queryKeys.items.all(), 'library-artifacts', max],
+            queryFn: async () => searchLibrary({ max, sort: 'recent' }),
+            ...options,
+        });
+    };
+    /**
+     * The featured artifacts, for the home page's ribbon.
+     *
+     * Anonymous-safe: the library answers this one without a token, and the
+     * service holds it for a minute, so a visit costs the platform nothing.
+     */
+    const useFeaturedItems = (max = 12, options) => {
+        return useQuery({
+            queryKey: [...queryKeys.items.featured(), max],
+            queryFn: async () => {
                 const resp = await requestDatalayer({
-                    url: `${configuration.libraryUrl}/api/library/v1/search?${queryString}`,
+                    url: `${configuration.libraryUrl}/api/library/v1/featured?max=${max}`,
                     method: 'GET',
                 });
                 if (!resp.success) {
-                    throw new Error(resp.message || 'Failed to search public items');
+                    throw new Error(resp.message || 'Failed to get the featured artifacts');
                 }
                 return (resp.items || [])
                     .map((item) => toItem(item))
                     .filter(Boolean);
             },
+            staleTime: 60_000,
+            ...options,
+        });
+    };
+    /**
+     * Everything an administrator has actually featured, and nothing else.
+     *
+     * Not `useFeaturedItems`. That one answers for the home page's ribbon: a
+     * public request, capped at what a row can show, ordered for reading. This
+     * one is what the administration page edits — everything featured, in rank
+     * order, however long the list is and whoever it belongs to — so that the
+     * page showing the ribbon's contents is showing the ribbon's contents and
+     * not a page of it. `platform_admin` only.
+     */
+    const useAllFeaturedItems = (options) => {
+        return useQuery({
+            queryKey: [...queryKeys.items.featured(), 'all'],
+            queryFn: async () => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/featured/all`,
+                    method: 'GET',
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to get the featured artifacts');
+                }
+                return (resp.items || [])
+                    .map((item) => toItem(item))
+                    .filter(Boolean);
+            },
+            ...options,
+        });
+    };
+    /**
+     * One public artifact by uid, with its content and its library metadata.
+     *
+     * The public pages used to `fetch` this endpoint themselves, which meant no
+     * token was ever sent and the page could not know whether the visitor
+     * orbits what they are reading.
+     */
+    const usePublicItem = (itemId, options) => {
+        return useQuery({
+            queryKey: queryKeys.items.publicItem(itemId || ''),
+            queryFn: async () => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/public/items/${encodeURIComponent(itemId)}`,
+                    method: 'GET',
+                });
+                if (!resp.success || !resp.item) {
+                    throw new Error(resp.message || 'Failed to get the public artifact');
+                }
+                return toItem(resp.item);
+            },
+            enabled: Boolean(itemId),
+            ...options,
+        });
+    };
+    /** The artifacts this account has published: a public profile page. */
+    const useAccountPublications = (handle, options) => {
+        return useQuery({
+            queryKey: queryKeys.items.byOwner(handle || ''),
+            queryFn: async () => searchLibrary({ owner: handle, max: 100, sort: 'recent' }),
+            enabled: Boolean(handle),
+            ...options,
+        });
+    };
+    /** The artifacts the signed-in visitor orbits. */
+    const useMyOrbits = (offset = 0, max = 20, options) => {
+        return useQuery({
+            queryKey: [...queryKeys.items.orbits(), offset, max],
+            queryFn: async () => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/orbits?offset=${offset}&max=${max}`,
+                    method: 'GET',
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to get the orbits');
+                }
+                return {
+                    items: (resp.items || [])
+                        .map((item) => toItem(item))
+                        .filter(Boolean),
+                    total: Number(resp.total ?? 0),
+                };
+            },
+            ...options,
+        });
+    };
+    /**
+     * What one account orbits, on its public profile.
+     *
+     * Whether it publishes them at all is the service's answer, not this
+     * caller's: `shown` says so, and an account that has not opted in reads the
+     * same as one that orbits nothing.
+     */
+    const useAccountOrbits = (handle, offset = 0, max = 12, options) => {
+        return useQuery({
+            queryKey: [
+                ...queryKeys.items.orbits(),
+                'account',
+                handle || '',
+                offset,
+                max,
+            ],
+            queryFn: async () => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/accounts/${encodeURIComponent(handle)}/orbits?offset=${offset}&max=${max}`,
+                    method: 'GET',
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to get the orbits');
+                }
+                return {
+                    items: (resp.items || [])
+                        .map((item) => toItem(item))
+                        .filter(Boolean),
+                    total: Number(resp.total ?? 0),
+                    shown: Boolean(resp.shown),
+                };
+            },
+            enabled: Boolean(handle),
+            ...options,
+        });
+    };
+    /** Who orbits an artifact. */
+    const useItemOrbiters = (itemId, offset = 0, max = 20, options) => {
+        return useQuery({
+            queryKey: [
+                ...queryKeys.items.orbiters(itemId || ''),
+                offset,
+                max,
+            ],
+            queryFn: async () => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/orbiters?offset=${offset}&max=${max}`,
+                    method: 'GET',
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to get the orbiters');
+                }
+                return {
+                    orbiters: resp.orbiters || [],
+                    total: Number(resp.total ?? 0),
+                };
+            },
+            enabled: Boolean(itemId),
+            ...options,
+        });
+    };
+    /**
+     * What was made of a public artifact (B5-04): every derivation counted by
+     * kind, and the derived artifacts that are public themselves, newest first.
+     */
+    const useItemDerivations = (itemId, offset = 0, max = 20, options) => {
+        return useQuery({
+            queryKey: [
+                ...queryKeys.items.derivations(itemId || ''),
+                offset,
+                max,
+            ],
+            queryFn: async () => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/derivations?offset=${offset}&max=${max}`,
+                    method: 'GET',
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to get the derivations');
+                }
+                return {
+                    derivations: (resp.derivations || []).map((derivation) => ({
+                        kind: String(derivation.kind || ''),
+                        fromVersion: derivation.fromVersion ?? null,
+                        derivedAt: derivation.derivedAt,
+                        item: toItem(derivation.item),
+                    })),
+                    counts: (resp.counts || {}),
+                    total: Number(resp.total ?? 0),
+                };
+            },
+            enabled: Boolean(itemId),
+            ...options,
+        });
+    };
+    /**
+     * Show an artifact as orbited before the server has said so, and put it
+     * back if the server disagrees.
+     *
+     * A star that waits for a round trip feels broken, and the count is on the
+     * button the visitor just pressed. The server answers with a recount, which
+     * is what finally lands in the cache.
+     */
+    const applyOrbitToCaches = (itemId, orbited, orbits) => {
+        const patch = (item) => {
+            if (!item || String(item.id ?? item.uid) !== String(itemId)) {
+                return item;
+            }
+            const nextOrbits = orbits !== undefined
+                ? orbits
+                : Math.max(0, Number(item.orbits || 0) + (orbited ? 1 : -1));
+            return { ...item, orbited, orbits: nextOrbits };
+        };
+        queryClient.setQueriesData({ queryKey: queryKeys.items.all() }, (data) => {
+            if (!data) {
+                return data;
+            }
+            if (Array.isArray(data)) {
+                return data.map(patch);
+            }
+            if (Array.isArray(data.items)) {
+                return { ...data, items: data.items.map(patch) };
+            }
+            if (data.id || data.uid) {
+                return patch(data);
+            }
+            return data;
+        });
+    };
+    const useOrbitItem = () => {
+        return useMutation({
+            mutationFn: async (itemId) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/orbit`,
+                    method: 'PUT',
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to orbit the artifact');
+                }
+                return { itemId, orbits: Number(resp.orbits ?? 0), orbited: true };
+            },
+            onMutate: async (itemId) => {
+                applyOrbitToCaches(itemId, true);
+                return { itemId };
+            },
+            onError: (_error, itemId) => {
+                applyOrbitToCaches(itemId, false);
+            },
+            onSuccess: result => {
+                applyOrbitToCaches(result.itemId, true, result.orbits);
+                queryClient.invalidateQueries({ queryKey: queryKeys.items.orbits() });
+            },
+        });
+    };
+    const useUnorbitItem = () => {
+        return useMutation({
+            mutationFn: async (itemId) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/orbit`,
+                    method: 'DELETE',
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to leave the orbit');
+                }
+                return { itemId, orbits: Number(resp.orbits ?? 0), orbited: false };
+            },
+            onMutate: async (itemId) => {
+                applyOrbitToCaches(itemId, false);
+                return { itemId };
+            },
+            onError: (_error, itemId) => {
+                applyOrbitToCaches(itemId, true);
+            },
+            onSuccess: result => {
+                applyOrbitToCaches(result.itemId, false, result.orbits);
+                queryClient.invalidateQueries({ queryKey: queryKeys.items.orbits() });
+            },
+        });
+    };
+    /** Feature an artifact on the home page. `platform_admin` only. */
+    const useFeatureItem = () => {
+        return useMutation({
+            mutationFn: async ({ itemId, rank, }) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/featured`,
+                    method: 'PUT',
+                    body: { rank: rank ?? null },
+                    // One toast, not two: the caller says which artifact failed and
+                    // why, so the generic report underneath is a duplicate.
+                    notifyOnError: false,
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to feature the artifact');
+                }
+                return resp;
+            },
+            onSuccess: () => {
+                invalidateEverywhere(queryClient, queryKeys.items.all());
+            },
+        });
+    };
+    const useUnfeatureItem = () => {
+        return useMutation({
+            mutationFn: async (itemId) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/featured`,
+                    method: 'DELETE',
+                    // One toast, not two: the caller says which artifact failed and
+                    // why, so the generic report underneath is a duplicate.
+                    notifyOnError: false,
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to unfeature the artifact');
+                }
+                return resp;
+            },
+            onSuccess: () => {
+                invalidateEverywhere(queryClient, queryKeys.items.all());
+            },
+        });
+    };
+    const useSetFeaturedRank = () => {
+        return useMutation({
+            mutationFn: async ({ itemId, rank, }) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/featured`,
+                    method: 'PATCH',
+                    body: { rank },
+                    // One toast, not two: the caller says which artifact failed and
+                    // why, so the generic report underneath is a duplicate.
+                    notifyOnError: false,
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to move the artifact');
+                }
+                return resp;
+            },
+            onSuccess: () => {
+                invalidateEverywhere(queryClient, queryKeys.items.featured());
+            },
+        });
+    };
+    /**
+     * Refresh everything that carries an artifact's public flag or its image.
+     *
+     * `items` and `spaces` cover the library listings, but an artifact opened in
+     * an editor is read through its own per-type query — `notebooks.detail(id)`
+     * for the editor, `notebooks.bySpace(id)` for the table — and neither
+     * shares a prefix with either of those. Leaving them alone is what made the
+     * Publish button keep saying "Publish" after publishing, and "Published"
+     * after withdrawing: the mutation succeeded, the cached copy still held the
+     * old `is_public_b`, and nothing asked for it again for five minutes.
+     *
+     * A course is a space, but it is not read through the `spaces` queries: it
+     * has a namespace of its own, so publishing one from its header left the
+     * course page holding the `public` flag it loaded with and the button
+     * saying the opposite of what had just happened.
+     *
+     * **`refetchType: 'all'`, which is what makes any of the above work.**
+     *
+     * Naming a query is not the same as making it ask again. The default,
+     * `'active'`, refetches the queries something is currently watching and
+     * leaves the rest marked stale — right nearly everywhere, and wrong here,
+     * because this application sets `refetchOnMount: false` (see
+     * `DEFAULT_QUERY_OPTIONS`, and the client the web application builds). A
+     * query that mounts holding stale data renders it and asks for nothing.
+     *
+     * So publishing worked exactly once. The editor it was published from was
+     * mounted and flipped its button; the notebooks table, the library, the
+     * search page and the artifact's own public page were not, and kept the
+     * answer they already had. Come back to the editor after that and *it* is
+     * now the page that was not mounted for the next withdrawal, so its button
+     * is wrong too — which is what "it works the first time" means.
+     *
+     * The whole of each type's namespace, not only its `details()`. A table
+     * lists its artifacts under `bySpace(spaceId)`, which shares no prefix with
+     * `detail(id)` — so publishing from an editor and walking back to the table
+     * showed the row exactly as it was, switch and all.
+     *
+     * The `model` queries are the one thing held out. A notebook's model is its
+     * content, megabytes of it, and it lives *under* `detail(id)` — so
+     * refetching a namespace would pull every open notebook's content over the
+     * wire each time somebody pressed Publish. Whether an artifact is public
+     * says nothing about what is in it.
+     */
+    const invalidateArtifactVisibility = () => {
+        const refetchType = 'all';
+        /** Everything about an artifact except what is written in it. */
+        const notItsContent = (query) => query.queryKey[query.queryKey.length - 1] !== 'model';
+        queryClient.invalidateQueries({
+            queryKey: queryKeys.items.all(),
+            refetchType,
+        });
+        queryClient.invalidateQueries({ queryKey: ['spaces'], refetchType });
+        for (const namespace of [
+            queryKeys.notebooks.all(),
+            queryKeys.documents.all(),
+            queryKeys.decks.all(),
+            queryKeys.cells.all(),
+            queryKeys.lessons.all(),
+            queryKeys.exercises.all(),
+            queryKeys.assignments.all(),
+            queryKeys.courses.all(),
+        ]) {
+            queryClient.invalidateQueries({
+                queryKey: namespace,
+                refetchType,
+                predicate: notItsContent,
+            });
+        }
+    };
+    /**
+     * What an artifact looks like in the library: a capture the publisher took,
+     * the box drawn for its kind, or an icon from the Datalayer set.
+     */
+    const useSetItemImage = () => {
+        return useMutation({
+            mutationFn: async ({ itemId, kind, ref, data, }) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/image`,
+                    method: 'PUT',
+                    body: { kind, ref, data },
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to set the image');
+                }
+                return resp.image;
+            },
+            onSuccess: invalidateArtifactVisibility,
+        });
+    };
+    const useResetItemImage = () => {
+        return useMutation({
+            mutationFn: async (itemId) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/image`,
+                    method: 'DELETE',
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to reset the image');
+                }
+                return resp.image;
+            },
+            onSuccess: invalidateArtifactVisibility,
+        });
+    };
+    /**
+     * Tell the library that an artifact was reused: cloned into a space, or
+     * instantiated as a runtime. The reuse itself belongs to the service that
+     * performed it, so this is a count, not the act.
+     */
+    const useCountItemReuse = () => {
+        return useMutation({
+            mutationFn: async ({ itemId, kind, }) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/reused`,
+                    method: 'POST',
+                    body: { kind },
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to count the reuse');
+                }
+                return resp;
+            },
+        });
+    };
+    /**
+     * Publish the platform's own catalogue — the agents — into the library.
+     * `platform_admin` only; the catalogue lives in this application's build.
+     */
+    const useSyncArtifactCatalogue = () => {
+        return useMutation({
+            mutationFn: async ({ artifacts, artifactType = 'agent', }) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/artifacts/sync`,
+                    method: 'PUT',
+                    body: { artifact_type: artifactType, artifacts },
+                    // One toast, not two: the caller says which artifact failed and
+                    // why, so the generic report underneath is a duplicate.
+                    notifyOnError: false,
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to synchronize the catalogue');
+                }
+                return resp;
+            },
+            onSuccess: () => {
+                invalidateEverywhere(queryClient, queryKeys.items.all());
+            },
+        });
+    };
+    /**
+     * Publish an artifact in the library: choose its image, then make it
+     * public.
+     *
+     * The one place that publishes. It used to be a `ToggleSwitch` in each of
+     * seven tables and three editors, each with its own copy of the mutation
+     * and its own idea of what to roll back; publishing is an act with
+     * consequences a switch cannot express — a picture to choose, a public page
+     * that appears, a search it enters.
+     *
+     * The image is set first: a failure there leaves the artifact private, which
+     * is recoverable by trying again, where the reverse would publish something
+     * showing the wrong picture.
+     */
+    const usePublishArtifact = () => {
+        const setImage = useSetItemImage();
+        return useMutation({
+            mutationFn: async ({ itemId, image, tags, description, }) => {
+                /*
+                 * Publish first, then dress it.
+                 *
+                 * The image used to be set before the artifact was made public, so
+                 * that a picture that would not take left it private rather than
+                 * published with the wrong one. That order could never work: the
+                 * library indexes public artifacts, so a private one has no
+                 * projection, and setting an image on it answered "The artifact is
+                 * not found" — every first publish with a picture failed.
+                 *
+                 * The intent survives the reordering. The artifact goes public, which
+                 * is what creates the projection; if the picture then will not take,
+                 * it is withdrawn again and the message still tells the truth.
+                 */
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/public`,
+                    method: 'PATCH',
+                    body: {
+                        is_public: true,
+                        // Absent, not null: the service reads "leave it alone" from a
+                        // missing key, and a caller that does not know an artifact's
+                        // words must not be able to clear them by omission.
+                        ...(tags === undefined ? {} : { tags }),
+                        ...(description === undefined ? {} : { description }),
+                    },
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to publish the artifact');
+                }
+                if (image) {
+                    try {
+                        await setImage.mutateAsync({ itemId, ...image });
+                    }
+                    catch (error) {
+                        // Back to private, so the artifact is never left public wearing
+                        // the drawing the publisher did not choose.
+                        try {
+                            await requestDatalayer({
+                                url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/public`,
+                                method: 'PATCH',
+                                body: { is_public: false },
+                            });
+                        }
+                        catch {
+                            // The withdrawal failed too; the error below is still the one
+                            // worth showing, and it is the more actionable of the two.
+                        }
+                        throw new Error(`The image could not be set, so the artifact stays private: ${error?.message || 'unknown error'}`, { cause: error });
+                    }
+                }
+                return resp;
+            },
+            onSuccess: invalidateArtifactVisibility,
+        });
+    };
+    /**
+     * Withdraw an artifact from the library. Its orbits are kept: publishing it
+     * again brings them back.
+     */
+    /**
+     * Rename a published artifact, or change what it says about itself.
+     *
+     * The words belong to the artifact rather than to the library — the
+     * library holds a projection of them — so the library service writes the
+     * artifact's own source and that write carries the change into the index.
+     * Which is why this is one request and not two.
+     *
+     * Every field is optional and every one means "leave it alone" when
+     * omitted, so a caller may change one without knowing the others.
+     */
+    const useUpdateArtifactDetails = () => {
+        return useMutation({
+            mutationFn: async ({ itemId, name, description, tags, }) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}`,
+                    method: 'PATCH',
+                    body: {
+                        ...(name === undefined ? {} : { name }),
+                        ...(description === undefined ? {} : { description }),
+                        ...(tags === undefined ? {} : { tags }),
+                    },
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to update the artifact');
+                }
+                return resp;
+            },
+            // The same fan-out publishing uses: a rename changes the card in every
+            // listing, the editor's own copy, and the artifact's public page.
+            onSuccess: invalidateArtifactVisibility,
+        });
+    };
+    const useUnpublishArtifact = () => {
+        return useMutation({
+            mutationFn: async (itemId) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/public`,
+                    method: 'PATCH',
+                    body: { is_public: false },
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to withdraw the artifact');
+                }
+                return resp;
+            },
+            onSuccess: invalidateArtifactVisibility,
         });
     };
     // ============================================================================
@@ -6342,28 +7378,6 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             ...options,
         });
     };
-    /**
-     * Refresh public courses list
-     * @param options - Mutation options
-     */
-    const useRefreshPublicCourses = (options) => {
-        const queryClient = useQueryClient();
-        return useMutation({
-            mutationFn: async () => {
-                const resp = await requestDatalayer({
-                    url: `${configuration.libraryUrl}/api/library/v1/courses/public`,
-                    method: 'GET',
-                });
-                return resp;
-            },
-            onSuccess: () => {
-                queryClient.invalidateQueries({
-                    queryKey: queryKeys.courses.public(),
-                });
-            },
-            ...options,
-        });
-    };
     /**
      * Refresh instructor courses list
      * @param options - Mutation options
@@ -6572,82 +7586,6 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             ...options,
         });
     };
-    /**
-     * Refresh a specific dataset
-     * @param options - Mutation options
-     */
-    const useRefreshDataset = (options) => {
-        const queryClient = useQueryClient();
-        return useMutation({
-            mutationFn: async (variables) => {
-                const datasetId = typeof variables === 'string' ? variables : variables.datasetId;
-                const selectedPrincipalUid = typeof variables === 'string'
-                    ? undefined
-                    : variables.selectedPrincipalUid;
-                const selectedPrincipalKind = typeof variables === 'string'
-                    ? undefined
-                    : variables.selectedPrincipalKind;
-                const params = new URLSearchParams();
-                if (selectedPrincipalUid) {
-                    params.set('selected_principal_uid', selectedPrincipalUid);
-                }
-                if (selectedPrincipalKind) {
-                    params.set('selected_principal_kind', selectedPrincipalKind);
-                }
-                const query = params.toString();
-                const resp = await requestDatalayer({
-                    url: `${configuration.runtimesUrl}/api/runtimes/v1/spaces/items/${datasetId}${query ? `?${query}` : ''}`,
-                    method: 'GET',
-                });
-                return resp;
-            },
-            onSuccess: (data, variables) => {
-                const datasetId = typeof variables === 'string' ? variables : variables.datasetId;
-                queryClient.invalidateQueries({
-                    queryKey: queryKeys.datasets.detail(datasetId),
-                });
-            },
-            ...options,
-        });
-    };
-    /**
-     * Refresh space datasets
-     * @param options - Mutation options
-     */
-    const useRefreshSpaceDatasets = (options) => {
-        const queryClient = useQueryClient();
-        return useMutation({
-            mutationFn: async (variables) => {
-                const spaceId = typeof variables === 'string' ? variables : variables.spaceId;
-                const selectedPrincipalUid = typeof variables === 'string'
-                    ? undefined
-                    : variables.selectedPrincipalUid;
-                const selectedPrincipalKind = typeof variables === 'string'
-                    ? undefined
-                    : variables.selectedPrincipalKind;
-                const params = new URLSearchParams();
-                if (selectedPrincipalUid) {
-                    params.set('selected_principal_uid', selectedPrincipalUid);
-                }
-                if (selectedPrincipalKind) {
-                    params.set('selected_principal_kind', selectedPrincipalKind);
-                }
-                const query = params.toString();
-                const resp = await requestDatalayer({
-                    url: `${configuration.runtimesUrl}/api/runtimes/v1/spaces/${spaceId}/items/types/dataset${query ? `?${query}` : ''}`,
-                    method: 'GET',
-                });
-                return resp;
-            },
-            onSuccess: (data, variables) => {
-                const spaceId = typeof variables === 'string' ? variables : variables.spaceId;
-                queryClient.invalidateQueries({
-                    queryKey: queryKeys.datasets.bySpace(spaceId),
-                });
-            },
-            ...options,
-        });
-    };
     /**
      * Refresh schools list
      * @param options - Mutation options
@@ -6668,28 +7606,6 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             ...options,
         });
     };
-    /**
-     * Get public items (query hook)
-     * @param options - Query options
-     */
-    const usePublicItems = (options) => {
-        return useQuery({
-            queryKey: queryKeys.items.public(),
-            queryFn: async () => {
-                const resp = await requestDatalayer({
-                    url: `${configuration.libraryUrl}/api/library/v1/search?q=*&max=-1`,
-                    method: 'GET',
-                });
-                return {
-                    ...resp,
-                    items: (resp.items || [])
-                        .map((item) => toItem(item))
-                        .filter(Boolean),
-                };
-            },
-            ...options,
-        });
-    };
     /**
      * Get the current user's own public items (publications).
      * @param options - Query options
@@ -6712,31 +7628,6 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             ...options,
         });
     };
-    /**
-     * Refresh public items
-     * @param options - Mutation options
-     */
-    const useRefreshPublicItems = (options) => {
-        const queryClient = useQueryClient();
-        return useMutation({
-            mutationFn: async () => {
-                const resp = await requestDatalayer({
-                    url: `${configuration.libraryUrl}/api/library/v1/search?q=*&max=-1`,
-                    method: 'GET',
-                });
-                return {
-                    ...resp,
-                    items: (resp.items || [])
-                        .map((item) => toItem(item))
-                        .filter(Boolean),
-                };
-            },
-            onSuccess: () => {
-                queryClient.invalidateQueries({ queryKey: queryKeys.items.public() });
-            },
-            ...options,
-        });
-    };
     /**
      * Refresh space items
      * @param options - Mutation options
@@ -7514,7 +8405,6 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
         // Courses
         useCourse,
         useUpdateCourse,
-        usePublicCourses,
         useInstructorCourses,
         useCourseEnrollments,
         useEnrollStudentToCourse,
@@ -7524,7 +8414,6 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
         useConfirmCourseItemCompletion,
         useSetCourseItems,
         useRefreshCourse,
-        useRefreshPublicCourses,
         useRefreshInstructorCourses,
         useRefreshCoursesEnrollments,
         useRefreshStudent,
@@ -7537,6 +8426,13 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
         useCloneNotebook,
         useRefreshNotebook,
         useRefreshSpaceNotebooks,
+        // Decks
+        useDeck,
+        useDecksBySpace,
+        useCreateDeck,
+        useUpdateDeck,
+        useUpdateDeckModel,
+        useCloneDeck,
         // Documents
         useDocument,
         useDocumentsBySpace,
@@ -7553,12 +8449,6 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
         useCloneCell,
         useRefreshCell,
         useRefreshSpaceCells,
-        // Datasets
-        useDataset,
-        useDatasetsBySpace,
-        useUpdateDataset,
-        useRefreshDataset,
-        useRefreshSpaceDatasets,
         // Environments
         useEnvironment,
         useEnvironmentsBySpace,
@@ -7596,23 +8486,33 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
         useMakeItemPublic,
         useMakeItemPrivate,
         useSearchPublicItems,
-        usePublicItems,
+        useLibraryArtifacts,
         usePublications,
-        useRefreshPublicItems,
+        // Library (search, orbits, featuring, images, reuse)
+        useFeaturedItems,
+        useAllFeaturedItems,
+        usePublicItem,
+        useAccountPublications,
+        useMyOrbits,
+        useAccountOrbits,
+        useItemOrbiters,
+        useItemDerivations,
+        useOrbitItem,
+        useUnorbitItem,
+        useFeatureItem,
+        useUnfeatureItem,
+        useSetFeaturedRank,
+        useSetItemImage,
+        useResetItemImage,
+        useCountItemReuse,
+        useSyncArtifactCatalogue,
+        usePublishArtifact,
+        useUnpublishArtifact,
+        useUpdateArtifactDetails,
         useRefreshSpaceItems,
         useClearCachedPublicItems,
         useClearCachedItems,
         // Pages
-        usePage,
-        usePages,
-        useCreatePage,
-        useUpdatePage,
-        useDeletePage,
-        // Datasources
-        useDatasource,
-        useDatasources,
-        useCreateDatasource,
-        useUpdateDatasource,
         // Secrets
         useSecret,
         useSecrets,
@@ -7661,6 +8561,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
         useDraftBulkEmailsOutbounds,
         useTryBulkEmailsOutbounds,
         useLaunchBulkEmailsOutbounds,
+        useMarkOutboundLaunched,
         useSendOutboundEmailToUser,
         useDeleteOutbound,
         useSubscribeUserToOutbounds,
@@ -7710,6 +8611,9 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
         documentUploadLoading,
         documentUploadProgress,
         resetDocumentUpload,
+        deckUploadLoading,
+        deckUploadProgress,
+        resetDeckUpload,
     };
 };
 export default useCache;