@selvajs/compute 4.0.0-beta.3 → 4.0.0-beta.5

package/dist/handle-files-DMK9bCOW.d.ts

@@ -1,231 +0,0 @@
-declare const ErrorCodes: {
-    readonly NETWORK_ERROR: "NETWORK_ERROR";
-    readonly AUTH_ERROR: "AUTH_ERROR";
-    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
-    readonly COMPUTATION_ERROR: "COMPUTATION_ERROR";
-    readonly TIMEOUT_ERROR: "TIMEOUT_ERROR";
-    readonly CORS_ERROR: "CORS_ERROR";
-    /** HTTP 404 — the endpoint path does not exist on the server (usually a typo'd route or wrong server). Never retried. */
-    readonly NOT_FOUND: "NOT_FOUND";
-    /** HTTP 429 — the server is rate-limiting requests. Retried by default (honors `Retry-After`); see `RetryPolicy.retryOn429`. */
-    readonly RATE_LIMIT: "RATE_LIMIT";
-    /**
-     * The server answered 2xx but the body is deterministically not JSON (the
-     * response declared a non-JSON `Content-Type`, e.g. an HTML captive-portal or
-     * proxy login page, or a misconfigured endpoint). Never retried — refetching
-     * returns the same page.
-     */
-    readonly INVALID_RESPONSE: "INVALID_RESPONSE";
-    readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
-    readonly INVALID_STATE: "INVALID_STATE";
-    readonly INVALID_INPUT: "INVALID_INPUT";
-    readonly INVALID_CONFIG: "INVALID_CONFIG";
-    readonly BROWSER_ONLY: "BROWSER_ONLY";
-    readonly ENVIRONMENT_ERROR: "ENVIRONMENT_ERROR";
-    readonly ENCODING_ERROR: "ENCODING_ERROR";
-    /** An input's `default` had a shape the normalizer didn't recognize (no innerTree key). */
-    readonly MALFORMED_DEFAULT: "MALFORMED_DEFAULT";
-    /** Scheduler latest-wins: this call was replaced by a newer one. */
-    readonly SUPERSEDED: "SUPERSEDED";
-    /** Scheduler / caller-supplied AbortSignal: this call was aborted. */
-    readonly ABORTED: "ABORTED";
-    /**
-     * Scheduler backpressure: the queue was already at `maxQueueDepth` when this
-     * call arrived, so it was rejected immediately rather than queued. Retryable — the
-     * caller (or an HTTP layer, as 503 + Retry-After) should back off and retry.
-     * The error `context` carries `{ queueDepth, maxQueueDepth }`.
-     */
-    readonly QUEUE_FULL: "QUEUE_FULL";
-    /**
-     * Scheduler backpressure: this call sat queued longer than `queueWaitMs`
-     * without starting, so it was rejected before wasting compute on a stale request.
-     * Retryable. The error `context` carries `{ waitedMs, queueWaitMs }`.
-     */
-    readonly QUEUE_TIMEOUT: "QUEUE_TIMEOUT";
-    /**
-     * A solve referenced a definition by `pointer` (server-side cache key), but the
-     * server no longer holds that definition (evicted / GC'd / a different child in
-     * the pool / server restarted). The caller should retry with the full
-     * definition. Surfaced when the server tags its error body with
-     * `code: "definition_not_cached"`, so it survives production message-scrubbing.
-     */
-    readonly DEFINITION_NOT_CACHED: "DEFINITION_NOT_CACHED";
-};
-type ErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes];
-/**
- * Simplified error for Rhino Compute operations
- *
- * @public Use this for error handling with error codes and context.
- */
-declare class ComputeError extends Error {
-    readonly code: ErrorCode;
-    readonly statusCode?: number;
-    readonly context?: Record<string, unknown>;
-    readonly originalError?: Error;
-    constructor(message: string, code?: ErrorCode, options?: {
-        statusCode?: number;
-        context?: Record<string, unknown>;
-        originalError?: Error;
-    });
-    /**
-     * Create an error for missing/empty values
-     */
-    static missingValues(inputName: string, expectedType?: string, context?: Record<string, unknown>): ComputeError;
-    /**
-     * Create an error for unknown parameter type
-     */
-    static unknownParamType(paramType: string, paramName?: string, context?: Record<string, unknown>): ComputeError;
-}
-
-/**
- * Backend wire code (the JSON error body's `code` field) → one of our
- * {@link ErrorCodes}. An unlisted code falls back to the status-based mapping.
- */
-type ServerErrorCodeMap = Record<string, ErrorCode>;
-interface RetryPolicy {
-    /** Maximum number of retry attempts after the initial request (default: 0). */
-    attempts?: number;
-    /** Base delay in milliseconds for exponential backoff (default: 500). */
-    baseDelayMs?: number;
-    /** Upper bound for backoff delay (default: 30_000). */
-    maxDelayMs?: number;
-    /** Whether to retry on 429 responses (default: true — honors Retry-After). */
-    retryOn429?: boolean;
-}
-interface ComputeConfig {
-    serverUrl: string;
-    /** Optional API key for authenticating with the server. Sent as {@link apiKeyHeader}. */
-    apiKey?: string;
-    /**
-     * Header name carrying `apiKey`. Defaults to `'RhinoComputeKey'` — the name
-     * rhino.compute expects. A different backend sets its own.
-     */
-    apiKeyHeader?: string;
-    /** Optional Bearer token for authentication (e.g., when behind a proxy or API gateway) */
-    authToken?: string;
-    headers?: Record<string, string>;
-    /** Enable debug logging to the console */
-    debug?: boolean;
-    /** Suppress browser security warnings in the console */
-    suppressBrowserWarning?: boolean;
-    timeoutMs?: number;
-    /**
-     * Retry policy for transient errors. Default: no retries.
-     */
-    retry?: RetryPolicy;
-    /**
-     * Optional caller-supplied AbortSignal. Composes with the internal timeout —
-     * whichever fires first wins. Lets callers cancel in-flight requests
-     * (e.g. on component unmount or when superseding a stale solve).
-     */
-    signal?: AbortSignal;
-    /**
-     * Machine-readable error codes this backend tags onto its error bodies, mapped
-     * to our {@link ErrorCodes}. A code here outranks the status-based mapping.
-     * Core knows no backend's codes — the client supplies its own table.
-     */
-    serverErrorCodes?: ServerErrorCodeMap;
-    onServerTiming?: (timing: ServerTiming, requestId: string) => void;
-}
-interface ServerTiming {
-    decode?: number;
-    solve?: number;
-    encode?: number;
-    raw: string;
-}
-
-/**
- * By-reference definition form for solves.
- *
- * Lets a caller that already knows a definition's identity (e.g. a stored
- * version's UUID) schedule solves without materializing the multi-MB bytes:
- * cache keys and the server-pointer map are derived from `key` alone, and
- * `load()` is only called when an upload is genuinely unavoidable (first solve
- * of a definition, or a server-side pointer miss).
- */
-/**
- * A definition identified by a stable key, with bytes materialized on demand.
- *
- * **Immutability contract — read this before constructing one.** `key` must
- * identify IMMUTABLE bytes: every `load()` for a given `key` must return the
- * same content, forever. All caching (the scheduler's result cache, the
- * server-pointer map, and any durable cache built on these keys) trusts the
- * key as the definition's identity WITHOUT looking at the bytes. If two
- * different byte contents ever share a key, cached solves from one are served
- * for the other — silent cache poisoning with no diagnostic. Use an identity
- * that can never be reused for different content (e.g. a version UUID), never
- * a mutable name or path.
- */
-interface DefinitionRef {
-    /**
-     * Identity of immutable bytes (e.g. a version UUID). Two different byte
-     * contents must never share a key — cache poisoning otherwise.
-     */
-    key: string;
-    /**
-     * Materialize the bytes. Called ONLY when an upload is unavoidable — inside
-     * the solve execution, so it counts toward the solve's abort semantics.
-     */
-    load: () => Promise<Uint8Array>;
-}
-/**
- * Every definition form accepted by the solve entry points:
- * - a URL, base64 string, or plain string (content-hashed for caching)
- * - raw `.gh` bytes (content-hashed)
- * - a {@link DefinitionRef} (identity-keyed; bytes loaded lazily)
- */
-type SolveDefinition = string | Uint8Array | DefinitionRef;
-/** Narrow a {@link SolveDefinition} to the by-reference form. */
-declare function isDefinitionRef(definition: SolveDefinition): definition is DefinitionRef;
-
-/**
- * Raw file data from Grasshopper/Rhino Compute response, with metadata for processing.
- * Files are typically combined with additional files and packaged into a ZIP archive.
- * @see {@link extractFilesFromComputeResponse} for extraction from compute responses
- */
-type FileData = {
-    /** Base filename without extension (e.g., "model") */
-    fileName: string;
-    /** File content, base64-encoded or plain string depending on isBase64Encoded flag */
-    data: string;
-    /** File extension including the dot (e.g., ".3dm", ".json"). Appended to fileName to create the full filename */
-    fileType: string;
-    /** Whether data is base64-encoded. If true, must be decoded to binary before use */
-    isBase64Encoded: boolean;
-    /** Directory path for archive organization (e.g., "subfolder/nested"). Empty string for root-level files */
-    subFolder: string;
-    /** Arbitrary metadata attached in Grasshopper. Not interpreted by compute; passed through for downstream consumers. May be absent on older payloads */
-    metadata?: Record<string, string>;
-};
-/**
- * Normalized file ready for consumption or archival.
- * Unified intermediate format from FileData or FileBaseInfo, ready to be packaged into archives or returned to callers.
- */
-type ProcessedFile = {
-    /** Full filename including extension (e.g., "model.3dm") */
-    fileName: string;
-    /** File content as binary data (Uint8Array for decoded base64 or fetched binary) or text */
-    content: Uint8Array | string;
-    /** File path for archive organization (e.g., "subfolder/model.3dm") */
-    path: string;
-};
-/**
- * Reference to an external file to be fetched and included in file operations.
- * Specifies additional files (beyond compute response files) to fetch and process as ProcessedFile.
- * @see {@link fetchRemoteFiles} for how FileBaseInfo is fetched and converted
- */
-type FileBaseInfo = {
-    /** Destination filename for the file in the archive or result set (e.g., "additional-data.json") */
-    fileName: string;
-    /** URL to fetch the file from. Must be accessible from the runtime environment */
-    filePath: string;
-    /** Optional directory path for archive organization (e.g., "extras/docs"). When omitted, file lands at archive root */
-    subFolder?: string;
-};
-
-/** Extracts and processes files from compute response data without downloading them. */
-declare const extractFilesFromComputeResponse: (downloadableFiles: FileData[], additionalFiles?: FileBaseInfo[] | FileBaseInfo | null) => Promise<ProcessedFile[]>;
-/** Downloads files from a compute response as a ZIP archive. */
-declare const downloadFileData: (downloadableFiles: FileData[], fileFoldername: string, additionalFiles?: FileBaseInfo[] | FileBaseInfo | null) => Promise<void>;
-
-export { type ComputeConfig as C, type DefinitionRef as D, type ErrorCode as E, type FileBaseInfo as F, type ProcessedFile as P, type RetryPolicy as R, type ServerErrorCodeMap as S, ComputeError as a, ErrorCodes as b, type FileData as c, type ServerTiming as d, type SolveDefinition as e, downloadFileData as f, extractFilesFromComputeResponse as g, isDefinitionRef as i };

package/dist/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/home/runner/work/selva/selva/packages/compute/dist/index.cjs"],"names":[],"mappings":"AAAA","file":"/home/runner/work/selva/selva/packages/compute/dist/index.cjs"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}