bleam 0.0.6 → 0.0.8

package/dist/ai.d.ts

@@ -1,6 +1,450 @@
-import { h as StandardSchema, p as SchemaResult, s as InferOutput } from "./schema-ipsECAso.js";
+import { s as FileRef } from "./files-VrkQlKIT.js";
+import { h as StandardSchema, p as SchemaResult, s as InferOutput } from "./schema-DOOjfXvs.js";
 
-//#region src/ai.d.ts
+//#region src/ai/errors.d.ts
+type AIErrorCode = 'unsupported_runtime' | 'unsupported_os' | 'model_unavailable' | 'generation_failed' | 'generation_canceled' | 'concurrent_request' | 'guardrail_violation' | 'unsupported_language_or_locale' | 'rate_limited' | 'tool_failed' | 'image_generation_failed' | 'invalid_message' | 'invalid_schema' | 'invalid_model' | 'validation_failed' | 'context_window_exceeded';
+type ImageGenerationStage = 'download' | 'tokenize' | 'encode' | 'denoise' | 'decode' | 'write';
+type ImageGenerationErrorDetails = {
+  stage: ImageGenerationStage;
+};
+declare class AIError extends Error {
+  readonly code: AIErrorCode;
+  readonly cause?: unknown | undefined;
+  constructor(code: AIErrorCode, message: string, cause?: unknown | undefined);
+}
+declare class ImageGenerationError extends AIError {
+  readonly stage: ImageGenerationStage;
+  constructor(stage: ImageGenerationStage, message: string, cause?: unknown);
+}
+//#endregion
+//#region src/ai/image-models.d.ts
+type FluxImageModelId = 'flux2-klein-4b-8bit-abliterated';
+type ImageModelCapability = 'text-to-image' | 'image-to-image' | 'inpainting' | 'outpainting' | 'references' | 'lora';
+type ImageModelMetadata = {
+  displayName: string;
+  family: 'flux2-klein';
+  precision: '8-bit';
+  estimatedMemoryGB: number;
+  quality: 'high';
+  speed: 'fast';
+  capabilities: ImageModelCapability[];
+};
+type FluxImageModelManifest = {
+  formatVersion: 1;
+  model: FluxImageModelId;
+  directory: string;
+  metadata: ImageModelMetadata;
+  components: {
+    textEncoder: FluxModelComponentManifest;
+    transformer: FluxModelComponentManifest;
+    vae: FluxModelComponentManifest;
+  };
+};
+type FluxModelComponentManifest = {
+  repo: string;
+  revision: string;
+  path: string;
+  files: string[];
+};
+type FluxTokenizedPrompt = {
+  inputIds: number[];
+  attentionMask: number[];
+};
+type FluxImageModelPaths = {
+  modelRoot: string;
+  textEncoderPath: string;
+  transformerPath: string;
+  vaePath: string;
+};
+type PrepareImageModelProgress = {
+  model: FluxImageModelId;
+  file: string;
+  index: number;
+  total: number;
+  bytesWritten: number;
+  totalBytes?: number;
+  fraction?: number;
+  modelBytesWritten: number;
+  totalModelBytes: number;
+  modelFraction: number;
+};
+type PrepareImageLoRAProgress = {
+  lora: string;
+  file: string;
+  bytesWritten: number;
+  totalBytes?: number;
+  fraction?: number;
+};
+type PrepareImageModelOptions = {
+  model?: FluxImageModelId;
+  accessToken?: string;
+  concurrency?: number;
+  onProgress?: (progress: PrepareImageModelProgress) => void;
+};
+type ImageLoRASource = {
+  type: 'local';
+  path: string;
+} | {
+  type: 'url';
+  url: string;
+  filename?: string;
+  bytes?: number;
+} | {
+  type: 'huggingface';
+  repo: string;
+  path?: string;
+  revision?: string;
+  bytes?: number;
+};
+type ImageLoRAPrecision = 'float16' | 'bfloat16' | 'float32';
+type ImageLoRAMetadata = {
+  baseModel?: FluxImageModelId;
+  precision?: ImageLoRAPrecision;
+  recommendedScale?: number;
+  sigmaSchedule?: number[];
+};
+type ImageLoRADefinition = {
+  id: string;
+  description?: string;
+  source: ImageLoRASource;
+  metadata?: ImageLoRAMetadata;
+  scale?: number;
+};
+type PrepareImageLoRAOptions = {
+  accessToken?: string;
+  signal?: AbortSignal;
+  onProgress?: (progress: PrepareImageLoRAProgress) => void;
+};
+type PreparedImageLoRA = {
+  id: string;
+  description?: string;
+  path: string;
+  uri: string;
+  scale: number;
+  source: ImageLoRASource;
+  metadata?: ImageLoRAMetadata;
+};
+type ImageLoRAState = PreparedImageLoRA & {
+  installed: boolean;
+  verified: boolean;
+  size?: number;
+};
+type PreparedImageModel = FluxImageModelPaths & {
+  model: FluxImageModelId;
+  tokenizer: FluxTokenizer;
+};
+type FluxTokenizer = (input: {
+  prompt: string;
+  maxLength: number;
+}) => Promise<FluxTokenizedPrompt> | FluxTokenizedPrompt;
+type ImageMaskMode = 'paint' | 'preserve';
+type ImageResizeMode = 'stretch' | 'fit' | 'crop';
+type ImageAspectRatio = '1:1' | '16:9' | '9:16' | '4:3' | '3:2' | '2:3' | '21:9';
+type ImageSize = {
+  width: number;
+  height: number;
+};
+type ImageOutpaintSourceRect = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+type ImageOutpaintOptions = {
+  width: number;
+  height: number;
+  sourceRect: ImageOutpaintSourceRect;
+  autoCrop?: boolean;
+};
+type GenerateImageOptions = {
+  prompt: string;
+  image?: string;
+  mask?: string;
+  maskMode?: ImageMaskMode;
+  outpaint?: ImageOutpaintOptions;
+  references?: string[];
+  referenceInfluences?: number[];
+  aspectRatio?: ImageAspectRatio;
+  resizeMode?: ImageResizeMode;
+  maxInputLongSide?: number | false;
+  loras?: ImageLoRADefinition[];
+  mode?: string;
+  width?: number;
+  height?: number;
+  steps?: number;
+  guidance?: number;
+  strength?: number;
+  seed?: number;
+  model?: FluxImageModelId;
+  modelRoot?: string;
+  tokenizer?: FluxTokenizer;
+  accessToken?: string;
+  concurrency?: number;
+  signal?: AbortSignal;
+  onModelProgress?: (progress: PrepareImageModelProgress) => void;
+  onProgress?: (progress: ImagegenProgress) => void;
+};
+type ImagegenProgress = {
+  currentStep: number;
+  totalSteps: number;
+  fraction: number;
+};
+type GenerateImageResult = {
+  uri: string;
+  width: number;
+  height: number;
+  model: FluxImageModelId;
+  metadata: GenerateImageMetadata;
+};
+type GenerateImagesOptions = GenerateImageOptions & {
+  count: number;
+};
+type ImageGenerationJobStatus = 'queued' | 'running' | 'completed' | 'failed' | 'canceled';
+type ImageGenerationJobSnapshot = {
+  id: string;
+  status: ImageGenerationJobStatus;
+  createdAt: string;
+  startedAt?: string;
+  completedAt?: string;
+  progress?: ImagegenProgress;
+  result?: GenerateImageResult;
+  error?: unknown;
+};
+type ImageGenerationJob = {
+  id: string;
+  promise: Promise<GenerateImageResult>;
+  cancel(): boolean;
+  getSnapshot(): ImageGenerationJobSnapshot;
+  subscribe(listener: (snapshot: ImageGenerationJobSnapshot) => void): () => void;
+};
+type GenerateImageMetadata = {
+  model: FluxImageModelId;
+  width: number;
+  height: number;
+  steps: number;
+  guidance: number;
+  strength?: number;
+  seed: number;
+  elapsedMs?: number;
+  appliedLoRAs?: Array<{
+    id?: string;
+    path: string;
+    scale: number;
+  }>;
+  sigmaSchedule?: number[];
+};
+type ImageModelState = {
+  model: FluxImageModelId;
+  modelRoot: string;
+  paths: FluxImageModelPaths;
+  installed: boolean;
+  verified: boolean;
+  bytesPresent: number;
+  totalBytes: number;
+  missingFiles: string[];
+  invalidFiles: string[];
+};
+type ImageMemoryTelemetry = {
+  activeMB: number;
+  cacheMB: number;
+};
+type UpscaleImageOptions = {
+  image: string;
+  scale?: number;
+  signal?: AbortSignal;
+};
+type UpscaleImageResult = {
+  uri: string;
+  width: number;
+  height: number;
+  scale: number;
+};
+declare const flux2Klein4B8BitAbliterated: FluxImageModelManifest;
+declare const imageModelManifests: readonly [FluxImageModelManifest];
+declare function imageModelManifest(model: FluxImageModelId): FluxImageModelManifest | undefined;
+declare function fluxImageModelPaths(modelRoot: string, manifest?: FluxImageModelManifest): FluxImageModelPaths;
+//#endregion
+//#region src/ai/image.d.ts
+declare const defaultImageLongSide = 1152;
+declare function normalizeImageSize(size: ImageSize, maxLongSide?: number | false): ImageSize;
+declare function imageSizeForPreset(aspectRatio: ImageAspectRatio, maxLongSide?: number): ImageSize;
+declare function prepareImageModel(options?: PrepareImageModelOptions): Promise<PreparedImageModel>;
+declare function verifyImageModel(options?: {
+  model?: FluxImageModelId;
+  modelRoot?: string;
+}): Promise<ImageModelState>;
+declare function listImageModels(options?: {
+  modelRoot?: string;
+}): Promise<ImageModelState[]>;
+declare function deleteImageModel(options?: {
+  model?: FluxImageModelId;
+  modelRoot?: string;
+}): Promise<void>;
+declare function imageMemoryTelemetry(): Promise<ImageMemoryTelemetry>;
+declare function unloadImageModel(): Promise<boolean>;
+declare function upscaleImage(options: UpscaleImageOptions): Promise<UpscaleImageResult>;
+declare function prepareImageLoRA(lora: ImageLoRADefinition, options?: PrepareImageLoRAOptions): Promise<PreparedImageLoRA>;
+declare function verifyImageLoRA(lora: ImageLoRADefinition): Promise<ImageLoRAState>;
+declare function listImageLoRAs(loras: ImageLoRADefinition[]): Promise<ImageLoRAState[]>;
+declare function deleteImageLoRA(lora: string | ImageLoRADefinition): Promise<void>;
+declare function generateImage(options: GenerateImageOptions): Promise<GenerateImageResult>;
+declare function generateImages(options: GenerateImagesOptions): Promise<GenerateImageResult[]>;
+declare function scheduleImageGeneration(options: GenerateImageOptions): ImageGenerationJob;
+declare function getImageGenerationJob(id: string): ImageGenerationJob | undefined;
+declare function listImageGenerationJobs(): {
+  id: string;
+  status: ImageGenerationJobStatus;
+  createdAt: string;
+  startedAt?: string;
+  completedAt?: string;
+  progress?: ImagegenProgress;
+  result?: GenerateImageResult;
+  error?: unknown;
+}[];
+//#endregion
+//#region src/ai/image-composer.d.ts
+type ImageComposerMode = 'text' | 'subject' | 'edit' | 'outpaint';
+type ImageComposerSize = {
+  width: number;
+  height: number;
+};
+type ImageComposerImage = FileRef & {
+  size: ImageComposerSize;
+};
+type ImageComposerRect = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+type ImageGenerationRequestInput = {
+  mode: 'text';
+  prompt: string;
+  refs?: ImageComposerImage[];
+} | {
+  mode: 'subject';
+  prompt: string;
+  subject: ImageComposerImage | null;
+  refs?: ImageComposerImage[];
+} | {
+  mode: 'edit';
+  prompt: string;
+  source: ImageComposerImage | null;
+  refs?: ImageComposerImage[];
+} | {
+  mode: 'outpaint';
+  prompt: string;
+  source: ImageComposerImage | null;
+  rect: ImageComposerRect | null;
+};
+type ImageComposerOptions = {
+  initialMode?: ImageComposerMode;
+  maxRefs?: number;
+  inputRoot?: string;
+};
+type TextComposerState = {
+  refs: ImageComposerImage[];
+  isPicking: boolean;
+  error: Error | null;
+};
+type SubjectComposerState = TextComposerState & {
+  subject: ImageComposerImage | null;
+};
+type EditComposerState = TextComposerState & {
+  source: ImageComposerImage | null;
+};
+type OutpaintComposerState = {
+  source: ImageComposerImage | null;
+  rect: ImageComposerRect | null;
+  isPicking: boolean;
+  error: Error | null;
+};
+type TextImageComposer = TextComposerState & {
+  mode: 'text';
+  pickRefs(): Promise<void>;
+  removeRef(index: number): void;
+  request(prompt: string): ImageGenerationRequestInput;
+  clear(): void;
+};
+type SubjectImageComposer = SubjectComposerState & {
+  mode: 'subject';
+  pickSubject(): Promise<void>;
+  removeSubject(): void;
+  pickRefs(): Promise<void>;
+  removeRef(index: number): void;
+  request(prompt: string): ImageGenerationRequestInput;
+  clear(): void;
+};
+type EditImageComposer = EditComposerState & {
+  mode: 'edit';
+  pickSource(): Promise<void>;
+  removeSource(): void;
+  pickRefs(): Promise<void>;
+  removeRef(index: number): void;
+  request(prompt: string): ImageGenerationRequestInput;
+  clear(): void;
+};
+type OutpaintImageComposer = OutpaintComposerState & {
+  mode: 'outpaint';
+  pickSource(): Promise<void>;
+  removeSource(): void;
+  setRect(rect: ImageComposerRect | null): void;
+  request(prompt: string): ImageGenerationRequestInput;
+  clear(): void;
+};
+type ImageComposer = TextImageComposer | SubjectImageComposer | EditImageComposer | OutpaintImageComposer;
+type ImageComposerController = {
+  mode: ImageComposerMode;
+  setMode(mode: ImageComposerMode): void;
+  active: ImageComposer;
+  text: TextImageComposer;
+  subject: SubjectImageComposer;
+  edit: EditImageComposer;
+  outpaint: OutpaintImageComposer;
+  isPicking: boolean;
+  error: Error | null;
+  request(prompt: string): ImageGenerationRequestInput;
+  clear(): void;
+};
+declare function roundImageDimension(value: number): number;
+declare function imageSizeForAspectRatio(size: ImageComposerSize, maxSide?: number): ImageComposerSize;
+declare function roundedImageSize(size: ImageComposerSize): ImageComposerSize;
+declare function clampOutpaintRect(rect: ImageComposerRect): ImageComposerRect;
+declare function rectForSourceScale(sourceSize: ImageComposerSize, scale: number, center?: {
+  x: number;
+  y: number;
+}): ImageComposerRect;
+declare function initialOutpaintRect(sourceSize: ImageComposerSize): ImageComposerRect;
+declare function buildImageGenerationRequest(input: ImageGenerationRequestInput, options?: Pick<GenerateImageOptions, 'signal' | 'onModelProgress' | 'onProgress' | 'model' | 'modelRoot' | 'tokenizer' | 'accessToken' | 'concurrency' | 'loras'>): GenerateImageOptions;
+declare function useImageComposer(options?: ImageComposerOptions): ImageComposerController;
+declare function useImageComposer(mode: 'text', options?: ImageComposerOptions): TextImageComposer;
+declare function useImageComposer(mode: 'subject', options?: ImageComposerOptions): SubjectImageComposer;
+declare function useImageComposer(mode: 'edit', options?: ImageComposerOptions): EditImageComposer;
+declare function useImageComposer(mode: 'outpaint', options?: ImageComposerOptions): OutpaintImageComposer;
+declare function useImageGeneration(): {
+  run: (input: ImageGenerationRequestInput, options?: Pick<GenerateImageOptions, "loras">) => Promise<GenerateImageResult | null>;
+  cancel: () => void;
+  clear: () => void;
+  imageUri: string | null;
+  result: GenerateImageResult | null;
+  progress: number;
+  status: string;
+  isGenerating: boolean;
+  error: Error | null;
+};
+declare function useImageModel(): {
+  installed: boolean;
+  verified: boolean;
+  missingFiles: string[];
+  bytesPresent: number;
+  totalBytes: number;
+  check: () => Promise<ImageModelState | null>;
+  checking: boolean;
+  state: ImageModelState | null;
+  error: Error | null;
+};
+//#endregion
+//#region src/ai/shape.d.ts
 type PrimitiveToken = 'string' | 'number' | 'boolean';
 type ShapeArray = readonly [ShapeDefinition];
 type ShapeObject = {
@@ -19,34 +463,73 @@ type BridgeSchema = {
   properties: Record<string, BridgeSchema>;
   required: string[];
 };
-type GenerateOptions<Output$1 extends StructuredSchema | undefined = undefined> = {
-  system?: string;
-  prompt?: string;
-  input?: string | StructuredInput;
-  output?: Output$1;
-  temperature?: number;
-  maxTokens?: number;
-};
 type StructuredInput = {
-  shape: StructuredSchema;
   value: unknown;
+  shape: BleamAIShape<unknown, unknown> | StandardSchema;
 };
 type StructuredSchema = BleamAIShape<unknown, unknown> | StandardSchema;
-type AIErrorCode = 'unsupported_runtime' | 'unsupported_os' | 'model_unavailable' | 'generation_failed' | 'invalid_message' | 'invalid_schema' | 'validation_failed' | 'context_window_exceeded';
-declare class AIError extends Error {
-  readonly code: AIErrorCode;
-  readonly cause?: unknown | undefined;
-  constructor(code: AIErrorCode, message: string, cause?: unknown | undefined);
-}
+type BridgeStructuredSchema = StandardSchema & {
+  toJSONSchema(): BridgeSchema;
+};
 interface BleamAIShape<Input, Output$1> extends StandardSchema<Input, Output$1> {
   parse(value: unknown): Output$1;
   safeParse(value: unknown): SchemaResult<Output$1>;
   toJSONSchema(): BridgeSchema;
 }
 type InferShapeOutput<Value extends BleamAIShape<unknown, unknown>> = Value extends BleamAIShape<unknown, infer Output> ? Output : never;
-type GenerateResult<Output$1 extends StructuredSchema | undefined> = Output$1 extends BleamAIShape<unknown, infer ShapeOutput> ? ShapeOutput : Output$1 extends StandardSchema ? InferOutput<Output$1> : string;
 declare function shape<Definition extends ShapeObject>(definition: Definition): BleamAIShape<InferShape<Definition>, InferShape<Definition>>;
+type GenerateResult<Output$1 extends StructuredSchema | undefined> = Output$1 extends BleamAIShape<unknown, infer ShapeOutput> ? ShapeOutput : Output$1 extends StandardSchema ? InferOutput<Output$1> : string;
+//#endregion
+//#region src/ai/native.d.ts
+type ModelAvailabilityResult = {
+  available: boolean;
+  reason?: 'device_not_eligible' | 'apple_intelligence_not_enabled' | 'model_not_ready' | 'unknown';
+};
+//#endregion
+//#region src/ai/text.d.ts
+type AITool<Input extends BridgeStructuredSchema = BridgeStructuredSchema> = {
+  name: string;
+  description: string;
+  input: Input;
+  execute(input: InferToolInput<Input>): unknown | Promise<unknown>;
+};
+type InferToolInput<Input extends BridgeStructuredSchema> = Input extends {
+  readonly '~standard': {
+    readonly types?: {
+      readonly output: infer Output;
+    };
+  };
+} ? Output : unknown;
+type GenerateOptions<Output$1 extends BridgeStructuredSchema | undefined = undefined> = {
+  system?: string;
+  prompt?: string;
+  input?: string | StructuredInput;
+  output?: Output$1;
+  temperature?: number;
+  maxTokens?: number;
+  tools?: readonly AITool[];
+  signal?: AbortSignal;
+};
+type StreamOptions = Omit<GenerateOptions<undefined>, 'output'>;
+type ModelAvailability = ModelAvailabilityResult;
 declare function isAvailable(): Promise<boolean>;
-declare function generate<Output$1 extends StructuredSchema | undefined = undefined>(options: GenerateOptions<Output$1>): Promise<GenerateResult<Output$1>>;
+declare function availability(): Promise<ModelAvailability>;
+declare function generate<Output$1 extends BridgeStructuredSchema | undefined = undefined>(options: GenerateOptions<Output$1>): Promise<GenerateResult<Output$1>>;
+declare function stream(options: StreamOptions): AsyncGenerator<string>;
+//#endregion
+//#region src/ai/text-hook.d.ts
+type TextGenerationState = {
+  text: string;
+  isGenerating: boolean;
+  error: Error | null;
+};
+declare function useTextGeneration(): {
+  run: (options: StreamOptions) => Promise<string | null>;
+  cancel: () => void;
+  clear: () => void;
+  text: string;
+  isGenerating: boolean;
+  error: Error | null;
+};
 //#endregion
-export { AIError, AIErrorCode, BleamAIShape, InferShapeOutput, generate, isAvailable, shape };
+export { AIError, AIErrorCode, AITool, BleamAIShape, EditImageComposer, FluxImageModelId, FluxImageModelManifest, FluxImageModelPaths, FluxModelComponentManifest, FluxTokenizedPrompt, FluxTokenizer, GenerateImageMetadata, GenerateImageOptions, GenerateImageResult, GenerateImagesOptions, GenerateOptions, ImageAspectRatio, ImageComposer, ImageComposerController, ImageComposerImage, ImageComposerMode, ImageComposerRect, ImageComposerSize, ImageGenerationError, ImageGenerationErrorDetails, ImageGenerationJob, ImageGenerationJobSnapshot, ImageGenerationJobStatus, ImageGenerationRequestInput, ImageGenerationStage, ImageLoRADefinition, ImageLoRAMetadata, ImageLoRAPrecision, ImageLoRASource, ImageLoRAState, ImageMaskMode, ImageMemoryTelemetry, ImageModelCapability, ImageModelMetadata, ImageModelState, ImageOutpaintOptions, ImageOutpaintSourceRect, ImageResizeMode, ImageSize, ImagegenProgress, InferShapeOutput, ModelAvailability, OutpaintImageComposer, PrepareImageLoRAOptions, PrepareImageLoRAProgress, PrepareImageModelOptions, PrepareImageModelProgress, PreparedImageLoRA, PreparedImageModel, StreamOptions, SubjectImageComposer, TextGenerationState, TextImageComposer, UpscaleImageOptions, UpscaleImageResult, availability, buildImageGenerationRequest, clampOutpaintRect, defaultImageLongSide, deleteImageLoRA, deleteImageModel, flux2Klein4B8BitAbliterated, fluxImageModelPaths, generate, generateImage, generateImages, getImageGenerationJob, imageMemoryTelemetry, imageModelManifest, imageModelManifests, imageSizeForAspectRatio, imageSizeForPreset, initialOutpaintRect, isAvailable, listImageGenerationJobs, listImageLoRAs, listImageModels, normalizeImageSize, prepareImageLoRA, prepareImageModel, rectForSourceScale, roundImageDimension, roundedImageSize, scheduleImageGeneration, shape, stream, unloadImageModel, upscaleImage, useImageComposer, useImageGeneration, useImageModel, useTextGeneration, verifyImageLoRA, verifyImageModel };