@atomic-chat/core 0.5.1

package/dist/contracts/diffusion.d.ts

@@ -0,0 +1,477 @@
+/**
+ * Image generation on the wire. A field-for-field mirror of the app's
+ * `web-app/src/services/diffusion/types.ts`, camelCase, including which optionals are absent and
+ * which are `null` (ADR 2026-09-17-diffusion-speaks-the-apps-camelcase-and-error-codes-verbatim).
+ * The same shapes are on disk: the recipe inside every PNG, `install.json`, `.flags.json`.
+ *
+ * Source of truth in the app: `src-tauri/plugins/tauri-plugin-atomic-diffusion/src/state.rs`.
+ */
+import type { DiffusionErrorCode } from './errors.js';
+/** Which native engine serves generation. Only `sd-cpp` exists in this build. */
+export type DiffusionEngineId = 'sd-cpp' | 'diffusers';
+/** The compute backend the engine build was made for. */
+export type DiffusionBackend = 'cpu' | 'metal' | 'cuda' | 'vulkan' | 'rocm';
+/** Where the weights live while generating; `args.ts` turns it into sd.cpp offload flags. */
+export type DiffusionOffloadPolicy = 'none' | 'group' | 'model';
+export type DiffusionModality = 'image' | 'video';
+export type DiffusionModelState = 'unloaded' | 'loading' | 'loaded' | 'unloading' | 'failed';
+/** What a request does with its images; every one of them is served by sd.cpp's single `img_gen`. */
+export type ImageWorkflowId = 'create' | 'transform' | 'inpaint' | 'extend' | 'upscale' | 'reference' | 'edit';
+export type ImageJobState = 'queued' | 'generating' | 'completed' | 'failed' | 'cancelled';
+/** `postprocessing` is in the app's union; nothing emits it yet. */
+export type ImageJobPhase = 'queued' | 'encoding' | 'sampling' | 'decoding' | 'postprocessing' | 'saving';
+/** Absolute paths of one checkpoint's files. Only `diffusionModel` is required. */
+export interface DiffusionModelFiles {
+    diffusionModel: string;
+    vae?: string;
+    /** `flux2` for the FLUX.2 VAE; absent otherwise. */
+    vaeFormat?: string;
+    clipL?: string;
+    t5xxl?: string;
+    llm?: string;
+    /** A VLM vision projector (Qwen Image 2.1's Qwen3-VL), passed to sd.cpp as `--llm_vision`. */
+    llmVision?: string;
+    qwen2vl?: string;
+    /** LTX-2: the audio VAE, passed to sd.cpp as `--audio-vae`. */
+    audioVae?: string;
+    /** LTX-2.3: the text-embedding connectors, passed to sd.cpp as `--embeddings-connectors`. */
+    embeddingsConnectors?: string;
+}
+/** What a video family generates by default; present on every video load, absent on image loads. */
+export interface DiffusionVideoDefaults {
+    /** Frames per second the model was trained at; a request naming another rate is refused. */
+    fps: number;
+    /** Default frame count; must itself satisfy `k * frameStep + frameOffset`. */
+    frames: number;
+    /** Valid frame counts are `k * frameStep + frameOffset` (LTX-2: 8k+1, Wan: 4k+1). */
+    frameStep: number;
+    frameOffset: number;
+    /** The sizes the family was trained for; the app's Resolution picker, never a hard limit. */
+    resolutionPresets: [number, number][];
+}
+/** Per-family defaults, handed over at load time so validation and the OpenAI facade need no catalog. */
+export interface DiffusionFamilyDefaults {
+    steps: number;
+    cfgScale: number;
+    guidance?: number;
+    samplingMethod?: string;
+    flowShift?: number;
+    width: number;
+    height: number;
+    /** A distilled model's fixed sigma schedule, sent as `custom_sigmas` when `steps` equals its length. */
+    sigmas?: number[];
+    video?: DiffusionVideoDefaults;
+}
+export interface DiffusionFamilyRanges {
+    steps: [number, number];
+    /** Inclusive min/max for both width and height. */
+    dims: [number, number];
+    dimMultiple: number;
+    /** Video only: inclusive min/max frame count. */
+    frames?: [number, number];
+}
+export interface LoadDiffusionModelRequest {
+    /** `<family>:<quantId>`, e.g. `z-image:q4_k_m`. */
+    modelId: string;
+    family: string;
+    modality: DiffusionModality;
+    displayName: string;
+    files: DiffusionModelFiles;
+    defaults: DiffusionFamilyDefaults;
+    ranges: DiffusionFamilyRanges;
+    offload: DiffusionOffloadPolicy;
+    engine?: DiffusionEngineId;
+    /** `--threads`, for CPU backends. */
+    threads?: number;
+    /** Seconds to wait for the model to load. Default 600. */
+    startupTimeoutSecs?: number;
+}
+export type DiffusionEngineInstall = {
+    state: 'not-installed';
+} | {
+    state: 'installed';
+    engine: DiffusionEngineId;
+    backend: DiffusionBackend;
+    /** Upstream release tag, e.g. `master-849-d04e895`. */
+    tag: string;
+    /** Manifest backend id, e.g. `macos-arm64`. */
+    backendId: string;
+    /** Absolute directory holding `sd-server`. */
+    dir: string;
+};
+export interface LoadedDiffusionModel {
+    modelId: string;
+    family: string;
+    modality: DiffusionModality;
+    displayName: string;
+    engine: DiffusionEngineId;
+    backend: DiffusionBackend;
+    offload: DiffusionOffloadPolicy;
+    /** True once the ggml-abort recovery restarted the server on the CPU backend. */
+    cpuFallback: boolean;
+    port: number;
+    pid: number;
+    loadedAtMs: number;
+}
+/** A diffusion failure as job records and events carry it. `details` is always a string. */
+export interface DiffusionErrorBody {
+    code: DiffusionErrorCode;
+    message: string;
+    details?: string;
+}
+export interface DiffusionStatus {
+    /** False until `PUT /diffusion/config` has been accepted by this core generation. */
+    configured: boolean;
+    install: DiffusionEngineInstall;
+    model: {
+        state: DiffusionModelState;
+        loaded: LoadedDiffusionModel | null;
+        error?: DiffusionErrorBody;
+    };
+    /** A queued or generating image job, so a reload can adopt it. */
+    activeJob: ImageJob | null;
+    /** The video counterpart; at most one of the two is set. */
+    activeVideoJob: VideoJob | null;
+    outputDir: string;
+    videoOutputDir: string;
+    /** Idle-unload timer in seconds; 0 = never. */
+    idleUnloadSecs: number;
+}
+/** What the loaded model can do; the app gates its form on this. */
+export interface ImageCapabilities {
+    workflows: ImageWorkflowId[];
+    minDim: number;
+    maxDim: number;
+    dimMultiple: number;
+    supportsNegativePrompt: boolean;
+    supportsGuidance: boolean;
+    /** Whether a running generation can be cancelled without stopping the server. */
+    cancelGenerating: boolean;
+    maxBatch: number;
+    defaults: DiffusionFamilyDefaults;
+    ranges: DiffusionFamilyRanges;
+}
+/** One image input: a file to read, or PNG bytes the app produced itself (a data-URL prefix is accepted). */
+export type ImageSource = {
+    path: string;
+} | {
+    base64: string;
+};
+export interface ImageGenerateRequest {
+    prompt: string;
+    negativePrompt?: string;
+    width: number;
+    height: number;
+    steps: number;
+    cfgScale: number;
+    guidance?: number;
+    /** Absent or negative: the core draws one; the recipe records the seed used. */
+    seed?: number;
+    /** Images per job (`batch_count`), 1..maxBatch. */
+    batchSize: number;
+    samplingMethod?: string;
+    flowShift?: number;
+    workflow?: ImageWorkflowId;
+    /** The source image of every workflow but `create`. */
+    initImage?: ImageSource;
+    /** `inpaint` / `extend`: white where the model repaints. */
+    maskImage?: ImageSource;
+    /** `reference`: extra references after the source. */
+    referenceImages?: ImageSource[];
+    /** Denoise strength 0..1 for the init-image workflows. */
+    strength?: number;
+}
+export interface ImageJobProgress {
+    phase: ImageJobPhase;
+    step: number;
+    totalSteps: number;
+    /** 0..1 estimate for the whole job. */
+    fraction: number;
+    etaSeconds: number | null;
+    /** Which image of the batch is being sampled, 0-based. */
+    batchIndex: number;
+    batchSize: number;
+    elapsedMs: number;
+}
+export interface ImageJob {
+    id: string;
+    state: ImageJobState;
+    modelId: string;
+    /** The request with inline image bytes blanked; file paths stay. */
+    request: ImageGenerateRequest;
+    createdAtMs: number;
+    startedAtMs?: number;
+    finishedAtMs?: number;
+    progress: ImageJobProgress | null;
+    outputs: GalleryImageItem[];
+    error?: DiffusionErrorBody;
+}
+/** Embedded verbatim in the PNG (`tEXt` keyword `atomic`). Enough to reproduce the image. */
+export interface ImageRecipe {
+    jobId: string;
+    /** 0-based index inside the batch. */
+    index: number;
+    prompt: string;
+    negativePrompt: string | null;
+    width: number;
+    height: number;
+    steps: number;
+    cfgScale: number;
+    guidance: number | null;
+    /** The seed this image was sampled with (`batchSeed + index`). */
+    seed: number;
+    /** The seed the batch was requested with. */
+    batchSeed: number;
+    batchSize: number;
+    samplingMethod: string | null;
+    flowShift: number | null;
+    workflow: ImageWorkflowId;
+    strength: number | null;
+    model: {
+        modelId: string;
+        family: string;
+        displayName: string;
+        /** Basename of the transformer file. */
+        filename: string;
+    };
+    engine: {
+        kind: DiffusionEngineId;
+        backend: DiffusionBackend;
+        tag: string;
+        offload: DiffusionOffloadPolicy;
+        cpuFallback: boolean;
+    };
+    createdAtMs: number;
+    durationMs: number;
+}
+export interface GalleryImageItem {
+    /** `<jobId>-<index:02>`; also the file stem. */
+    id: string;
+    path: string;
+    /** The 256 px thumbnail, or null when it could not be written. */
+    thumbnailPath: string | null;
+    width: number;
+    height: number;
+    sizeBytes: number;
+    createdAtMs: number;
+    pinned: boolean;
+    archived: boolean;
+    recipe: ImageRecipe;
+}
+export interface GalleryPage {
+    items: GalleryImageItem[];
+    hasMore: boolean;
+    total: number;
+}
+export interface GalleryListOptions {
+    offset: number;
+    limit: number;
+    /** Default false: archived items are hidden. */
+    includeArchived?: boolean;
+}
+export interface GalleryFlags {
+    pinned?: boolean;
+    archived?: boolean;
+}
+/** A file found under `<data>/diffusion/models`. */
+export interface DiffusionModelFile {
+    path: string;
+    /** Relative to the models root, `/`-separated. */
+    relativePath: string;
+    bytes: number;
+}
+export interface DiffusionBackendInstallRecord {
+    tag: string;
+    backendId: string;
+    backend: DiffusionBackend;
+    engine: DiffusionEngineId;
+    sha256: string | null;
+    installedAtMs: number;
+    dir: string;
+}
+export interface FinalizeBackendInstallArgs {
+    dir: string;
+    tag: string;
+    backendId: string;
+    backend: DiffusionBackend;
+    engine: DiffusionEngineId;
+    sha256?: string;
+}
+/** Sent by the app once per core generation, before anything else. */
+export interface DiffusionConfig {
+    /** Must be the core's own data folder. */
+    dataFolder: string;
+    /** Override for the gallery folder; absent for `<data>/images`. */
+    outputDir?: string;
+    /** Override for the video folder; absent for `<data>/videos`. */
+    videoOutputDir?: string;
+    /** 0 = never unload on idle. */
+    idleUnloadSecs?: number;
+}
+export interface DiffusionCancelResult {
+    cancelled: boolean;
+    /** True when the server had to be stopped to interrupt the generation. */
+    serverStopped: boolean;
+}
+/** `image-to-video` is reserved: parsed, recorded, and refused until the workflow lands. */
+export type VideoWorkflowId = 'create' | 'image-to-video';
+export type VideoJobState = ImageJobState;
+export type VideoJobPhase = ImageJobPhase;
+/** The one container sd.cpp writes that the app can play: VP8 in WebM. */
+export type VideoOutputFormat = 'webm';
+/** What the loaded video model can do; the app gates its form on this. */
+export interface VideoCapabilities {
+    workflows: VideoWorkflowId[];
+    minDim: number;
+    maxDim: number;
+    dimMultiple: number;
+    supportsNegativePrompt: boolean;
+    supportsGuidance: boolean;
+    /** Whether a running generation can be cancelled without stopping the server. */
+    cancelGenerating: boolean;
+    fps: number;
+    frames: {
+        min: number;
+        max: number;
+        step: number;
+        offset: number;
+        default: number;
+    };
+    resolutionPresets: [number, number][];
+    outputFormat: VideoOutputFormat;
+    /** From the engine's `output_formats_by_mode.vid_gen`; null when the build did not report formats. */
+    webmSupported: boolean | null;
+    defaults: DiffusionFamilyDefaults;
+    ranges: DiffusionFamilyRanges;
+}
+export interface VideoGenerateRequest {
+    prompt: string;
+    negativePrompt?: string;
+    width: number;
+    height: number;
+    /** Absent: the family default. Must be `k * frameStep + frameOffset` within `ranges.frames`. */
+    frames?: number;
+    /** Absent: the family rate. Any other value is refused. */
+    fps?: number;
+    steps: number;
+    cfgScale: number;
+    guidance?: number;
+    /** Absent or negative: the core draws one; the recipe records the seed used. */
+    seed?: number;
+    samplingMethod?: string;
+    flowShift?: number;
+    workflow?: VideoWorkflowId;
+    /** Reserved for `image-to-video`: the first frame. */
+    initImage?: ImageSource;
+    /** Reserved for `image-to-video`: the last frame. */
+    endImage?: ImageSource;
+}
+/** One clip per job, so no batch fields. */
+export interface VideoJobProgress {
+    phase: VideoJobPhase;
+    step: number;
+    totalSteps: number;
+    /** 0..1 estimate for the whole job. */
+    fraction: number;
+    etaSeconds: number | null;
+    elapsedMs: number;
+}
+export interface VideoJob {
+    id: string;
+    state: VideoJobState;
+    modelId: string;
+    /** The request with inline image bytes blanked; file paths stay. */
+    request: VideoGenerateRequest;
+    createdAtMs: number;
+    startedAtMs?: number;
+    finishedAtMs?: number;
+    progress: VideoJobProgress | null;
+    /** Zero or one item. */
+    outputs: GalleryVideoItem[];
+    error?: DiffusionErrorBody;
+}
+/** Written as `<jobId>.json` beside the video (WebM has no text chunk). Enough to reproduce the clip. */
+export interface VideoRecipe {
+    jobId: string;
+    prompt: string;
+    negativePrompt: string | null;
+    width: number;
+    height: number;
+    /** The frame count that was requested and validated. */
+    frames: number;
+    /** The frame count the engine reported for the file it wrote, after its own normalisation. */
+    frameCount: number;
+    fps: number;
+    steps: number;
+    cfgScale: number;
+    guidance: number | null;
+    seed: number;
+    samplingMethod: string | null;
+    flowShift: number | null;
+    workflow: VideoWorkflowId;
+    outputFormat: VideoOutputFormat;
+    model: {
+        modelId: string;
+        family: string;
+        displayName: string;
+        /** Basename of the transformer file. */
+        filename: string;
+    };
+    engine: {
+        kind: DiffusionEngineId;
+        backend: DiffusionBackend;
+        tag: string;
+        offload: DiffusionOffloadPolicy;
+        cpuFallback: boolean;
+    };
+    createdAtMs: number;
+    durationMs: number;
+}
+export interface GalleryVideoItem {
+    /** The job id (32 hex characters); also the file stem. */
+    id: string;
+    path: string;
+    /** `<id>.thumb.png`, once the app uploaded a poster; null until then. */
+    posterPath: string | null;
+    width: number;
+    height: number;
+    fps: number;
+    frameCount: number;
+    /** `frameCount / fps`. */
+    durationSecs: number;
+    sizeBytes: number;
+    createdAtMs: number;
+    pinned: boolean;
+    archived: boolean;
+    recipe: VideoRecipe;
+}
+export interface VideoGalleryPage {
+    items: GalleryVideoItem[];
+    hasMore: boolean;
+    total: number;
+}
+export interface DiffusionVideoProgressEvent {
+    jobId: string;
+    progress: VideoJobProgress;
+}
+export interface DiffusionVideoJobEvent {
+    job: VideoJob;
+}
+/** Payloads of the four `diffusion:*` events (`events.rs` in the plugin). */
+export interface DiffusionStateEvent {
+    status: DiffusionStatus;
+    reason?: string;
+}
+export interface DiffusionProgressEvent {
+    jobId: string;
+    progress: ImageJobProgress;
+}
+export interface DiffusionJobEvent {
+    job: ImageJob;
+}
+export interface DiffusionErrorEvent {
+    jobId?: string;
+    code: DiffusionErrorCode;
+    message: string;
+    details?: string;
+}

package/dist/contracts/diffusion.js

@@ -0,0 +1,10 @@
+/**
+ * Image generation on the wire. A field-for-field mirror of the app's
+ * `web-app/src/services/diffusion/types.ts`, camelCase, including which optionals are absent and
+ * which are `null` (ADR 2026-09-17-diffusion-speaks-the-apps-camelcase-and-error-codes-verbatim).
+ * The same shapes are on disk: the recipe inside every PNG, `install.json`, `.flags.json`.
+ *
+ * Source of truth in the app: `src-tauri/plugins/tauri-plugin-atomic-diffusion/src/state.rs`.
+ */
+export {};
+//# sourceMappingURL=diffusion.js.map

package/dist/contracts/diffusion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diffusion.js","sourceRoot":"","sources":["../../src/contracts/diffusion.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/contracts/errors.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Error codes shared with the Atomic Chat app. The app matches on `code` verbatim
+ * (`extractModelErrorMessage`, `classifyDownloadFailure`), so these strings are a wire contract.
+ *
+ * Source of truth in the app: src-tauri/plugins/tauri-plugin-llamacpp-upstream/src/error.rs,
+ * src-tauri/src/core/downloads/disk.rs, src-tauri/src/core/server/proxy.rs.
+ */
+/** Runtime / model-load codes (Rust `ErrorCode`, `#[serde(rename_all = "SCREAMING_SNAKE_CASE")]`). */
+export type RuntimeErrorCode = 'BINARY_NOT_FOUND' | 'MODEL_LOAD_FAILED' | 'MODEL_FILE_NOT_FOUND' | 'MODEL_LOAD_TIMED_OUT'
+/** The user stopped a load before the engine reported ready (the plugins' `ModelLoadCancelled`). */
+ | 'MODEL_LOAD_CANCELLED' | 'INVALID_ARGUMENT' | 'IO_ERROR' | 'INTERNAL_ERROR' | 'DEVICE_LIST_PARSE_FAILED' | 'OS_VERSION_UNSUPPORTED' | 'OUT_OF_MEMORY' | 'MODEL_ARCH_NOT_SUPPORTED' | 'MULTIMODAL_PROJECTOR_LOAD_FAILED' | 'MODEL_FILE_CORRUPT' | 'LLAMA_CPP_PROCESS_ERROR'
+/** MLX plugin (`tauri-plugin-mlx/src/error.rs`): an mlx-server failure no pattern explained. */
+ | 'MLX_PROCESS_ERROR'
+/** Foundation Models plugin (`tauri-plugin-foundation-models/src/error.rs`). */
+ | 'FOUNDATION_MODELS_UNAVAILABLE' | 'SERVER_START_FAILED' | 'SERVER_START_TIMED_OUT' | 'PROCESS_ERROR';
+/**
+ * Codes raised by the TypeScript extension layer of the app (coded `Error.code` own-properties);
+ * the web-app maps them to actionable toasts. Source: extensions/llamacpp-upstream-extension/src/index.ts:173-204, util.ts:49.
+ */
+export type ExtensionErrorCode = 'MODEL_SHARDS_INCOMPLETE' | 'CPU_NO_AVX' | 'BACKEND_TAG_UNRESOLVED' | 'BACKEND_INSUFFICIENT_DISK_SPACE' | 'TRANSCRIPTION_MODEL_MISSING' | 'TRANSCRIPTION_UNSUPPORTED';
+/** Codes raised by the core itself (new; not present in the Rust app). */
+export type CoreErrorCode = 'CORE_ALREADY_RUNNING' | 'CORE_NOT_RUNNING' | 'CORE_START_FAILED' | 'CORE_PROTOCOL_MISMATCH' | 'ALREADY_MIGRATED' | 'NO_MODEL_LOADED' | 'MODEL_NOT_LOADED' | 'MODEL_NOT_FOUND' | 'PROVIDER_NOT_FOUND' | 'UNAUTHORIZED' | 'FORBIDDEN_HOST'
+/** No ChatGPT subscription is connected, or its sign-in expired and needs doing again. */
+ | 'AUTH_REQUIRED'
+/** A sign-in did not complete: the browser reported an error, `state` did not match, or the code exchange failed. */
+ | 'AUTH_FAILED' | 'AUTH_CANCELLED'
+/** An external service (a token endpoint, the subscription API) could not be reached or refused. */
+ | 'UPSTREAM_ERROR'
+/** A tunnel needs a running public server to point at. */
+ | 'REMOTE_ACCESS_SERVER_STOPPED'
+/** The tunnel is being stopped; ask again once it is down. */
+ | 'REMOTE_ACCESS_OPERATION_IN_PROGRESS'
+/** A previous tunnel could not be confirmed dead; only Stop is offered until it is. */
+ | 'REMOTE_ACCESS_STOP_FAILED';
+/**
+ * Image generation (`tauri-plugin-atomic-diffusion/src/error.rs`, `NativeDiffusionErrorCode` in the
+ * web app). `lib/diffusion/errors.ts` matches on them. Three are spelled like codes above and are
+ * shared with them: `MODEL_LOAD_FAILED`, `MODEL_NOT_LOADED`, `OUT_OF_MEMORY`.
+ */
+export declare const DIFFUSION_ERROR_CODES: readonly ["ENGINE_MISSING", "ENGINE_UPDATE_REQUIRED", "ENGINE_INSTALL_FAILED", "ENGINE_CRASHED", "MODEL_MISSING", "SIDE_FILE_MISSING", "MODEL_LOAD_FAILED", "MODEL_INCOMPATIBLE", "MODEL_NOT_LOADED", "OUT_OF_MEMORY", "UNSUPPORTED_BACKEND", "UNSUPPORTED_WORKFLOW", "INVALID_DIMENSIONS", "INVALID_REQUEST", "INVALID_OUTPUT", "JOB_BUSY", "JOB_NOT_FOUND", "QUEUE_FULL", "CANCELLED", "DISK_FULL", "BACKEND_IN_USE", "NOT_CONFIGURED", "INTERNAL"];
+export type DiffusionErrorCode = (typeof DIFFUSION_ERROR_CODES)[number];
+export type ErrorCode = RuntimeErrorCode | ExtensionErrorCode | CoreErrorCode | DiffusionErrorCode;
+/**
+ * Disk-failure tags. Rendered into the error message as `Error: [<tag>] <detail>`; the app's
+ * telemetry parses the tag out of the string. Byte-identical with `disk.rs`.
+ */
+export declare const DISK_ERROR_TAGS: readonly ["disk_full", "disk_permission", "disk_file_locked", "disk_path_too_long", "disk_device_lost", "disk_io"];
+export type DiskErrorTag = (typeof DISK_ERROR_TAGS)[number];
+/** Wire shape of every error the core returns over HTTP / stdout. */
+export interface ErrorBody {
+    code: ErrorCode;
+    message: string;
+    details?: string;
+}
+export declare class AtomicCoreError extends Error {
+    readonly code: ErrorCode;
+    readonly details: string | undefined;
+    constructor(code: ErrorCode, message: string, details?: string);
+    toJSON(): ErrorBody;
+    static fromBody(body: ErrorBody): AtomicCoreError;
+}

package/dist/contracts/errors.js

@@ -0,0 +1,70 @@
+/**
+ * Error codes shared with the Atomic Chat app. The app matches on `code` verbatim
+ * (`extractModelErrorMessage`, `classifyDownloadFailure`), so these strings are a wire contract.
+ *
+ * Source of truth in the app: src-tauri/plugins/tauri-plugin-llamacpp-upstream/src/error.rs,
+ * src-tauri/src/core/downloads/disk.rs, src-tauri/src/core/server/proxy.rs.
+ */
+/**
+ * Image generation (`tauri-plugin-atomic-diffusion/src/error.rs`, `NativeDiffusionErrorCode` in the
+ * web app). `lib/diffusion/errors.ts` matches on them. Three are spelled like codes above and are
+ * shared with them: `MODEL_LOAD_FAILED`, `MODEL_NOT_LOADED`, `OUT_OF_MEMORY`.
+ */
+export const DIFFUSION_ERROR_CODES = [
+    'ENGINE_MISSING',
+    /** The installed engine build is too old for the family being loaded (Qwen Image 2.1, Krea 2 Turbo). */
+    'ENGINE_UPDATE_REQUIRED',
+    'ENGINE_INSTALL_FAILED',
+    'ENGINE_CRASHED',
+    'MODEL_MISSING',
+    'SIDE_FILE_MISSING',
+    'MODEL_LOAD_FAILED',
+    'MODEL_INCOMPATIBLE',
+    'MODEL_NOT_LOADED',
+    'OUT_OF_MEMORY',
+    'UNSUPPORTED_BACKEND',
+    'UNSUPPORTED_WORKFLOW',
+    'INVALID_DIMENSIONS',
+    'INVALID_REQUEST',
+    /** sd.cpp returned an image that is not one: unreadable, or a blank all-black/all-white frame. */
+    'INVALID_OUTPUT',
+    'JOB_BUSY',
+    'JOB_NOT_FOUND',
+    'QUEUE_FULL',
+    'CANCELLED',
+    'DISK_FULL',
+    'BACKEND_IN_USE',
+    'NOT_CONFIGURED',
+    'INTERNAL',
+];
+/**
+ * Disk-failure tags. Rendered into the error message as `Error: [<tag>] <detail>`; the app's
+ * telemetry parses the tag out of the string. Byte-identical with `disk.rs`.
+ */
+export const DISK_ERROR_TAGS = [
+    'disk_full',
+    'disk_permission',
+    'disk_file_locked',
+    'disk_path_too_long',
+    'disk_device_lost',
+    'disk_io',
+];
+export class AtomicCoreError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.name = 'AtomicCoreError';
+        this.code = code;
+        this.details = details;
+    }
+    toJSON() {
+        return this.details === undefined
+            ? { code: this.code, message: this.message }
+            : { code: this.code, message: this.message, details: this.details };
+    }
+    static fromBody(body) {
+        return new AtomicCoreError(body.code, body.message, body.details);
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/contracts/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/contracts/errors.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAmEH;;;;GAIG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,gBAAgB;IAChB,wGAAwG;IACxG,wBAAwB;IACxB,uBAAuB;IACvB,gBAAgB;IAChB,eAAe;IACf,mBAAmB;IACnB,mBAAmB;IACnB,oBAAoB;IACpB,kBAAkB;IAClB,eAAe;IACf,qBAAqB;IACrB,sBAAsB;IACtB,oBAAoB;IACpB,iBAAiB;IACjB,kGAAkG;IAClG,gBAAgB;IAChB,UAAU;IACV,eAAe;IACf,YAAY;IACZ,WAAW;IACX,WAAW;IACX,gBAAgB;IAChB,gBAAgB;IAChB,UAAU;CACF,CAAA;AAKV;;;GAGG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,WAAW;IACX,iBAAiB;IACjB,kBAAkB;IAClB,oBAAoB;IACpB,kBAAkB;IAClB,SAAS;CACD,CAAA;AAUV,MAAM,OAAO,eAAgB,SAAQ,KAAK;IAC/B,IAAI,CAAW;IACf,OAAO,CAAoB;IAEpC,YAAY,IAAe,EAAE,OAAe,EAAE,OAAgB;QAC5D,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAA;QAC7B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;IACxB,CAAC;IAED,MAAM;QACJ,OAAO,IAAI,CAAC,OAAO,KAAK,SAAS;YAC/B,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE;YAC5C,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAA;IACvE,CAAC;IAED,MAAM,CAAC,QAAQ,CAAC,IAAe;QAC7B,OAAO,IAAI,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAA;IACnE,CAAC;CACF"}