@civitai/sdk 0.2.0

package/dist/host/index.d.ts

@@ -0,0 +1,47 @@
+import { type BlockTransport } from '../core/transport.js';
+import type { Session } from '../session/index.js';
+import type { DownloadRequest, PickedResource, ResourcePickerType } from './protocol.js';
+export type { ConsentRefusal, DownloadRequest, PickedResource, ResourcePickerType, } from './protocol.js';
+export interface HostCallOptions {
+    signal?: AbortSignal;
+}
+/** Asking the host page to show its own UI. Data goes over the API, not here. */
+export interface Host {
+    /** Resizes the frame, clamped to the manifest's bounds. */
+    resize(height: number): void;
+    /** Keeps the frame as tall as `element` (the body by default). Returns a stop function. */
+    autoResize(element?: Element): () => void;
+    /** `fatal` swaps the block for the host's fallback, for a block that cannot continue. */
+    reportError(message: string, args?: {
+        fatal?: boolean;
+    }): void;
+    /** Deep-links within this app's own sub-paths; the host refuses anything else. */
+    navigate(path: string, args?: {
+        target?: 'current' | 'new_tab';
+    }): void;
+    /** Fires `false` when the page hides and `true` when it returns. */
+    onVisibilityChange(handler: (visible: boolean) => void): () => void;
+    /** Starts sign-in; the block re-initialises as a signed-in viewer. */
+    requestSignIn(args?: {
+        returnUrl?: string;
+    }): void;
+    /**
+     * Saves to the viewer's device through the host, because a sandboxed frame
+     * cannot. The host fetches only from origins it allowlists.
+     */
+    download(request: DownloadRequest, opts?: HostCallOptions): Promise<void>;
+    /** civitai's own picker. Resolves the one resource chosen, or `null` if dismissed. */
+    openResourcePicker(args: {
+        resourceType: ResourcePickerType;
+        baseModelGroup?: string;
+    }, opts?: HostCallOptions): Promise<PickedResource | null>;
+    /** `suggestedAmount` is a starting point the viewer can change. */
+    openBuzzPurchase(args?: {
+        suggestedAmount?: number;
+    }, opts?: HostCallOptions): Promise<{
+        purchased: boolean;
+    }>;
+}
+export declare function createHost(transport: BlockTransport): Host;
+/** The token the host minted for this block, kept current as the host rotates it. */
+export declare function createHostSession(transport: BlockTransport): Session;

package/dist/host/index.js

@@ -0,0 +1,92 @@
+import { createCaller, createListener, createNotifier } from '../core/messaging.js';
+import { tokenFromWrapped } from '../core/transport.js';
+const call = createCaller();
+const notify = createNotifier();
+const on = createListener();
+export function createHost(transport) {
+    return {
+        resize: (height) => notify('RESIZE_IFRAME', { height }, { transport }),
+        autoResize(element) {
+            const target = element ?? globalThis.document?.body;
+            if (!target || typeof ResizeObserver === 'undefined')
+                return () => { };
+            let sent = -1;
+            const report = () => {
+                const height = Math.ceil(target.getBoundingClientRect().height);
+                if (height === sent)
+                    return;
+                sent = height;
+                notify('RESIZE_IFRAME', { height }, { transport });
+            };
+            const observer = new ResizeObserver(report);
+            observer.observe(target);
+            report();
+            return () => observer.disconnect();
+        },
+        reportError: (message, args = {}) => notify('BLOCK_ERROR', { message, fatal: args.fatal ?? false }, { transport }),
+        navigate: (path, args = {}) => notify('NAVIGATE', { path, target: args.target ?? 'current' }, { transport }),
+        onVisibilityChange(handler) {
+            const offSuspend = on(transport, 'SUSPEND', () => handler(false));
+            const offResume = on(transport, 'RESUME', () => handler(true));
+            return () => {
+                offSuspend();
+                offResume();
+            };
+        },
+        requestSignIn: (args = {}) => notify('REQUEST_SIGN_IN', args, { transport }),
+        async download(request, opts = {}) {
+            await call('SAVE_IMAGE', request, { ...opts, transport });
+        },
+        async openResourcePicker(args, opts = {}) {
+            return (await call('OPEN_RESOURCE_PICKER', args, { ...opts, transport })).selected ?? null;
+        },
+        async openBuzzPurchase(args = {}, opts = {}) {
+            const { purchased } = await call('OPEN_BUZZ_PURCHASE', args, { ...opts, transport });
+            return { purchased };
+        },
+    };
+}
+/** The token the host minted for this block, kept current as the host rotates it. */
+export function createHostSession(transport) {
+    return {
+        async getToken({ fresh, signal } = {}) {
+            if (!fresh)
+                return transport.snapshot.get().token.raw;
+            const { blockInstanceId } = transport.snapshot.get();
+            const { token } = await call('REQUEST_TOKEN', { blockInstanceId }, { transport, signal });
+            return tokenFromWrapped(token).raw;
+        },
+        requestGrants: (scopes, opts = {}) => requestGrants(transport, scopes, opts),
+    };
+}
+/**
+ * The host re-mints the token once the viewer consents, so a grant arrives as
+ * a token carrying the scopes. A viewer who closes the dialog sends nothing,
+ * so pass a `signal` to bound the wait.
+ */
+function requestGrants(transport, scopes, { signal }) {
+    const granted = () => {
+        const held = new Set(transport.snapshot.get().token.scopes);
+        return scopes.every((scope) => held.has(scope));
+    };
+    if (granted())
+        return Promise.resolve(true);
+    if (signal?.aborted)
+        return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+        const release = [];
+        const settle = (finish) => {
+            for (const off of release)
+                off();
+            finish();
+        };
+        release.push(transport.snapshot.subscribe(() => granted() && settle(() => resolve(true))));
+        release.push(on(transport, 'CONSENT_UNAVAILABLE', () => settle(() => resolve(false))));
+        if (signal) {
+            const onAbort = () => settle(() => reject(signal.reason));
+            signal.addEventListener('abort', onAbort, { once: true });
+            release.push(() => signal.removeEventListener('abort', onAbort));
+        }
+        notify('REQUEST_CONSENT', { scopes: [...scopes] }, { transport });
+    });
+}

package/dist/host/protocol.d.ts

@@ -0,0 +1,86 @@
+import type { WrappedToken } from '../core/handshake.js';
+export type ResourcePickerType = 'Checkpoint' | 'LORA';
+/** The one resource the viewer picked. Discovery only: nothing here is an entitlement. */
+export interface PickedResource {
+    versionId: number;
+    modelId: number;
+    modelName: string;
+    versionName: string;
+    baseModel: string;
+    modelType: string;
+    strength?: number;
+    minStrength?: number;
+    maxStrength?: number;
+    trainedWords?: string[];
+    clipSkip?: number | null;
+}
+export interface DownloadRequest {
+    /** An own-output URL. The host allowlists the origin it will fetch. */
+    url: string;
+    filename?: string;
+}
+/** Why consent can never be granted in this environment. */
+export type ConsentRefusal = 'ungrantable';
+export type HostRequests = {
+    SAVE_IMAGE: {
+        params: DownloadRequest;
+        result: {
+            ok?: boolean;
+        };
+    };
+    OPEN_RESOURCE_PICKER: {
+        params: {
+            resourceType: ResourcePickerType;
+            baseModelGroup?: string;
+        };
+        result: {
+            selected?: PickedResource;
+        };
+    };
+    OPEN_BUZZ_PURCHASE: {
+        params: {
+            suggestedAmount?: number;
+        };
+        result: {
+            purchased: boolean;
+            newBalance?: number;
+        };
+    };
+    REQUEST_TOKEN: {
+        params: {
+            blockInstanceId: string;
+        };
+        result: {
+            token: WrappedToken;
+        };
+    };
+};
+export type HostNotifications = {
+    RESIZE_IFRAME: {
+        height: number;
+    };
+    BLOCK_ERROR: {
+        message: string;
+        fatal: boolean;
+    };
+    NAVIGATE: {
+        path: string;
+        target: 'current' | 'new_tab';
+    };
+    REQUEST_SIGN_IN: {
+        returnUrl?: string;
+    };
+    REQUEST_CONSENT: {
+        scopes?: string[];
+    };
+};
+export type HostPushes = {
+    /** The page is hidden; stop timers and polling until `RESUME`. */
+    SUSPEND: undefined;
+    RESUME: undefined;
+    /** `scopes` is advisory and may be empty; the message itself is the refusal. */
+    CONSENT_UNAVAILABLE: {
+        reason: ConsentRefusal;
+        scopes: string[];
+    };
+};

package/dist/host/protocol.js

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

package/dist/http/index.d.ts

@@ -0,0 +1,23 @@
+import { CivitaiError } from '../core/errors.js';
+import type { Session } from '../session/index.js';
+export type QueryValue = string | number | boolean | null | undefined;
+export type Query = Record<string, QueryValue | readonly QueryValue[]>;
+export interface RequestOptions {
+    query?: Query;
+    body?: unknown;
+    signal?: AbortSignal;
+}
+export declare class ApiError extends CivitaiError {
+    readonly status: number;
+    /** The response body, parsed as JSON when it was JSON. */
+    readonly body: unknown;
+    constructor(status: number, message: string, body: unknown);
+}
+export interface HttpOptions {
+    session: Session;
+    baseUrl: string;
+    fetch?: typeof fetch;
+}
+export type Http = <T>(method: string, path: string, opts?: RequestOptions) => Promise<T>;
+/** A JSON client that sends the session's token and survives one expired token. */
+export declare function createHttp(options: HttpOptions): Http;

package/dist/http/index.js

@@ -0,0 +1,76 @@
+import { CivitaiError } from '../core/errors.js';
+export class ApiError extends CivitaiError {
+    status;
+    /** The response body, parsed as JSON when it was JSON. */
+    body;
+    constructor(status, message, body) {
+        super(message);
+        this.name = 'ApiError';
+        this.status = status;
+        this.body = body;
+    }
+}
+/** A JSON client that sends the session's token and survives one expired token. */
+export function createHttp(options) {
+    let baseUrl = options.baseUrl;
+    while (baseUrl.endsWith('/'))
+        baseUrl = baseUrl.slice(0, -1);
+    const send = (method, path, opts, token) => {
+        const doFetch = options.fetch ?? globalThis.fetch;
+        const headers = { Authorization: `Bearer ${token}` };
+        let body;
+        if (opts.body !== undefined) {
+            headers['Content-Type'] = 'application/json';
+            body = JSON.stringify(opts.body);
+        }
+        return doFetch(urlFor(baseUrl, path, opts.query), { method, headers, body, signal: opts.signal });
+    };
+    return async (method, path, opts = {}) => {
+        const { session } = options;
+        let response = await send(method, path, opts, await session.getToken({ signal: opts.signal }));
+        // One retry: a token that expired in flight is routine, a second refusal is not.
+        if (response.status === 401) {
+            const fresh = await session.getToken({ fresh: true, signal: opts.signal });
+            response = await send(method, path, opts, fresh);
+        }
+        return read(response);
+    };
+}
+function urlFor(baseUrl, path, query) {
+    const url = new URL(`${baseUrl}/${path.replace(/^\/+/, '')}`);
+    for (const [key, value] of Object.entries(query ?? {})) {
+        const values = Array.isArray(value) ? value : [value];
+        for (const item of values) {
+            if (item != null)
+                url.searchParams.append(key, String(item));
+        }
+    }
+    return url.toString();
+}
+async function read(response) {
+    const text = await response.text();
+    let body = text;
+    if (text !== '') {
+        try {
+            body = JSON.parse(text);
+        }
+        catch {
+            // Not JSON; keep the text so an error can still say what came back.
+        }
+    }
+    if (!response.ok) {
+        throw new ApiError(response.status, messageOf(body) ?? response.statusText, body);
+    }
+    return (text === '' ? undefined : body);
+}
+/** civitai reports `{ error }` or `{ message }`; the orchestrator reports problem details. */
+function messageOf(body) {
+    if (body == null || typeof body !== 'object')
+        return undefined;
+    const fields = body;
+    for (const key of ['error', 'message', 'detail', 'title']) {
+        if (typeof fields[key] === 'string')
+            return fields[key];
+    }
+    return undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `const app = await initialize()`, then `app.site`, `app.orchestration` and,
+ * inside a civitai.com page, `app.host`. Outside one, `createSignIn()` gets the token.
+ */
+export { initialize } from './app/index.js';
+export type { AppClient, BlockAppClient, BlockInitializeOptions, TokenInitializeOptions, } from './app/index.js';
+export { createSignIn, SignInError } from './sign-in/index.js';
+export type { SignIn, SignInOptions } from './sign-in/index.js';
+export { SCOPES } from './session/index.js';
+export type { GrantOptions, Scope, TokenOptions, TokenSource } from './session/index.js';
+export type { SiteClient } from './site/index.js';
+export { isTerminal } from './orchestration/index.js';
+export type { OrchestrationClient, Step, StepTemplate, WaitOptions, Workflow, WorkflowPage, WorkflowQuery, WorkflowStatus, WorkflowTemplate, } from './orchestration/index.js';
+export { createHost } from './host/index.js';
+export type { ConsentRefusal, DownloadRequest, Host, HostCallOptions, PickedResource, ResourcePickerType, } from './host/index.js';
+export { ApiError } from './http/index.js';
+export type { Query, QueryValue, RequestOptions } from './http/index.js';
+export { BridgeError, CivitaiError } from './core/errors.js';
+export type { BridgeErrorCode, BridgeFailureCode } from './core/errors.js';
+export { getTransport } from './core/get-transport.js';
+export type { DetectOptions } from './core/get-transport.js';
+export type { BlockSnapshot, BlockTransport } from './core/transport.js';
+export type { BlockCheckpointInfo, BlockContext, BlockSettings, BlockToken, ColorDomain, ModelSlotContext, ModelSlotId, PageSlotContext, PageSlotId, ShowcaseImage, Theme, UnknownSlotContext, ViewerInfo, } from './core/handshake.js';

package/dist/index.js

@@ -0,0 +1,12 @@
+/**
+ * `const app = await initialize()`, then `app.site`, `app.orchestration` and,
+ * inside a civitai.com page, `app.host`. Outside one, `createSignIn()` gets the token.
+ */
+export { initialize } from './app/index.js';
+export { createSignIn, SignInError } from './sign-in/index.js';
+export { SCOPES } from './session/index.js';
+export { isTerminal } from './orchestration/index.js';
+export { createHost } from './host/index.js';
+export { ApiError } from './http/index.js';
+export { BridgeError, CivitaiError } from './core/errors.js';
+export { getTransport } from './core/get-transport.js';

package/dist/orchestration/index.d.ts

@@ -0,0 +1,53 @@
+import type { Workflow as GeneratedWorkflow, WorkflowStatus, WorkflowTemplate as GeneratedWorkflowTemplate } from '@civitai/orchestration-client/dist/generated/types.gen.js';
+import { type Http } from '../http/index.js';
+import type { Step, StepTemplate } from './steps.generated.js';
+export type { Step, StepTemplate, WorkflowStatus };
+/** What to run. `currencies` defaults server-side, so it is optional here. */
+export type WorkflowTemplate = Omit<GeneratedWorkflowTemplate, 'steps' | 'currencies'> & {
+    steps: StepTemplate[];
+    currencies?: GeneratedWorkflowTemplate['currencies'];
+};
+export type Workflow = Omit<GeneratedWorkflow, 'steps'> & {
+    readonly steps: Step[];
+};
+export interface WorkflowPage {
+    next: string;
+    items: Workflow[];
+}
+export declare const DEFAULT_ORCHESTRATION_URL = "https://orchestration.civitai.com";
+export interface CallOptions {
+    signal?: AbortSignal;
+}
+export interface WaitOptions extends CallOptions {
+    /** Seconds the orchestrator may hold the reply. */
+    wait?: number;
+    /** What ends the hold early: the workflow finishing (the default), or any change to it. */
+    until?: 'completion' | 'change';
+}
+export interface WorkflowQuery {
+    cursor?: string;
+    take?: number;
+    tags?: string[];
+    excludeFailed?: boolean;
+}
+/**
+ * Workflows on the orchestrator, as the viewer. Steps are the orchestrator's
+ * own `WorkflowStepTemplate`s, so a step type it gains needs no release here.
+ */
+export interface OrchestrationClient {
+    submitWorkflow(template: WorkflowTemplate, opts?: WaitOptions): Promise<Workflow>;
+    /** Prices a workflow without running it. */
+    estimateWorkflow(template: WorkflowTemplate, opts?: CallOptions): Promise<Workflow>;
+    getWorkflow(workflowId: string, opts?: WaitOptions): Promise<Workflow>;
+    /**
+     * Yields the workflow now and again each time it changes, ending at a final
+     * status. Break out of the loop to stop watching.
+     */
+    watchWorkflow(workflowId: string, opts?: CallOptions): AsyncGenerator<Workflow, void, undefined>;
+    /** Resolves once the workflow reaches a final status, whichever it is. */
+    waitForWorkflow(workflowId: string, opts?: CallOptions): Promise<Workflow>;
+    cancelWorkflow(workflowId: string, opts?: CallOptions): Promise<void>;
+    queryWorkflows(query?: WorkflowQuery, opts?: CallOptions): Promise<WorkflowPage>;
+}
+export declare function isTerminal(workflow: Workflow): boolean;
+export declare function createOrchestrationClient(http: Http): OrchestrationClient;

package/dist/orchestration/index.js

@@ -0,0 +1,81 @@
+import { ApiError } from '../http/index.js';
+export const DEFAULT_ORCHESTRATION_URL = 'https://orchestration.civitai.com';
+const WORKFLOWS = 'v2/consumer/workflows';
+const TERMINAL = new Set([
+    'succeeded',
+    'failed',
+    'canceled',
+    'expired',
+]);
+/** How long the orchestrator holds each read while watching, in seconds. */
+const HELD_READ_SECONDS = 20;
+/** Waits between consecutive failed reads while watching; a success resets it. */
+const RETRY_BACKOFF_MS = [250, 1_000, 4_000];
+export function isTerminal(workflow) {
+    return TERMINAL.has(workflow.status);
+}
+export function createOrchestrationClient(http) {
+    const getWorkflow = (workflowId, { wait, until, signal } = {}) => http('GET', `${WORKFLOWS}/${encodeURIComponent(workflowId)}`, {
+        query: { wait, until },
+        signal,
+    });
+    async function* watchWorkflow(workflowId, { signal } = {}) {
+        let seen;
+        let failures = 0;
+        let held = false;
+        for (;;) {
+            let workflow;
+            try {
+                workflow = await getWorkflow(workflowId, held ? { wait: HELD_READ_SECONDS, until: 'change', signal } : { signal });
+                failures = 0;
+            }
+            catch (error) {
+                if (signal?.aborted || !isTransient(error) || failures >= RETRY_BACKOFF_MS.length)
+                    throw error;
+                await sleep(RETRY_BACKOFF_MS[failures++], signal);
+                continue;
+            }
+            held = true;
+            // Compared whole, so anything the orchestrator adds to a workflow counts as progress.
+            const snapshot = JSON.stringify(workflow);
+            if (snapshot !== seen) {
+                seen = snapshot;
+                yield workflow;
+            }
+            if (isTerminal(workflow))
+                return;
+        }
+    }
+    return {
+        submitWorkflow: (template, { wait, signal } = {}) => http('POST', WORKFLOWS, { body: template, query: { wait }, signal }),
+        estimateWorkflow: (template, { signal } = {}) => http('POST', WORKFLOWS, { body: template, query: { whatif: true }, signal }),
+        getWorkflow,
+        watchWorkflow,
+        async waitForWorkflow(workflowId, opts = {}) {
+            let last;
+            for await (const workflow of watchWorkflow(workflowId, opts))
+                last = workflow;
+            return last;
+        },
+        cancelWorkflow: async (workflowId, { signal } = {}) => {
+            await http('PUT', `${WORKFLOWS}/${encodeURIComponent(workflowId)}`, {
+                body: { status: 'canceled' },
+                signal,
+            });
+        },
+        queryWorkflows: (query = {}, { signal } = {}) => http('GET', WORKFLOWS, { query: { ...query }, signal }),
+    };
+}
+/** A blip is worth waiting out; a refusal is an answer. */
+function isTransient(error) {
+    return !(error instanceof ApiError) || error.status >= 500 || error.status === 429;
+}
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(resolve, ms);
+        signal?.addEventListener('abort', () => {
+            clearTimeout(timer);
+            reject(signal.reason);
+        }, { once: true });
+    });
+}

package/dist/orchestration/steps.generated.d.ts

@@ -0,0 +1,5 @@
+import type { AceStepAudioStepTemplate, AgeClassificationStepTemplate, AudioCaptioningStepTemplate, BlobArchiveStepTemplate, ChatCompletionStepTemplate, ComfyNodepackSnapshotStepTemplate, ComfyStepTemplate, ComposeMediaStepTemplate, ConvertImageStepTemplate, CustomComfyStepTemplate, EchoStepTemplate, ImageBackgroundRemovalStepTemplate, ImageGenStepTemplate, ImageResourceTrainingStepTemplate, ImageToSvgStepTemplate, ImageUploadStepTemplate, ImageUpscalerStepTemplate, MediaCaptioningStepTemplate, MediaHashStepTemplate, MediaRatingStepTemplate, MiniMaxMusic3StepTemplate, Model3dPreviewStepTemplate, ModelClamScanStepTemplate, ModelHashStepTemplate, ModelParseMetadataStepTemplate, ModelPickleScanStepTemplate, PolyGenStepTemplate, PreprocessImageStepTemplate, PreprocessVideoStepTemplate, PromptEnhancementStepTemplate, QwenImageBenchStepTemplate, ShieldstralModerationStepTemplate, TextToImageStepTemplate, TextToSpeechStepTemplate, TrainingStepTemplate, TranscodeStepTemplate, TranscriptionStepTemplate, VideoBackgroundRemovalStepTemplate, VideoEnhancementStepTemplate, VideoFrameExtractionStepTemplate, VideoGenStepTemplate, VideoInterpolationStepTemplate, VideoMetadataStepTemplate, VideoUpscalerStepTemplate, WdTaggingStepTemplate, WebScrapeStepTemplate, WebSearchStepTemplate, XGuardModerationStepTemplate, AceStepAudioStep, AgeClassificationStep, AudioCaptioningStep, BlobArchiveStep, ChatCompletionStep, ComfyNodepackSnapshotStep, ComfyStep, ComposeMediaStep, ConvertImageStep, CustomComfyStep, EchoStep, ImageBackgroundRemovalStep, ImageGenStep, ImageResourceTrainingStep, ImageToSvgStep, ImageUploadStep, ImageUpscalerStep, MediaCaptioningStep, MediaHashStep, MediaRatingStep, MiniMaxMusic3Step, Model3dPreviewStep, ModelClamScanStep, ModelHashStep, ModelParseMetadataStep, ModelPickleScanStep, PolyGenStep, PreprocessImageStep, PreprocessVideoStep, PromptEnhancementStep, QwenImageBenchStep, ShieldstralModerationStep, TextToImageStep, TextToSpeechStep, TrainingStep, TranscodeStep, TranscriptionStep, VideoBackgroundRemovalStep, VideoEnhancementStep, VideoFrameExtractionStep, VideoGenStep, VideoInterpolationStep, VideoMetadataStep, VideoUpscalerStep, WdTaggingStep, WebScrapeStep, WebSearchStep, XGuardModerationStep } from '@civitai/orchestration-client/dist/generated/types.gen.js';
+/** Any step a workflow can be submitted with, discriminated by `$type`. */
+export type StepTemplate = AceStepAudioStepTemplate | AgeClassificationStepTemplate | AudioCaptioningStepTemplate | BlobArchiveStepTemplate | ChatCompletionStepTemplate | ComfyNodepackSnapshotStepTemplate | ComfyStepTemplate | ComposeMediaStepTemplate | ConvertImageStepTemplate | CustomComfyStepTemplate | EchoStepTemplate | ImageBackgroundRemovalStepTemplate | ImageGenStepTemplate | ImageResourceTrainingStepTemplate | ImageToSvgStepTemplate | ImageUploadStepTemplate | ImageUpscalerStepTemplate | MediaCaptioningStepTemplate | MediaHashStepTemplate | MediaRatingStepTemplate | MiniMaxMusic3StepTemplate | Model3dPreviewStepTemplate | ModelClamScanStepTemplate | ModelHashStepTemplate | ModelParseMetadataStepTemplate | ModelPickleScanStepTemplate | PolyGenStepTemplate | PreprocessImageStepTemplate | PreprocessVideoStepTemplate | PromptEnhancementStepTemplate | QwenImageBenchStepTemplate | ShieldstralModerationStepTemplate | TextToImageStepTemplate | TextToSpeechStepTemplate | TrainingStepTemplate | TranscodeStepTemplate | TranscriptionStepTemplate | VideoBackgroundRemovalStepTemplate | VideoEnhancementStepTemplate | VideoFrameExtractionStepTemplate | VideoGenStepTemplate | VideoInterpolationStepTemplate | VideoMetadataStepTemplate | VideoUpscalerStepTemplate | WdTaggingStepTemplate | WebScrapeStepTemplate | WebSearchStepTemplate | XGuardModerationStepTemplate;
+/** Any step a workflow reports back, discriminated by `$type`. */
+export type Step = AceStepAudioStep | AgeClassificationStep | AudioCaptioningStep | BlobArchiveStep | ChatCompletionStep | ComfyNodepackSnapshotStep | ComfyStep | ComposeMediaStep | ConvertImageStep | CustomComfyStep | EchoStep | ImageBackgroundRemovalStep | ImageGenStep | ImageResourceTrainingStep | ImageToSvgStep | ImageUploadStep | ImageUpscalerStep | MediaCaptioningStep | MediaHashStep | MediaRatingStep | MiniMaxMusic3Step | Model3dPreviewStep | ModelClamScanStep | ModelHashStep | ModelParseMetadataStep | ModelPickleScanStep | PolyGenStep | PreprocessImageStep | PreprocessVideoStep | PromptEnhancementStep | QwenImageBenchStep | ShieldstralModerationStep | TextToImageStep | TextToSpeechStep | TrainingStep | TranscodeStep | TranscriptionStep | VideoBackgroundRemovalStep | VideoEnhancementStep | VideoFrameExtractionStep | VideoGenStep | VideoInterpolationStep | VideoMetadataStep | VideoUpscalerStep | WdTaggingStep | WebScrapeStep | WebSearchStep | XGuardModerationStep;

package/dist/orchestration/steps.generated.js

@@ -0,0 +1,2 @@
+// Generated by scripts/gen-step-types.mjs from @civitai/orchestration-client/dist/generated/types.gen.js. Do not edit.
+export {};

package/dist/session/index.d.ts

@@ -0,0 +1,29 @@
+/** Every scope an app can hold, as the site names them. */
+export declare const SCOPES: readonly ['ai:write:budgeted', 'apps:storage:read', 'apps:storage:shared:read', 'apps:storage:shared:write', 'apps:storage:write', 'buzz:read:self', 'collections:read:private', 'collections:read:self', 'collections:write:self', 'models:read:self', 'posts:write:self', 'social:tip:self', 'user:read:self'];
+export type Scope = (typeof SCOPES)[number];
+export interface TokenOptions {
+    /** Skip the held token and get a new one, e.g. after the API refused it. */
+    fresh?: boolean;
+    signal?: AbortSignal;
+}
+export interface GrantOptions {
+    signal?: AbortSignal;
+}
+/** Where the app's token comes from. Everything that calls an API reads it here. */
+export interface Session {
+    getToken(opts?: TokenOptions): Promise<string>;
+    requestGrants(scopes: readonly Scope[], opts?: GrantOptions): Promise<boolean>;
+}
+export type TokenSource = string | ((opts: {
+    signal?: AbortSignal;
+}) => string | Promise<string>);
+export interface TokenSessionOptions {
+    token: TokenSource;
+    /** How to get a new token when the API refuses one. Defaults to reading `token` again. */
+    refresh?: (opts: {
+        signal?: AbortSignal;
+    }) => string | Promise<string>;
+    /** How to ask the viewer for more scopes. Defaults to refusing, since there is no one to ask. */
+    requestGrants?: (scopes: readonly Scope[], opts: GrantOptions) => boolean | Promise<boolean>;
+}
+export declare function createTokenSession(options: TokenSessionOptions): Session;

package/dist/session/index.js

@@ -0,0 +1,23 @@
+/** Every scope an app can hold, as the site names them. */
+export const SCOPES = [
+    'ai:write:budgeted',
+    'apps:storage:read',
+    'apps:storage:shared:read',
+    'apps:storage:shared:write',
+    'apps:storage:write',
+    'buzz:read:self',
+    'collections:read:private',
+    'collections:read:self',
+    'collections:write:self',
+    'models:read:self',
+    'posts:write:self',
+    'social:tip:self',
+    'user:read:self',
+];
+export function createTokenSession(options) {
+    const read = (signal) => Promise.resolve(typeof options.token === 'string' ? options.token : options.token({ signal }));
+    return {
+        getToken: ({ fresh, signal } = {}) => fresh && options.refresh ? Promise.resolve(options.refresh({ signal })) : read(signal),
+        requestGrants: (scopes, opts = {}) => Promise.resolve(options.requestGrants ? options.requestGrants(scopes, opts) : false),
+    };
+}

package/dist/sign-in/index.d.ts

@@ -0,0 +1,45 @@
+import { CivitaiError } from '../core/errors.js';
+import type { GrantOptions, Scope, TokenSessionOptions } from '../session/index.js';
+export declare const DEFAULT_AUTH_URL = "https://auth.civitai.com";
+export declare class SignInError extends CivitaiError {
+    readonly status?: number;
+    constructor(message: string, status?: number, options?: ErrorOptions);
+}
+type SignInStorage = Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
+export interface SignInOptions {
+    /** The OAuth client registered on Civitai as a public (browser) client. */
+    clientId: string;
+    scopes: readonly Scope[];
+    /** Must be registered on the client. Defaults to the current page without its query. */
+    redirectUri?: string;
+    /** Defaults to `https://auth.civitai.com`. */
+    authUrl?: string;
+    /** Holds the sign-in in flight and whether the viewer signed in before; never a token. Defaults to `localStorage`. */
+    storage?: SignInStorage;
+    fetch?: typeof fetch;
+    window?: Window;
+}
+/** Pass it to `initialize()` as it is: it is the token, its refresh and the way to ask for grants. */
+export interface SignIn extends TokenSessionOptions {
+    token(): Promise<string>;
+    refresh(): Promise<string>;
+    requestGrants(scopes: readonly Scope[], opts?: GrantOptions): Promise<boolean>;
+    readonly signedIn: boolean;
+    /** Signed in on an earlier visit. Tokens live only in memory, so `signIn()` again; Civitai remembers the consent. */
+    readonly returning: boolean;
+    readonly grantedScopes: readonly Scope[];
+    /** Why the last return from Civitai did not sign in, e.g. the viewer declined. */
+    readonly error: SignInError | null;
+    /** Leaves the page for Civitai's sign-in and consent; it comes back to `redirectUri`. */
+    signIn(opts?: {
+        scopes?: readonly Scope[];
+    }): Promise<never>;
+    signOut(): Promise<void>;
+}
+export declare function scopeBitmask(scopes: readonly Scope[]): number;
+/**
+ * Sign-in with Civitai for an app outside civitai.com. Completes the return
+ * from Civitai when the page has just come back from it.
+ */
+export declare function createSignIn(options: SignInOptions): Promise<SignIn>;
+export {};