@cueframe/kernel 0.2.57 → 0.2.59-rc.0

package/dist/_members/composition-ops/index.d.ts

@@ -1050,8 +1050,8 @@ export declare function applyOp(composition: Composition, op: CompositionOp): Co
 export declare function applyOpToStore(store: HeadlessStore, op: CompositionOp): void;
 export declare function invertOp(before: Composition, op: CompositionOp): CompositionOp;
 export { createRecordingStore, type RecordingStore } from './recordingStore.js';
-export { wrapWithOpRecorder, type RecordableOps, type OpRecorderOpts } from './opRecorder.js';
+export { wrapWithOpRecorder, NON_DOCUMENT_METHODS, type RecordableOps, type OpRecorderOpts } from './opRecorder.js';
 export { materializeCompositionCaptions, materializeCaptionsFromComposition, captionSourceMediaIds, CaptionMaterializationError, type CaptionMaterializationErrorCode, } from './materializeCaptions.js';
 export { materializeGridMarkers, GridError, GRID_DEFAULT_MAX_MARKERS, GRID_HARD_MAX_MARKERS, type GridKind, type GridErrorCode, type GridPlacement, } from './materializeGrid.js';
 export { replaceRegion, type CutSpan, type ReplaceRegionInput } from './replaceRegion.js';
-export { collectAlphaLayerClips, type AlphaLayerClipRef, collectUnbakedComponentClips, type UnbakedComponentClipRef, collectRawComponentClips, } from './alphaLayers.js';
+export { collectAlphaLayerClips, type AlphaLayerClipRef, collectRawComponentClips, } from './alphaLayers.js';

package/dist/_members/composition-ops/opRecorder.d.ts

@@ -1,10 +1,17 @@
-import type { Composition, TimelineClip, Marker, Track, Format, ReframeSegment, CaptionSegment, CaptionStyle, PerClipEffect } from '../composition/validators/index.js';
+import type { Composition, TimelineClip, Marker, Track, Format, ReframeSegment, CaptionSegment, CaptionStyle, CaptionLayout, PerClipEffect } from '../composition/validators/index.js';
 import { type CompositionOp } from './index.js';
 export interface RecordableOps {
     addClip(clip: TimelineClip, options?: {
         newTrack?: boolean;
         newTrackId?: string;
     }): void;
+    addClipToTrack(clip: TimelineClip, target: {
+        trackId: string;
+    } | {
+        kind: Track['kind'];
+        newTrack?: boolean;
+        newTrackId?: string;
+    }): void;
     removeClip(id: string): void;
     updateClip(id: string, updates: Partial<TimelineClip>): void;
     removeClipsByMediaId(mediaId: string): void;
@@ -23,13 +30,15 @@ export interface RecordableOps {
     setEffects(clipId: string, effects: PerClipEffect[]): void;
     setCaptionStyle(style: CaptionStyle): void;
     setCaptions(segments: CaptionSegment[], style?: CaptionStyle): void;
+    setCaptionLayouts(layouts: CaptionLayout[]): void;
+    setCaptionDepth(zPlane: 'front' | 'behind-subject'): void;
     setFormat(format: Pick<Format, 'aspectRatio' | 'fps' | 'resolution'>): void;
     addTrack(kind: Track['kind'], name?: string, id?: string): void;
     removeTrack(trackId: string): void;
     updateTrack(trackId: string, updates: Partial<Pick<Track, 'name' | 'enabled'>>): void;
     reorderTracks(fromIndex: number, toIndex: number): void;
     moveClipToTrack(clipId: string, targetTrackId: string, newStartTime?: number): void;
-    duplicateClip(id: string): unknown;
+    duplicateClip(id: string): string | undefined;
     cutAndRipple(start: number, end: number): void;
     ripple(time: number, amount: number): void;
     addExcludedRange(clipId: string, sourceStart: number, sourceEnd: number, reason?: string): void;
@@ -38,6 +47,17 @@ export interface RecordableOps {
 export interface OpRecorderOpts {
     record: (op: CompositionOp, before: Composition) => void;
     getComposition: () => Composition;
-    onUnjournalable?: (reason: string) => void;
+    /**
+     * An edit no op expresses: journal the timeline it produces (`after`) as a
+     * replacement. Called before the edit is applied.
+     */
+    onUnjournalable?: (reason: string, after: Composition) => void;
 }
+/**
+ * Store members that change no document state, so they are not journaled.
+ * Every other function a wrapped store has must be journaled: an unlisted
+ * member is refused when the store is wrapped, so a new edit method cannot
+ * reach the document without reaching the journal.
+ */
+export declare const NON_DOCUMENT_METHODS: ReadonlySet<string>;
 export declare function wrapWithOpRecorder<T extends RecordableOps>(base: T, opts: OpRecorderOpts): T;

package/dist/_members/core/render/exportSettings.d.ts

@@ -1,7 +1,9 @@
 import type { CaptionStyle } from './types.js';
-export type ExportQuality = 'maximum' | 'social' | 'web' | 'potato' | 'source';
+export declare const EXPORT_QUALITIES: readonly ["maximum", "social", "web", "potato", "source"];
+export type ExportQuality = (typeof EXPORT_QUALITIES)[number];
 export type ExportFormat = 'source' | '16:9' | '9:16' | '4:5' | '1:1';
-export type ExportResolution = 'source' | '1080p' | '1440p' | '4k';
+export declare const EXPORT_RESOLUTIONS: readonly ["source", "1080p", "1440p", "4k"];
+export type ExportResolution = (typeof EXPORT_RESOLUTIONS)[number];
 export interface FormatPreset {
     label: string;
     aspectWidth: number;

package/dist/_members/core/render/index.d.ts

@@ -14,7 +14,7 @@ export { extractCaptionWordsFromDoc, sliceTranscriptWords, splitIntoSentences }
 export { compositionToRenderInput, referencedMediaIds, assembleRenderInput, assemblePreparedRenderInput, validateComposition, compositionFormatDimensions, captionVisibilityWindowsForComposition, playableSpans, projectMediaPlaybackSpans, assertBehindSubjectCaptionCoverage, visiblePackedHostWindows, } from './compositionRender.js';
 export { bookendFrames, resolveBookendTimeline, CARD_BOOKEND_DEFAULT_MS, VIDEO_BOOKEND_DEFAULT_MS, } from './bookends.js';
 export type { BookendTimeline } from './bookends.js';
-export { DEFAULT_FPS, DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_RENDER_SETTINGS, FORMAT_PRESETS, RESOLUTION_PRESETS, bppToCrf, ensureEven, qualityToCrf, resolutionToOutputSize, } from './exportSettings.js';
+export { DEFAULT_FPS, DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_RENDER_SETTINGS, FORMAT_PRESETS, RESOLUTION_PRESETS, EXPORT_QUALITIES, EXPORT_RESOLUTIONS, bppToCrf, ensureEven, qualityToCrf, resolutionToOutputSize, } from './exportSettings.js';
 export type { ExportFormat, ExportQuality, ExportResolution, FormatPreset, RenderSettings, } from './exportSettings.js';
 export { faceArea, resolveSubjectFaces, selectedFaceCenter, isJump, emaSmooth, clip01, captionBandReserve, aspectWhRatio, nearestKpValue, activeWindowsFor, perSubjectSeries, calibrateShotScale, deriveSegment, deriveTrajectory, buildEasedZooms, buildPannedCenters, easeOutCubic, JUMP_THRESHOLD, MIN_SUBJECT_RESOLUTION, } from './deriveTrajectory.js';
 export type { Subject, Center, TrajectorySubject, TrajectorySegment, TrajectoryData, Face, FaceBox, SubjectTrack, ReframeSegment, } from './deriveTrajectory.js';

package/dist/_members/core/render/vcam/requiredRegion.d.ts

@@ -9,6 +9,5 @@ export declare function padBox(box: NormBox, pad?: number): RequiredRegion;
 export declare function pointRegion(c: Center, pad?: number): RequiredRegion;
 export declare function centerRegion(): RequiredRegion;
 export declare function regionsFromBoxes(boxes: Array<NormBox | null>, pad?: number): Array<RequiredRegion | null>;
-export declare function regionsFromCenters(centers: Array<Center | null>, pad?: number): Array<RequiredRegion | null>;
 export declare function medianFilterRegions(regions: Array<RequiredRegion | null>, r: number, shotStart: number, shotEnd: number): Array<RequiredRegion | null>;
 export declare function buildRequiredRegions(boxes: Array<NormBox | null>, fps: number, interiorCuts: Iterable<number>, pad?: number): Array<RequiredRegion | null>;

package/dist/_members/director/ai-sdk/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./messages.js";
-export * from "./chunks.js";
 export * from "./context.js";
 export * from "./generationTool.js";

package/dist/_members/director/ai-sdk/messages.d.ts

@@ -132,7 +132,6 @@ export declare const cueFrameDataPartSchemas: {
         source: z.ZodOptional<z.ZodEnum<{
             provider: "provider";
             generation: "generation";
-            materialisation: "materialisation";
             agent: "agent";
             transport: "transport";
         }>>;

package/dist/_members/director/domain/chat.d.ts

@@ -1,9 +1,5 @@
 import { z } from "zod";
 import { type Envelope } from "../../errors/index.js";
-export declare const ConversationId: z.core.$ZodBranded<z.ZodString, "Id<conversation>", "out">;
-export type ConversationId = z.infer<typeof ConversationId>;
-export declare const DirectorRunId: z.core.$ZodBranded<z.ZodString, "Id<directorRun>", "out">;
-export type DirectorRunId = z.infer<typeof DirectorRunId>;
 export declare const ProjectRef: z.ZodObject<{
     id: z.ZodString;
     home: z.ZodEnum<{
@@ -49,7 +45,6 @@ export declare const ChatErrorView: z.ZodObject<{
     source: z.ZodOptional<z.ZodEnum<{
         provider: "provider";
         generation: "generation";
-        materialisation: "materialisation";
         agent: "agent";
         transport: "transport";
     }>>;
@@ -59,76 +54,3 @@ export declare const ChatErrorView: z.ZodObject<{
 export type ChatErrorView = z.infer<typeof ChatErrorView>;
 export declare function chatErrorViewFromEnvelope(envelope: Envelope, source?: ChatErrorView["source"]): ChatErrorView;
 export declare function chatErrorViewFromUnknown(error: unknown, source?: ChatErrorView["source"]): ChatErrorView;
-export declare const DirectorEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"text-delta">;
-    text: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"reasoning-delta">;
-    text: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"phase">;
-    phase: z.ZodString;
-    detail: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"generation">;
-    artifact: z.ZodObject<{
-        artifactVersion: z.ZodLiteral<1>;
-        clientRequestId: z.core.$ZodBranded<z.ZodString, "Id<generationRequest>", "out">;
-        generationId: z.core.$ZodBranded<z.ZodString, "Id<generation>", "out">;
-        mediaId: z.core.$ZodBranded<z.ZodString, "Id<media>", "out">;
-        generationGroupId: z.core.$ZodBranded<z.ZodString, "Id<generationGroup>", "out">;
-        version: z.ZodNumber;
-        kind: z.ZodEnum<{
-            video: "video";
-            audio: "audio";
-            image: "image";
-        }>;
-        requestSummary: z.ZodString;
-        status: z.ZodEnum<{
-            generating: "generating";
-            processing: "processing";
-            cancelled: "cancelled";
-            ready: "ready";
-            failed: "failed";
-            draft: "draft";
-            submitting: "submitting";
-            queued: "queued";
-            provider_complete: "provider_complete";
-            materialising: "materialising";
-            cancelling: "cancelling";
-        }>;
-        progress: z.ZodOptional<z.ZodNumber>;
-        placementReady: z.ZodDefault<z.ZodBoolean>;
-        parentMediaId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Id<media>", "out">>;
-        estimateUsd: z.ZodOptional<z.ZodNumber>;
-        failure: z.ZodOptional<z.ZodObject<{
-            code: z.ZodString;
-            title: z.ZodString;
-            recovery: z.ZodOptional<z.ZodString>;
-            retryable: z.ZodBoolean;
-            correlationId: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        createdAt: z.ZodNumber;
-        updatedAt: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"error">;
-    error: z.ZodObject<{
-        code: z.ZodString;
-        title: z.ZodString;
-        recovery: z.ZodOptional<z.ZodString>;
-        retryable: z.ZodBoolean;
-        source: z.ZodOptional<z.ZodEnum<{
-            provider: "provider";
-            generation: "generation";
-            materialisation: "materialisation";
-            agent: "agent";
-            transport: "transport";
-        }>>;
-        correlationId: z.ZodOptional<z.ZodString>;
-        details: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"finish">;
-}, z.core.$strip>], "type">;
-export type DirectorEvent = z.infer<typeof DirectorEvent>;

package/dist/_members/director/domain/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./generation.js";
 export * from "./chat.js";
-export * from "./ports.js";

package/dist/_members/errors/registry.d.ts

@@ -27,6 +27,12 @@ export declare const ERROR_CODES: {
         readonly retryable: false;
         readonly httpStatus: 404;
     };
+    readonly system_project: {
+        readonly stage: "auth";
+        readonly category: "authoring";
+        readonly retryable: false;
+        readonly httpStatus: 409;
+    };
     readonly billing_required: {
         readonly stage: "billing";
         readonly category: "authoring";
@@ -573,6 +579,36 @@ export declare const ERROR_CODES: {
         readonly retryable: false;
         readonly httpStatus: 413;
     };
+    readonly template_parameter_undeclared: {
+        readonly stage: "validate";
+        readonly category: "authoring";
+        readonly retryable: false;
+        readonly httpStatus: 422;
+    };
+    readonly template_values_invalid: {
+        readonly stage: "validate";
+        readonly category: "authoring";
+        readonly retryable: false;
+        readonly httpStatus: 422;
+    };
+    readonly template_media_kind_mismatch: {
+        readonly stage: "validate";
+        readonly category: "authoring";
+        readonly retryable: false;
+        readonly httpStatus: 422;
+    };
+    readonly template_component_conflict: {
+        readonly stage: "validate";
+        readonly category: "authoring";
+        readonly retryable: false;
+        readonly httpStatus: 409;
+    };
+    readonly template_media_import_failed: {
+        readonly stage: "import";
+        readonly category: "authoring";
+        readonly retryable: false;
+        readonly httpStatus: 422;
+    };
     readonly invalid_webhook_url: {
         readonly stage: "validate";
         readonly category: "authoring";
@@ -1101,6 +1137,12 @@ export declare const ERROR_CODES: {
         readonly retryable: false;
         readonly httpStatus: 422;
     };
+    readonly component_api_mismatch: {
+        readonly stage: "validate";
+        readonly category: "authoring";
+        readonly retryable: false;
+        readonly httpStatus: 422;
+    };
     readonly component_graphics_unavailable: {
         readonly stage: "render";
         readonly category: "authoring";

package/dist/_members/foundation/canonical/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Canonical JSON: sorted keys, `undefined` fields dropped (`null` inside an
+ * array, as `JSON.stringify` does), everything else as `JSON.stringify` writes
+ * it. Composition etags are this string's SHA-256, and they are stored
+ * (`compositionVersions.etag`, `restorePoints.etag`) and compared across
+ * processes for If-Match, so these bytes never change.
+ *
+ * It is not the component source identity (`@cueframe/component-runtime`
+ * `canonicalIdentity`), which normalizes text and refuses what it cannot
+ * hash exactly, nor the scene capture JSON (`@cueframe/core/render`
+ * `canonicalSceneJsonV1`). Their bytes are persisted too, and differ on
+ * edge inputs, so the three are kept apart on purpose.
+ */
+export declare function canonicalJson(value: unknown): string;

package/dist/_members/foundation/index.d.ts

@@ -1,2 +1,2 @@
 export * from "./primitives/index.js";
-export * from "./codes/index.js";
+export * from "./canonical/index.js";

package/dist/_members/foundation/primitives/index.d.ts

@@ -5,5 +5,3 @@ export declare const ISODateTime: z.ZodString;
 export type ISODateTime = z.infer<typeof ISODateTime>;
 export declare const EntityId: <T extends string>(_table: T) => PropertyKey extends `Id<${T}>` ? z.ZodString : z.core.$ZodBranded<z.ZodString, `Id<${T}>`, "out">;
 export type EntityId<T extends string> = z.infer<ReturnType<typeof EntityId<T>>>;
-export declare const ParamsBag: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-export type ParamsBag = z.infer<typeof ParamsBag>;

package/dist/_members/foundation/testing/index.d.ts

@@ -0,0 +1 @@
+export { contractFacts, type KnownRed } from "./knownRed.js";

package/dist/_members/foundation/testing/knownRed.d.ts

@@ -0,0 +1,13 @@
+/** A contract fact a lane is known to fail, and the error it fails with today. */
+export interface KnownRed {
+    fact: string;
+    failsWith: RegExp;
+}
+type It = (name: string, fn: () => Promise<void> | void) => void;
+/**
+ * Registers contract facts. A known-red fact must still fail, and with its
+ * named error: any other failure (a crash, an outage) fails the run, and a pass
+ * says to delete the entry.
+ */
+export declare function contractFacts(it: It, knownRed?: readonly KnownRed[]): (name: string, fn: () => Promise<void> | void) => void;
+export {};

package/dist/_members/mcp/adapter.d.ts

@@ -79,4 +79,25 @@ export interface CuratedToolSetOpts {
         sleep?: (ms: number) => Promise<void>;
     };
 }
+export type PreviewAugmented = {
+    __preview: true;
+    text: string;
+    images: string[];
+};
+export declare function previewVisionModelOutput({ output }: {
+    output: unknown;
+}): {
+    type: 'content';
+    value: ({
+        type: 'text';
+        text: string;
+    } | {
+        type: 'image-data';
+        mediaType: string;
+        data: string;
+    })[];
+} | {
+    type: 'text';
+    value: string;
+};
 export declare function buildCuratedToolSet(ex: Executor, opts: CuratedToolSetOpts): ToolSet;

package/dist/_members/mcp/compositionOps.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const DESCRIBE_COMPOSITION_OPS_DESCRIPTION = "Discover the exact CompositionOp vocabulary accepted by apply_composition. Omit type for a compact list of operation names and descriptions; pass type for only that operation's JSON Schema. Read this before authoring edits or captions.";
+export declare const DescribeCompositionOpsInput: z.ZodObject<{
+    type: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Read from the same discriminated union that validates composition edits. Loaded on first
+ * call: composition-ops carries the whole composition schema, which no other tool needs at init.
+ */
+export declare function describeCompositionOps(type?: string): Promise<Record<string, unknown>>;

package/dist/_members/mcp/server.d.ts

@@ -20,8 +20,6 @@ export declare function registerCuratedTools(server: McpServer, ex: Executor, op
     expert?: boolean;
     onEvent?: McpTelemetrySink;
 }): void;
-/** Read from the same discriminated union that validates composition edits. */
-export declare function describeCompositionOps(type?: string): Record<string, unknown>;
 export interface BuildServerOpts {
     executor: Executor;
     expert?: boolean;

package/dist/_members/mcp/wait.d.ts

@@ -5,7 +5,9 @@ export type WaitResult = {
     stillRunning?: boolean;
     mediaUrls?: string[];
 };
-export type WaitKind = 'media' | 'render' | 'compose' | 'suggestions' | 'verify' | 'preview_frame' | 'preview' | 'brand_kit_extract' | 'consult';
+/** Every job kind wait_job waits on; both the MCP server and the Director's tool take this list. */
+export declare const WAIT_KINDS: readonly ["media", "render", "compose", "suggestions", "verify", "preview_frame", "preview", "brand_kit_extract", "consult"];
+export type WaitKind = (typeof WAIT_KINDS)[number];
 export interface WaitDeps {
     sleep?: (ms: number) => Promise<void>;
     now?: () => number;

package/dist/_members/media-model/generation.d.ts

@@ -200,28 +200,3 @@ export declare const GenerationCapabilities: z.ZodArray<z.ZodObject<{
     supportsQuote: z.ZodBoolean;
 }, z.core.$strip>>;
 export type GenerationCapabilities = z.infer<typeof GenerationCapabilities>;
-export interface GenerationStateSources {
-    attempt: {
-        status: Exclude<GenerationStatus, "materialising" | "processing" | "ready">;
-        progress?: number;
-        failure?: GenerationFailure;
-    };
-    resource: {
-        kind: MediaKind;
-        durable: boolean;
-        decodable: boolean;
-        metadataReady: boolean;
-        placementReady: boolean;
-    };
-    materialisation: {
-        required: boolean;
-        status: "not_started" | "pending_source" | "downloading" | "complete" | "failed";
-        verifiedBytes: boolean;
-        failure?: GenerationFailure;
-    };
-}
-export declare function deriveGenerationStatus(sources: GenerationStateSources): {
-    status: GenerationStatus;
-    placementReady: boolean;
-    failure?: GenerationFailure;
-};

package/dist/_members/nle-export/xml-utils.d.ts

@@ -1,9 +1 @@
-export interface FrameRateInfo {
-    displayRate: number;
-    isNtsc: boolean;
-    frameDuration: string;
-}
-export declare function getFrameRateInfo(fps: number): FrameRateInfo;
-export declare function toRationalTime(seconds: number, fps: number): string;
-export declare function toFrames(seconds: number, fps: number): number;
 export declare function slugify(s: string): string;

package/dist/_members/plane/conformance.d.ts

@@ -14,3 +14,23 @@ export declare const CONFORMANCE_COMPOSITION: Composition;
 export declare const CONFORMANCE_DURATION_SEC = 5;
 export declare const PREVIEW_FRAME_CASES: readonly ConformanceCase[];
 export declare function isKnownRed(c: ConformanceCase, lane: Lane): boolean;
+/** Whether a lane's answer is the one the case expects. */
+export declare function meetsExpectation(c: ConformanceCase, answer: {
+    status: number;
+    code?: string;
+}): boolean;
+/**
+ * Checks a lane's answer to a case. A known-red case must still answer, and
+ * still differently from the expectation: it fails the run once the lane
+ * conforms (so the marker is deleted), and a crash before any answer fails it
+ * too, because the runner awaits the answer rather than expecting a throw.
+ */
+export declare function conformanceVerdict(c: ConformanceCase, lane: Lane, answer: {
+    status: number;
+    code?: string;
+}): {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};

package/dist/_members/primitives/backgrounds/dynamic-grid/config.d.ts

@@ -5,9 +5,9 @@ declare const paramsSchema: z.ZodObject<{
     lineColor: z.ZodDefault<z.ZodString>;
     background: z.ZodDefault<z.ZodString>;
     direction: z.ZodDefault<z.ZodEnum<{
+        diagonal: "diagonal";
         horizontal: "horizontal";
         vertical: "vertical";
-        diagonal: "diagonal";
     }>>;
     speed: z.ZodDefault<z.ZodNumber>;
 }, z.core.$loose>;

package/dist/_members/primitives/effects/blur/config.d.ts

@@ -2,8 +2,8 @@ import { z } from 'zod';
 import type { PrimitiveMeta } from '../../lib/types.js';
 declare const paramsSchema: z.ZodObject<{
     type: z.ZodDefault<z.ZodEnum<{
-        motion: "motion";
         gaussian: "gaussian";
+        motion: "motion";
     }>>;
     radius: z.ZodDefault<z.ZodNumber>;
     animateFrom: z.ZodOptional<z.ZodNumber>;

package/dist/_members/primitives/effects/color-grade/config.d.ts

@@ -3,11 +3,11 @@ import type { PrimitiveMeta } from '../../lib/types.js';
 declare const paramsSchema: z.ZodObject<{
     preset: z.ZodDefault<z.ZodEnum<{
         cinematic: "cinematic";
-        none: "none";
         vintage: "vintage";
+        cool: "cool";
+        none: "none";
         "bleach-bypass": "bleach-bypass";
         sepia: "sepia";
-        cool: "cool";
         warm: "warm";
     }>>;
     brightness: z.ZodOptional<z.ZodNumber>;

package/dist/_members/primitives/effects/grain/config.d.ts

@@ -5,11 +5,11 @@ declare const paramsSchema: z.ZodObject<{
     speed: z.ZodDefault<z.ZodNumber>;
     blendMode: z.ZodDefault<z.ZodEnum<{
         overlay: "overlay";
-        normal: "normal";
-        "hard-light": "hard-light";
+        "soft-light": "soft-light";
         multiply: "multiply";
         screen: "screen";
-        "soft-light": "soft-light";
+        "hard-light": "hard-light";
+        normal: "normal";
     }>>;
     monochrome: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$loose>;

package/dist/_members/primitives/effects/particles/config.d.ts

@@ -2,12 +2,12 @@ import { z } from 'zod';
 import type { PrimitiveMeta } from '../../lib/types.js';
 declare const paramsSchema: z.ZodObject<{
     preset: z.ZodDefault<z.ZodEnum<{
+        bokeh: "bokeh";
         snow: "snow";
+        fireflies: "fireflies";
         dust: "dust";
-        bokeh: "bokeh";
         sparks: "sparks";
         embers: "embers";
-        fireflies: "fireflies";
     }>>;
     count: z.ZodDefault<z.ZodNumber>;
     size: z.ZodOptional<z.ZodNumber>;

package/dist/_members/primitives/effects/stage-camera/config.d.ts

@@ -2,21 +2,21 @@ import { z } from 'zod';
 import type { PrimitiveMeta } from '../../lib/types.js';
 declare const paramsSchema: z.ZodObject<{
     move: z.ZodDefault<z.ZodEnum<{
-        static: "static";
+        orbit: "orbit";
         "dolly-in": "dolly-in";
-        "dolly-out": "dolly-out";
-        drift: "drift";
         "tilt-reveal": "tilt-reveal";
-        orbit: "orbit";
+        drift: "drift";
+        static: "static";
+        "dolly-out": "dolly-out";
     }>>;
     fov: z.ZodDefault<z.ZodNumber>;
     amount: z.ZodOptional<z.ZodNumber>;
     easing: z.ZodDefault<z.ZodEnum<{
         emphasis: "emphasis";
-        playful: "playful";
         none: "none";
-        exit: "exit";
+        playful: "playful";
         entrance: "entrance";
+        exit: "exit";
         cross: "cross";
         drama: "drama";
     }>>;

package/dist/_members/primitives/effects/vignette/config.d.ts

@@ -4,8 +4,8 @@ declare const paramsSchema: z.ZodObject<{
     intensity: z.ZodDefault<z.ZodNumber>;
     spread: z.ZodDefault<z.ZodNumber>;
     shape: z.ZodDefault<z.ZodEnum<{
-        circle: "circle";
         ellipse: "ellipse";
+        circle: "circle";
     }>>;
     color: z.ZodDefault<z.ZodString>;
 }, z.core.$loose>;

package/dist/_members/primitives/index.d.ts

@@ -1,13 +1,3 @@
-import type { Catalog, PrimitiveMeta } from './lib/types.js';
+import type { Catalog } from './lib/types.js';
 export declare const allPrimitives: Catalog;
-export declare const catalogs: {
-    readonly text: Catalog;
-    readonly effects: Catalog;
-    readonly transitions: Catalog;
-    readonly layouts: Catalog;
-    readonly backgrounds: Catalog;
-    readonly 'ui-blocks': Catalog;
-    readonly scenes: Catalog;
-};
-export declare function resolvePrimitive(id: string): PrimitiveMeta | undefined;
 export type { Catalog, PrimitiveMeta } from './lib/types.js';

package/dist/_members/primitives/layouts/flex-layout/config.d.ts

@@ -2,8 +2,8 @@ import { z } from 'zod';
 import type { PrimitiveMeta } from '../../lib/types.js';
 declare const paramsSchema: z.ZodObject<{
     direction: z.ZodDefault<z.ZodEnum<{
-        column: "column";
         row: "row";
+        column: "column";
     }>>;
     gap: z.ZodDefault<z.ZodNumber>;
     padding: z.ZodDefault<z.ZodNumber>;
@@ -49,12 +49,12 @@ declare const paramsSchema: z.ZodObject<{
     }, z.core.$strict>]>>>;
     fits: z.ZodOptional<z.ZodArray<z.ZodObject<{
         mode: z.ZodEnum<{
-            position: "position";
             stretch: "stretch";
+            position: "position";
+            matte: "matte";
             contain: "contain";
             cover: "cover";
             scale: "scale";
-            matte: "matte";
         }>;
         aspect: z.ZodOptional<z.ZodNumber>;
         size: z.ZodOptional<z.ZodObject<{

package/dist/_members/primitives/layouts/picture-in-picture/config.d.ts

@@ -2,10 +2,10 @@ import { z } from 'zod';
 import type { PrimitiveMeta } from '../../lib/types.js';
 declare const paramsSchema: z.ZodObject<{
     position: z.ZodDefault<z.ZodEnum<{
+        "bottom-right": "bottom-right";
+        "top-right": "top-right";
         "top-left": "top-left";
         "bottom-left": "bottom-left";
-        "top-right": "top-right";
-        "bottom-right": "bottom-right";
     }>>;
     size: z.ZodDefault<z.ZodNumber>;
     borderRadius: z.ZodDefault<z.ZodNumber>;

package/dist/_members/primitives/lib/index.d.ts

@@ -2,7 +2,7 @@ export type { PrimitiveMeta, PrimitiveCategory, PrimitiveKind, Mood, Example, To
 export { SOFT, OUT_EXPO, OUT_BACK, OUT_CUBIC, IN_OUT_CUBIC, IN_OUT_QUART, IN_QUART, LINEAR, STEP, EASING_BY_INTENT, type EasingIntent, } from './easings.js';
 export { pick, range, gauss, SeededPRNG } from './seeded-random.js';
 export { frameScale, useFrameScale, FRAME_BASELINE_WIDTH } from './frameScale.js';
-export { resolveTokenValue, applyBrandCascade, resolveParams, isContrastCritical, CONTRAST_CRITICAL_PATHS, ALLOWED_BRAND_PATHS, FROZEN_CORE_PATHS, TIER2B_EXTENSION_PATHS, lintBrandPath, } from './tokens.js';
+export { isContrastCritical, CONTRAST_CRITICAL_PATHS, ALLOWED_BRAND_PATHS, FROZEN_CORE_PATHS, TIER2B_EXTENSION_PATHS, lintBrandPath, } from './tokens.js';
 export { NEUTRAL_RAMP } from '../../brand-derivation/constants.js';
 export { zodToJsonSchemaFor, zodToDefaults, zodToControls, type ControlConfig, type ControlType, } from './schema.js';
 export { PrimitivePreview, type PrimitivePreviewProps } from './preview.js';