@comfyorg/sdk 0.1.0

package/dist/sdk/exceptions.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Idiomatic `sdk` exceptions.
+ *
+ * These wrap the protocol-level `low.ApiError` codes with names an
+ * integrator catches directly (`JobFailed`, `QueueFull`, ...). `toSdkError`
+ * maps a raised `ApiError` to the right subclass; anything unmapped stays a
+ * `ComfyError` carrying the original code. Mirrors `comfy_sdk.exceptions`
+ * in the Python SDK.
+ */
+import { ApiError } from "../low/index.js";
+import type { JobError } from "../low/index.js";
+export interface ComfyErrorOptions {
+    code?: string;
+    httpStatus?: number;
+    details?: Record<string, unknown> | null;
+}
+export declare class ComfyError extends Error {
+    readonly code?: string;
+    readonly httpStatus?: number;
+    readonly details: Record<string, unknown> | null;
+    constructor(message: string, options?: ComfyErrorOptions);
+}
+/** The surface rejected the request for lack of a valid key. Comfy Cloud
+ * and serverless require a key; a self-hosted proxy needs none. */
+export declare class Unauthorized extends ComfyError {
+}
+export declare class Forbidden extends ComfyError {
+}
+export declare class NotFound extends ComfyError {
+}
+/** Structural/validation failure; `details` carries per-node errors. */
+export declare class InvalidWorkflow extends ComfyError {
+}
+/** UI-export JSON was submitted instead of the API-format graph. */
+export declare class WorkflowFormatUi extends InvalidWorkflow {
+}
+/** A `core/ASSET` reference was not usable (unknown/unscanned/not owned). */
+export declare class MissingAsset extends ComfyError {
+}
+/** Uploaded bytes did not match the declared `expectedHash`. */
+export declare class HashMismatch extends ComfyError {
+}
+/** from-hash / existence probe found no blob the caller can mint from. */
+export declare class BlobNotFound extends ComfyError {
+}
+/** The idempotency key was reused. Keys are single-use (reject-on-duplicate,
+ * no replay): any second request with the same key — a retry, a concurrent
+ * duplicate, or the same key with a different body — is rejected. */
+export declare class IdempotencyKeyReuse extends ComfyError {
+}
+export declare class InsufficientCredits extends ComfyError {
+}
+/** Backpressure: the queue is full. `retryAfter` is seconds to wait. */
+export declare class QueueFull extends ComfyError {
+    readonly retryAfter: number;
+    constructor(message: string, options: ComfyErrorOptions & {
+        retryAfter: number;
+    });
+}
+/**
+ * A job reached a non-success terminal state. `error` carries the
+ * node-level detail (`code`, `nodeId`, `message`, `traceback`) when the
+ * platform provided one.
+ */
+export declare class JobFailed extends ComfyError {
+    readonly error: JobError | null;
+    constructor(message: string, options?: {
+        error?: JobError | null;
+    });
+}
+/** Translate a protocol `ApiError` into the idiomatic SDK exception. */
+export declare function toSdkError(exc: ApiError): ComfyError;
+/**
+ * Run `fn`, re-raising any protocol `ApiError` as its idiomatic SDK
+ * exception. Wrap every `sdk`-level operation that calls into `low` with
+ * this so integrators only ever catch `sdk` exceptions (`MissingAsset`,
+ * `HashMismatch`, `NotFound`, ...), never the raw protocol error.
+ */
+export declare function translate<T>(fn: () => Promise<T>): Promise<T>;

package/dist/sdk/exceptions.js

@@ -0,0 +1,114 @@
+/**
+ * Idiomatic `sdk` exceptions.
+ *
+ * These wrap the protocol-level `low.ApiError` codes with names an
+ * integrator catches directly (`JobFailed`, `QueueFull`, ...). `toSdkError`
+ * maps a raised `ApiError` to the right subclass; anything unmapped stays a
+ * `ComfyError` carrying the original code. Mirrors `comfy_sdk.exceptions`
+ * in the Python SDK.
+ */
+import { ApiError } from "../low/index.js";
+export class ComfyError extends Error {
+    code;
+    httpStatus;
+    details;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = new.target.name;
+        this.code = options.code;
+        this.httpStatus = options.httpStatus;
+        this.details = options.details ?? null;
+    }
+}
+/** The surface rejected the request for lack of a valid key. Comfy Cloud
+ * and serverless require a key; a self-hosted proxy needs none. */
+export class Unauthorized extends ComfyError {
+}
+export class Forbidden extends ComfyError {
+}
+export class NotFound extends ComfyError {
+}
+/** Structural/validation failure; `details` carries per-node errors. */
+export class InvalidWorkflow extends ComfyError {
+}
+/** UI-export JSON was submitted instead of the API-format graph. */
+export class WorkflowFormatUi extends InvalidWorkflow {
+}
+/** A `core/ASSET` reference was not usable (unknown/unscanned/not owned). */
+export class MissingAsset extends ComfyError {
+}
+/** Uploaded bytes did not match the declared `expectedHash`. */
+export class HashMismatch extends ComfyError {
+}
+/** from-hash / existence probe found no blob the caller can mint from. */
+export class BlobNotFound extends ComfyError {
+}
+/** The idempotency key was reused. Keys are single-use (reject-on-duplicate,
+ * no replay): any second request with the same key — a retry, a concurrent
+ * duplicate, or the same key with a different body — is rejected. */
+export class IdempotencyKeyReuse extends ComfyError {
+}
+export class InsufficientCredits extends ComfyError {
+}
+/** Backpressure: the queue is full. `retryAfter` is seconds to wait. */
+export class QueueFull extends ComfyError {
+    retryAfter;
+    constructor(message, options) {
+        super(message, options);
+        this.retryAfter = options.retryAfter;
+    }
+}
+/**
+ * A job reached a non-success terminal state. `error` carries the
+ * node-level detail (`code`, `nodeId`, `message`, `traceback`) when the
+ * platform provided one.
+ */
+export class JobFailed extends ComfyError {
+    error;
+    constructor(message, options = {}) {
+        super(message, { code: options.error?.code ?? "job_failed" });
+        this.error = options.error ?? null;
+    }
+}
+const BY_CODE = {
+    invalid_workflow: InvalidWorkflow,
+    workflow_format_ui: WorkflowFormatUi,
+    missing_asset: MissingAsset,
+    hash_mismatch: HashMismatch,
+    blob_not_found: BlobNotFound,
+    idempotency_key_reuse: IdempotencyKeyReuse,
+    insufficient_credits: InsufficientCredits,
+    not_found: NotFound,
+    unauthorized: Unauthorized,
+    forbidden: Forbidden,
+};
+/** Translate a protocol `ApiError` into the idiomatic SDK exception. */
+export function toSdkError(exc) {
+    if (exc.code === "queue_full") {
+        return new QueueFull(exc.message, {
+            retryAfter: exc.retryAfter ?? 0,
+            code: exc.code,
+            httpStatus: exc.httpStatus,
+            details: exc.details,
+        });
+    }
+    const cls = BY_CODE[exc.code] ?? ComfyError;
+    return new cls(exc.message, { code: exc.code, httpStatus: exc.httpStatus, details: exc.details });
+}
+/**
+ * Run `fn`, re-raising any protocol `ApiError` as its idiomatic SDK
+ * exception. Wrap every `sdk`-level operation that calls into `low` with
+ * this so integrators only ever catch `sdk` exceptions (`MissingAsset`,
+ * `HashMismatch`, `NotFound`, ...), never the raw protocol error.
+ */
+export async function translate(fn) {
+    try {
+        return await fn();
+    }
+    catch (exc) {
+        if (exc instanceof ApiError) {
+            throw toSdkError(exc);
+        }
+        throw exc;
+    }
+}

package/dist/sdk/hashing.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Local blake3 content hashing (via `hash-wasm`, which runs anywhere Node
+ * runs — no native addon).
+ *
+ * The hash is computed client-side purely as a dedup hint — the server
+ * always recomputes it from the received bytes and that value is
+ * authoritative. Files are hashed by streaming in chunks so a multi-GB
+ * input is never buffered whole. Mirrors `comfy_sdk._hashing` in the
+ * Python SDK.
+ */
+/** `blake3:<hex>` of an in-memory buffer. */
+export declare function hashBytes(data: Uint8Array): Promise<string>;
+/** `blake3:<hex>` of a file on disk, streamed in chunks. */
+export declare function hashFile(path: string): Promise<string>;

package/dist/sdk/hashing.js

@@ -0,0 +1,28 @@
+/**
+ * Local blake3 content hashing (via `hash-wasm`, which runs anywhere Node
+ * runs — no native addon).
+ *
+ * The hash is computed client-side purely as a dedup hint — the server
+ * always recomputes it from the received bytes and that value is
+ * authoritative. Files are hashed by streaming in chunks so a multi-GB
+ * input is never buffered whole. Mirrors `comfy_sdk._hashing` in the
+ * Python SDK.
+ */
+import { createReadStream } from "node:fs";
+import { createBLAKE3 } from "hash-wasm";
+/** `blake3:<hex>` of an in-memory buffer. */
+export async function hashBytes(data) {
+    const hasher = await createBLAKE3();
+    hasher.init();
+    hasher.update(data);
+    return `blake3:${hasher.digest()}`;
+}
+/** `blake3:<hex>` of a file on disk, streamed in chunks. */
+export async function hashFile(path) {
+    const hasher = await createBLAKE3();
+    hasher.init();
+    for await (const chunk of createReadStream(path)) {
+        hasher.update(chunk);
+    }
+    return `blake3:${hasher.digest()}`;
+}

package/dist/sdk/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `sdk` — the idiomatic, hand-written layer integrators import (the
+ * package's default export surface, re-exported from the package root).
+ * Mirrors `comfy_sdk`'s `__init__.py` in the Python SDK, minus the
+ * sync/async duplication (JS is async-native).
+ */
+export { Comfy, type ComfyOptions } from "./client.js";
+export { Asset, AssetFactory } from "./assets.js";
+export { Workflow, WorkflowFactory, type WorkflowGraph } from "./workflows.js";
+export { Job, JobFactory } from "./jobs.js";
+export { Output } from "./outputs.js";
+export type { ComfyEvent, Log, OutputReady, Preview, Progress, StatusChange } from "./events.js";
+export { BlobNotFound, ComfyError, Forbidden, HashMismatch, IdempotencyKeyReuse, InsufficientCredits, InvalidWorkflow, JobFailed, MissingAsset, NotFound, QueueFull, Unauthorized, WorkflowFormatUi, } from "./exceptions.js";

package/dist/sdk/index.js

@@ -0,0 +1,12 @@
+/**
+ * `sdk` — the idiomatic, hand-written layer integrators import (the
+ * package's default export surface, re-exported from the package root).
+ * Mirrors `comfy_sdk`'s `__init__.py` in the Python SDK, minus the
+ * sync/async duplication (JS is async-native).
+ */
+export { Comfy } from "./client.js";
+export { Asset, AssetFactory } from "./assets.js";
+export { Workflow, WorkflowFactory } from "./workflows.js";
+export { Job, JobFactory } from "./jobs.js";
+export { Output } from "./outputs.js";
+export { BlobNotFound, ComfyError, Forbidden, HashMismatch, IdempotencyKeyReuse, InsufficientCredits, InvalidWorkflow, JobFailed, MissingAsset, NotFound, QueueFull, Unauthorized, WorkflowFormatUi, } from "./exceptions.js";

package/dist/sdk/jobs.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Job handles — the resumable, poll-authoritative core of the SDK.
+ *
+ * A {@link Job} is rehydratable purely from its ID. `wait` polls
+ * `GET /api/v2/jobs/{id}` with adaptive backoff as the source of truth for
+ * terminal status and outputs, so a stream that is throttled, dropped, or
+ * permanently unavailable never stalls completion. `events` is the live SSE
+ * stream on top: typed, auto-reconnecting (no replay — the stream carries
+ * no cursor), with the poll path as its backstop. Mirrors `comfy_sdk.jobs`
+ * in the Python SDK — one async class since JS is async-native.
+ */
+import type { ComfyLow, Job as LowJob } from "../low/index.js";
+import { type ComfyEvent } from "./events.js";
+import { Output } from "./outputs.js";
+export declare class Job {
+    private readonly low;
+    private model;
+    constructor(low: ComfyLow, model: LowJob);
+    get id(): string;
+    get status(): string;
+    get outputs(): Output[];
+    get error(): LowJob["error"];
+    getOutputs(nodeId: string): Output[];
+    private bindOutput;
+    /** Poll `GET /api/v2/jobs/{id}` once and adopt the fresh state. */
+    refresh(signal?: AbortSignal): Promise<this>;
+    /** Poll to a terminal state (adaptive backoff). Rejects with a
+     * `TimeoutError` if `timeoutMs` elapses first, or immediately if `signal`
+     * aborts — the abort interrupts the backoff wait itself, not just the
+     * in-flight poll request. */
+    wait(timeoutMs?: number, signal?: AbortSignal): Promise<this>;
+    /** Wait for terminal, then throw `JobFailed` unless it succeeded. */
+    result(signal?: AbortSignal): Promise<this>;
+    cancel(signal?: AbortSignal): Promise<this>;
+    /**
+     * Typed live event iterator. Auto-reconnects with no replay; falls back
+     * to polling to detect terminal status if the stream ends early. An
+     * aborted `signal` stops both the current SSE connection/poll and the
+     * pause between reconnect attempts.
+     */
+    events(signal?: AbortSignal): AsyncGenerator<ComfyEvent, void, void>;
+}
+export declare class JobFactory {
+    private readonly low;
+    constructor(low: ComfyLow);
+    get(jobId: string): Promise<Job>;
+}

package/dist/sdk/jobs.js

@@ -0,0 +1,145 @@
+/**
+ * Job handles — the resumable, poll-authoritative core of the SDK.
+ *
+ * A {@link Job} is rehydratable purely from its ID. `wait` polls
+ * `GET /api/v2/jobs/{id}` with adaptive backoff as the source of truth for
+ * terminal status and outputs, so a stream that is throttled, dropped, or
+ * permanently unavailable never stalls completion. `events` is the live SSE
+ * stream on top: typed, auto-reconnecting (no replay — the stream carries
+ * no cursor), with the poll path as its backstop. Mirrors `comfy_sdk.jobs`
+ * in the Python SDK — one async class since JS is async-native.
+ */
+import { abortableSleep } from "./abortable-sleep.js";
+import { backoffSchedule, isTerminal, SUCCESS } from "./core.js";
+import { eventFromRaw } from "./events.js";
+import { JobFailed, translate } from "./exceptions.js";
+import { Output } from "./outputs.js";
+// Pause before reconnecting an SSE stream that dropped mid-job, without a
+// terminal frame having been seen.
+const RECONNECT_PAUSE_MS = 100;
+export class Job {
+    low;
+    model;
+    constructor(low, model) {
+        this.low = low;
+        this.model = model;
+    }
+    get id() {
+        return this.model.id;
+    }
+    get status() {
+        return this.model.status;
+    }
+    get outputs() {
+        return this.model.outputs.map((o) => this.bindOutput(o));
+    }
+    get error() {
+        return this.model.error;
+    }
+    getOutputs(nodeId) {
+        return this.model.outputs.filter((o) => o.node_id === nodeId).map((o) => this.bindOutput(o));
+    }
+    bindOutput(model) {
+        return new Output(model, this.low);
+    }
+    /** Poll `GET /api/v2/jobs/{id}` once and adopt the fresh state. */
+    async refresh(signal) {
+        this.model = await translate(() => this.low.getJob(this.model.urls.self || this.model.id, { signal }));
+        return this;
+    }
+    /** Poll to a terminal state (adaptive backoff). Rejects with a
+     * `TimeoutError` if `timeoutMs` elapses first, or immediately if `signal`
+     * aborts — the abort interrupts the backoff wait itself, not just the
+     * in-flight poll request. */
+    async wait(timeoutMs, signal) {
+        const deadline = timeoutMs === undefined ? undefined : Date.now() + timeoutMs;
+        const backoff = backoffSchedule();
+        for (;;) {
+            await this.refresh(signal);
+            if (isTerminal(this.status))
+                return this;
+            if (deadline !== undefined && Date.now() >= deadline) {
+                throw new Error(`job ${this.id} not terminal after ${timeoutMs}ms (status=${this.status})`);
+            }
+            await abortableSleep(backoff.next().value, signal);
+        }
+    }
+    /** Wait for terminal, then throw `JobFailed` unless it succeeded. */
+    async result(signal) {
+        await this.wait(undefined, signal);
+        if (this.status !== SUCCESS) {
+            throw new JobFailed(`job ${this.id} ended ${this.status}`, { error: this.model.error });
+        }
+        return this;
+    }
+    async cancel(signal) {
+        this.model = await translate(() => this.low.cancelJob(this.model.urls.cancel || this.model.id, { signal }));
+        return this;
+    }
+    /**
+     * Typed live event iterator. Auto-reconnects with no replay; falls back
+     * to polling to detect terminal status if the stream ends early. An
+     * aborted `signal` stops both the current SSE connection/poll and the
+     * pause between reconnect attempts.
+     */
+    async *events(signal) {
+        const eventsUrl = this.model.urls.events || this.model.id;
+        // Progress is monotonic across the whole stream, reconnects included: a
+        // frame whose value regresses (e.g. a lower value replayed by the server
+        // after a mid-stream drop) is suppressed so a consumer's progress never
+        // goes backwards.
+        let lastProgress = Number.NEGATIVE_INFINITY;
+        for (;;) {
+            let terminalSeen = false;
+            try {
+                for await (const raw of this.low.getJobEvents(eventsUrl, { signal })) {
+                    const event = eventFromRaw(raw, (data) => this.bindOutput(data));
+                    if (event === null)
+                        continue;
+                    if (event.kind === "progress") {
+                        if (event.value < lastProgress)
+                            continue;
+                        lastProgress = event.value;
+                    }
+                    if (event.kind === "statusChange" && isTerminal(event.status)) {
+                        terminalSeen = true;
+                        yield event;
+                        return;
+                    }
+                    yield event;
+                }
+            }
+            catch (exc) {
+                // A caller abort must propagate (and stop the loop), not be
+                // swallowed as an ordinary mid-stream drop.
+                if (signal?.aborted)
+                    throw exc;
+                // Connection dropped mid-stream — reconnect below.
+            }
+            if (terminalSeen)
+                return;
+            // Stream ended without a terminal frame. Poll the authoritative
+            // state: stop if already terminal, else reconnect for fresh frames.
+            await this.refresh(signal);
+            if (isTerminal(this.status)) {
+                const statusChange = {
+                    kind: "statusChange",
+                    status: this.status,
+                    queuePosition: null,
+                };
+                yield statusChange;
+                return;
+            }
+            await abortableSleep(RECONNECT_PAUSE_MS, signal);
+        }
+    }
+}
+export class JobFactory {
+    low;
+    constructor(low) {
+        this.low = low;
+    }
+    async get(jobId) {
+        return new Job(this.low, await translate(() => this.low.getJob(jobId)));
+    }
+}

package/dist/sdk/outputs.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Output handles — typed, range-aware download over an asset id.
+ *
+ * An output is an asset: the bytes are retrievable via `getAssetContent`
+ * (which serves directly or redirects to a signed URL) for as long as the
+ * job is retained. `toFile` streams to disk; `toBytes` buffers. Mirrors
+ * `comfy_sdk.outputs` in the Python SDK.
+ */
+import type { ComfyLow, Output as LowOutput } from "../low/index.js";
+export declare class Output {
+    private readonly model;
+    private readonly low;
+    constructor(model: LowOutput, low: ComfyLow);
+    get nodeId(): string;
+    get name(): string;
+    get type(): LowOutput["type"];
+    get id(): string;
+    get sizeBytes(): number;
+    get contentType(): string;
+    toFile(path: string, options?: {
+        range?: readonly [number, number];
+    }): Promise<string>;
+    toBytes(options?: {
+        range?: readonly [number, number];
+    }): Promise<Uint8Array>;
+}

package/dist/sdk/outputs.js

@@ -0,0 +1,48 @@
+/**
+ * Output handles — typed, range-aware download over an asset id.
+ *
+ * An output is an asset: the bytes are retrievable via `getAssetContent`
+ * (which serves directly or redirects to a signed URL) for as long as the
+ * job is retained. `toFile` streams to disk; `toBytes` buffers. Mirrors
+ * `comfy_sdk.outputs` in the Python SDK.
+ */
+import { createWriteStream } from "node:fs";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+export class Output {
+    model;
+    low;
+    constructor(model, low) {
+        this.model = model;
+        this.low = low;
+    }
+    get nodeId() {
+        return this.model.node_id;
+    }
+    get name() {
+        return this.model.name;
+    }
+    get type() {
+        return this.model.type;
+    }
+    get id() {
+        return this.model.id;
+    }
+    get sizeBytes() {
+        return this.model.size_bytes;
+    }
+    get contentType() {
+        return this.model.content_type;
+    }
+    async toFile(path, options = {}) {
+        const response = await this.low.getAssetContent(this.model.id, { range: options.range });
+        if (!response.body)
+            throw new Error(`empty response body for asset ${this.model.id}`);
+        await pipeline(Readable.fromWeb(response.body), createWriteStream(path));
+        return path;
+    }
+    async toBytes(options = {}) {
+        const response = await this.low.getAssetContent(this.model.id, { range: options.range });
+        return new Uint8Array(await response.arrayBuffer());
+    }
+}

package/dist/sdk/workflows.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Workflow construction and mutation.
+ *
+ * A {@link Workflow} is a thin, local wrapper over the raw API-format
+ * graph. The graph stays a freely-mutable object (`wf.json`); `setInput` is
+ * sugar for `wf.json[node].inputs[field] = value` that also accepts an
+ * asset handle (substituted into a `core/ASSET` object at submit time).
+ * Construction does no network I/O in v1. Mirrors `comfy_sdk.workflows` in
+ * the Python SDK.
+ */
+export type WorkflowGraph = Record<string, unknown>;
+export declare class Workflow {
+    json: WorkflowGraph;
+    constructor(graph: WorkflowGraph);
+    /**
+     * Set `node.inputs.field`. `value` may be a plain JSON value or an asset
+     * handle; handles are substituted into `core/ASSET` objects when the
+     * workflow is submitted.
+     */
+    setInput(nodeId: string, field: string, value: unknown): void;
+}
+/**
+ * `client.workflows` — alternative constructors for {@link Workflow}.
+ * Namespaced on the client (rather than free-standing) because
+ * construction is expected to become client-bound once server-side
+ * subgraphs land; in v1 it is purely local.
+ */
+export declare class WorkflowFactory {
+    fromFile(path: string): Promise<Workflow>;
+    fromJson(graph: WorkflowGraph): Workflow;
+    fromString(text: string): Workflow;
+}

package/dist/sdk/workflows.js

@@ -0,0 +1,45 @@
+/**
+ * Workflow construction and mutation.
+ *
+ * A {@link Workflow} is a thin, local wrapper over the raw API-format
+ * graph. The graph stays a freely-mutable object (`wf.json`); `setInput` is
+ * sugar for `wf.json[node].inputs[field] = value` that also accepts an
+ * asset handle (substituted into a `core/ASSET` object at submit time).
+ * Construction does no network I/O in v1. Mirrors `comfy_sdk.workflows` in
+ * the Python SDK.
+ */
+import { readFile } from "node:fs/promises";
+export class Workflow {
+    json;
+    constructor(graph) {
+        this.json = graph;
+    }
+    /**
+     * Set `node.inputs.field`. `value` may be a plain JSON value or an asset
+     * handle; handles are substituted into `core/ASSET` objects when the
+     * workflow is submitted.
+     */
+    setInput(nodeId, field, value) {
+        const node = (this.json[nodeId] ??= {});
+        const inputs = (node.inputs ??= {});
+        inputs[field] = value;
+    }
+}
+/**
+ * `client.workflows` — alternative constructors for {@link Workflow}.
+ * Namespaced on the client (rather than free-standing) because
+ * construction is expected to become client-bound once server-side
+ * subgraphs land; in v1 it is purely local.
+ */
+export class WorkflowFactory {
+    async fromFile(path) {
+        const text = await readFile(path, "utf-8");
+        return new Workflow(JSON.parse(text));
+    }
+    fromJson(graph) {
+        return new Workflow(graph);
+    }
+    fromString(text) {
+        return new Workflow(JSON.parse(text));
+    }
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@comfyorg/sdk",
+  "version": "0.1.0",
+  "private": false,
+  "description": "TypeScript SDK for running ComfyUI workflows via the Comfy API v2 (self-hosted, Comfy Cloud, serverless).",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./low": {
+      "types": "./dist/low/index.d.ts",
+      "default": "./dist/low/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "generate": "openapi-ts",
+    "lint": "oxlint .",
+    "format": "oxfmt --write .",
+    "format:check": "oxfmt --check .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "check:spec-drift": "node scripts/check-spec-drift.mjs"
+  },
+  "dependencies": {
+    "eventsource-parser": "^3.0.0",
+    "hash-wasm": "^4.11.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@hey-api/openapi-ts": "0.99.0",
+    "@types/node": "^22.10.0",
+    "@vitest/coverage-v8": "^4.1.0",
+    "oxfmt": "^0.45.0",
+    "oxlint": "^1.62.0",
+    "typescript": "^5.8.3",
+    "vitest": "^4.1.0",
+    "yaml": "^2.9.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "packageManager": "pnpm@11.13.0"
+}