@riverbankcms/sdk 0.108.0 → 0.109.0

package/dist/_dts/media-core/src/fileMimeDetection.d.ts

@@ -8,3 +8,19 @@ export type MagicDetectedMimeType = 'image/png' | 'image/jpeg' | 'image/gif' | '
  */
 export declare function detectMimeTypeFromBuffer(buffer: Uint8Array | null | undefined): MagicDetectedMimeType | undefined;
 export declare function bufferAsLatin1(buffer: Uint8Array, maxBytes?: number): string;
+/**
+ * Recognizes an SVG document by its leading element only.
+ *
+ * Within a bounded window we skip an optional UTF-8 BOM, whitespace, and any XML
+ * prolog constructs (XML declaration / processing instructions, comments, and a
+ * DOCTYPE) and then require the very first element to be `<svg>`. Requiring the
+ * root element — rather than scanning for `<svg` anywhere — is the false-positive
+ * guard: an HTML document that merely embeds inline `<svg>` further down (its
+ * first element is `<html>`/`<body>`/etc.) is deliberately NOT recognized as SVG.
+ *
+ * DOCTYPE is skipped rather than rejected here so a DOCTYPE-bearing SVG is still
+ * recognized and routed to the finalize sanitizer (which rejects DOCTYPE/entities
+ * outright) instead of failing earlier as an opaque MIME mismatch. This probe is
+ * intentionally trusted only through the contract-gated `svg-fallback` strategy.
+ */
+export declare function looksLikeSvgBuffer(buffer: Uint8Array | null | undefined): boolean;

package/dist/_dts/media-core/src/fileStorage.d.ts

@@ -9,6 +9,7 @@ export declare const PUBLIC_SITE_FILE_STORAGE_BUCKETS: readonly [StorageBucketNa
 export declare const FILE_UPLOAD_STAGING_PREFIX = "temp-file-uploads";
 export declare const DURABLE_FILE_STORAGE_PREFIX = "sites";
 export declare const DURABLE_FILE_FOLDER = "files";
+export declare const SDK_UPLOAD_STAGING_PREFIX = "sdk-staging";
 export declare const PRIVATE_SITE_FILE_BUCKET_MIME_TYPES: readonly ["application/pdf", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "text/plain", "application/rtf", "text/rtf", "image/jpeg", "image/png", "image/webp", "image/gif", "image/avif", "image/heic", "image/heif", "image/svg+xml", "text/csv", "application/csv", "application/vnd.ms-excel", "application/zip", "application/x-zip-compressed", "audio/mpeg", "audio/mp4", "audio/wav", "audio/x-wav", "audio/ogg", "audio/webm", "audio/flac", "video/mp4", "video/webm", "video/quicktime"];
 export declare const TEMP_UPLOAD_BUCKET_MIME_TYPES: readonly ["application/pdf", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "text/plain", "application/rtf", "text/rtf", "image/jpeg", "image/png", "image/webp", "image/gif", "image/avif", "image/heic", "image/heif", "image/svg+xml", "text/csv", "application/csv", "application/vnd.ms-excel", "application/zip", "application/x-zip-compressed", "audio/mpeg", "audio/mp4", "audio/wav", "audio/x-wav", "audio/ogg", "audio/webm", "audio/flac", "video/mp4", "video/webm", "video/quicktime", "font/woff2", "application/font-woff2", "application/x-font-woff2", "application/octet-stream"];
 export type FileStoragePathError = 'unsafe-path-segment';
@@ -39,3 +40,10 @@ export declare function buildStagedUploadStoragePath(input: StagedUploadStorageP
  */
 export declare function buildDurableFileStoragePath(input: DurableFileStoragePathInput): Result<SiteScopedStoragePath, FileStoragePathError>;
 export declare function parseStoragePath(value: string): Result<StoragePath, FileStoragePathError>;
+/**
+ * Builds the private staging path for an SDK-management upload from its intended
+ * durable relative path: `sdk-staging/{siteId}/{durableRelativePath}`. Finalize
+ * promotes the object from here (in `temp-uploads`) to the public bucket only
+ * after verification + sanitization.
+ */
+export declare function buildSdkStagedStoragePath(siteId: SiteId, durableRelativePath: string): Result<StoragePath, FileStoragePathError>;

package/dist/_dts/media-core/src/storagePathDomain.d.ts

@@ -22,6 +22,8 @@ export type StoragePathParseError = {
     tag: 'DOUBLE_SLASH';
 } | {
     tag: 'TRAVERSAL';
+} | {
+    tag: 'PERCENT_ENCODING';
 } | {
     tag: 'SITE_SCOPED_PATH';
 } | {

package/dist/_dts/media-core/src/uploadVerificationContract.d.ts

@@ -17,6 +17,9 @@ export type UploadVerificationStrategy = Readonly<{
 }> | Readonly<{
     tag: 'rtf-fallback';
     detectedMimeType: 'application/rtf';
+}> | Readonly<{
+    tag: 'svg-fallback';
+    detectedMimeType: 'image/svg+xml';
 }>;
 export type AcceptedUploadKindContract = Readonly<{
     kind: FileKind;

package/dist/_dts/preview-next/src/client/blocks/BlockToolbar.d.ts

@@ -1,6 +1,7 @@
 import React from 'react';
 import { type BookingOfferingPresetSummary, type Theme } from '../../../../blocks/src/index';
 import { type BackgroundColorPalette } from '../../../../blocks/src/system/customize/backgrounds';
+import { type GradientPresetId } from '../../../../theme-core/src/gradients/index';
 import { type PreviewChromeFloatingPlacement } from '../preview/previewChromePlacement';
 export declare function BlockToolbar({ blockId, blockKind, content, bookingOfferingPresets, theme, placement, }: {
     blockId: string;
@@ -10,4 +11,5 @@ export declare function BlockToolbar({ blockId, blockKind, content, bookingOffer
     theme?: Theme | null;
     placement?: PreviewChromeFloatingPlacement;
 }): React.JSX.Element;
+export declare function gradientPreviewCss(gradientId: GradientPresetId): string;
 export declare function readBackgroundColorPaletteSnapshot(): BackgroundColorPalette | null;

package/dist/_dts/preview-next/src/client/preview/StyleConfigurator.state.d.ts

@@ -213,6 +213,7 @@ export declare function reconcilePaletteLibraryActive(state: StyleConfiguratorSt
  */
 export declare function rebasePaletteLibraryAuthority(state: StyleConfiguratorState, committedPalette: ResolvedPaletteSelection): StyleConfiguratorState;
 export declare function selectionSnapshotsEqual(a: SelectionSnapshot, b: SelectionSnapshot): boolean;
+export declare function typographyObjectsEqual(a: ThemeTypography, b: ThemeTypography): boolean;
 type ModernRuntimePaletteState = Extract<RuntimePaletteState, Readonly<{
     authority: 'curated';
 }>> | Extract<RuntimePaletteState, Readonly<{

package/dist/_dts/preview-next/src/client/preview/styleConfiguratorApplyPayload.d.ts

@@ -20,7 +20,7 @@ export type ApplySiteStyleSelectionBodyBuildResult = Readonly<{
     ok: false;
     error: Extract<PaletteApplyCommandPlan, {
         ok: false;
-    }>['error'];
+    }>['error'] | 'no-selection-changes';
 }>;
 export declare function buildApplySiteStyleSelectionBody(input: Readonly<{
     base: SelectionSnapshot;

package/dist/_dts/sdk/src/cli/commands/audit.d.ts

@@ -99,4 +99,4 @@ export declare function auditOrphanedEntries(ctx: Pick<AuditContext, 'localEntry
 export declare function auditContentTypes(localContentTypes: Set<string>, validContentTypes: Set<string>): AuditIssue[];
 export declare function auditEventReferences(events: LocalEvent[], ctx: Pick<AuditContext, 'localVenueRefs' | 'remoteVenueRefs' | 'localCategoryRefs' | 'remoteCategoryRefs' | 'localFormRefs' | 'remoteFormRefs'>): AuditIssue[];
 export declare function auditCourseReferences(courses: LocalCourse[], ctx: Pick<AuditContext, 'localVenueRefs' | 'remoteVenueRefs' | 'localCategoryRefs' | 'remoteCategoryRefs' | 'localFormRefs' | 'remoteFormRefs'>): AuditIssue[];
-export declare const auditCommand: Command;
+export declare const createAuditCommand: () => Command;

package/dist/_dts/sdk/src/cli/commands/compare.d.ts

@@ -58,5 +58,5 @@ export declare function compareLocalVsCms(localEntries: LocalEntry[], remoteEntr
     data: Record<string, unknown>;
     status: string;
 }>, contentType: string): ComparisonResult;
-export declare const compareCommand: Command;
+export declare const createCompareCommand: () => Command;
 export {};

package/dist/_dts/sdk/src/cli/commands/deploy.d.ts

@@ -39,5 +39,5 @@ export declare function checkWorkingDirectoryClean(git: SimpleGit, prebuildOutpu
  * @internal Exported for testing
  */
 export declare function commitCacheIfChanged(git: SimpleGit, prebuildOutput: string): Promise<boolean>;
-export declare const deployCommand: Command;
+export declare const createDeployCommand: () => Command;
 export {};

package/dist/_dts/sdk/src/cli/commands/drafts.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Drafts Command (Phase 7.3)
+ *
+ * Cross-type overview of pages and entries with pending (unpublished) changes.
+ * Consumes the SDK `pull.drafts()` operation (server-side `GET pull/drafts`),
+ * which is correctly server-filtered and fully enumerated — replacing the
+ * post-pagination `entry list --status draft` trap.
+ *
+ * Usage:
+ *   riverbankcms drafts
+ *   riverbankcms drafts --json
+ */
+import { Command } from 'commander';
+import type { PulledDrafts } from '../../client/management/types';
+/** Flatten the drafts overview into unified table rows for human display. */
+export declare function draftsToTableRows(drafts: PulledDrafts): string[][];
+export declare const createDraftsCommand: () => Command;
+export declare const draftsCommand: Command;

package/dist/_dts/sdk/src/cli/commands/entry.d.ts

@@ -12,6 +12,7 @@
  *   riverbankcms entry list <type> [--limit N] [--page N]
  */
 import { Command } from 'commander';
+import { type EntryScaffold } from '../../../../content-model/src/index';
 import type { ManagementClient, ManagementEntry } from '../../client/management/types';
 import { type MediaValidationResult } from '../media/write-guard';
 export declare const ENTRY_LIST_COLUMNS: readonly ["id", "identifier", "slug", "status", "hasUnpublishedChanges", "updatedAt", "createdAt", "publishedAt", "title", "contentType"];
@@ -37,4 +38,18 @@ export declare function findEntryById(client: ManagementClient, contentType: str
     limit?: number;
     maxPages?: number;
 }): Promise<ManagementEntry | null>;
+/**
+ * Resolve a scaffold for a content type from the discovery catalog (the field
+ * DSL), or an error listing the available keys. Sourced from
+ * `client.catalog.contentTypes()`, matching how `content-type list` resolves its
+ * source from the client. (An offline local-config fallback is not implemented:
+ * the normalized field DSL is only exposed over the catalog API, and
+ * `content-type list` likewise has no local fallback.)
+ */
+export declare function resolveEntryScaffold(client: ManagementClient, contentType: string): Promise<{
+    scaffold: EntryScaffold;
+} | {
+    error: string;
+    availableKeys: string[];
+}>;
 export declare const entryCommand: Command;

package/dist/_dts/sdk/src/cli/commands/init-docs.d.ts

@@ -9,5 +9,5 @@ interface InitDocsOptions {
     config?: string;
 }
 export declare function runInitDocs(options: InitDocsOptions, command: Command): Promise<void>;
-declare const initDocsCommand: Command;
-export { initDocsCommand };
+export declare const createInitDocsCommand: () => Command;
+export {};

package/dist/_dts/sdk/src/cli/commands/publish-all.d.ts

@@ -47,4 +47,4 @@ export declare function categorizeEntries(entries: ManagementEntry[]): {
  * Exported for testing.
  */
 export declare function aggregateResults(results: PublishResult[]): Omit<PublishAllSummary, 'total'>;
-export declare const publishAllCommand: Command;
+export declare const createPublishAllCommand: () => Command;

package/dist/_dts/sdk/src/cli/commands/pull.d.ts

@@ -39,4 +39,5 @@ export declare function shouldPromptForOverwrite(opts: {
     force: boolean;
     yes: boolean;
 }): boolean;
+export declare const createPullCommand: () => Command;
 export declare const pullCommand: Command;

package/dist/_dts/sdk/src/cli/commands/push/execute/diff.d.ts

@@ -16,4 +16,4 @@ export declare function displayDiff(params: {
     remoteContent: PulledContent;
     humanDiff?: boolean;
     mediaReport?: LocalMediaPushReport;
-}): void;
+}): unknown;

package/dist/_dts/sdk/src/cli/commands/push/options.d.ts

@@ -5,7 +5,10 @@ export interface PushOptions {
     force?: boolean;
     forceUpdateAsset?: boolean;
     allowTruncated?: boolean;
+    /** @deprecated Use `--diff-detail` instead; folded into the `--json` envelope. */
     jsonDiff?: string;
+    /** Diff verbosity carried in the `--json` envelope: 'summary' (default) or 'full'. */
+    diffDetail?: string;
     withConfig?: boolean;
     withTheme?: boolean;
     syncMedia?: boolean;

package/dist/_dts/sdk/src/cli/commands/push-execute.d.ts

@@ -7,6 +7,17 @@ import { type PushScope } from './push/consts';
 export interface PushExecutionResult {
     success: boolean;
 }
+/**
+ * Single command-owned result for a push, assembled once at the end of the push
+ * command (finding 4). `executePushForEnv` writes the diff into `detail` and the
+ * sync outcome into `execution`; the command adds `verification` and emits the
+ * whole object exactly once, so no stage's result clobbers another's.
+ */
+export interface PushResultAccumulator {
+    detail?: unknown;
+    execution?: unknown;
+    verification?: unknown;
+}
 export declare function noContentFoundWarningDetails(contentDir: string): Readonly<{
     contentDir: string;
     expectedFiles: readonly string[];
@@ -39,5 +50,5 @@ export declare function executePushForEnv(output: OutputContext, target: EnvTarg
     jsonDiffMode?: JsonDiffMode | null;
 }, globalOpts: {
     json?: boolean;
-}): Promise<PushExecutionResult>;
+}, resultSink?: PushResultAccumulator): Promise<PushExecutionResult>;
 export {};

package/dist/_dts/sdk/src/cli/commands/setup.d.ts

@@ -1,2 +1,3 @@
 import { Command } from 'commander';
+export declare function createSetupCommand(): Command;
 export declare const setupCommand: Command;

package/dist/_dts/sdk/src/cli/commands/verify.d.ts

@@ -7,4 +7,5 @@
  *   riverbankcms verify [--env=remote] [--config <path>]
  */
 import { Command } from 'commander';
+export declare const createVerifyCommand: () => Command;
 export declare const verifyCommand: Command;

package/dist/_dts/sdk/src/cli/helpers.d.ts

@@ -7,8 +7,29 @@
 import { Command } from 'commander';
 import type { SiteId } from '../../../core/src/index';
 import type { ManagementClient } from '../client/management/types';
-import { type OutputContext } from './output';
+import { InvocationEnvelope, type OutputContext } from './output';
 import { type CliErrorContext } from './errors';
+/**
+ * Run `fn` within a fresh invocation envelope. Returns the envelope so `runCli`
+ * can flush it and derive the exit code after the run completes (or fails).
+ */
+export declare function runWithInvocation<T>(fn: (envelope: InvocationEnvelope) => Promise<T>): {
+    envelope: InvocationEnvelope;
+    done: Promise<T>;
+};
+/** The current invocation's envelope, if output is running inside `runCli`. */
+export declare function currentInvocationEnvelope(): InvocationEnvelope | undefined;
+/**
+ * Build the space-separated command path for the envelope's `command` field,
+ * excluding the root program name (e.g. `entry upsert`, `drafts`).
+ */
+export declare function resolveCommandPath(command: Command): string;
+/**
+ * Create an OutputContext bound to a command. In JSON mode it resolves the
+ * current invocation's envelope from the async context, so all output funnels
+ * into one document.
+ */
+export declare function createOutputForCommand(command: Command): OutputContext;
 /**
  * Environment target for CLI operations.
  */

package/dist/_dts/sdk/src/cli/index.d.ts

@@ -3,5 +3,9 @@
  *
  * CLI tools for SDK site developers.
  * Supports bidirectional content management: pull content from CMS and push content back.
+ *
+ * This module is the bin entry point: it loads env files, then runs the CLI via
+ * `runCli`, which owns the process exit code and guarantees exactly one JSON
+ * envelope per invocation under `--json`. The command tree lives in `program.ts`.
  */
 export {};

package/dist/_dts/sdk/src/cli/output.d.ts

@@ -2,12 +2,100 @@
  * CLI Output Formatting
  *
  * Provides consistent output formatting for CLI commands.
+ *
+ * ## Single JSON envelope contract (Phase 7.1)
+ *
+ * Under `--json`, EVERY command emits EXACTLY ONE JSON document on stdout:
+ *
+ *   { ok: boolean, command: string, result: <command-specific>, warnings: [...], errors: [...] }
+ *
+ * This is enforced structurally: in JSON mode the terminal output methods
+ * (`success`/`result`/`json`/`table`) do NOT print — they buffer their payload
+ * into the invocation's {@link InvocationEnvelope}. `warn` appends to `warnings`,
+ * `error`/`fail` append to `errors`. A single writer (`InvocationEnvelope.flush`)
+ * emits the one envelope: on success via the program's `postAction` hook, on
+ * failure via `error()` (which throws `CliExit` so `runCli` owns the exit code),
+ * and for parse/help/version via `runCli` itself. Commands can therefore never
+ * double-print a JSON document, no matter how many output calls they make.
+ *
+ * Human (non-`--json`) output is unchanged.
+ */
+/** A structured warning or error entry inside the JSON envelope. */
+export interface EnvelopeMessage {
+    message: string;
+    code?: string;
+    details?: unknown;
+    suggestion?: unknown;
+}
+/**
+ * The single machine-readable document emitted per invocation under `--json`.
+ *
+ * Closed discriminated final state: an `ok: false` envelope ALWAYS carries at
+ * least one typed error (`errors` is a non-empty tuple), and an `ok: true`
+ * envelope never carries errors. The invariant is enforced by
+ * {@link InvocationEnvelope.flush}, so `{ ok: false, errors: [] }` is
+ * unrepresentable in the emitted output.
  */
+export type JsonEnvelope = {
+    ok: true;
+    command: string;
+    result: unknown;
+    warnings: EnvelopeMessage[];
+    errors: [];
+} | {
+    ok: false;
+    command: string;
+    result: unknown;
+    warnings: EnvelopeMessage[];
+    errors: [EnvelopeMessage, ...EnvelopeMessage[]];
+};
+/**
+ * Raised by `output.error` (and mapped by `runCli`) to terminate a command with a
+ * non-zero exit code WITHOUT calling `process.exit` inside command code — so the
+ * single envelope is always flushed first and the exit code is owned in one place.
+ */
+export declare class CliExit extends Error {
+    readonly code: number;
+    constructor(code: number);
+}
+/**
+ * Accumulates the single JSON envelope for ONE CLI invocation. Created once per
+ * invocation (owned by the fresh root program) and threaded to every command's
+ * output, so all output — success, warnings, errors, and even parse/help/version
+ * handled by `runCli` — funnels into one document. `flush()` is idempotent and is
+ * the ONLY writer of the stdout JSON.
+ */
+export declare class InvocationEnvelope {
+    private resultValue;
+    private failed;
+    private readonly warnings;
+    private readonly errors;
+    private flushed;
+    setResult(value: unknown): void;
+    addWarning(warning: EnvelopeMessage): void;
+    addError(error: EnvelopeMessage): void;
+    markFailed(): void;
+    hasFlushed(): boolean;
+    /** True once at least one error has been recorded or a failure marked. */
+    isFailed(): boolean;
+    private finalState;
+    /** Emit the single envelope. Idempotent: subsequent calls are no-ops. */
+    flush(command: string): void;
+}
 export interface OutputOptions {
     /** Output in JSON format for machine parsing */
     json?: boolean;
     /** Minimal output (suppress non-essential messages) */
     quiet?: boolean;
+    /**
+     * In JSON mode, the invocation-scoped envelope all terminal output funnels into
+     * so exactly one document is emitted. Always supplied by `createOutputForCommand`
+     * in JSON mode; if absent, JSON-mode terminal writes are dropped (never a stray
+     * second document).
+     */
+    envelope?: InvocationEnvelope;
+    /** Full command path (e.g. "entry upsert") for the envelope's `command` field. */
+    command?: string;
 }
 export interface OutputContext {
     success(message: string, data?: unknown): void;

package/dist/_dts/sdk/src/cli/program.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Riverbank CMS SDK CLI — program construction and invocation.
+ *
+ * `createProgram()` builds the full Commander command tree; `runCli()` drives it
+ * so that under `--json` EXACTLY ONE envelope reaches stdout for EVERY outcome,
+ * including the paths Commander itself owns — parse errors, `--help`, and
+ * `--version` (which would otherwise bypass command actions entirely).
+ *
+ * `runCli`:
+ *  - runs `parseAsync` inside an AsyncLocalStorage invocation scope so all output
+ *    (actions, and the parse/help/version handling below) funnels into ONE
+ *    envelope, isolated per concurrent invocation;
+ *  - installs `exitOverride` + `configureOutput` on every command so Commander's
+ *    exits and its help/version/error text are intercepted rather than written
+ *    raw or exiting the process; and
+ *  - owns the process exit code (commands never call `process.exit`).
+ */
+import { Command } from 'commander';
+export declare function createProgram(): Command;
+/**
+ * Parse and run the CLI. Returns the process exit code (the caller sets
+ * `process.exitCode`); it never calls `process.exit` itself, so it is safe to
+ * drive from tests. Under `--json`, exactly one envelope is written to stdout for
+ * every outcome — success, non-fatal failure, thrown error, parse error, `--help`,
+ * and `--version`.
+ */
+export declare function runCli(argv: string[], options?: {
+    program?: Command;
+}): Promise<number>;

package/dist/_dts/sdk/src/cli/push-config.d.ts

@@ -45,5 +45,5 @@ export declare function pushConfigAction(output: OutputContext, options: PushCon
 /**
  * push-config command definition
  */
-export declare const pushConfigCommand: Command;
+export declare const createPushConfigCommand: () => Command;
 export {};

package/dist/_dts/sdk/src/client/management/catalog.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Catalog (discovery surface) operations for the Management Client.
+ *
+ * Read-only catalogs an agent enumerates to act without reading repo source.
+ */
+import type { HttpClient } from './http';
+import type { Capabilities, CatalogOperations, DemoContent } from './types';
+export declare function createCatalogOperations(http: HttpClient): CatalogOperations;
+export declare function createCapabilitiesOperation(http: HttpClient): () => Promise<Capabilities>;
+export declare function createDemoContentOperation(http: HttpClient): () => Promise<DemoContent>;

package/dist/_dts/sdk/src/client/management/http.d.ts

@@ -25,7 +25,13 @@ export declare class ManagementApiError extends Error {
     readonly details?: unknown;
     readonly statusCode?: number;
     readonly request?: ManagementApiErrorRequest;
-    constructor(message: string, code: string, details?: unknown, statusCode?: number, request?: ManagementApiErrorRequest);
+    /**
+     * Precise failure tag from the server's `DomainServiceError` (e.g. `STALE_BASE`,
+     * `PALETTE_CAP_REACHED`). Branch on this when the coarse `code`/`statusCode`
+     * collapses several failures into one.
+     */
+    readonly tag?: string;
+    constructor(message: string, code: string, details?: unknown, statusCode?: number, request?: ManagementApiErrorRequest, tag?: string);
 }
 /**
  * Type guard to check if an error is a 404 Not Found response.

package/dist/_dts/sdk/src/client/management/index.d.ts

@@ -36,7 +36,7 @@ import { CourseSessionConflictError } from './courses';
  * @returns ManagementClient instance
  */
 export declare function createManagementClient(config: ManagementClientConfig): ManagementClient;
-export type { ManagementClient, ManagementClientConfig, ManagementEntry, ManagementPage, ManagementBlock, ManagementNavigationMenu, ManagementNavigationItem, ManagementSettings, ManagementForm, ManagementFormField, ManagementFormSchema, ManagementFormSettings, ManagementVenue, VenueAddress, VenueLocation, VenueUpsertInput, ManagementEventCategory, EventCategoryUpsertInput, ManagementEventSeries, EventSchedule, EventScheduleUpsertInput, EventStartDurationSchedule, EventStartEndSchedule, EventPricing, EventPaymentTerms, EventPaymentTermsInput, EventContent, EventSeriesUpsertInput, ManagementCourseRun, CourseRunUpsertInput, CourseSession, CourseProgramContent, CourseSessionConflict, EntryUpsertInput, EntryPublishUpsertResult, UpsertedManagementEntry, PageUpsertInput, PagePublishUpsertResult, BlockUpsertInput, NavigationMenuUpsertInput, NavigationItemInput, FormUpsertInput, SiteStyleSelectionApplyCommand, SiteStyleSelectionApplyCommandInput, ThemeUpsertInitializeInput, ThemeUpsertInput, ThemeUpsertResult, ThemeUpsertUpdateInput, ThemeStyleSelectionApplyInput, ThemeStyleSelectionApplyResult, FooterContent, ManagementFooterContent, FooterContentUpsertInput, FooterOperations, PulledFooter, PulledEntries, PulledPages, PulledDrafts, PulledNavigation, PulledSettings, PulledForms, PulledTheme, PulledVenues, PulledEventCategories, PulledEvents, PulledCourses, PulledSiteInfo, PulledContentType, PulledContentTypes, PulledContent, PaginationOptions, PaginatedResult, EntryOperations, PageOperations, BlockOperations, NavigationOperations, SettingsOperations, SettingsUpdateInput, WebhookOperations, SetupRevalidationWebhookInput, SetupRevalidationWebhookResult, ManagementWebhookEndpoint, RevalidationWebhookPlannedEndpoint, FormOperations, ThemeOperations, VenueOperations, EventCategoryOperations, EventOperations, CourseOperations, PullOperations, IdentifiersOperations, BackfillResult, BackfillPageResult, BackfillBlockResult, BackfillEntryResult, MediaOperations, MediaUploadResult, } from './types';
+export type { ManagementClient, ManagementClientConfig, ManagementEntry, ManagementPage, ManagementBlock, ManagementNavigationMenu, ManagementNavigationItem, ManagementSettings, ManagementForm, ManagementFormField, ManagementFormSchema, ManagementFormSettings, ManagementVenue, VenueAddress, VenueLocation, VenueUpsertInput, ManagementEventCategory, EventCategoryUpsertInput, ManagementEventSeries, EventSchedule, EventScheduleUpsertInput, EventStartDurationSchedule, EventStartEndSchedule, EventPricing, EventPaymentTerms, EventPaymentTermsInput, EventContent, EventSeriesUpsertInput, ManagementCourseRun, CourseRunUpsertInput, CourseSession, CourseProgramContent, CourseSessionConflict, EntryUpsertInput, EntryPublishUpsertResult, UpsertedManagementEntry, PageUpsertInput, PagePublishUpsertResult, BlockUpsertInput, NavigationMenuUpsertInput, NavigationItemInput, FormUpsertInput, SiteStyleSelectionApplyCommand, SiteStyleSelectionApplyCommandInput, ThemeUpsertInitializeInput, ThemeUpsertInput, ThemeUpsertResult, ThemeUpsertUpdateInput, ThemeStyleSelectionApplyInput, ThemeStyleSelectionApplyResult, FooterContent, ManagementFooterContent, FooterContentUpsertInput, FooterOperations, PulledFooter, PulledEntries, PulledPages, PulledDrafts, PulledNavigation, PulledSettings, PulledForms, PulledTheme, PulledVenues, PulledEventCategories, PulledEvents, PulledCourses, PulledSiteInfo, PulledContentType, PulledContentTypes, PulledContent, PaginationOptions, PaginatedResult, EntryOperations, PageOperations, BlockOperations, NavigationOperations, SettingsOperations, SettingsUpdateInput, WebhookOperations, SetupRevalidationWebhookInput, SetupRevalidationWebhookResult, ManagementWebhookEndpoint, RevalidationWebhookPlannedEndpoint, FormOperations, ThemeOperations, VenueOperations, EventCategoryOperations, EventOperations, CourseOperations, PullOperations, CatalogOperations, PulledCatalogTheme, PulledCatalogBlocks, PulledCatalogContentTypes, Capabilities, DemoContent, IdentifiersOperations, BackfillResult, BackfillPageResult, BackfillBlockResult, BackfillEntryResult, MediaOperations, MediaUploadResult, } from './types';
 export { ManagementApiError, type ManagementApiErrorRequest } from './http';
 export { BlockPatchStaleContentError, isBlockPatchStaleContentError, } from './blocks';
 export { applySiteStyleSelectionBodyFromCommand, buildApplySiteStyleSelectionCommand, } from './theme';

package/dist/_dts/sdk/src/client/management/types.d.ts

@@ -11,6 +11,7 @@ import type { SdkEventPaymentTerms, SdkEventPaymentTermsInput } from '../../../.
 import type { SdkEventUpsertBody } from '../../../../api/src/sdk-event-upsert';
 import type { SdkManagementEventSeries } from '../../../../api/src/sdkContracts';
 import type { SdkPullTruncationMeta } from '../../../../api/src/sdkContracts';
+import type { SdkCapabilitiesResponse, SdkCatalogBlocksResponse, SdkCatalogContentTypesResponse, SdkCatalogThemeResponse, SdkDemoContentResponse } from '../../../../api/src/sdkContracts';
 import type { SdkEntryPublishErrorCode, SdkPagePublishErrorCode, SdkPublicationOutcome } from '../../../../api/src/sdkContracts';
 import type { PaletteSelection } from '../../../../theme-core/src/palette/index';
 import type { Theme } from '../../contracts';
@@ -559,28 +560,18 @@ export interface ThemeUpsertResult {
 export type SiteStyleSelectionApplyCommand = SiteCommandOf<'applySiteStyleSelection'>;
 export type SiteStyleSelectionApplyCommandInput = SiteStyleSelectionApplyCommand['input'];
 /**
- * Public SDK input for style-selection apply, derived from the shared command
- * IR so SDK, CLI, and AI proposal flows stay aligned. The IR permits the
- * minimal request ({siteStyleId, baseSelectionVersion}); omitted choices
- * default from the curated style server-side. Wire IDs are strings at this
- * boundary; the server schema brands and validates them. The canonical header
- * pair is atomic at the type level: both omitted (site-style default), both
- * null (legacy default), or both supplied.
+ * Public SDK delta contract. `siteStyleRef` is command orchestration identity;
+ * semantic style changes live only in the `changes` batch.
  */
-export type ThemeStyleSelectionApplyInput = Omit<SiteStyleSelectionApplyCommandInput, 'siteStyleId' | 'headerLayoutId' | 'headerStyleId'> & Readonly<{
-    siteStyleId: string;
+export type ThemeStyleSelectionApplyInput = Omit<SiteStyleSelectionApplyCommandInput, 'changes'> & Readonly<{
+    siteStyleRef: string;
     baseSelectionVersion: number;
     selectionId?: string | null;
-}> & (Readonly<{
-    headerLayoutId?: undefined;
-    headerStyleId?: undefined;
-}> | Readonly<{
-    headerLayoutId: null;
-    headerStyleId: null;
-}> | Readonly<{
-    headerLayoutId: string;
-    headerStyleId: string;
-}>);
+    changes: readonly [
+        SiteStyleSelectionApplyCommandInput['changes'][number],
+        ...SiteStyleSelectionApplyCommandInput['changes'][number][]
+    ];
+}>;
 export interface ThemeStyleSelectionApplyResult {
     success: boolean;
     themeId: string;
@@ -911,6 +902,12 @@ export interface ApiErrorResponse {
             code: string;
             message: string;
         }>;
+        /**
+         * Precise failure tag from the originating server `DomainServiceError`
+         * (e.g. `STALE_BASE`, `PALETTE_CAP_REACHED`). Optional; the coarse `code`
+         * collapses several tags into one HTTP status.
+         */
+        tag?: string;
     };
 }
 export type ApiResponse<T> = ApiSuccessResponse<T> | ApiErrorResponse;
@@ -1048,6 +1045,20 @@ export interface PullOperations {
      */
     contentTypes(): Promise<PulledContentTypes>;
 }
+export type PulledCatalogTheme = SdkCatalogThemeResponse;
+export type PulledCatalogBlocks = SdkCatalogBlocksResponse;
+export type PulledCatalogContentTypes = SdkCatalogContentTypesResponse;
+export type Capabilities = SdkCapabilitiesResponse;
+/** Demo-seed provenance listing (plan 8.2). */
+export type DemoContent = SdkDemoContentResponse;
+export interface CatalogOperations {
+    /** Theme discovery catalog: styles, personalities, palettes, looks + current selection. */
+    theme(): Promise<PulledCatalogTheme>;
+    /** Block discovery catalog: manifest fields, content-source, theme-aware variant availability. */
+    blocks(): Promise<PulledCatalogBlocks>;
+    /** Content-type discovery catalog: normalized field DSL per content type. */
+    contentTypes(): Promise<PulledCatalogContentTypes>;
+}
 export interface BackfillPageResult {
     pagesUpdated: number;
     identifiersAssigned: Record<string, string>;
@@ -1134,6 +1145,19 @@ export interface ManagementClient {
     events: EventOperations;
     courses: CourseOperations;
     pull: PullOperations;
+    /** Discovery catalogs (theme / blocks / content-types). */
+    catalog: CatalogOperations;
     identifiers: IdentifiersOperations;
     media: MediaOperations;
+    /**
+     * Thin capabilities index: API version, catalog links, and per-catalog content
+     * hashes so agents can cache catalogs and detect drift.
+     */
+    capabilities(): Promise<Capabilities>;
+    /**
+     * Demo-seed provenance ledger: the resources demo recipe runs created on this
+     * site (plan 8.2), so an agent can distinguish placeholder demo content from
+     * authored content and drive cleanup.
+     */
+    demoContent(): Promise<DemoContent>;
 }