@pitcher/js-api 1.29.0 → 1.31.0

package/lib/components/masterCanvases/masterFromCanvas.use.d.ts

@@ -0,0 +1,122 @@
+import { CanvasRetrieve } from '../../../types/openapi';
+/**
+ * PIT-7488 block 3 — turning an existing pitchdeck into a master.
+ *
+ * The deck is DUPLICATED, never mutated: the rep keeps the deck they were presenting, and a new
+ * `is_master` copy appears on the master tab.
+ *
+ * **The promoter owns the master, always — so the create payload must OMIT `owned_by_id`**
+ * (PIT-8362; the payload itself is `buildMasterFromCanvasPayload`, beside its block-4 mirror in
+ * `createFromMaster.use`). Django declares that field
+ * `default=CreateOnlyDefault(CurrentUserDefault())`, so leaving it out is precisely what assigns
+ * the caller; sending anything is a transfer, which `CanvasOwnedByFieldValidator` 400s for anyone
+ * but an org/instance admin.
+ *
+ * This reverses block 3's original rule, so read the history before "fixing" it back. That rule
+ * kept the SOURCE deck's owner, on the reasoning that a master should stay attributed to whoever
+ * built the deck. Vontobel's validation rejected it: "My Master Pitchdecks" is a personal,
+ * RESTRICTED, owner-scoped tab that the promote flow navigates to on success, so a master owned by
+ * someone else lands in a tab it does not belong in — invisible to a rep (`filter_by_member_access`
+ * is `owned_by=me OR public`), and attributed to a stranger for an admin, who sees the whole
+ * instance anyway.
+ */
+/**
+ * Context keys that must NOT survive onto a master.
+ *
+ * A master is a reusable *source*, so anything baked into its context propagates to every deck
+ * built from it later — `{{user.name}}` would render whoever ran "Use as master" rather than the
+ * rep actually presenting. That is the wrong-identity-on-a-copy defect class, one step upstream, and it is the
+ * same reasoning that keeps the master download path from PATCHing `context`.
+ *
+ * This is a DENYLIST on purpose. `pitcher_canvas.context` is a free-form client-written
+ * JSONField that also carries customer-specific keys, so an allowlist would silently drop those,
+ * and would drop any config key added later — which is exactly how PIT-7473 broke the pitchdeck
+ * wizard. Failing this way round means a *new* identity key leaks until it is listed here, which
+ * shows up as a visibly wrong name on a deck and is a one-line fix.
+ */
+export declare const MASTER_CONTEXT_IDENTITY_KEYS: readonly ["user", "today", "Account", "salesforce_data", "Meeting", "pitcher_data", "analytics", "account", "meeting", "SelectedAccount"];
+/**
+ * Top-level context key FAMILIES that are identity, matched by prefix rather than by name.
+ *
+ * `ctx_overwrite_<slideIndex>` is written by the `react-salesforce-admin` populator
+ * (`public/populator.html:509-525`) and holds BOTH a `pitcher_data` and a `salesforce_data` copy of
+ * a matched customer record, scoped to one slide — the same two namespaces
+ * `MASTER_CONTEXT_IDENTITY_KEYS` already strips at the top level, one nesting deeper and therefore
+ * invisible to a literal-key `omit`. A master promoted from a rep's deck carried the promoter's
+ * customer (client name, ids, figures) onto every deck built from it, per slide (PIT-8399 review).
+ *
+ * The key count is unbounded (one per matched slide) and the names embed a component id, so this
+ * cannot be expressed as literals — hence a prefix list.
+ *
+ * **Not to be confused with `context.wizard.overwrite_<sectionListId>_<n>`**, which is the WIZARD's
+ * positional slide override (`buildStepUpdate`) and is curation a master must keep. The two are
+ * cleanly separable: the populator's lives at the top level, the wizard's inside `wizard`.
+ */
+export declare const MASTER_CONTEXT_IDENTITY_KEY_PREFIXES: readonly ["ctx_overwrite_"];
+/** Drops every top-level key matching one of the identity prefixes above. Non-mutating. */
+export declare function withoutPrefixedIdentityKeys(context: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Whether a context carries a wizard artifact the restore could actually rebuild POINTS from.
+ *
+ * Mirrors the two — and only two — skeleton sources of the app's restore walk: the enrichment's
+ * per-point spans (`react_wizard.points`) and the vanilla group selections
+ * (`group_selections_<sectionListId>`). BOTH must be non-empty arrays: `for (const sel of
+ * selections)` and the enrichment loop each build zero skeletons from `[]`, so a present-but-empty
+ * key describes nothing. Checking only the selections KEY made this looser than the app's
+ * `fromArtifact` (which uses `selections.length > 0`) — and on the duplicate path, which has no
+ * second gate, looser means unguarded. Everything else under `wizard` is answers, cover picks or
+ * admin config: the live repro deck carries `selected_assets`, `selected_asset_url`, `selected_file`
+ * and `title`, and the populator reads a `wizard.dataIndexMap` — none of which can rebuild a point.
+ *
+ * So `!!context.wizard` is NOT the same question, and the difference bites hardest in
+ * `buildDuplicateContext`: its marker selects `react_saved`, which resolves to the EDIT flow, whose
+ * restore is deliberately ungated on the app's own `fromArtifact` check (a vanilla deck legitimately
+ * restores by attribution). A master whose `wizard` held only cover picks therefore opened with an
+ * agenda rebuilt by attribution — the PIT-7488 QA Q9 outcome — with nothing downstream to catch it
+ * (peer review F2).
+ *
+ * Deliberately WEAKER than the app's `fromArtifact`, which also requires the enrichment spans to
+ * partition the node's ref list. The host has no refs to hand here, so it answers "are there
+ * skeleton sources at all"; the app makes the precise call. That is the two-gate design, and it is
+ * why the two predicates are allowed to differ.
+ */
+export declare function hasRestorableArtifact(context?: Record<string, unknown> | null): boolean;
+/** Suffix appended to the source deck's name to seed the dialog. Matches the prototype. */
+export declare const MASTER_NAME_SUFFIX = "(master)";
+/**
+ * Strips the identity above out of `context.wizard`, leaving the curation intact.
+ *
+ * Non-mutating — `omit` returns a new object at every level this touches, so the source master's
+ * own context is never altered. A `wizard` (or a `react_wizard`) left with nothing in it is
+ * dropped rather than kept as `{}`, the same rule `withoutPitcherKeys` follows for
+ * `context.pitcher`. A context carrying no `wizard` at all is returned untouched, which is what
+ * makes this safe to compose onto every master-context builder.
+ *
+ * Deliberately does NOT touch `react_wizard.points` / `version`: `restoreAgenda` validates the
+ * enrichment by checking that its per-point `slide_count`s partition the node's ref list exactly,
+ * so pruning identity here cannot invalidate the artifact the agenda is rebuilt from.
+ */
+export declare function withoutWizardIdentity(context: Record<string, unknown>): Record<string, unknown>;
+/**
+ * The context to store on the new master: everything the source deck carried, minus identity.
+ *
+ * Identity is pruned at all THREE places it hides — the top-level keys above, the prefixed
+ * `ctx_overwrite_*` families (`withoutPrefixedIdentityKeys`), and the wizard artifact's own
+ * (`withoutWizardIdentity`). A master promoted from a deck the rep had run the
+ * wizard on carried the promoter's customer in `wizard.subtitle`, which deck templates render on
+ * the cover slide, so the top-level pass alone was not enough (PIT-8399).
+ *
+ * Deliberately NOT gated on `copy_context_to_canvas`. That flag exists because copying context
+ * wholesale was risky, and the risk was the identity keys stripped here — gating on it would
+ * hand flag-off instances a master with no `section_list_config`, reintroducing PIT-7473 for
+ * every deck built from it.
+ *
+ * Returns `undefined` rather than `{}` when nothing survives, so the create payload omits the
+ * field instead of writing an empty object over the server's default.
+ */
+export declare function buildMasterContext(context?: CanvasRetrieve['context'] | null): Record<string, unknown> | undefined;
+/**
+ * Seeds the dialog's name field. The rep can overwrite it; the suffix only exists so the master
+ * is distinguishable from the deck it came from in a list sorted by name.
+ */
+export declare function defaultMasterNameFor(sourceName?: string | null): string;

package/lib/components/masterCanvases/masterFromCanvas.use.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/masterCanvases/masterFromTemplate.use.d.ts

@@ -0,0 +1,50 @@
+import { CanvasCreateRequest, CanvasRetrieve } from '../../../types/openapi';
+/**
+ * PIT-7488 — creating a master FROM AN ADMIN TEMPLATE.
+ *
+ * The fourth and last of the master copy paths, and the one that was missing: block 3 is
+ * deck -> master (`buildMasterContext`), block 4 is master -> deck (`buildContextFromMaster`),
+ * block 5 is master -> shared copy (next-core's `buildSharedCopyContext`), and this is
+ * template -> master.
+ *
+ * It exists because **Django does not clone a template server-side.** `POST /canvases` stores
+ * `template_id` as a plain FK and nothing else, so every create path clones client-side —
+ * `canvas.create.ts` for pitchdecks, `buildCreateFromMasterPayload` for decks from masters. The
+ * master tab was the one path that never did, so a master built from a template was created
+ * EMPTY: no `content` means no `SectionList`/`ContentList` nodes, and
+ * `useCanvasCompletionWizard.isCompletionWizardEnabled` is `wizardSteps.length > 0`, so the
+ * pitchdeck wizard could never run on it either. One missing clone, two reported symptoms.
+ *
+ * Not built on `slotty-ui-ng`'s shared `createCanvas` util on purpose: that util assigns
+ * `content`/`theme`/`context` AFTER spreading the caller's payload, so a sanitized master context
+ * cannot be passed in — and what it writes instead is wrong in both flag states (with
+ * `copy_context_to_canvas` on it copies the template context wholesale, identity and completed
+ * wizard state included; with it off it writes `{}`, losing `section_list_config`). It also
+ * prompts for an account and merges CRM data into the context on orgs with
+ * `require_account_on_canvas_creation`, which no master may carry.
+ */
+/** The narrow slice of a fetched template this needs — request it as `fields=content,theme,context`. */
+export interface MasterTemplateSource extends Pick<CanvasRetrieve, 'content' | 'theme' | 'context'> {
+}
+/** The create-payload fields to spread over the master's own invariants. */
+export interface MasterFromTemplatePayload extends Pick<CanvasCreateRequest, 'content' | 'theme' | 'context'> {
+}
+/**
+ * Builds the `content`/`theme`/`context` a master should inherit from the template it was created
+ * from. Pure, non-mutating, and **deliberately ungated**.
+ *
+ * Not gated on `copy_context_to_canvas` for the same reason `buildMasterContext` is not: that flag
+ * exists because copying context wholesale was risky, and the risk *is* the identity keys stripped
+ * here. Gating on it would hand flag-off instances a master with no `section_list_config`, which is
+ * PIT-7473 reintroduced for every deck later built from that master.
+ *
+ * `metadata` is deliberately NOT copied. Nothing the wizard reads lives there, and a template's
+ * metadata carries its own bookkeeping — the async-download record (`job_id`, `pdf_url`, `pptx_url`,
+ * `conversion_date`) and `frozen_until`, which would make a brand-new master born read-only and
+ * offering a download of the TEMPLATE. Having none is the truthful state for a new master.
+ *
+ * Every field is omitted rather than emitted as `undefined`/`{}` when there is nothing to carry, so
+ * the no-template case ("New master pitchdeck") posts byte-identical to what it posts today instead
+ * of writing empty objects over the server's defaults.
+ */
+export declare function buildMasterFromTemplatePayload(template?: MasterTemplateSource | null): MasterFromTemplatePayload;

package/lib/components/masterCanvases/masterFromTemplate.use.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/savedCanvases/CSavedCanvasesManagement.use.d.ts

@@ -4,6 +4,209 @@ export type FreezeStatus = 'active' | 'expired' | null;
 export declare function getFreezeStatus(canvas: Pick<CanvasRetrieve, 'metadata'>): FreezeStatus;
 export declare const SYSTEM_EXCLUDED_TAGS: readonly ["home", "share", "sharebox"];
 export declare function hasHidingTag(tags?: string[], dynamicTags?: string[]): boolean;
+export declare function isTemplateHiddenFromReps(canvas: Pick<CanvasRetrieve, 'tags' | 'template'>, rendererExcludedTags?: string[]): boolean;
+/**
+ * PIT-7488 — which canvas list `CSavedCanvasesManagement` is rendering.
+ *
+ * Everything the variant changes lives in the pure resolvers below rather than inline in the
+ * SFC, because three of them guard state that is SHARED between simultaneously-reachable
+ * instances of the component (localStorage / sessionStorage), where a wrong answer shows up as
+ * the other tab misbehaving and is invisible in normal single-tab use.
+ */
+export type CanvasesManagementVariant = 'pitchdecks' | 'masters';
+export declare function isMastersVariant(variant?: CanvasesManagementVariant): boolean;
+/**
+ * Smart folders are a pitchdeck-only view. `isSmartFoldersView` is a `useLocalStorage`, shared
+ * across every instance of the component, so without the variant guard a rep who switched the
+ * Pitchdecks tab to smart folders would find the master tab rendering `SmartFolders` — which
+ * lists ordinary pitchdecks. Masters aren't foldered, so they have no smart-folder equivalent.
+ */
+export declare function resolveCanvasesView(opts: {
+    isMasters: boolean;
+    smartFoldersEnabled?: boolean;
+    isSmartFoldersView?: boolean;
+}): 'smartFolders' | 'normal';
+/**
+ * The localStorage key `useTableColumnsSettings` persists show/hide/reorder under. Must differ
+ * per variant: a shared key lets the two tabs overwrite each other's layout, and writes the
+ * masters-only `shared_with` column into the pitchdeck tab's saved settings.
+ *
+ * The masters key is `ciq_master_canvases_management_table_columns_settings`. It was renamed off
+ * `…master_pitchdecks…` with the rest of the feature, which resets any column layout a tester had
+ * already saved on the master tab — once, and only for that tab.
+ */
+export declare function resolveColumnSettingsKey(isMasters: boolean): string;
+/**
+ * Which `canvas_manager_table_columns` key to read LD column visibility from. Masters get their
+ * own so ops can configure the two lists independently — `getVisibleColumns` degrades to "show
+ * every column" when the key is absent, whereas reusing `canvases` would mean hiding a column on
+ * the Pitchdecks tab silently hid it here too.
+ *
+ * The masters key is now `master_canvases`: ops must rename it inside the
+ * `canvas_manager_table_columns` LD value, and until they do the helper degrades to "show every
+ * column" rather than failing closed.
+ */
+export declare function resolveColumnVisibilityView(isMasters: boolean): 'canvases' | 'master_canvases';
+/**
+ * PIT-8360 QA — the copy that must NAME a master instead of saying "canvas".
+ *
+ * QA read the delete and unfreeze confirmations on the masters tab as belonging to an ordinary
+ * pitchdeck, because every sentence in them says "canvas". Instances rename that word through
+ * `translation_overrides` (a whole-word replace, so Vontobel's "canvas" -> "PitchDeck" makes them
+ * read "this PitchDeck"), which means the fix is NOT a per-instance label change: the source
+ * string has to carry the qualifier so the same override yields "master PitchDeck". This is also
+ * why the master strings say "master canvas" rather than "master pitchdeck" — the override only
+ * fires on the word it knows.
+ *
+ * Two shapes were rejected, and both failures are worth keeping written down:
+ *
+ * 1. An `{entity}` placeholder in the shared sentences. The pitchdeck tab uses the same strings in
+ *    14 locales, where a swapped-in noun would have to agree in article and gender.
+ * 2. A `resolveKey(copy, isMasters)` table returning the i18n key. **`vue-i18n-extract` runs with
+ *    `--remove` in CI** (`scripts/lib-extract-translations.js`, and slotty's `extract:translations`)
+ *    and finds keys by scanning source for literal translation calls — a computed key is
+ *    invisible to it, so it deleted the master keys AND the pitchdeck keys whose literals the
+ *    table had replaced. Every i18n key must appear spelled out as the argument of a translation
+ *    call at its own call site; that is why the master copy is selected with a ternary over two
+ *    whole calls rather than by picking a key. `resolveBulkEntityType` below is fine because it
+ *    names an ENTITY, not a key — its `canvasUI.common.masterCanvas` literal lives in
+ *    `getCanvasTypeTranslation`. Mind this when writing about i18n in a comment, too: a
+ *    call-shaped example inside the scan glob is harvested as a real key.
+ */
+/**
+ * The noun the BULK dialogs put in front of the rep ("delete the 2 selected …").
+ *
+ * Only the two bulk dialogs the masters tab actually offers take this — delete and manage
+ * attributes. The tag dialogs are hidden there (`moreActions.addTags: !isMasters`) and keep the
+ * plain `CanvasType`, because their value is also sent to the instance-tags endpoint as
+ * `canvas_type`, where `'master-canvas'` is not a thing.
+ */
+export declare function resolveBulkEntityType(isMasters: boolean): 'canvas' | 'master-canvas';
+/**
+ * Account scoping for the fetch. Never applies to masters: they are account-less server-side
+ * (`resolve_account` nulls it on write), so an `account__id` filter matches nothing and empties
+ * the whole list. The selected account comes from localStorage and therefore survives across
+ * tabs — so this fires on the master tab even when no account was ever picked there.
+ */
+export declare function resolveAccountFilterId(opts: {
+    isMasters: boolean;
+    accountVisibilityEnabled?: boolean;
+    selectedAccountId?: string | null;
+}): string | undefined;
+/** Masters have no account, so the column would render a dash on every row. */
+export declare function shouldShowAccountColumn(opts: {
+    isMasters: boolean;
+    isCRM?: boolean;
+}): boolean;
+/**
+ * Masters always show Owner: block 5 lets colleagues share a master, so the list stops being
+ * "only mine" and the owner becomes what distinguishes rows. On the pitchdeck tab it stays
+ * admin-gated exactly as before.
+ */
+export declare function shouldShowOwnerColumn(opts: {
+    isMasters: boolean;
+    isAnyTypeOfAdmin?: boolean;
+    accountVisibilityEnabled?: boolean;
+}): boolean;
+/**
+ * Whether the Documents column shows (PIT-8360).
+ *
+ * Pitchdecks only. It shipped on the MASTER tab, where the signed-off prototype never put it — the
+ * prototype's "Document download" column belongs to the pitchdecks tab. Nothing is lost by
+ * removing it from the masters list: a master's rendered documents are still reachable from its row
+ * actions (Download PDF / PPTX / Regenerate), which read the same server-side state the column did.
+ *
+ * The `enable_scale_content` term is not belt-and-braces. That flag selects which conversion path
+ * runs for a DECK, and only the pdftopptx path it enables ever writes the `pdf_url`/`pptx_url`
+ * metadata this column reads — so with it off every row would render a dash under a header
+ * promising documents. Hidden beats uniformly empty.
+ *
+ * The downloader term follows how `shared_with` gates on its fetcher: a host that supplies none
+ * would otherwise get a column whose PDF/PPTX buttons render and then do nothing — the silent-no-op
+ * failure this file's `template`-column comment records as a reported QA bug.
+ *
+ * Gated here rather than through the LD column config because `getVisibleColumns` degrades to
+ * "show every column" when an instance configures no entry for the view, so the config cannot
+ * express "never on this tab".
+ */
+export declare function shouldShowDocumentsColumn(opts: {
+    isMasters: boolean;
+    scaleContentEnabled?: boolean;
+    /** The host callback behind the column's click; without it the buttons are inert. */
+    hasDocumentDownloader?: boolean;
+}): boolean;
+/**
+ * Whether duplicating should prompt for an account first.
+ *
+ * Never for masters. Not merely because the value would be redundant (the server nulls it) — the
+ * master tab passes `accounts: []`, so the modal would open with an empty list, the rep could
+ * select nothing, and the duplicate would silently abort with no toast and no error.
+ */
+export declare function shouldRequireAccountOnDuplicate(opts: {
+    isMasters: boolean;
+    isCRM?: boolean;
+    requireAccountOnCanvasCreation?: boolean;
+}): boolean;
+/**
+ * PIT-7488 block 4 — inputs shared by the two places the create-from-master flow can be started.
+ *
+ * The host capabilities are part of the gate on purpose: the flow needs a way to LIST masters (for
+ * the picker, and to resolve a preselected id to a label) and a way to create an ORDINARY deck
+ * (the masters tab's own `creator` makes masters). A flag turned on without them renders an entry
+ * that cannot work, which reads as a broken feature rather than an unconfigured one.
+ *
+ * `isCanvasCreationDisabled` matters because this creates a canvas — the same permission bypass
+ * CodeRabbit caught on block 3's "Use as master", where a rep without `canvas.create` could make
+ * one anyway.
+ */
+interface CreateFromMasterCapability {
+    masterCanvasesEnabled?: boolean;
+    hasMasterFetcher?: boolean;
+    hasCanvasFromMasterCreator?: boolean;
+    isCanvasCreationDisabled?: boolean;
+}
+/** Enables the master row's "Use to create pitchdeck" button (rendered disabled until block 4). */
+export declare function canUseMasterToCreateCanvas(opts: CreateFromMasterCapability): boolean;
+/**
+ * Whether NEW becomes a dropdown offering "From my master pitchdeck".
+ *
+ * The ONLY difference from `canUseMasterToCreateCanvas` is the variant term, and it is not
+ * cosmetic: `CSavedCanvasesManagementToolbar` renders for BOTH variants, so without the guard the
+ * master tab's own NEW grows an entry that builds a deck from a master while standing in the master
+ * list — the same shared-surface trap as the smart-folders view and the column-settings key.
+ */
+export declare function shouldOfferCreateFromMaster(opts: CreateFromMasterCapability & {
+    isMasters: boolean;
+}): boolean;
+/**
+ * PIT-8398 — apply a known field delta to one loaded row, instead of refetching the page to
+ * discover what the caller just wrote.
+ *
+ * Two properties this relies on, both load-bearing:
+ *
+ * 1. **Immutable replacement**, because this is a pure function — it must not mutate the array
+ *    the caller handed it, which is also what makes it testable in isolation. Note this is NOT
+ *    a reactivity requirement: `CTable` renders each cell from `row.original`, so Vue's deep
+ *    proxy tracks a nested write and an in-place `rows[i].metadata = …` re-renders too
+ *    (measured, not assumed). Replacement is preferred anyway — it matches the three existing
+ *    row-write patterns in the consuming component (`updateProperty`, `refreshCanvasMetadata`,
+ *    `startAsyncDownload`) and it does not depend on the row being a reactive proxy at all,
+ *    which a plain snapshot passed through `deepToRaw` would not be.
+ * 2. **Spread onto the existing row, never replace it.** A PATCH response carries only the
+ *    canvas fields; it does not carry the list-only ones the row already holds (`indicators`
+ *    from the list serializer, the account name injected by `enrichCanvasesWithAccountNames`).
+ *    Overwriting the row with a response would silently drop them — the trap `updateProperty`
+ *    works around by re-attaching `indicators` by hand.
+ *
+ * `patched` is false when the id is not on the current page, so a caller can fall back to a
+ * full `refetch()` rather than assume the UI caught up.
+ */
+export declare function applyRowPatch<T extends {
+    id: string;
+}>(rows: T[], id: T['id'], patch: Partial<T>): {
+    rows: T[];
+    patched: boolean;
+};
 export declare function useCSavedCanvasesManagement(): {
     statusOptions: {
         label: string;
@@ -13,3 +216,4 @@ export declare function useCSavedCanvasesManagement(): {
         [key: string]: any;
     }>[];
 };
+export {};

package/lib/components/savedCanvases/savedCanvasDocuments.use.d.ts

@@ -0,0 +1,111 @@
+import { MasterDocumentsState } from '../masterCanvases/masterCanvasDocuments.use';
+/**
+ * PIT-8360 — the Documents column on the PITCHDECK tab.
+ *
+ * The column shipped on the master tab, which the signed-off prototype never had: its
+ * "Document download" column sits on the pitchdecks tab. Moving it there means feeding the SAME
+ * cell from a different artifact store, because the two tabs' documents come from different
+ * pipelines and only one of them is server-orchestrated:
+ *
+ *  - a MASTER's artifacts live in `core_master_canvas_documents`, rendered server-side by
+ *    next-core, and the bulk read is also the scheduler;
+ *  - a DECK's artifacts live in its own `metadata` (`pdf_url` / `pptx_url` / `conversion_date` /
+ *    `job_id`), written by the pdftopptx callback server when a rep asks for a download.
+ *
+ * So this is an adapter, not a second fetch: everything it needs is already on the row the list
+ * fetched. That is the whole reason the column could move without touching the backend — and why
+ * relaxing next-core's `c.is_master = true` filters was not necessary. It also means the pitchdeck
+ * column adds no requests and schedules no renders, which matters: reps hold far more decks than
+ * masters, so scheduling one render per listed row would have multiplied Gotenberg load.
+ *
+ * Kept free of Vue so the mapping is testable on its own, like its master-side counterpart.
+ */
+/**
+ * What `getAsyncDownloadState` in `CSavedCanvasesManagement` returns.
+ *
+ * Declared here rather than exported from the component: it is a local `const` inside a
+ * 2000-line SFC, and the call site is what structurally checks the two against each other, so a
+ * drift shows up as a type error there. `undefined` is part of the contract — that function
+ * returns it outright when `enable_scale_content` is off.
+ */
+export interface SavedCanvasDownloadNotStarted {
+    status: 'not_started';
+}
+export interface SavedCanvasDownloadInProgress {
+    status: 'in_progress';
+    jobId?: string;
+    /** `metadata.conversion_date` verbatim — when the job was queued. See the staleness rule below. */
+    conversionDate?: string | null;
+    /**
+     * The rep started this download in THIS session, so the component is already polling it and it is
+     * live by construction. Exempt from the staleness rule, and legitimately stampless.
+     */
+    startedThisSession?: boolean;
+}
+export interface SavedCanvasDownloadCompleted {
+    status: 'completed';
+    pdfUrl?: string;
+    pptxUrl?: string;
+    jobId?: string;
+    /** The presigned artifact is past the instance's `async_download_expiration_hours` window. */
+    isExpired?: boolean;
+    /**
+     * `metadata.conversion_date` verbatim. Needed here because `isExpired` alone cannot be trusted —
+     * see the age guards in `toDocumentsState`.
+     */
+    conversionDate?: string | null;
+}
+/**
+ * A `type` because it is a union, which an interface cannot express; the object shapes above are
+ * interfaces per the repo convention.
+ */
+export type SavedCanvasAsyncDownloadState = SavedCanvasDownloadNotStarted | SavedCanvasDownloadInProgress | SavedCanvasDownloadCompleted;
+/**
+ * Maps a deck's async-download state onto the shape `CMasterCanvasesDocumentsCell` renders.
+ *
+ * `null` means "no documents", which the cell draws as a dash. Three states reach it:
+ *
+ *  - the pipeline is off (`undefined`), so no deck can have artifacts;
+ *  - nobody has downloaded this deck yet;
+ *  - the artifacts have EXPIRED. Returning the URLs anyway would hand the rep two buttons
+ *    pointing at objects that are gone — the actions menu already refuses to offer them
+ *    (`!props.isExpired` gates its PDF/PPTX entries) and offers Regenerate instead, so a dash here
+ *    keeps the two surfaces telling the same story.
+ *
+ * Note what is deliberately NOT mapped:
+ *
+ *  - `is_stale` is always false. Staleness is a master concept — the server re-renders a master
+ *    whose slides have moved on, and the cell keeps the old links plus a quiet refresh spinner. A
+ *    deck's artifact is never refreshed behind the rep's back; it expires instead.
+ *  - there is no `failed`. `getAsyncDownloadState` never reports one, so `canRetryDocuments` stays
+ *    false and the cell renders no Retry button — which is correct, because re-running a deck
+ *    conversion is the actions menu's Download entry, not this cell's job.
+ *  - `rendered_at` and `error` stay null: the deck pipeline records neither, and inventing values
+ *    would claim knowledge the cell would then display.
+ */
+export declare function toDocumentsState(asyncState: SavedCanvasAsyncDownloadState | undefined | null): MasterDocumentsState | null;
+/**
+ * The predicate behind `openableUrl`, exported because the row's Download actions need the same
+ * answer: they build their own anchor instead of going through the host's opener, so without this
+ * they are the only artifact surface with no scheme check on them at all.
+ */
+export declare function isOpenableDocumentUrl(url: string | null | undefined): url is string;
+/**
+ * Whether the cell should offer a download for a deck that has no artifact yet (PIT-8360 follow-up).
+ *
+ * The column started as a mirror of existing artifacts, so a deck nobody had downloaded showed a
+ * dash — which reads as "no documents available" when the truth is "nobody has asked yet". The
+ * developer's call: a READY deck always offers PDF and PPTX, and the click generates them.
+ *
+ * Gated on Ready (`is_draft === false`) because that is the signal the rep uses to mean "this deck
+ * is finished". A draft still keeps its Download action in the row menu, so nothing is lost — the
+ * column simply does not invite a render of something still being written.
+ *
+ * `isDraft` is optional and a missing value is treated as NOT ready: a partially-fetched row must
+ * not invite a Gotenberg render on a deck whose state we do not actually know.
+ */
+export declare function shouldOfferDocumentDownload(opts: {
+    isDraft?: boolean;
+    /** Present when the artifacts already exist — then the cell shows real links, not an offer. */
+    hasDocuments?: boolean;
+}): boolean;

package/lib/components/savedCanvases/savedCanvasDocuments.use.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/savedCanvases/smartFolders/SmartFolders.use.d.ts

@@ -65,6 +65,7 @@ export default function useSmartFolders(emit?: (event: 'open', ...args: any[]) =
         is_template?: boolean | undefined;
         is_section?: boolean | undefined;
         is_block?: boolean | undefined;
+        is_master?: boolean | undefined;
         is_editable?: boolean | undefined;
         is_default?: boolean | undefined;
         metadata?: any;
@@ -150,6 +151,7 @@ export default function useSmartFolders(emit?: (event: 'open', ...args: any[]) =
         is_template?: boolean | undefined;
         is_section?: boolean | undefined;
         is_block?: boolean | undefined;
+        is_master?: boolean | undefined;
         is_editable?: boolean | undefined;
         is_default?: boolean | undefined;
         metadata?: any;
@@ -215,6 +217,7 @@ export default function useSmartFolders(emit?: (event: 'open', ...args: any[]) =
         is_template?: boolean | undefined;
         is_section?: boolean | undefined;
         is_block?: boolean | undefined;
+        is_master?: boolean | undefined;
         is_editable?: boolean | undefined;
         is_default?: boolean | undefined;
         metadata?: any;
@@ -281,6 +284,7 @@ export default function useSmartFolders(emit?: (event: 'open', ...args: any[]) =
         is_template?: boolean | undefined;
         is_section?: boolean | undefined;
         is_block?: boolean | undefined;
+        is_master?: boolean | undefined;
         is_editable?: boolean | undefined;
         is_default?: boolean | undefined;
         metadata?: any;

package/lib/composables/useCourseOnlyApps.d.ts

@@ -7,5 +7,5 @@ import { AppFile } from '../types/app';
  */
 export declare function useCourseOnlyApps(): {
     allowCourseOnlyApps: boolean;
-    isAppAllowed: (app: AppFile) => boolean;
+    isAppAllowedInHost: (app: AppFile) => boolean;
 };

package/lib/composables/usePdfInterpolation.d.ts

@@ -1,7 +1,7 @@
-import { default as PSPDFKitType, ServerConfiguration } from 'pspdfkit';
+import { default as PSPDFKitType, Configuration } from '@nutrient-sdk/viewer';
 declare function annotationsInterpolation({ PSPDFKit, config, data, }: {
     PSPDFKit: typeof PSPDFKitType;
-    config: ServerConfiguration;
+    config: Configuration;
     data: Record<string, string>;
 }): Promise<void>;
 export default function usePdfInterpolation(strategy?: 'annotations' | 'text'): typeof annotationsInterpolation;

package/lib/composables/useWindowEvents.d.ts

@@ -9,7 +9,7 @@ export type InactiveEventPayload = {
     file_id?: string;
     [key: string]: any;
 };
-export default function (track: (eventName: string, payload: any) => void, pitcherApi?: ReturnType<typeof usePitcherApi>, flushTrack?: (eventName: string, payload: any) => void): {
+export default function (track: (eventName: string, payload: any) => void, pitcherApi?: ReturnType<typeof usePitcherApi>, flushTrack?: (eventName: string, payload: any) => void, heartbeatIntervalMs?: number): {
     registerInactiveEvent: ({ id, payload, enterEvent, exitEvent, type, }: {
         id: string;
         payload: InactiveEventPayload | ((type?: EventLifecycle) => InactiveEventPayload);

package/lib/constants/cdp.const.d.ts

@@ -10,6 +10,7 @@ export declare const CDP_EVENT_TYPE: {
     readonly appExited: "App Exited";
     readonly canvasEntered: "Canvas Entered";
     readonly canvasExited: "Canvas Exited";
+    readonly canvasHeartbeat: "Canvas Heartbeat";
     readonly wizardEntered: "Wizard Entered";
     readonly wizardExited: "Wizard Exited";
     readonly canvasShared: "Canvas Shared";
@@ -50,6 +51,7 @@ export declare const PLATFORM_TYPE: {
     readonly ios: "ios";
     readonly android: "android";
     readonly windows: "windows";
+    readonly macos: "macos";
 };
 export declare const EMBED_TYPE: {
     readonly standalone: "standalone";