@beeintel/batch-image 0.0.0-stage → 1.0.1

package/dist/chunks/search-BjTSm1KS.js

@@ -0,0 +1,18 @@
+import { J as e } from "./entry-DK9FjQZ_.js";
+/**
+ * @license @lucide/vue v1.47.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const c = {
+  name: "search",
+  size: 24,
+  node: [
+    ["path", { d: "m21 21-4.34-4.34", key: "14j7rj" }],
+    ["circle", { cx: "11", cy: "11", r: "8", key: "4ej97u" }]
+  ]
+}, r = e(c);
+export {
+  r as S
+};

package/dist/chunks/standard-cutout-vPpP6xBc.js

@@ -0,0 +1,45 @@
+import { L as n } from "./hosted-resources-COzZ7nZY.js";
+const w = "" + new URL("../assets/standard-cutout.worker-BYLzdpR-.js", import.meta.url).href;
+class f {
+  constructor(r) {
+    this.options = r;
+  }
+  worker;
+  nextId = 0;
+  stopped = !1;
+  pending;
+  run(r, s = () => {
+  }, p = "transparent", d = !1, u = 0) {
+    if (!this.options?.resources)
+      return Promise.reject(new Error("MISSING_RESOURCE: 显式标准模型/ORT资源尚未配置"));
+    if (this.stopped) return Promise.reject(new Error("本机标准抠图已停止"));
+    if (this.pending) return Promise.reject(new Error("标准模式上一项尚未结束，请稍后重试。"));
+    const o = this.worker ??= this.options?.workerUrl ? n(this.options.workerUrl, { type: "module" }) : n(w, { type: "module" }), t = ++this.nextId;
+    return new Promise((h, c) => {
+      const i = setTimeout(
+        () => this.dispose(new Error("标准模式处理超时，请检查模型下载或选择其它模式。")),
+        12e5
+      );
+      this.pending = { id: t, reject: c, timer: i }, o.onmessage = ({ data: e }) => {
+        this.worker !== o || this.pending?.id !== t || e.id !== t || (e.type === "progress" ? s(e.progress) : e.type === "error" ? this.dispose(new Error(e.error)) : e.type === "result" && (clearTimeout(i), this.pending = void 0, h(e.result)));
+      }, o.onerror = (e) => {
+        e.preventDefault(), this.worker === o && this.dispose(new Error(e.message || "标准推理Worker无法启动"));
+      }, o.postMessage({
+        id: t,
+        blob: r,
+        background: p,
+        trimTransparent: d,
+        trimPadding: u,
+        resources: this.options?.resources
+      });
+    });
+  }
+  dispose(r = new Error("本机标准抠图已停止")) {
+    this.stopped = !0, this.worker?.terminate(), this.worker = void 0;
+    const s = this.pending;
+    this.pending = void 0, s && (clearTimeout(s.timer), s.reject(r));
+  }
+}
+export {
+  f as StandardCutoutEngine
+};

package/dist/chunks/static-logo-2F9ORZWc.js

@@ -0,0 +1,34 @@
+import { w as l, F as L, G as c, C as P } from "./hosted-resources-COzZ7nZY.js";
+const f = (o) => {
+  throw Object.assign(new Error(o), { code: "INVALID_IMAGE" });
+}, h = [137, 80, 78, 71, 13, 10, 26, 10];
+function N(o) {
+  if ((!(o instanceof Uint8Array) || o.length < 2 || o.length > 5 * 1024 * 1024) && f("Logo为空或超过5MiB限制"), o.length >= 8 && h.every((e, g) => o[g] === e)) {
+    let e = 8, g = 0, a = !1, t = !1;
+    for (; e < o.length; ) {
+      (++g > 4096 || e + 12 > o.length) && f("Logo PNG段不完整");
+      const n = l(o).getUint32(e), r = e + 12 + n;
+      (n > 2147483647 || r > o.length) && f("Logo PNG段越界");
+      const i = L(o, e + 4, e + 8);
+      if ((!/^[A-Za-z]{4}$/.test(i) || i[2] !== i[2].toUpperCase() || c(o.subarray(e + 4, r - 4)) !== l(o).getUint32(r - 4)) && f("Logo PNG段或CRC无效"), (g === 1 && (i !== "IHDR" || n !== 13) || g > 1 && i === "IHDR") && f("Logo PNG头无效"), ["acTL", "fcTL", "fdAT"].includes(i) && f("Logo必须为静态单帧，不支持PNG动画"), i === "IDAT" ? (t && f("Logo PNG图像段顺序无效"), a = !0) : a && (t = !0), e = r, i === "IEND") {
+        (n || e !== o.length || !a) && f("Logo PNG结尾无效");
+        return;
+      }
+    }
+    f("Logo PNG缺少结尾");
+  }
+  if (P(o, 0, "RIFF") && P(o, 8, "WEBP")) {
+    (o.length < 20 || l(o).getUint32(4, !0) + 8 !== o.length) && f("Logo WebP RIFF长度无效");
+    let e = 12, g = 0, a = !1;
+    for (; e < o.length; ) {
+      (++g > 4096 || e + 8 > o.length) && f("Logo WebP段不完整");
+      const t = L(o, e, e + 4), n = l(o).getUint32(e + 4, !0), r = e + 8 + n, i = r + n % 2;
+      (i > o.length || !/^[\x20-\x7e]{4}$/.test(t) || n % 2 && o[r] !== 0) && f("Logo WebP段越界或padding无效"), (t === "ANIM" || t === "ANMF") && f("Logo必须为静态单帧，不支持WebP动画"), t === "VP8X" && ((g !== 1 || a || n !== 10) && f("Logo WebP扩展头无效"), a = !0, o[e + 8] & 2 && f("Logo必须为静态单帧，不支持WebP动画")), e = i;
+    }
+    return;
+  }
+  o[0] === 255 && o[1] === 216 || f("Logo仅支持PNG、JPEG及WebP");
+}
+export {
+  N as a
+};

package/dist/config.d.ts

@@ -0,0 +1,66 @@
+/** An exact allowlist. New tools, entries and execution modes stay closed. */
+export interface WorkspaceCapability {
+    toolId: string;
+    entryId?: string;
+    execution: 'local' | 'remote';
+    mode?: string;
+}
+export type WorkspaceResetAction = 'draft' | 'newBatch' | 'restoreVersion';
+export interface WorkspaceResetRequest {
+    readonly action: WorkspaceResetAction;
+    /** full clears the tool draft; parameters preserves its selected assets/mode where supported. */
+    readonly intent?: 'full' | 'parameters';
+    readonly toolId?: string;
+    readonly entryId?: string;
+    readonly batchId: string;
+}
+export interface WorkspaceParameterDefault {
+    readonly schemaVersion: 1;
+    readonly toolId: string;
+    readonly entryId?: string;
+    /** Existing tool parameter schema. Asset/task identities are never accepted in defaults. */
+    readonly params: Readonly<Record<string, unknown>>;
+}
+export interface WorkspaceNavigationRequest {
+    readonly reason: 'busy' | 'history' | 'readonly';
+    readonly batchId: string;
+    readonly toolId?: string;
+    readonly entryId?: string;
+}
+export interface WorkspaceConfig {
+    toolOptions?: {
+        translation?: {
+            targets: readonly {
+                code: string;
+                label: string;
+            }[];
+        };
+        expand?: {
+            prompt?: boolean;
+            ratios?: readonly string[];
+        };
+    };
+    /** The host opens its route/container. The core never constructs a product URL. */
+    navigation?: {
+        openWorkspace(request: WorkspaceNavigationRequest): void | Promise<void>;
+    };
+    parameterDefaults?: readonly WorkspaceParameterDefault[];
+    capabilities?: readonly WorkspaceCapability[];
+    visibility?: {
+        brand?: boolean;
+        history?: boolean;
+        import?: boolean;
+        export?: boolean;
+        newBatch?: boolean;
+        draftReset?: boolean;
+        theme?: boolean;
+        language?: boolean;
+        /** 服务可用性诊断与重新检测入口；不影响实际执行能力检查。 */
+        serviceStatus?: boolean;
+    };
+    /** Host confirmation/reset policy. False or rejection preserves the original state. */
+    beforeReset?(request: WorkspaceResetRequest): boolean | Promise<boolean>;
+}
+/** V1 compatibility only: omitting config retains the original metadata tool.
+ * Passing an explicit {} closes it too. Every newly introduced tool stays closed. */
+export declare const DEFAULT_WORKSPACE_CONFIG: WorkspaceConfig;

package/dist/contracts.d.ts

@@ -0,0 +1,272 @@
+import type { WorkspaceConfig } from './config';
+import type { WorkspaceServices } from './service-contracts';
+export * from './service-contracts';
+/** Version 1 candidate surface. No product identity, authorization or wallet objects. */
+export interface MetadataParameters {
+    version: 1;
+    removeGps: true;
+    removeDevice: true;
+    removeSerial: true;
+    removeTime: boolean;
+    removeAuthorComments: boolean;
+}
+export interface MetadataResult {
+    blob: Blob;
+    inputSha256: string;
+    outputSha256: string;
+    changed: boolean;
+    format: 'png' | 'jpeg' | 'webp';
+    removedCount: number;
+    removed: Record<'gps' | 'device' | 'serial' | 'time' | 'authorComments', number>;
+}
+export interface MetadataExecutor {
+    run(blob: Blob, params: MetadataParameters | {
+        execution: 'browser';
+        mode: 'declare';
+    }, expectedSha256?: string, signal?: AbortSignal): Promise<MetadataResult>;
+    dispose(): void;
+}
+export interface WorkspaceFile {
+    name: string;
+    blob: Blob;
+    itemId: string;
+    versionId: string;
+}
+export interface WorkspaceAssetIdentity {
+    assetId: string;
+    assetVersionId: string;
+    sha256: string;
+}
+export interface WorkspaceAssetReference extends WorkspaceAssetIdentity {
+    mime: string;
+    bytes: number;
+    width: number;
+    height: number;
+}
+export interface WorkspaceExternalSource {
+    readonly url: string;
+    readonly expectedSha256?: string;
+}
+export interface WorkspaceExecutionPlan {
+    readonly clientRequestId: string;
+    readonly operationId: string;
+    readonly itemId: string;
+    readonly inputVersionId: string;
+    readonly inputSha256: string;
+    readonly toolId: string;
+    readonly toolVersion: '1' | '2';
+    readonly params: Readonly<Record<string, unknown>>;
+}
+export interface WorkspaceDisclosure {
+    method?: 'manual' | 'ai';
+    decision: 'YES' | 'NO' | 'REVIEW';
+    reason: string;
+    status: 'verified' | 'unchanged' | 'review';
+    verified: boolean;
+    keywordPresent: boolean;
+    fileSha256: string;
+}
+export type WorkspaceLocalResult = {
+    kind: 'image';
+    blob: Blob;
+    reason?: string;
+    disclosure?: WorkspaceDisclosure;
+} | {
+    kind: 'analysis';
+    reason: string;
+    skipped?: boolean;
+    disclosure?: WorkspaceDisclosure;
+};
+export interface WorkspaceLocalExecutor {
+    run(plan: WorkspaceExecutionPlan, input: Blob, context: {
+        signal: AbortSignal;
+        readAsset(reference: WorkspaceAssetIdentity): Promise<Blob>;
+        progress(value: {
+            stage: 'decode' | 'process' | 'encode';
+            completed: number;
+            total?: number;
+        }): void;
+    }): Promise<WorkspaceLocalResult>;
+    dispose(): void;
+}
+export interface WorkspaceLocalCapability {
+    supports?(params: Readonly<Record<string, unknown>>): boolean;
+    createExecutor(): WorkspaceLocalExecutor;
+}
+import type { WorkspaceRemoteExecution, WorkspaceRemoteResultDetails } from './remote-contracts';
+export * from './remote-contracts';
+export interface WorkspacePageSession {
+    readonly active: boolean;
+    readonly batchId: string | undefined;
+    start(): Promise<void>;
+    bind(batchId: string): void;
+    stop(): void;
+}
+export interface BatchWorkspaceAdapter {
+    namespace: string;
+    /** SDK 页签绑定；需配合按项目读取的持久化，缺省保留旧的命名空间单写者契约。 */
+    pageSession?: () => WorkspacePageSession;
+    services?: WorkspaceServices;
+    coordination?: {
+        acquire(namespace: string): Promise<() => void | Promise<void>>;
+    };
+    assets: {
+        read(key: string): Promise<Blob | undefined>;
+        write(key: string, blob: Blob): Promise<void>;
+        remove(key: string): Promise<void>;
+        describe(blob: Blob): Promise<{
+            sha256: string;
+            width: number;
+            height: number;
+        }>;
+        /** Resolve a frozen identity without relying on mutable UI draft metadata. */
+        resolveReference?(identity: WorkspaceAssetIdentity, signal?: AbortSignal): Promise<WorkspaceAssetReference>;
+        readReference?(reference: WorkspaceAssetReference, signal?: AbortSignal): Promise<Blob>;
+        /** Explicit host-owned external IO. Frozen versions require an expected hash. */
+        readExternal?(source: WorkspaceExternalSource, signal?: AbortSignal): Promise<Blob>;
+    };
+    execution?: {
+        local?: Readonly<Record<string, WorkspaceLocalCapability>>;
+        remote?: WorkspaceRemoteExecution;
+    };
+    persistence: {
+        load(page?: {
+            batchId?: string;
+        }): Promise<unknown>;
+        save(snapshot: unknown): Promise<void>;
+        loadBatch?(batchId: string): Promise<unknown>;
+        list?(): Promise<unknown[]>;
+        removeBatch?(batchId: string): Promise<void>;
+    };
+    metadata: {
+        createExecutor(): MetadataExecutor;
+    };
+    download?(file: WorkspaceFile): Promise<void> | void;
+}
+export type WorkspaceCommand = {
+    type: 'updateConfig';
+    config: WorkspaceConfig;
+    display?: WorkspaceDisplay;
+} | {
+    type: 'updateContext';
+    adapter: BatchWorkspaceAdapter;
+    revision: string;
+    display?: WorkspaceDisplay;
+} | {
+    type: 'newBatch';
+} | {
+    type: 'openBatch';
+    batchId: string;
+} | {
+    type: 'restoreVersion';
+    itemId: string;
+    versionId: string;
+} | {
+    type: 'resetDraft';
+    toolId: string;
+    entryId?: string;
+} | {
+    type: 'runTool';
+    toolId: string;
+    params: Readonly<Record<string, unknown>>;
+} | {
+    type: 'cancelAttempt';
+    attemptId: string;
+} | {
+    type: 'queryAttempt' | 'stopWaiting' | 'resumeWaiting' | 'cancelRemote';
+    attemptId: string;
+} | {
+    type: 'importFiles';
+    files: File[];
+} | {
+    type: 'openTool';
+    toolId: string;
+    entryId?: string;
+} | {
+    type: 'runMetadataCleanup';
+    removeTime?: boolean;
+    removeAuthorComments?: boolean;
+} | {
+    type: 'select';
+    itemIds: string[];
+} | {
+    type: 'exportCurrent';
+    itemIds?: string[];
+};
+export type WorkspaceCommandResult = {
+    status: 'completed';
+    operationId?: string;
+    files?: readonly WorkspaceFile[];
+} | {
+    status: 'rejected';
+    code: string;
+    message: string;
+};
+export interface WorkspaceSnapshot {
+    readonly schemaVersion: 1;
+    readonly context: Readonly<{
+        namespace: string;
+        revision: string;
+    }>;
+    readonly writable: boolean;
+    readonly ready: boolean;
+    readonly batchId: string;
+    readonly selectedIds: readonly string[];
+    readonly items: readonly {
+        readonly id: string;
+        readonly name: string;
+        readonly currentVersionId: string;
+        readonly versions: readonly {
+            readonly id: string;
+            readonly sha256?: string;
+            readonly parentVersionId?: string;
+        }[];
+    }[];
+    readonly attempts: readonly {
+        readonly id: string;
+        readonly clientRequestId: string;
+        readonly operationId: string;
+        readonly itemId: string;
+        readonly taskId?: string;
+        readonly inputVersionId?: string;
+        readonly status: string;
+        readonly statusVersion: number;
+        readonly outcome?: Readonly<Omit<WorkspaceRemoteResultDetails, 'disclosure'>> & {
+            readonly disclosure?: Readonly<WorkspaceDisclosure> | null;
+        };
+        readonly admission?: 'accepted' | 'not_accepted' | 'unknown';
+        readonly remoteExecutionStatus?: string;
+        readonly publicationStatus?: 'pending' | 'unknown' | 'published';
+        readonly waitingStopped?: boolean;
+        readonly applied?: boolean;
+        readonly error?: string;
+    }[];
+    readonly operations: readonly {
+        readonly id: string;
+        readonly toolId: string;
+        readonly toolVersion: string;
+        readonly params: Readonly<Record<string, unknown>>;
+    }[];
+}
+export interface WorkspaceEvent {
+    readonly type: 'ready' | 'changed' | 'disposed' | 'error';
+    readonly snapshot: WorkspaceSnapshot;
+    readonly message?: string;
+}
+export interface BatchWorkspaceHandle {
+    command(command: WorkspaceCommand): Promise<WorkspaceCommandResult>;
+    snapshot(): WorkspaceSnapshot;
+    subscribe(listener: (event: WorkspaceEvent) => void): () => void;
+    dispose(): Promise<void>;
+}
+export interface BatchWorkspaceProps {
+    adapter: BatchWorkspaceAdapter;
+    config?: WorkspaceConfig;
+    display?: WorkspaceDisplay;
+    revision?: string;
+    onEvent?: (event: WorkspaceEvent) => void;
+}
+export interface WorkspaceDisplay {
+    locale?: 'en' | 'zh-CN' | 'ja' | 'ko' | 'ar' | 'es' | 'fr' | 'de';
+    theme?: 'light' | 'dark' | 'system';
+}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+import { type DefineComponent, type SlotsType, type ComputedOptions, type MethodOptions, type ComponentOptionsMixin, type PublicProps } from 'vue';
+import type { WorkspaceConfig } from './config';
+import type { WorkspaceSlots } from './slots';
+import type { BatchWorkspaceAdapter, BatchWorkspaceHandle, BatchWorkspaceProps, WorkspaceDisplay } from './contracts';
+export * from './contracts';
+export * from './config';
+export * from './slots';
+export * from './resource-contracts';
+export { createBrowserCutoutCapability } from './browser-cutout-capability';
+export { createBrowserCutoutResources } from './browser-cutout-resources';
+export { resolveWorkspaceCapability, workspaceExecutionSupport, workspaceToolVisible, } from './capabilities';
+export { createBrowserBatchAdapter } from './browser-adapter';
+export { createBrowserLocalCapabilities } from './browser-local-capabilities';
+export declare function createBatchWorkspace(options: {
+    adapter: BatchWorkspaceAdapter;
+    config?: WorkspaceConfig;
+    slots?: WorkspaceSlots;
+    display?: WorkspaceDisplay;
+    revision?: string;
+}): BatchWorkspaceHandle & {
+    mount(container: HTMLElement): Promise<void>;
+};
+export declare const BatchWorkspace: DefineComponent<BatchWorkspaceProps, BatchWorkspaceHandle, {}, ComputedOptions, MethodOptions, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, BatchWorkspaceProps, {}, SlotsType<WorkspaceSlots>>;

package/dist/index.js

@@ -0,0 +1,13 @@
+import { b7 as r, b8 as s, b9 as o, ba as t, bb as c, bc as b, bd as p, be as i, bf as l, bg as u } from "./chunks/entry-DK9FjQZ_.js";
+export {
+  r as BatchWorkspace,
+  s as DEFAULT_WORKSPACE_CONFIG,
+  o as createBatchWorkspace,
+  t as createBrowserBatchAdapter,
+  c as createBrowserCutoutCapability,
+  b as createBrowserCutoutResources,
+  p as createBrowserLocalCapabilities,
+  i as resolveWorkspaceCapability,
+  l as workspaceExecutionSupport,
+  u as workspaceToolVisible
+};

package/dist/node/catalog.mjs

@@ -0,0 +1,45 @@
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+
+const metadata = new URL('../resources/cutout/', import.meta.url);
+export function digest(bytes) {
+  return createHash('sha256').update(bytes).digest('hex');
+}
+export async function readCatalog() {
+  const catalog = JSON.parse(await readFile(new URL('resources.json', metadata), 'utf8'));
+  const names = new Set();
+  if (catalog.schemaVersion !== 1 || !Array.isArray(catalog.assets) || !catalog.assets.length)
+    throw Error('Invalid SDK resource catalog');
+  for (const asset of catalog.assets) {
+    if (
+      !/^[a-f0-9]{64}\.(bin|json)$/.test(asset.name) ||
+      asset.name.split('.')[0] !== asset.sha256 ||
+      names.has(asset.name) ||
+      !Number.isSafeInteger(asset.bytes) ||
+      asset.bytes <= 0 ||
+      asset.bytes > 32 * 1024 * 1024 ||
+      ![
+        'application/octet-stream',
+        'application/json',
+        'application/wasm',
+        'text/javascript',
+      ].includes(asset.mime)
+    )
+      throw Error('Invalid SDK resource entry');
+    names.add(asset.name);
+  }
+  return catalog;
+}
+export async function readManifest(binding) {
+  if (
+    !/^[a-f0-9]{64}\.json$/.test(binding.manifest) ||
+    binding.manifest !== `${binding.manifestSha256}.json`
+  )
+    throw Error('Invalid SDK manifest binding');
+  const bytes = await readFile(new URL(binding.manifest, metadata));
+  if (digest(bytes) !== binding.manifestSha256) throw Error('SDK model manifest hash mismatch');
+  return { bytes, manifest: JSON.parse(bytes) };
+}
+export async function readSources() {
+  return JSON.parse(await readFile(new URL('sources.json', metadata), 'utf8'));
+}

package/dist/node/cli.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { prepareBatchResources } from './prepare.mjs';
+import path from 'node:path';
+
+const args = process.argv.slice(2);
+const offline = args.includes('--offline');
+const positional = args.filter((arg) => arg !== '--offline');
+if (positional.length !== 1 || positional.some((arg) => arg.startsWith('-')))
+  throw Error('Usage: batch-images-prepare-resources <directory> [--offline]');
+const assets = await prepareBatchResources({ directory: path.resolve(positional[0]), offline });
+console.log(`Batch resources verified: ${assets.length} immutable files`);

package/dist/node/index.d.mts

@@ -0,0 +1,20 @@
+import type { Plugin } from 'vite';
+export interface BatchResourceAsset {
+  name: string;
+  sha256: string;
+  bytes: number;
+  mime: string;
+}
+export interface BatchResourceOptions {
+  /** Explicit local resource/cache directory, kept outside Git. */
+  directory: string;
+}
+export declare function verifyBatchResources(
+  options: BatchResourceOptions,
+): Promise<BatchResourceAsset[]>;
+export declare function prepareBatchResources(
+  options: BatchResourceOptions & { offline?: boolean },
+): Promise<BatchResourceAsset[]>;
+export declare function createBatchResourcesPlugin(
+  options: BatchResourceOptions & { publicPath?: string },
+): Plugin;

package/dist/node/index.mjs

@@ -0,0 +1,2 @@
+export { prepareBatchResources, verifyBatchResources } from './prepare.mjs';
+export { createBatchResourcesPlugin } from './vite.mjs';

package/dist/node/prepare.mjs

@@ -0,0 +1,114 @@
+import { createRequire } from 'node:module';
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, writeFile, rename, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { digest, readCatalog, readManifest, readSources } from './catalog.mjs';
+
+const require = createRequire(import.meta.url);
+function resourceDirectory(options) {
+  if (!options?.directory?.trim()) throw Error('An explicit resource directory is required');
+  return path.resolve(options.directory);
+}
+async function valid(directory, asset) {
+  try {
+    const bytes = await readFile(path.join(directory, asset.name));
+    return bytes.length === asset.bytes && digest(bytes) === asset.sha256;
+  } catch (error) {
+    if (error.code === 'ENOENT') return false;
+    throw error;
+  }
+}
+async function download(url, size, sha256) {
+  const response = await fetch(url, {
+    headers: { 'User-Agent': 'Mozilla/5.0', Referer: 'https://img.ly/' },
+    signal: AbortSignal.timeout(20 * 60_000),
+  });
+  if (!response.ok || !response.body) throw Error(`Resource download failed: ${response.status}`);
+  const parts = [];
+  let received = 0;
+  for await (const part of response.body) {
+    received += part.length;
+    if (received > size) throw Error('Resource exceeds declared size');
+    parts.push(part);
+  }
+  const bytes = Buffer.concat(parts);
+  if (bytes.length !== size || digest(bytes) !== sha256)
+    throw Error('Resource download integrity failure');
+  return bytes;
+}
+async function store(directory, name, bytes, expected) {
+  if (
+    !/^[a-f0-9]{64}\.(bin|json)$/.test(name) ||
+    name.split('.')[0] !== expected ||
+    digest(bytes) !== expected
+  )
+    throw Error('Resource name/hash mismatch');
+  const target = path.join(directory, name);
+  const temporary = `${target}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, bytes);
+    await rename(temporary, target);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+}
+export async function verifyBatchResources(options) {
+  const directory = resourceDirectory(options);
+  const catalog = await readCatalog();
+  for (const asset of catalog.assets) {
+    if (!(await valid(directory, asset)))
+      throw Error(
+        `Batch resource missing or corrupt: ${asset.name}; run batch-images-prepare-resources`,
+      );
+  }
+  return catalog.assets;
+}
+export async function prepareBatchResources(options) {
+  const directory = resourceDirectory(options);
+  if (options.offline) return verifyBatchResources(options);
+  const index = await readCatalog();
+  const sources = await readSources();
+  await mkdir(directory, { recursive: true });
+  for (const [model, binding] of Object.entries(index.models)) {
+    const { bytes: manifestBytes, manifest } = await readManifest(binding);
+    for (const [logicalPath, entry] of Object.entries(manifest.files)) {
+      const assets = entry.chunks.map((chunk) => ({
+        name: chunk.name,
+        sha256: chunk.sha256,
+        bytes: chunk.offsets[1] - chunk.offsets[0],
+      }));
+      if ((await Promise.all(assets.map((asset) => valid(directory, asset)))).every(Boolean))
+        continue;
+      const source = sources.find(
+        (item) =>
+          item.logicalPath === logicalPath &&
+          (model === 'isnet_fp16' ? item.upstreamChunks : !item.upstreamChunks),
+      );
+      if (!source || source.sha256 !== entry.sha256 || source.size !== entry.size)
+        throw Error('Source does not match the SDK manifest');
+      let bytes;
+      if (source.npm) {
+        const transformersRequire = createRequire(require.resolve('@huggingface/transformers'));
+        const runtime = path.dirname(transformersRequire.resolve('onnxruntime-web'));
+        bytes = await readFile(path.join(runtime, path.basename(source.npmPath)));
+      } else if (source.upstreamChunks) {
+        const parts = [];
+        for (const chunk of source.upstreamChunks)
+          parts.push(
+            await download(
+              new URL(chunk.name, source.url).href,
+              chunk.offsets[1] - chunk.offsets[0],
+              chunk.hash,
+            ),
+          );
+        bytes = Buffer.concat(parts);
+      } else bytes = await download(source.url, source.size, source.sha256);
+      if (bytes.length !== entry.size || digest(bytes) !== entry.sha256)
+        throw Error(`SDK source integrity failure: ${logicalPath}`);
+      for (const chunk of entry.chunks)
+        await store(directory, chunk.name, bytes.subarray(...chunk.offsets), chunk.sha256);
+    }
+    await store(directory, binding.manifest, manifestBytes, binding.manifestSha256);
+  }
+  return verifyBatchResources(options);
+}