@kubohiroya/turbowarp-asset-cache 0.1.0

package/dist/types/composition.d.ts

@@ -0,0 +1,111 @@
+import { type AssetManagerFeatureFlags } from './feature-flags.js';
+import { type BinaryBundleBackendStatus, type BinaryBundlePruneResult, type BinaryBundleStoreStats, type BinaryBundleKeyInput, type BinaryBundleOperationOptions, type BinaryBundlePutInput, type BinaryBundleRegistration, type BinaryBundleResult, type BinaryBundleStoreOptions } from './binary-bundle-store.js';
+import { type VerifiedRemoteBinaryCacheOptions, type VerifiedRemoteBinaryInput, type VerifiedRemoteBinaryResolveOptions, type VerifiedRemoteBinaryResult, type VerifiedRemoteCachePruneResult, type VerifiedRemoteCacheStats, type VerifiedRemoteStoryCacheDeleteResult, type VerifiedRemoteStoryCacheInfo, type VerifiedRemoteStoryCachePruneResult } from './verified-remote-cache.js';
+import { type SessionBinaryBacking, type SessionBinaryBackingInput, type SessionBinaryBackingOptions } from './session-binary-backing.js';
+import { type DOMImageResource } from './dom-image-resource.js';
+import { type NamedAssetBodyProvider } from './named-body-provider.js';
+export { type AssetManagerAudioVoice, type AssetManagerAudioVoiceOptions } from './audio-voice.js';
+import { type AssetManagerAudioVoice, type AssetManagerAudioVoiceOptions } from './audio-voice.js';
+export { type DOMImageResource } from './dom-image-resource.js';
+export { NAMED_ASSET_BODY_NAMESPACE, NamedAssetBodyError, type NamedAssetBodyErrorCode, type NamedAssetBodyMetadata, type NamedAssetBodyOpenOptions, type NamedAssetBodyProvider, type NamedAssetBodyReference, type NamedAssetBodySnapshot } from './named-body-provider.js';
+export { createBinaryBundleStore, type BinaryBundleBackendStatus, type BinaryBundleBackendWarning, type BinaryBundleFileInput, type BinaryBundleFileRegistration, type BinaryBundleFileResult, type BinaryBundleKeyInput, type BinaryBundleOperationOptions, type BinaryBundlePruneResult, type BinaryBundlePutInput, type BinaryBundleRegistration, type BinaryBundleResult, type BinaryBundleStore, type BinaryBundleStoreStats, type BinaryBundleStoreOptions } from './binary-bundle-store.js';
+export { createIndexedDBBinaryObjectStore, createOpfsBinaryObjectStore, type BinaryObjectDescriptor, type BinaryObjectOperationOptions, type BinaryObjectResult, type BinaryObjectStore, type BinaryObjectStoreStats, type BinaryObjectStatsOptions, type BinaryStorageBackendPolicy, type IndexedDBBinaryObjectStoreOptions, type OpfsBinaryObjectStoreOptions, type OpfsStorageManager } from './binary-object-store.js';
+export { createVerifiedRemoteBinaryCache, createVerifiedRemoteCacheDatabaseName, type NormalizedVerifiedRemoteBinaryInput, type VerifiedRemoteBinaryCache, type VerifiedRemoteBinaryCacheOptions, type VerifiedRemoteBinaryInput, type VerifiedRemoteBinaryLoadResult, type VerifiedRemoteBinaryResolveOptions, type VerifiedRemoteBinaryResult, type VerifiedRemoteCacheWarning, type VerifiedRemoteCacheIdentity, type VerifiedRemoteCacheIdentityInput, type VerifiedRemoteCachePruneResult, type VerifiedRemoteCacheStats, type VerifiedRemoteStoryCacheDeleteResult, type VerifiedRemoteStoryCacheInfo, type VerifiedRemoteStoryCachePruneResult } from './verified-remote-cache.js';
+export { createSessionBinaryBacking, type SessionBinaryBacking, type SessionBinaryBackingAssetInput, type SessionBinaryBackingInput, type SessionBinaryBackingMode, type SessionBinaryBackingOptions, type SessionBinaryBackingPolicy, type SessionBinaryBackingSource, type SessionBinaryBackingSourceAsset, type SessionBinaryBackingWarning } from './session-binary-backing.js';
+export interface EmbeddedAssetBytesInput {
+    name: unknown;
+    nameMode?: AssetNameMode;
+    bytes: ArrayBuffer | Uint8Array;
+    mimeType: unknown;
+    sourceName?: unknown;
+    bitmapResolution?: 1 | 2;
+}
+export interface EmbeddedAssetRegistration {
+    readonly name: string;
+    readonly mimeType: string;
+}
+export type AssetNameMode = 'trimmed' | 'literal';
+export type ProjectAssetLocator = Readonly<{
+    kind: 'backdrop';
+    name: string;
+}> | Readonly<{
+    kind: 'costume';
+    target: string;
+    name: string;
+}> | Readonly<{
+    kind: 'sound';
+    name: string;
+    target?: string;
+}>;
+export type ProjectAssetRegistrationInput = Readonly<{
+    name: unknown;
+    nameMode?: AssetNameMode;
+    resourceId: unknown;
+    locator?: never;
+}> | Readonly<{
+    name: unknown;
+    nameMode?: AssetNameMode;
+    locator: ProjectAssetLocator;
+    resourceId?: never;
+}>;
+export interface AssetManagerCompositionTarget {
+    readonly id: string;
+    readonly isStage: boolean;
+}
+export interface DOMImageResourceTarget {
+    readonly namespaceURI?: string | null;
+    readonly localName?: string;
+    getAttribute(name: string): string | null;
+    setAttribute(name: string, value: string): void;
+    removeAttribute(name: string): void;
+}
+export interface DOMImageResourceBindingOptions {
+    readonly attribute?: 'href' | 'src';
+    readonly owner?: AssetManagerCompositionTarget;
+}
+export interface AssetManagerCompositionOptions {
+    readonly verifiedRemoteCache?: VerifiedRemoteBinaryCacheOptions;
+    readonly binaryBundleStore?: BinaryBundleStoreOptions;
+    readonly sessionBinaryBacking?: SessionBinaryBackingOptions;
+}
+export interface AssetManagerComposition {
+    registerProjectAsset(input: ProjectAssetRegistrationInput): Promise<EmbeddedAssetRegistration>;
+    registerEmbeddedAsset(input: EmbeddedAssetBytesInput): Promise<EmbeddedAssetRegistration>;
+    releaseAsset(name: unknown): void;
+    releaseAll(): void;
+    isRegistered(name: unknown): boolean;
+    getMimeType(name: unknown): string;
+    getNamedBodyProvider(): NamedAssetBodyProvider | null;
+    getNamedDataProvider(): NamedAssetBodyProvider | null;
+    resolveDOMImageResource(name: unknown): Promise<DOMImageResource>;
+    applyDOMImageResource(name: unknown, target: DOMImageResourceTarget, options?: DOMImageResourceBindingOptions): Promise<DOMImageResource>;
+    releaseDOMImageResource(target: DOMImageResourceTarget): void;
+    releaseAllDOMImageResources(): void;
+    applyToStage(name: unknown): Promise<void>;
+    applyToTarget(name: unknown, target: AssetManagerCompositionTarget): Promise<void>;
+    playSound(name: unknown, options?: Readonly<{
+        untilDone?: boolean;
+    }>): Promise<void>;
+    createAudioVoice(name: unknown, options?: AssetManagerAudioVoiceOptions): Promise<AssetManagerAudioVoice>;
+    stopSound(name: unknown): void;
+    stopAllSounds(): void;
+    resolveVerifiedRemoteBinary(input: VerifiedRemoteBinaryInput, options: VerifiedRemoteBinaryResolveOptions): Promise<VerifiedRemoteBinaryResult>;
+    getVerifiedRemoteCacheStats(): Promise<VerifiedRemoteCacheStats>;
+    pruneVerifiedRemoteCache(): Promise<VerifiedRemoteCachePruneResult>;
+    clearVerifiedRemoteCache(): Promise<VerifiedRemoteCachePruneResult>;
+    listVerifiedRemoteStoryCaches(): Promise<ReadonlyArray<VerifiedRemoteStoryCacheInfo>>;
+    pruneVerifiedRemoteStoryCaches(): Promise<VerifiedRemoteStoryCachePruneResult>;
+    deleteVerifiedRemoteStoryCache(databaseName: unknown): Promise<VerifiedRemoteStoryCacheDeleteResult>;
+    renewVerifiedRemoteStoryCacheLease(): Promise<void>;
+    releaseVerifiedRemoteStoryCacheLease(): Promise<void>;
+    putBinaryBundle(input: BinaryBundlePutInput, options?: BinaryBundleOperationOptions): Promise<BinaryBundleRegistration>;
+    getBinaryBundle(input: BinaryBundleKeyInput, options?: BinaryBundleOperationOptions): Promise<BinaryBundleResult>;
+    deleteBinaryBundle(input: BinaryBundleKeyInput, options?: BinaryBundleOperationOptions): Promise<void>;
+    getBinaryBundleBackendStatus(): BinaryBundleBackendStatus;
+    getBinaryBundleStoreStats(): Promise<BinaryBundleStoreStats>;
+    pruneBinaryBundleStore(): Promise<BinaryBundlePruneResult>;
+    clearBinaryBundleStore(): Promise<BinaryBundlePruneResult>;
+    releaseBinaryStore(): Promise<void>;
+    createSessionBinaryBacking(input: SessionBinaryBackingInput, options?: BinaryBundleOperationOptions): Promise<SessionBinaryBacking>;
+}
+export declare function createAssetManagerComposition(featureFlags?: AssetManagerFeatureFlags, options?: AssetManagerCompositionOptions): AssetManagerComposition;

package/dist/types/dom-image-resource.d.ts

@@ -0,0 +1,18 @@
+export interface DOMImageResource {
+    readonly url: string;
+    readonly mimeType: string;
+    readonly width: number;
+    readonly height: number;
+    readonly released: boolean;
+    release(): void;
+}
+export interface DOMImageResourceInput {
+    readonly name: string;
+    readonly bytes: Uint8Array;
+    readonly mimeType: string;
+}
+export interface DOMImageResourceBacking {
+    acquire(onRelease?: (resource: DOMImageResource) => void): DOMImageResource;
+}
+export declare function createDOMImageResource(input: DOMImageResourceInput, onRelease?: (resource: DOMImageResource) => void): Promise<DOMImageResource>;
+export declare function createDOMImageResourceBacking(input: DOMImageResourceInput, onIdle?: (backing: DOMImageResourceBacking) => void): Promise<DOMImageResourceBacking>;

package/dist/types/extension.d.ts

@@ -0,0 +1,257 @@
+import { AssetManagerError } from './asset-cache-error.js';
+import { type AssetManagerFeatureFlags } from './feature-flags.js';
+import { type DOMImageResource } from './dom-image-resource.js';
+import { type AssetManagerAudioVoice, type AssetManagerAudioVoiceOptions } from './audio-voice.js';
+import { type NamedAssetBodyProvider } from './named-body-provider.js';
+export declare const EXTENSION_ID = "kubohiroyaassetcache";
+export declare const EXTENSION_VERSION = "0.14.0";
+export declare const EXTENSION_DOCS_URI = "https://kubohiroya.github.io/turbowarp-asset-cache/";
+export declare const BLOCK_ICON_URI: string;
+type BlockArgs = Record<string, unknown>;
+export type AssetKind = 'external' | 'costume' | 'backdrop' | 'sound' | 'text';
+export interface EmbeddedAssetBytesInput {
+    name: unknown;
+    bytes: ArrayBuffer | Uint8Array;
+    mimeType: unknown;
+    sourceName?: unknown;
+    bitmapResolution?: 1 | 2;
+}
+export interface EmbeddedAssetRegistration {
+    readonly name: string;
+    readonly mimeType: string;
+}
+export interface ResolvedImageAssetBytes {
+    readonly bytes: Uint8Array;
+    readonly mimeType: string;
+}
+export interface AssetManagerDOMImageCapability {
+    isRegistered(name: unknown): boolean;
+    getMimeType(name: unknown): string;
+    resolveDOMImageResource(name: unknown): Promise<DOMImageResource>;
+}
+export type { NamedAssetBodyMetadata, NamedAssetBodyOpenOptions, NamedAssetBodyProvider, NamedAssetBodyReference, NamedAssetBodySnapshot } from './named-body-provider.js';
+interface ResolvedSkin {
+    skinId: number;
+    sourceSize: number | null;
+}
+export type ParsedResourceIdentifier = {
+    kind: 'cache';
+} | {
+    kind: 'external';
+    url: string;
+} | {
+    kind: 'costume';
+    spriteName: string;
+    costumeName: string | null;
+} | {
+    kind: 'backdrop';
+    backdropName: string;
+} | {
+    kind: 'sound';
+    spriteName: string;
+    soundName: string;
+} | {
+    kind: 'text';
+    runtimeVariableName: string;
+};
+export type ProjectAssetLocator = Readonly<{
+    kind: 'backdrop';
+    name: string;
+}> | Readonly<{
+    kind: 'costume';
+    target: string;
+    name: string;
+}> | Readonly<{
+    kind: 'sound';
+    name: string;
+    target?: string;
+}>;
+export type ProjectAssetAddressValidation = {
+    ok: true;
+    kind: ParsedResourceIdentifier['kind'];
+    projectLocal: boolean;
+} | {
+    ok: false;
+    type: string;
+    label: string;
+    message: string;
+};
+export declare function normalizeName(value: unknown): string;
+export declare function parseProjectAssetLocator(value: unknown): ProjectAssetLocator;
+export declare function guessMimeType(value: unknown): string;
+export declare function normalizeMimeType(mimeType: unknown, urlOrName: unknown): string;
+export declare function parseResourceIdentifier(value: unknown, fallbackAssetName?: unknown): ParsedResourceIdentifier;
+export declare function validateProjectAssetAddress(runtime: TurboWarpRuntime, assetName: unknown, resourceIdentifier: unknown): ProjectAssetAddressValidation;
+export declare class AssetManagerExtension {
+    protected readonly runtime: TurboWarpRuntime;
+    private readonly renderer;
+    private readonly externalAssets;
+    private readonly costumeAssets;
+    private readonly soundAssets;
+    private readonly textAssets;
+    private readonly assetRegistry;
+    private readonly displayedAssets;
+    private readonly playingAudio;
+    private readonly audioVoiceStops;
+    private readonly registrationVersions;
+    private readonly successfulRegistrationVersions;
+    private readonly registrationCancellationVersions;
+    private readonly registrationCommits;
+    private readonly committedCacheRecords;
+    protected readonly featureFlags: AssetManagerFeatureFlags;
+    private loadingBackdropName;
+    private loadingCostumes?;
+    private loadingAssetCountValue?;
+    private lastAssetErrorType;
+    private lastAssetErrorLabel;
+    private assetErrorVersion;
+    private readonly domImageResourceVersions;
+    private readonly domImageResourceBackings;
+    private readonly activeDOMImageResources;
+    private readonly activeDOMImageResourcesByName;
+    private domImageCapabilityValue?;
+    private namedBodyProviderValue?;
+    private namedBodyProviderRegistration;
+    private unbindNamedDataRegistryLifecycle;
+    private readonly openNamedBodySnapshots;
+    private namedBodyLifecycleVersion;
+    private listeningForNamedBodyLifecycle;
+    private listeningForDOMImageLifecycle;
+    private readonly releaseAllDOMImageResourcesForLifecycle;
+    private readonly releaseDOMImageResourcesForRuntimeDispose;
+    private readonly releaseNamedBodySnapshotsForLifecycle;
+    private readonly unregisterNamedBodyProviderForRuntimeDispose;
+    constructor(featureFlags?: AssetManagerFeatureFlags);
+    setLoadingBackdrop(args: BlockArgs): void;
+    setLoadingCostumes(args: BlockArgs): void;
+    prepareLoadingAssets(args: BlockArgs, util: ScratchBlockUtility): void;
+    loadingAssetCount(): number;
+    loadingBackdrop(): string;
+    loadingCostumeAt(args: BlockArgs): string;
+    getInfo(): {
+        id: string;
+        name: string;
+        docsURI: string;
+        blockIconURI: string;
+        color1: string;
+        color2: string;
+        color3: string;
+        blocks: Record<string, unknown>[];
+    };
+    /**
+     * Exposes the stock extension registry through a host-neutral DOM image
+     * resource contract for other unsandboxed extensions.
+     */
+    getDOMImageCapability(): AssetManagerDOMImageCapability;
+    /**
+     * Returns the optional read-only `asset` body provider. The startup-fixed
+     * feature flag keeps the adapter completely absent from the default path.
+     */
+    getNamedBodyProvider(): NamedAssetBodyProvider | null;
+    /** Canonical typed entry point for the existing asset registry provider. */
+    getNamedDataProvider(): NamedAssetBodyProvider | null;
+    validateProjectAssetAddress(args: BlockArgs): string;
+    registerProjectAssetLiteral(assetName: unknown, locatorInput: unknown): Promise<void>;
+    registerAsset(args: BlockArgs): Promise<void>;
+    registerEmbeddedAsset(input: EmbeddedAssetBytesInput): Promise<EmbeddedAssetRegistration>;
+    assetErrorType(): string;
+    assetErrorLabel(): string;
+    /** Legacy opcode retained for existing projects. */
+    loadAsset(args: BlockArgs): Promise<void>;
+    deleteMemoryAsset(args: BlockArgs): void;
+    deleteAllMemoryAssets(): void;
+    deleteCachedAsset(args: BlockArgs): Promise<void>;
+    deleteAllCachedAssets(): Promise<void>;
+    isLoaded(args: BlockArgs): boolean;
+    setThisSpriteSkin(args: BlockArgs, util: ScratchBlockUtility): Promise<void>;
+    setSpriteSkin(args: BlockArgs, util?: ScratchBlockUtility): Promise<void>;
+    setStageSkin(args: BlockArgs): Promise<void>;
+    playSound(args: BlockArgs): Promise<void>;
+    playSoundUntilDone(args: BlockArgs): Promise<void>;
+    createAudioVoice(value: unknown, options?: AssetManagerAudioVoiceOptions): Promise<AssetManagerAudioVoice>;
+    stopSound(args: BlockArgs): void;
+    stopAllSounds(): void;
+    getAssetMimeType(args: BlockArgs): string;
+    resolveImageAssetBytes(args: BlockArgs): Promise<ResolvedImageAssetBytes>;
+    getVersion(): string;
+    setTextValue(args: BlockArgs): Promise<void>;
+    setTextStyle(args: BlockArgs): void;
+    protected assetNotRegistered(operation: string, name: string): AssetManagerError;
+    protected assetTypeMismatch(operation: string, name: string, expectedKind: string, actualKind: string): AssetManagerError;
+    private toScratchBlock;
+    private requireAssetName;
+    private requireTextAssetName;
+    private clearAssetError;
+    private beginRegistration;
+    private cancelRegistrations;
+    private isRegistrationCancellationCurrent;
+    private registerExternalAsset;
+    private registerCostumeReference;
+    private registerBackdropReference;
+    private registerSoundReference;
+    private registerLiteralSoundReference;
+    private registerTextReference;
+    private unregisterAsset;
+    private commitPreparedAsset;
+    private commitPreparedAssetNow;
+    private assertReplacementKind;
+    private replaceRegisteredAsset;
+    private getRegisteredAsset;
+    private installRegisteredAsset;
+    private removeRegisteredAsset;
+    private disposeRegisteredAsset;
+    private externalMediaKind;
+    private openDatabase;
+    private transaction;
+    private cacheGet;
+    private cachePut;
+    private cacheDelete;
+    private cacheClear;
+    private restoreCacheIfGeneration;
+    private fetchExternalAsset;
+    private getStageTarget;
+    protected findTargetByName(name: string): TurboWarpTarget | null;
+    private resolveReferencedTarget;
+    private findCostume;
+    private findSound;
+    protected resolveSkin(value: unknown): Promise<ResolvedSkin>;
+    protected applyAssetToTarget(target: TurboWarpTarget, value: unknown, util?: ScratchBlockUtility): Promise<void>;
+    protected setDisplayBinding(target: TurboWarpTarget, name: string, kind: AssetKind, skinId?: number): void;
+    private isDisplayBindingCurrent;
+    protected applyResolvedSkinToTarget(target: TurboWarpTarget, name: string, skin: ResolvedSkin): void;
+    private applyTextToTarget;
+    private applyTextReferenceToTarget;
+    private requireTemporaryVariables;
+    private setRuntimeVariable;
+    private requireAnimatedTextOpcode;
+    private ensureExternalSkin;
+    private resolveProjectImageStorageAsset;
+    private cancelledDOMImageResolution;
+    private resolveExtensionDOMImageResource;
+    private releaseActiveDOMImageResource;
+    private invalidateDOMImageResources;
+    private releaseAllDOMImageResources;
+    private startListeningForDOMImageLifecycle;
+    private stopListeningForDOMImageLifecycle;
+    private createNamedBodyProvider;
+    private resolveNamedBodySource;
+    private releaseOpenNamedBodySnapshots;
+    private startListeningForNamedBodyLifecycle;
+    private stopListeningForNamedBodyLifecycle;
+    private ensureExternalAssetSkin;
+    private resolveSkinFromAsset;
+    private resolveCostumeReference;
+    private resolveCostumeAssetReference;
+    private resolveSoundAssetReference;
+    private resolveSoundReference;
+    private deleteOwnedSkinIfExists;
+    protected applySkinToTarget(target: TurboWarpTarget, skin: ResolvedSkin): void;
+    protected playResolvedSound(value: unknown, waitUntilDone: boolean): Promise<void>;
+    private resolveAudioBytes;
+    private startBrowserAudioVoice;
+    private playExternalSound;
+    private stopExternalAudio;
+    private playProjectSound;
+    private playbackError;
+    private projectAssetMimeType;
+}

package/dist/types/feature-flags.d.ts

@@ -0,0 +1,10 @@
+export interface AssetManagerFeatureFlags {
+    readonly ENABLE_LIVE_ASSET_REPLACEMENT: boolean;
+    readonly ENABLE_STRICT_ASSET_KIND_REPLACEMENT: boolean;
+    readonly NAMED_ASSET_BODY_PROVIDER: boolean;
+}
+/**
+ * Startup-fixed rollout flags. Optional features remain disabled unless a host
+ * explicitly configures them before loading the extension bundle.
+ */
+export declare const FEATURE_FLAGS: AssetManagerFeatureFlags;

package/dist/types/index.d.ts

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

package/dist/types/named-body-provider.d.ts

@@ -0,0 +1,12 @@
+import { NamedDataError, type NamedDataBody, type NamedDataErrorCode, type NamedDataMetadata, type NamedDataProvider, type NamedDataReference, type NamedDataResolveContext } from '@kubohiroya/turbowarp-named-data/composition';
+export declare const NAMED_ASSET_BODY_NAMESPACE: "asset";
+export declare const NamedAssetBodyError: typeof NamedDataError;
+export type NamedAssetBodyErrorCode = NamedDataErrorCode;
+export type NamedAssetBodyMetadata = NamedDataMetadata;
+export type NamedAssetBodyReference = NamedDataReference;
+export type NamedAssetBodySnapshot = NamedDataBody;
+export type NamedAssetBodyOpenOptions = NamedDataResolveContext;
+export type NamedAssetBodyProvider = NamedDataProvider;
+export declare function requireNamedAssetBodyReference(value: unknown): NamedDataReference;
+export declare function namedBodyAbortError(): NamedDataError;
+export declare function throwIfNamedBodyAborted(signal?: AbortSignal): void;

package/dist/types/opfs-binary-bundle-store.d.ts

@@ -0,0 +1,19 @@
+import type { BinaryBundleStore } from './binary-bundle-store.js';
+import type { BinaryObjectStore } from './binary-object-store.js';
+export interface OpfsBinaryBundleStoreOptions {
+    readonly objectStore: BinaryObjectStore;
+    readonly indexedDB?: IDBFactory;
+    readonly databaseName: string;
+    readonly subtleCrypto?: SubtleCrypto;
+    readonly now?: () => number;
+    readonly maxFilesPerBundle?: number;
+    readonly maxBundleBytes?: number;
+    readonly maxStoredBundles?: number;
+    readonly maxStoreBytes?: number;
+    readonly ttlMs?: number;
+    readonly recoveryBatchSize?: number;
+}
+export interface EstablishedOpfsBinaryBundleStore extends BinaryBundleStore {
+    establish(): Promise<void>;
+}
+export declare function createOpfsBinaryBundleStore(options: OpfsBinaryBundleStoreOptions): EstablishedOpfsBinaryBundleStore;

package/dist/types/server-manifest.d.ts

@@ -0,0 +1,16 @@
+import { type ExtensionManifest, type ExtensionManifestBlock } from '@kubohiroya/turbowarp-extension-manifest';
+export interface AssetCacheManifestBlock extends ExtensionManifestBlock {
+    resultType: 'boolean' | 'string' | 'void';
+    effect: 'control' | 'pure' | 'storage-write';
+    immutable: boolean;
+    errors: string[];
+    server: {
+        supported: false;
+    };
+}
+export interface AssetCacheManifest extends Omit<ExtensionManifest, 'formatVersion' | 'blocks'> {
+    formatVersion: 2;
+    blocks: AssetCacheManifestBlock[];
+}
+export declare function createAssetCacheManifest(id: string, definitions: unknown): AssetCacheManifest;
+export declare function serializeAssetCacheManifest(id: string, definitions: unknown): string;

package/dist/types/session-binary-backing.d.ts

@@ -0,0 +1,59 @@
+import { type BinaryBundleBackendWarning, type BinaryBundleFileInput, type BinaryBundleFileRegistration, type BinaryBundleKeyInput, type BinaryBundleOperationOptions, type BinaryBundleResult } from './binary-bundle-store.js';
+import type { BinaryStorageBackendPolicy, OpfsBinaryObjectStoreOptions } from './binary-object-store.js';
+export type SessionBinaryBackingPolicy = 'prefer' | 'required' | 'disabled';
+export type SessionBinaryBackingMode = 'session' | 'direct';
+export interface SessionBinaryBackingAssetInput extends BinaryBundleKeyInput {
+    readonly files: ReadonlyArray<BinaryBundleFileRegistration>;
+}
+export interface SessionBinaryBackingSourceAsset extends BinaryBundleKeyInput {
+    readonly files: ReadonlyArray<BinaryBundleFileInput>;
+}
+export interface SessionBinaryBackingSource {
+    read(asset: SessionBinaryBackingAssetInput, options?: BinaryBundleOperationOptions): Promise<SessionBinaryBackingSourceAsset>;
+    release(): Promise<void> | void;
+}
+export interface SessionBinaryBackingWarning {
+    readonly code: 'ASSET_SESSION_BINARY_DIRECT_FALLBACK';
+    readonly causeCode: string;
+}
+export interface SessionBinaryBackingInput {
+    readonly policy: unknown;
+    readonly sessionId: unknown;
+    readonly assets: ReadonlyArray<SessionBinaryBackingAssetInput>;
+    readonly source: SessionBinaryBackingSource;
+    readonly onFatalError?: (error: Error) => void;
+}
+export interface SessionBinaryBackingOptions {
+    readonly indexedDB?: IDBFactory;
+    readonly subtleCrypto?: SubtleCrypto;
+    readonly databaseName?: string;
+    readonly now?: () => number;
+    readonly maxFilesPerAsset?: number;
+    readonly maxAssetBytes?: number;
+    readonly maxSessionAssets?: number;
+    readonly maxSessionBytes?: number;
+    readonly leaseTtlMs?: number;
+    readonly heartbeatIntervalMs?: number;
+    readonly orphanCleanupBatchSize?: number;
+    readonly backendPolicy?: BinaryStorageBackendPolicy;
+    readonly opfs?: OpfsBinaryObjectStoreOptions;
+    readonly opfsMetadataDatabaseName?: string;
+}
+export interface SessionBinaryBacking {
+    readonly sessionId: string;
+    readonly mode: SessionBinaryBackingMode;
+    readonly backend: 'direct' | 'indexeddb' | 'opfs';
+    readonly warning?: SessionBinaryBackingWarning;
+    readonly storageWarning?: BinaryBundleBackendWarning;
+    get(input: BinaryBundleKeyInput, options?: BinaryBundleOperationOptions): Promise<BinaryBundleResult>;
+    renewLease(): Promise<void>;
+    dispose(): Promise<void>;
+}
+/**
+ * Establish a fixed direct or IndexedDB-backed binary session without changing persistent caches.
+ *
+ * The source must remain readable until `release` is called. A `prefer` fallback keeps that same
+ * source for direct reads; an established session releases it only after every bundle passes
+ * commit and integrity read-back.
+ */
+export declare function createSessionBinaryBacking(inputValue: SessionBinaryBackingInput, optionValue?: SessionBinaryBackingOptions, operationOptions?: BinaryBundleOperationOptions): Promise<SessionBinaryBacking>;

package/dist/types/text-style.d.ts

@@ -0,0 +1,24 @@
+export declare const TEXT_RUNTIME_NAMESPACE = "text";
+export declare const TEXT_STYLE_RUNTIME_NAMESPACE = "textStyle";
+export declare const TEXT_STYLE_PROPERTIES: readonly ["animation", "font", "color", "width", "align"];
+export type TextStyleProperty = typeof TEXT_STYLE_PROPERTIES[number];
+export type TextAnimation = 'none' | 'type' | 'rainbow' | 'zoom' | 'shake';
+export type TextAlignment = 'left' | 'center' | 'right';
+export interface TextStyle {
+    animation: TextAnimation;
+    font: string;
+    color: string;
+    width: number;
+    align: TextAlignment;
+}
+export declare const DEFAULT_OUTLINE_WIDTH = 2;
+export declare const DEFAULT_OUTLINE_COLOR = "#000000";
+export declare function textRuntimeVariableName(name: string): string;
+export declare function textStyleRuntimeVariableName(name: string, property: TextStyleProperty): string;
+export declare function normalizeTextStyleProperty(value: unknown): TextStyleProperty;
+/**
+ * Normalize a DSL-facing style value for runtime-variable storage.
+ * An empty value intentionally resets the property to its default.
+ */
+export declare function normalizeTextStyleValue(property: TextStyleProperty, value: unknown): string;
+export declare function resolveTextStyle(name: string, stageWidth: unknown, getRuntimeVariable: (variableName: string) => unknown): TextStyle;

package/dist/types/verified-cache-catalog.d.ts

@@ -0,0 +1,57 @@
+export interface VerifiedRemoteStoryCacheInfo {
+    readonly databaseName: string;
+    readonly id: string;
+    readonly label: string;
+    readonly entries: number;
+    readonly bytes: number;
+    readonly lastOpenedAt: number;
+    readonly lastAccessedAt: number;
+    readonly lastCleanupAt: number | null;
+    readonly active: boolean;
+}
+export interface VerifiedRemoteStoryCachePruneResult {
+    readonly removedDatabases: number;
+    readonly removedEntries: number;
+    readonly removedBytes: number;
+    readonly remainingDatabases: number;
+    readonly remainingBytes: number;
+    readonly highWaterBytes: number;
+    readonly lowWaterBytes: number;
+    readonly warnings: ReadonlyArray<string>;
+}
+export interface VerifiedRemoteStoryCacheDeleteResult {
+    readonly databaseName: string;
+    readonly deleted: boolean;
+    readonly removedEntries: number;
+    readonly removedBytes: number;
+}
+export interface StoryCacheCatalogIdentity {
+    readonly databaseName: string;
+    readonly id: string;
+    readonly label: string;
+}
+export interface StoryCacheCatalogStats {
+    readonly entries: number;
+    readonly bytes: number;
+    readonly lastCleanupAt: number | null;
+    readonly revision: number;
+}
+export declare class StoryCacheCatalog {
+    #private;
+    constructor(indexedDB: IDBFactory | undefined, now: () => number);
+    acquireLease(identity: StoryCacheCatalogIdentity, accessedAt: number, token: string, expiresAt: number): Promise<void>;
+    upsertAndRenewLease(identity: StoryCacheCatalogIdentity, stats: StoryCacheCatalogStats, accessedAt: number, token: string, expiresAt: number): Promise<void>;
+    touchAndRenewLease(identity: StoryCacheCatalogIdentity, accessedAt: number, token: string, expiresAt: number): Promise<void>;
+    list(): Promise<ReadonlyArray<VerifiedRemoteStoryCacheInfo>>;
+    delete(databaseName: string, deletionToken: string): Promise<VerifiedRemoteStoryCacheDeleteResult>;
+    releaseLease(databaseName: string, token: string): Promise<void>;
+    prune(options: {
+        readonly highWaterBytes: number;
+        readonly lowWaterBytes: number;
+        readonly ttlMs: number;
+        readonly incomingBytes?: number;
+        readonly pinnedDatabaseName?: string | null;
+        readonly force?: boolean;
+        readonly createDeletionToken: () => string;
+    }): Promise<VerifiedRemoteStoryCachePruneResult>;
+}