@plasius/gpu-model-runtime 0.1.1

package/dist/index.d.cts

@@ -0,0 +1,275 @@
+type ModelSourceKind = "file-path" | "url" | "blob-storage-url" | "blob" | "array-buffer" | "uint8-array" | "stream";
+type ModelProvenance = Readonly<{
+    sourceId?: string;
+    sourceSystem?: string;
+    acquiredAt?: string;
+    licenseHint?: string;
+}>;
+type ModelResourceInput = Readonly<{
+    bytes: ArrayBuffer | Blob | Uint8Array;
+    contentType?: string;
+    integrity?: string;
+}>;
+type ModelPackage = Readonly<{
+    entrypoint?: string;
+    baseUrl?: string;
+    resources?: Readonly<Record<string, ModelResourceInput>>;
+}>;
+type ModelSource = Readonly<{
+    kind: "file-path";
+    path: string;
+    mimeTypeHint?: string;
+    fileNameHint?: string;
+    package?: ModelPackage;
+    provenance?: ModelProvenance;
+}> | Readonly<{
+    kind: "url";
+    url: string;
+    headers?: Readonly<Record<string, string>>;
+    mimeTypeHint?: string;
+    package?: ModelPackage;
+    provenance?: ModelProvenance;
+}> | Readonly<{
+    kind: "blob-storage-url";
+    url: string;
+    credentialMode?: "anonymous" | "signed" | "runtime-resolved";
+    mimeTypeHint?: string;
+    package?: ModelPackage;
+    provenance?: ModelProvenance;
+}> | Readonly<{
+    kind: "blob";
+    blob: Blob;
+    fileNameHint?: string;
+    mimeTypeHint?: string;
+    package?: ModelPackage;
+    provenance?: ModelProvenance;
+}> | Readonly<{
+    kind: "array-buffer";
+    bytes: ArrayBuffer;
+    fileNameHint?: string;
+    mimeTypeHint?: string;
+    package?: ModelPackage;
+    provenance?: ModelProvenance;
+}> | Readonly<{
+    kind: "uint8-array";
+    bytes: Uint8Array;
+    fileNameHint?: string;
+    mimeTypeHint?: string;
+    package?: ModelPackage;
+    provenance?: ModelProvenance;
+}> | Readonly<{
+    kind: "stream";
+    stream: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>;
+    fileNameHint?: string;
+    mimeTypeHint?: string;
+    byteLengthHint?: number;
+    package?: ModelPackage;
+    provenance?: ModelProvenance;
+}>;
+type ResourceReference = Readonly<{
+    path: string;
+    contentType?: string;
+    integrity?: string;
+}>;
+type ResolvedResource = Readonly<{
+    path: string;
+    bytes: Uint8Array;
+    contentType?: string;
+    contentHash: string;
+    rangeSupported: boolean;
+}>;
+interface ResourceResolver {
+    resolve(reference: string | ResourceReference, options?: ResolveResourceOptions): Promise<ResolvedResource>;
+}
+type ResolveResourceOptions = Readonly<{
+    signal?: AbortSignal;
+    range?: Readonly<{
+        start: number;
+        end?: number;
+    }>;
+}>;
+type FetchPolicy = Readonly<{
+    maxAttempts?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    timeoutMs?: number;
+}>;
+type RuntimeFetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
+type ReadFile = (path: string, signal?: AbortSignal) => Promise<Uint8Array>;
+type HashBytes = (bytes: Uint8Array) => Promise<string>;
+type Sleep = (milliseconds: number, signal?: AbortSignal) => Promise<void>;
+type BlobStorageUrlResolver = (baseUrl: string, reference: string) => string | Promise<string>;
+type RuntimeDependencies = Readonly<{
+    fetch?: RuntimeFetch;
+    readFile?: ReadFile;
+    hashBytes?: HashBytes;
+    sleep?: Sleep;
+    blobStorageUrlResolver?: BlobStorageUrlResolver;
+}>;
+type ResolvedModelSource = Readonly<{
+    source: ModelSource;
+    bytes: Uint8Array;
+    contentType?: string;
+    fileName?: string;
+    contentHash: string;
+    rangeSupported: boolean;
+    resourceResolver: ResourceResolver;
+}>;
+type SniffInput = Readonly<{
+    bytes: Uint8Array;
+    contentType?: string;
+    fileName?: string;
+    sourceKind: ModelSourceKind;
+}>;
+type AdapterLoadContext = Readonly<{
+    signal: AbortSignal;
+    mode: "strict" | "tolerant" | "forensic";
+    execution: "main" | "worker";
+    adapterOptions: unknown;
+}>;
+type AdapterLoadResult<TCanonicalModel, TRendererReady = unknown> = Readonly<{
+    canonicalModel: TCanonicalModel;
+    rendererReady?: TRendererReady;
+    diagnostics?: readonly unknown[];
+}>;
+interface ModelAdapter<TCanonicalModel, TRendererReady = unknown> {
+    readonly formatId: string;
+    readonly supportsWorker?: boolean;
+    sniff(input: SniffInput): number | boolean;
+    load(input: ResolvedModelSource, context: AdapterLoadContext): Promise<AdapterLoadResult<TCanonicalModel, TRendererReady>>;
+}
+type AdapterModule<TCanonicalModel, TRendererReady = unknown> = ModelAdapter<TCanonicalModel, TRendererReady> | Readonly<{
+    default: ModelAdapter<TCanonicalModel, TRendererReady>;
+}>;
+type AdapterRegistration<TCanonicalModel = unknown, TRendererReady = unknown> = Readonly<{
+    formatId: string;
+    extensions?: readonly string[];
+    mimeTypes?: readonly string[];
+    sniff?: (input: SniffInput) => number | boolean;
+    load: () => Promise<AdapterModule<TCanonicalModel, TRendererReady>>;
+}>;
+type WorkerLoadRequest = Readonly<{
+    formatId: string;
+    input: ResolvedModelSource;
+    context: AdapterLoadContext;
+}>;
+interface WorkerDispatcher {
+    dispatch<TCanonicalModel, TRendererReady = unknown>(request: WorkerLoadRequest): Promise<AdapterLoadResult<TCanonicalModel, TRendererReady>>;
+}
+type ModelCache = Readonly<{
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+}>;
+type LoadModelOptions = Readonly<{
+    signal?: AbortSignal;
+    mode?: "strict" | "tolerant" | "forensic";
+    adapterOptions?: unknown;
+    formatId?: string;
+    fetchPolicy?: FetchPolicy;
+    integrity?: string;
+    useCache?: boolean;
+    worker?: Readonly<{
+        mode?: "auto" | "never" | "always";
+    }>;
+}>;
+type ModelLoadResult<TCanonicalModel, TRendererReady = unknown> = Readonly<{
+    canonicalModel: TCanonicalModel;
+    rendererReady?: TRendererReady;
+    diagnostics?: readonly unknown[];
+    contentHash: string;
+    cacheKey: string;
+    fromCache: boolean;
+    contentType?: string;
+    sourceKind: ModelSourceKind;
+}>;
+
+declare class MemoryModelCache implements ModelCache {
+    private readonly entries;
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+}
+declare function createModelCacheKey(contentHash: string, formatId: string, adapterOptions: unknown): string;
+
+type FetchedResource = Readonly<{
+    bytes: Uint8Array;
+    contentType?: string;
+    rangeSupported: boolean;
+}>;
+declare function defaultSleep(milliseconds: number, signal?: AbortSignal): Promise<void>;
+declare function sha256Hex(bytes: Uint8Array): Promise<string>;
+declare function fetchResource(url: string, options: Readonly<{
+    fetch: RuntimeFetch;
+    hashBytes: HashBytes;
+    sleep: Sleep;
+    headers?: Readonly<Record<string, string>>;
+    integrity?: string;
+    policy?: FetchPolicy;
+    resolveOptions?: ResolveResourceOptions;
+}>): Promise<FetchedResource>;
+declare function verifyIntegrity(bytes: Uint8Array, integrity: string | undefined, hashBytes: HashBytes): Promise<void>;
+
+declare class AdapterRegistry {
+    private readonly registrations;
+    register<TCanonicalModel, TRendererReady>(registration: AdapterRegistration<TCanonicalModel, TRendererReady>): this;
+    resolve<TCanonicalModel = unknown, TRendererReady = unknown>(input: SniffInput, formatId?: string): Promise<ModelAdapter<TCanonicalModel, TRendererReady>>;
+}
+declare class PackageResourceResolver implements ResourceResolver {
+    private readonly memoryResources;
+    private readonly baseUrl?;
+    private readonly sourceKind;
+    private readonly fetch;
+    private readonly hashBytes;
+    private readonly sleep;
+    private readonly fetchPolicy;
+    private readonly headers?;
+    private readonly blobStorageUrlResolver?;
+    constructor(options: Readonly<{
+        sourceKind: ModelSourceKind;
+        baseUrl?: string;
+        package?: ModelPackage;
+        fetch: RuntimeFetch;
+        hashBytes: HashBytes;
+        sleep: Sleep;
+        fetchPolicy?: LoadModelOptions["fetchPolicy"];
+        headers?: Readonly<Record<string, string>>;
+        blobStorageUrlResolver?: RuntimeDependencies["blobStorageUrlResolver"];
+    }>);
+    resolve(reference: string | ResourceReference, options?: ResolveResourceOptions): Promise<ResolvedResource>;
+    private resolveUrl;
+}
+declare class ModelRuntime {
+    private readonly registry;
+    private readonly cache;
+    private readonly fetch;
+    private readonly readFile?;
+    private readonly hashBytes;
+    private readonly sleep;
+    private readonly workerDispatcher?;
+    private readonly blobStorageUrlResolver?;
+    private readonly cacheKeys;
+    constructor(options?: Readonly<{
+        registry?: AdapterRegistry;
+        cache?: ModelCache;
+        dependencies?: RuntimeDependencies;
+        workerDispatcher?: WorkerDispatcher;
+    }>);
+    get adapters(): AdapterRegistry;
+    invalidate(contentHash?: string): Promise<void>;
+    loadModel<TCanonicalModel, TRendererReady = unknown>(source: ModelSource, options?: LoadModelOptions): Promise<ModelLoadResult<TCanonicalModel, TRendererReady>>;
+    private loadWithExecution;
+    private resolveSource;
+}
+
+/** Package identity and rollout metadata for the runtime boundary. */
+declare const packageName: "@plasius/gpu-model-runtime";
+declare const packageBootstrap: Readonly<{
+    readonly packageName: "@plasius/gpu-model-runtime";
+    readonly featureFlag: "gpu.model.conversion.enabled";
+    readonly status: "runtime";
+}>;
+
+export { type AdapterLoadContext, type AdapterLoadResult, type AdapterModule, type AdapterRegistration, AdapterRegistry, type BlobStorageUrlResolver, type FetchPolicy, type FetchedResource, type HashBytes, type LoadModelOptions, MemoryModelCache, type ModelAdapter, type ModelCache, type ModelLoadResult, type ModelPackage, type ModelProvenance, type ModelResourceInput, ModelRuntime, type ModelSource, type ModelSourceKind, PackageResourceResolver, type ReadFile, type ResolveResourceOptions, type ResolvedModelSource, type ResolvedResource, type ResourceReference, type ResourceResolver, type RuntimeDependencies, type RuntimeFetch, type Sleep, type SniffInput, type WorkerDispatcher, type WorkerLoadRequest, createModelCacheKey, defaultSleep, fetchResource, packageBootstrap, packageName, sha256Hex, verifyIntegrity };

package/dist/index.d.ts

@@ -0,0 +1,275 @@
+type ModelSourceKind = "file-path" | "url" | "blob-storage-url" | "blob" | "array-buffer" | "uint8-array" | "stream";
+type ModelProvenance = Readonly<{
+    sourceId?: string;
+    sourceSystem?: string;
+    acquiredAt?: string;
+    licenseHint?: string;
+}>;
+type ModelResourceInput = Readonly<{
+    bytes: ArrayBuffer | Blob | Uint8Array;
+    contentType?: string;
+    integrity?: string;
+}>;
+type ModelPackage = Readonly<{
+    entrypoint?: string;
+    baseUrl?: string;
+    resources?: Readonly<Record<string, ModelResourceInput>>;
+}>;
+type ModelSource = Readonly<{
+    kind: "file-path";
+    path: string;
+    mimeTypeHint?: string;
+    fileNameHint?: string;
+    package?: ModelPackage;
+    provenance?: ModelProvenance;
+}> | Readonly<{
+    kind: "url";
+    url: string;
+    headers?: Readonly<Record<string, string>>;
+    mimeTypeHint?: string;
+    package?: ModelPackage;
+    provenance?: ModelProvenance;
+}> | Readonly<{
+    kind: "blob-storage-url";
+    url: string;
+    credentialMode?: "anonymous" | "signed" | "runtime-resolved";
+    mimeTypeHint?: string;
+    package?: ModelPackage;
+    provenance?: ModelProvenance;
+}> | Readonly<{
+    kind: "blob";
+    blob: Blob;
+    fileNameHint?: string;
+    mimeTypeHint?: string;
+    package?: ModelPackage;
+    provenance?: ModelProvenance;
+}> | Readonly<{
+    kind: "array-buffer";
+    bytes: ArrayBuffer;
+    fileNameHint?: string;
+    mimeTypeHint?: string;
+    package?: ModelPackage;
+    provenance?: ModelProvenance;
+}> | Readonly<{
+    kind: "uint8-array";
+    bytes: Uint8Array;
+    fileNameHint?: string;
+    mimeTypeHint?: string;
+    package?: ModelPackage;
+    provenance?: ModelProvenance;
+}> | Readonly<{
+    kind: "stream";
+    stream: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>;
+    fileNameHint?: string;
+    mimeTypeHint?: string;
+    byteLengthHint?: number;
+    package?: ModelPackage;
+    provenance?: ModelProvenance;
+}>;
+type ResourceReference = Readonly<{
+    path: string;
+    contentType?: string;
+    integrity?: string;
+}>;
+type ResolvedResource = Readonly<{
+    path: string;
+    bytes: Uint8Array;
+    contentType?: string;
+    contentHash: string;
+    rangeSupported: boolean;
+}>;
+interface ResourceResolver {
+    resolve(reference: string | ResourceReference, options?: ResolveResourceOptions): Promise<ResolvedResource>;
+}
+type ResolveResourceOptions = Readonly<{
+    signal?: AbortSignal;
+    range?: Readonly<{
+        start: number;
+        end?: number;
+    }>;
+}>;
+type FetchPolicy = Readonly<{
+    maxAttempts?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    timeoutMs?: number;
+}>;
+type RuntimeFetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
+type ReadFile = (path: string, signal?: AbortSignal) => Promise<Uint8Array>;
+type HashBytes = (bytes: Uint8Array) => Promise<string>;
+type Sleep = (milliseconds: number, signal?: AbortSignal) => Promise<void>;
+type BlobStorageUrlResolver = (baseUrl: string, reference: string) => string | Promise<string>;
+type RuntimeDependencies = Readonly<{
+    fetch?: RuntimeFetch;
+    readFile?: ReadFile;
+    hashBytes?: HashBytes;
+    sleep?: Sleep;
+    blobStorageUrlResolver?: BlobStorageUrlResolver;
+}>;
+type ResolvedModelSource = Readonly<{
+    source: ModelSource;
+    bytes: Uint8Array;
+    contentType?: string;
+    fileName?: string;
+    contentHash: string;
+    rangeSupported: boolean;
+    resourceResolver: ResourceResolver;
+}>;
+type SniffInput = Readonly<{
+    bytes: Uint8Array;
+    contentType?: string;
+    fileName?: string;
+    sourceKind: ModelSourceKind;
+}>;
+type AdapterLoadContext = Readonly<{
+    signal: AbortSignal;
+    mode: "strict" | "tolerant" | "forensic";
+    execution: "main" | "worker";
+    adapterOptions: unknown;
+}>;
+type AdapterLoadResult<TCanonicalModel, TRendererReady = unknown> = Readonly<{
+    canonicalModel: TCanonicalModel;
+    rendererReady?: TRendererReady;
+    diagnostics?: readonly unknown[];
+}>;
+interface ModelAdapter<TCanonicalModel, TRendererReady = unknown> {
+    readonly formatId: string;
+    readonly supportsWorker?: boolean;
+    sniff(input: SniffInput): number | boolean;
+    load(input: ResolvedModelSource, context: AdapterLoadContext): Promise<AdapterLoadResult<TCanonicalModel, TRendererReady>>;
+}
+type AdapterModule<TCanonicalModel, TRendererReady = unknown> = ModelAdapter<TCanonicalModel, TRendererReady> | Readonly<{
+    default: ModelAdapter<TCanonicalModel, TRendererReady>;
+}>;
+type AdapterRegistration<TCanonicalModel = unknown, TRendererReady = unknown> = Readonly<{
+    formatId: string;
+    extensions?: readonly string[];
+    mimeTypes?: readonly string[];
+    sniff?: (input: SniffInput) => number | boolean;
+    load: () => Promise<AdapterModule<TCanonicalModel, TRendererReady>>;
+}>;
+type WorkerLoadRequest = Readonly<{
+    formatId: string;
+    input: ResolvedModelSource;
+    context: AdapterLoadContext;
+}>;
+interface WorkerDispatcher {
+    dispatch<TCanonicalModel, TRendererReady = unknown>(request: WorkerLoadRequest): Promise<AdapterLoadResult<TCanonicalModel, TRendererReady>>;
+}
+type ModelCache = Readonly<{
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+}>;
+type LoadModelOptions = Readonly<{
+    signal?: AbortSignal;
+    mode?: "strict" | "tolerant" | "forensic";
+    adapterOptions?: unknown;
+    formatId?: string;
+    fetchPolicy?: FetchPolicy;
+    integrity?: string;
+    useCache?: boolean;
+    worker?: Readonly<{
+        mode?: "auto" | "never" | "always";
+    }>;
+}>;
+type ModelLoadResult<TCanonicalModel, TRendererReady = unknown> = Readonly<{
+    canonicalModel: TCanonicalModel;
+    rendererReady?: TRendererReady;
+    diagnostics?: readonly unknown[];
+    contentHash: string;
+    cacheKey: string;
+    fromCache: boolean;
+    contentType?: string;
+    sourceKind: ModelSourceKind;
+}>;
+
+declare class MemoryModelCache implements ModelCache {
+    private readonly entries;
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+}
+declare function createModelCacheKey(contentHash: string, formatId: string, adapterOptions: unknown): string;
+
+type FetchedResource = Readonly<{
+    bytes: Uint8Array;
+    contentType?: string;
+    rangeSupported: boolean;
+}>;
+declare function defaultSleep(milliseconds: number, signal?: AbortSignal): Promise<void>;
+declare function sha256Hex(bytes: Uint8Array): Promise<string>;
+declare function fetchResource(url: string, options: Readonly<{
+    fetch: RuntimeFetch;
+    hashBytes: HashBytes;
+    sleep: Sleep;
+    headers?: Readonly<Record<string, string>>;
+    integrity?: string;
+    policy?: FetchPolicy;
+    resolveOptions?: ResolveResourceOptions;
+}>): Promise<FetchedResource>;
+declare function verifyIntegrity(bytes: Uint8Array, integrity: string | undefined, hashBytes: HashBytes): Promise<void>;
+
+declare class AdapterRegistry {
+    private readonly registrations;
+    register<TCanonicalModel, TRendererReady>(registration: AdapterRegistration<TCanonicalModel, TRendererReady>): this;
+    resolve<TCanonicalModel = unknown, TRendererReady = unknown>(input: SniffInput, formatId?: string): Promise<ModelAdapter<TCanonicalModel, TRendererReady>>;
+}
+declare class PackageResourceResolver implements ResourceResolver {
+    private readonly memoryResources;
+    private readonly baseUrl?;
+    private readonly sourceKind;
+    private readonly fetch;
+    private readonly hashBytes;
+    private readonly sleep;
+    private readonly fetchPolicy;
+    private readonly headers?;
+    private readonly blobStorageUrlResolver?;
+    constructor(options: Readonly<{
+        sourceKind: ModelSourceKind;
+        baseUrl?: string;
+        package?: ModelPackage;
+        fetch: RuntimeFetch;
+        hashBytes: HashBytes;
+        sleep: Sleep;
+        fetchPolicy?: LoadModelOptions["fetchPolicy"];
+        headers?: Readonly<Record<string, string>>;
+        blobStorageUrlResolver?: RuntimeDependencies["blobStorageUrlResolver"];
+    }>);
+    resolve(reference: string | ResourceReference, options?: ResolveResourceOptions): Promise<ResolvedResource>;
+    private resolveUrl;
+}
+declare class ModelRuntime {
+    private readonly registry;
+    private readonly cache;
+    private readonly fetch;
+    private readonly readFile?;
+    private readonly hashBytes;
+    private readonly sleep;
+    private readonly workerDispatcher?;
+    private readonly blobStorageUrlResolver?;
+    private readonly cacheKeys;
+    constructor(options?: Readonly<{
+        registry?: AdapterRegistry;
+        cache?: ModelCache;
+        dependencies?: RuntimeDependencies;
+        workerDispatcher?: WorkerDispatcher;
+    }>);
+    get adapters(): AdapterRegistry;
+    invalidate(contentHash?: string): Promise<void>;
+    loadModel<TCanonicalModel, TRendererReady = unknown>(source: ModelSource, options?: LoadModelOptions): Promise<ModelLoadResult<TCanonicalModel, TRendererReady>>;
+    private loadWithExecution;
+    private resolveSource;
+}
+
+/** Package identity and rollout metadata for the runtime boundary. */
+declare const packageName: "@plasius/gpu-model-runtime";
+declare const packageBootstrap: Readonly<{
+    readonly packageName: "@plasius/gpu-model-runtime";
+    readonly featureFlag: "gpu.model.conversion.enabled";
+    readonly status: "runtime";
+}>;
+
+export { type AdapterLoadContext, type AdapterLoadResult, type AdapterModule, type AdapterRegistration, AdapterRegistry, type BlobStorageUrlResolver, type FetchPolicy, type FetchedResource, type HashBytes, type LoadModelOptions, MemoryModelCache, type ModelAdapter, type ModelCache, type ModelLoadResult, type ModelPackage, type ModelProvenance, type ModelResourceInput, ModelRuntime, type ModelSource, type ModelSourceKind, PackageResourceResolver, type ReadFile, type ResolveResourceOptions, type ResolvedModelSource, type ResolvedResource, type ResourceReference, type ResourceResolver, type RuntimeDependencies, type RuntimeFetch, type Sleep, type SniffInput, type WorkerDispatcher, type WorkerLoadRequest, createModelCacheKey, defaultSleep, fetchResource, packageBootstrap, packageName, sha256Hex, verifyIntegrity };