@playcraft/cli 0.1.55-beta → 0.1.57-beta

package/templates/preview-runtime/v1/types/adapters.d.ts

@@ -1,4 +1,4 @@
-import type { FieldCapability, RawDocuments } from './protocol.js';
+import type { FieldCapability, ImageResourceRequest, RawDocuments } from './protocol.js';
 export interface ApplyContext<C> {
     beforeConfig: C;
     config: C;
@@ -6,6 +6,7 @@ export interface ApplyContext<C> {
     fields: FieldCapability[];
     signal: AbortSignal;
     assertCurrent(): void;
+    loadImage(field: FieldCapability, value: string): Promise<HTMLImageElement>;
 }
 /** All callbacks must check cancellation before late asynchronous side effects. */
 export interface GameAdapter<C> {
@@ -23,4 +24,8 @@ export interface RuntimeOptions<C> {
         install(config: C): unknown;
     };
     createGame(context: ApplyContext<C>): Promise<GameAdapter<C>>;
+    loadImage?(request: ImageResourceRequest, signal: AbortSignal): Promise<HTMLImageElement | {
+        image: HTMLImageElement;
+        contentHash?: string;
+    }>;
 }

package/templates/preview-runtime/v1/types/preview.d.ts

@@ -1,5 +1,6 @@
 import type { RuntimeOptions } from './adapters.js';
 import type { SessionBinding } from './protocol.js';
+export { ResourceLoadError } from './protocol.js';
 /** Reads only the platform's explicit context; a game receives no platform credentials. */
 export declare function readWorkspacePreviewContext(expectedContractVersion: string): {
     binding: SessionBinding;
@@ -12,6 +13,7 @@ export declare function connectPreviewRuntime<C>(options: RuntimeOptions<C> & {
         hello(value: unknown): import("./protocol.js").Capabilities;
         snapshot(value: unknown): import("./protocol.js").Receipt;
         patch(value: unknown): import("./protocol.js").Receipt;
+        refreshImages(value: unknown): import("./protocol.js").ImageRefreshReceipt;
         restart(value: unknown): import("./protocol.js").Receipt;
         status(value: unknown): import("./protocol.js").ApplicationResult;
         subscribe(fn: (result: import("./protocol.js").ApplicationResult) => void): () => boolean;

package/templates/preview-runtime/v1/types/protocol.d.ts

@@ -30,11 +30,14 @@ export interface FieldCapability {
     effectivePath: string[];
     groupId: string;
     mode: ApplyMode;
+    resource?: 'image';
 }
 export interface Capabilities extends Identity {
     stage: 'bootstrap-ready' | 'game-ready';
     canAcceptSnapshot: boolean;
     fields: FieldCapability[];
+    canRefreshImages?: true;
+    canReportMissingImages?: true;
 }
 export type Operation = {
     op: 'set';
@@ -60,6 +63,20 @@ export interface Receipt {
     accepted: true;
     receivedRevision: number;
 }
+export type ImageRefreshTarget = {
+    documentId: string;
+    path: string[];
+    /** Null reports a confirmed missing file; it does not clear the configured image. */
+    contentHash: string | null;
+};
+export interface ImageRefreshRequest extends Identity {
+    draftRevision: number;
+    resourceSequence: number;
+    images: ImageRefreshTarget[];
+}
+export interface ImageRefreshReceipt extends Receipt {
+    resourceSequence: number;
+}
 export interface GroupResult {
     groupId: string;
     appliedRevision: number;
@@ -73,6 +90,42 @@ export interface ApplicationResult extends Identity {
     status: 'idle' | 'applying' | 'applied' | 'pending-commit' | 'requires-reload' | 'error';
     groups: GroupResult[];
     error?: string;
+    recoverable?: true;
+    resourceErrors?: Array<{
+        documentId: string;
+        path: string[];
+        error: string;
+    }>;
+}
+export interface ImageResourceRequest extends Identity {
+    draftRevision: number;
+    documentId: string;
+    path: string[];
+    value: string;
+    resourceSequence?: number;
+    expectedContentHash?: string;
+}
+export type ImageResourceData = {
+    mimeType: string;
+    dataUrl: string;
+    contentHash?: string;
+};
+export type ImageResourceResponse = ImageResourceRequest & (({
+    status: 'ready';
+} & ImageResourceData) | {
+    status: 'failed';
+    error: string;
+} | {
+    status: 'stale';
+});
+export declare const MAX_IMAGE_RESOURCE_BYTES: number;
+/** Loading failures retain the last rendered image and allow another parameter patch. */
+export declare class ResourceLoadError extends Error {
+    constructor(message: string);
+}
+/** A newer value replaced this resource while it was being prepared. */
+export declare class SupersededResourceError extends Error {
+    constructor();
 }
 export declare class ProtocolError extends Error {
     readonly code: string;
@@ -88,6 +141,9 @@ export declare function assertIdentity(value: unknown): asserts value is Identit
 export declare function sameIdentity(a: Identity, b: unknown): b is Identity;
 export declare function assertBinding(expected: SessionBinding, actual: Hello): void;
 export declare function assertDocuments(value: unknown): asserts value is RawDocuments;
+export declare function assertImageResourceRequest(value: unknown): asserts value is ImageResourceRequest;
+export declare function assertImageRefresh(value: unknown): asserts value is ImageRefreshRequest;
+export declare function assertImageResourceData(value: unknown): asserts value is ImageResourceData;
 export declare function assertSnapshot(value: unknown): asserts value is SnapshotRequest;
 export declare function assertPatch(value: unknown): asserts value is PatchRequest;
 export declare function applyOperations(documents: RawDocuments, operations: Operation[]): RawDocuments;

package/templates/preview-runtime/v1/types/runtime.d.ts

@@ -1,9 +1,10 @@
 import type { RuntimeOptions } from './adapters.js';
-import type { ApplicationResult, Capabilities, Receipt } from './protocol.js';
+import type { ApplicationResult, Capabilities, ImageRefreshReceipt, Receipt } from './protocol.js';
 export declare function createParameterRuntime<C>(options: RuntimeOptions<C>): {
     hello(value: unknown): Capabilities;
     snapshot(value: unknown): Receipt;
     patch(value: unknown): Receipt;
+    refreshImages(value: unknown): ImageRefreshReceipt;
     restart(value: unknown): Receipt;
     status(value: unknown): ApplicationResult;
     subscribe(fn: (result: ApplicationResult) => void): () => boolean;