@omnicross/core 0.1.10 → 0.2.0

package/dist/types-Bd72H4SB.d.ts

@@ -0,0 +1,196 @@
+import * as _omnicross_contracts_image_generation_types from '@omnicross/contracts/image-generation-types';
+import { ImageArtifactMetadata, ImageRequestOptions } from '@omnicross/contracts/image-generation-types';
+import { I as ImageAsset, p as ImageReferenceLease, K as OpenAIOperationHandler, h as ImageOrchestrator, L as OpenAIOperationHandlerContext, s as ImageReferenceStore, u as ImageRetentionPolicy } from './types-CVRge76p.js';
+import { FileHandle } from 'node:fs/promises';
+
+type ResourceKind = 'input' | 'spool';
+declare const IMAGE_REQUEST_DIRECTORY_MARKER_NAME = ".omnicross-images-owner.json";
+declare const IMAGE_REQUEST_DIRECTORY_MARKER_CONTENT = "{\"schema\":\"omnicross-images-temporary\",\"version\":1}\n";
+/** Internal request-scoped file. It deliberately has no path property or getter. */
+declare class StagedTemporaryFile {
+    #private;
+    readonly byteLength: number;
+    constructor(scope: ImageRequestResourceScope, path: string, byteLength: number, kind: ResourceKind);
+    open(signal?: AbortSignal): Promise<ReadableStream<Uint8Array>>;
+    /** Internal validator seam; no path is returned or retained by the caller. */
+    inspect<T>(callback: (privatePath: string) => Promise<T>): Promise<T>;
+    dispose(): Promise<void>;
+    toImageAsset(metadata: Omit<ImageArtifactMetadata, 'artifactId' | 'byteLength' | 'independentlyDecodable'>): TemporaryImageAsset;
+}
+declare class TemporaryImageAsset implements ImageAsset {
+    #private;
+    readonly artifactId: _omnicross_contracts_image_generation_types.ImageArtifactId;
+    readonly mimeType: `image/${string}`;
+    readonly byteLength: number;
+    readonly width: number;
+    readonly height: number;
+    readonly hasAlpha: boolean | undefined;
+    readonly sha256: string | undefined;
+    readonly independentlyDecodable: true;
+    constructor(file: StagedTemporaryFile, metadata: Omit<ImageArtifactMetadata, 'artifactId' | 'byteLength' | 'independentlyDecodable'>);
+    open(options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<ReadableStream<Uint8Array>>;
+}
+declare class RequestFileWriter {
+    #private;
+    constructor(options: {
+        scope: ImageRequestResourceScope;
+        handle: FileHandle;
+        path: string;
+        kind: ResourceKind;
+        maxBytes: number;
+        declaredBytes?: number;
+    });
+    get byteLength(): number;
+    write(chunk: Uint8Array, signal?: AbortSignal): Promise<void>;
+    finish(): Promise<StagedTemporaryFile>;
+    abort(): Promise<void>;
+}
+interface CreateImageRequestResourceScopeOptions {
+    readonly limits: ImageApiLimits;
+    readonly signal: AbortSignal;
+    readonly tempRoot?: string;
+    /** Trusted tenant identity; required whenever a shared budget is injected. */
+    readonly tenantId?: string;
+    readonly sharedBudget?: ImageTemporaryResourceBudget;
+    /** Write the fixed, content-free daemon ownership marker into the request directory. */
+    readonly ownedDirectoryMarker?: boolean;
+    /** Host-private lease hook used to keep recurring cleanup away from live scopes. */
+    readonly onDirectoryActive?: (privateDirectory: string) => () => void;
+}
+/** One active-scope reservation from the daemon's cross-request budget. */
+interface ImageTemporaryResourceBudgetLease {
+    /** Atomically charge bytes before a write; a thrown call MUST charge nothing. */
+    reserve(bytes: number): void;
+    /** Infallibly release up to the bytes previously reserved by this lease. */
+    release(bytes: number): void;
+    /** Idempotently and infallibly release the active-scope reservation. */
+    releaseScope(): void;
+}
+/** Credential/content-blind shared temporary budget port. */
+interface ImageTemporaryResourceBudget {
+    /** Atomically acquire one active scope for a trusted, non-empty tenant. */
+    acquireScope(tenantId: string): ImageTemporaryResourceBudgetLease;
+}
+interface ImageRequestResourceOwnership {
+    readonly tenantId: string;
+    readonly sharedBudget: ImageTemporaryResourceBudget;
+    readonly ownedDirectoryMarker?: boolean;
+}
+declare class ImageRequestResourceScope {
+    #private;
+    private constructor();
+    static create(options: CreateImageRequestResourceScopeOptions): Promise<ImageRequestResourceScope>;
+    assertActive(): void;
+    reserve(kind: ResourceKind, bytes: number): void;
+    unreserve(kind: ResourceKind, bytes: number): void;
+    writerFinished(writer: RequestFileWriter): void;
+    releaseSpool(privatePath: string, bytes: number): Promise<void>;
+    createWriter(options: {
+        readonly kind: ResourceKind;
+        readonly maxBytes: number;
+        readonly declaredBytes?: number;
+    }): Promise<RequestFileWriter>;
+    materialize(source: AsyncIterable<Uint8Array>, options?: {
+        readonly kind?: ResourceKind;
+        readonly maxBytes?: number;
+        readonly declaredBytes?: number;
+        readonly signal?: AbortSignal;
+    }): Promise<StagedTemporaryFile>;
+    addLease(lease: ImageReferenceLease): void;
+    cleanup(): Promise<void>;
+}
+declare function createImageRequestResourceScope(limits: ImageApiLimits, signal: AbortSignal, tempRoot?: string, ownership?: ImageRequestResourceOwnership): Promise<ImageRequestResourceScope>;
+
+interface ImageApiLimits {
+    readonly maxJsonBytes: number;
+    readonly maxMultipartBytes: number;
+    readonly maxFileBytes: number;
+    readonly maxTotalInputBytes: number;
+    readonly maxFiles: number;
+    readonly maxFields: number;
+    readonly maxParts: number;
+    readonly maxHeaderPairs: number;
+    readonly maxFieldNameBytes: number;
+    readonly maxFieldValueBytes: number;
+    readonly maxPixels: number;
+    readonly maxRawBytes: number;
+    readonly maxOutputBytes: number;
+    readonly maxTotalOutputBytes: number;
+    readonly maxSpoolBytes: number;
+    readonly maxRedirects: number;
+    readonly maxRemoteUrlBytes: number;
+    readonly maxRemoteHeaderBytes: number;
+    readonly remoteConnectTimeoutMs: number;
+    readonly remoteTotalTimeoutMs: number;
+}
+declare const DEFAULT_IMAGE_API_LIMITS: ImageApiLimits;
+declare function assertFiniteImageApiLimits(limits: ImageApiLimits): void;
+interface ImageRemoteMaterializer {
+    materialize(source: AsyncIterable<Uint8Array>, declaredBytes: number | undefined, signal: AbortSignal): Promise<ImageAsset>;
+}
+interface RemoteImageAssetResolver {
+    resolve(input: {
+        readonly url: string;
+        readonly signal: AbortSignal;
+        readonly limits: ImageApiLimits;
+        readonly materializer: ImageRemoteMaterializer;
+    }): Promise<ImageAsset>;
+}
+interface ImageApiRuntime {
+    readonly tenantId: string;
+    readonly providerId: string;
+    readonly defaultModel: string;
+    readonly modelAliases: ReadonlyMap<string, string>;
+    readonly limits: ImageApiLimits;
+    readonly preferredAccountId?: string;
+    readonly preferredAccountGroup?: string;
+    readonly boundAccountFallbackPolicy?: 'strict' | 'pool';
+    readonly referenceStore?: ImageReferenceStore;
+    readonly remoteResolver?: RemoteImageAssetResolver;
+    readonly fingerprintUser?: (value: string) => string;
+    readonly retention?: ImageRetentionPolicy;
+}
+type ImageApiRuntimeResolver = (context: OpenAIOperationHandlerContext) => Promise<ImageApiRuntime> | ImageApiRuntime;
+interface ImageApiAuditRecord {
+    readonly requestId: string;
+    readonly operationId: 'images.generate' | 'images.edit';
+    readonly providerId?: string;
+    readonly model?: string;
+    readonly options?: Pick<ImageRequestOptions, 'n' | 'quality' | 'background' | 'outputFormat' | 'stream' | 'partialImages'>;
+    readonly inputCount?: number;
+    readonly inputBytes?: number;
+    readonly referenceOutcomes?: {
+        readonly hits: number;
+        readonly notFound: number;
+        readonly expired: number;
+        readonly failed: number;
+    };
+    readonly cleanupOutcome?: 'completed' | 'failed';
+    readonly terminal: 'completed' | 'failed' | 'cancelled';
+    readonly errorCode?: string;
+}
+interface ImageApiContributionsDeps {
+    readonly orchestrator: ImageOrchestrator;
+    readonly resolveRuntime: ImageApiRuntimeResolver;
+    readonly createRequestId?: () => string;
+    readonly now?: () => number;
+    readonly createResourceScope?: (limits: ImageApiLimits, signal: AbortSignal, tenantId: string) => Promise<ImageRequestResourceScope>;
+    readonly audit?: (record: ImageApiAuditRecord) => void | Promise<void>;
+}
+interface ImageOpenAIOperationContribution {
+    readonly operationId: 'images.generate' | 'images.edit';
+    readonly handler: OpenAIOperationHandler;
+}
+interface ImageApiContributions {
+    readonly generate: ImageOpenAIOperationContribution & {
+        readonly operationId: 'images.generate';
+    };
+    readonly edit: ImageOpenAIOperationContribution & {
+        readonly operationId: 'images.edit';
+    };
+    readonly all: readonly ImageOpenAIOperationContribution[];
+}
+
+export { type CreateImageRequestResourceScopeOptions as C, DEFAULT_IMAGE_API_LIMITS as D, IMAGE_REQUEST_DIRECTORY_MARKER_CONTENT as I, type RemoteImageAssetResolver as R, IMAGE_REQUEST_DIRECTORY_MARKER_NAME as a, type ImageApiAuditRecord as b, type ImageApiContributions as c, type ImageApiContributionsDeps as d, type ImageApiLimits as e, type ImageApiRuntime as f, type ImageApiRuntimeResolver as g, type ImageOpenAIOperationContribution as h, type ImageRemoteMaterializer as i, type ImageRequestResourceOwnership as j, ImageRequestResourceScope as k, type ImageTemporaryResourceBudget as l, type ImageTemporaryResourceBudgetLease as m, assertFiniteImageApiLimits as n, createImageRequestResourceScope as o };