@uploadista/core 0.0.2

package/dist/chunk-CUT6urMc.cjs

@@ -0,0 +1 @@
+var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},s=(n,r,a)=>(a=n==null?{}:e(i(n)),o(r||!n||!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n));Object.defineProperty(exports,`__toESM`,{enumerable:!0,get:function(){return s}});

package/dist/debounce-C2SeqcxD.js

@@ -0,0 +1,2 @@
+const e={leading:!1,trailing:!0};function t(t,n,r={}){let i={...e,...r},a;return function(...e){i.leading&&!a?(console.log(`leading`),t.apply(this,e),a=setTimeout(()=>{a=void 0},n)):(clearTimeout(a),a=setTimeout(()=>{i.trailing?(t.apply(this,e),i.leading&&setTimeout(()=>{a=void 0},n)):a=void 0},n))}}export{t as debounce};
+//# sourceMappingURL=debounce-C2SeqcxD.js.map

package/dist/debounce-C2SeqcxD.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce-C2SeqcxD.js","names":["defaultDebounceOptions: DebounceOptions","timer: ReturnType<typeof setTimeout> | undefined"],"sources":["../src/utils/debounce.ts"],"sourcesContent":["type DebounceOptions = {\n  // Whether the first call to the debounced function is run immediately.\n  leading?: boolean;\n\n  // Whether the last call to the debounced function is run after delay\n  // milliseconds have elapsed since the last call.\n  trailing?: boolean;\n};\n\nconst defaultDebounceOptions: DebounceOptions = {\n  leading: false,\n  trailing: true,\n};\n\n/**\n * Returns `fn` wrapped by a function that delays invoking `fn` for `delay`\n * milliseconds since the last call. Set `options.leading` to invoke `fn` on\n * the leading edge of the delay, and/or set `options.trailing` to invoke `fn`\n * on the trailing edge of the delay (true by default).\n *\n * Example for `debounce(fn, 30, {leading: true, trailing: true})`,\n * where `fn` is called twice, with the second call made 20 ms after the first:\n *\n * Time:     0                   20                            50 (ms)\n * Timeline: |----------------------------------------------------------------|\n *           ^                   ^                             ^\n *           |                   |                             |\n *           | First call.       | Second call 20ms after the  | End of delay.\n *           | (instant leading  | first.                      | (trailing edge\n *           |  edge call)       |                             |  call)\n *                               |-----------------------------|\n *                               |  30 ms delay for debounce.  |\n *\n *\n * Note that if both `options.leading` and `options.trailing` are true, `fn`\n * will only be invoked on the trailing edge if the debounced function is called\n * more than once during the delay.\n *\n * @param fn - Function to debounce.\n * @param delay - Milliseconds to delay calling `fn` since the last call.\n * @param debounceOptions - See `DebounceOptions` and `defaultDebounceOptions`.\n * @returns A debounced `fn`.\n */\nexport function debounce<T, A extends unknown[]>(\n  fn: (this: T, ...args: A) => void,\n  delay: number,\n  debounceOptions: DebounceOptions = {},\n): (this: T, ...args: A) => void {\n  const options = { ...defaultDebounceOptions, ...debounceOptions };\n\n  let timer: ReturnType<typeof setTimeout> | undefined;\n\n  return function (this: T, ...args: A): void {\n    if (options.leading && !timer) {\n      // Leading edge.\n      // Call fn on the leading edge, when debouncing hasn't started yet.\n      console.log(\"leading\");\n      fn.apply(this, args);\n\n      // Debounce the next call.\n      timer = setTimeout(() => {\n        timer = undefined;\n      }, delay);\n    } else {\n      // Trailing edge.\n      // Postpone calling fn until the delay has elapsed since the last call.\n      // Each call clears any previously delayed call and resets the delay, so\n      // the postponed call will always be the last one.\n      clearTimeout(timer);\n      timer = setTimeout(() => {\n        if (options.trailing) {\n          // Call fn on the trailing edge.\n          fn.apply(this, args);\n\n          if (options.leading) {\n            // Debounce next leading call since a trailing call was just made.\n            setTimeout(() => {\n              timer = undefined;\n            }, delay);\n          }\n        } else {\n          // No trailing call. Since the delay has elapsed since the last call,\n          // immediately reset the debouncing delay.\n          timer = undefined;\n        }\n      }, delay);\n    }\n  };\n}\n"],"mappings":"AASA,MAAMA,EAA0C,CAC9C,QAAS,GACT,SAAU,GACX,CA+BD,SAAgB,EACd,EACA,EACA,EAAmC,EAAE,CACN,CAC/B,IAAM,EAAU,CAAE,GAAG,EAAwB,GAAG,EAAiB,CAE7DC,EAEJ,OAAO,SAAmB,GAAG,EAAe,CACtC,EAAQ,SAAW,CAAC,GAGtB,QAAQ,IAAI,UAAU,CACtB,EAAG,MAAM,KAAM,EAAK,CAGpB,EAAQ,eAAiB,CACvB,EAAQ,IAAA,IACP,EAAM,GAMT,aAAa,EAAM,CACnB,EAAQ,eAAiB,CACnB,EAAQ,UAEV,EAAG,MAAM,KAAM,EAAK,CAEhB,EAAQ,SAEV,eAAiB,CACf,EAAQ,IAAA,IACP,EAAM,EAKX,EAAQ,IAAA,IAET,EAAM"}

package/dist/debounce-LZK7yS7Z.cjs

@@ -0,0 +1 @@
+const e={leading:!1,trailing:!0};function t(t,n,r={}){let i={...e,...r},a;return function(...e){i.leading&&!a?(console.log(`leading`),t.apply(this,e),a=setTimeout(()=>{a=void 0},n)):(clearTimeout(a),a=setTimeout(()=>{i.trailing?(t.apply(this,e),i.leading&&setTimeout(()=>{a=void 0},n)):a=void 0},n))}}Object.defineProperty(exports,`debounce`,{enumerable:!0,get:function(){return t}});

package/dist/errors/index.cjs

@@ -0,0 +1 @@
+const e=require(`../uploadista-error-BB-Wdiz9.cjs`);require(`../errors-CRm1FHHT.cjs`),exports.ERRORS=e.ERROR_CATALOG,exports.ERROR_CATALOG=e.ERROR_CATALOG,exports.UploadistaError=e.UploadistaError,exports.httpFailureEffect=e.httpFailureEffect,exports.isUploadistaError=e.isUploadistaError;

package/dist/errors/index.d.cts

@@ -0,0 +1,3 @@
+import { ERROR_CATALOG, UploadistaError, UploadistaErrorCode, httpFailureEffect, isUploadistaError } from "../uploadista-error-kKlhLRhY.cjs";
+import "../index-BtBZHVmz.cjs";
+export { ERROR_CATALOG as ERRORS, ERROR_CATALOG, UploadistaError, UploadistaErrorCode, httpFailureEffect, isUploadistaError };

package/dist/errors/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./uploadista-error.js";
+export { ERROR_CATALOG as ERRORS } from "./uploadista-error.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,OAAO,EAAE,aAAa,IAAI,MAAM,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/errors/index.js

@@ -0,0 +1,2 @@
+export * from "./uploadista-error.js";
+export { ERROR_CATALOG as ERRORS } from "./uploadista-error.js";

package/dist/errors/uploadista-error.d.ts

@@ -0,0 +1,209 @@
+import { Effect } from "effect";
+/**
+ * Union type of all possible error codes in the Uploadista system.
+ *
+ * Each error code corresponds to a specific error condition with predefined
+ * HTTP status codes and messages in the ERROR_CATALOG.
+ */
+export type UploadistaErrorCode = "MISSING_OFFSET" | "ABORTED" | "INVALID_TERMINATION" | "ERR_LOCK_TIMEOUT" | "INVALID_CONTENT_TYPE" | "FLOW_STRUCTURE_ERROR" | "FLOW_CYCLE_ERROR" | "FLOW_NODE_NOT_FOUND" | "FLOW_NODE_ERROR" | "FLOW_NOT_AUTHORIZED" | "FLOW_NOT_FOUND" | "FILE_READ_ERROR" | "FLOW_JOB_NOT_FOUND" | "FLOW_JOB_ERROR" | "DATASTORE_NOT_FOUND" | "FILE_NOT_FOUND" | "INVALID_OFFSET" | "FILE_NO_LONGER_EXISTS" | "ERR_SIZE_EXCEEDED" | "ERR_MAX_SIZE_EXCEEDED" | "INVALID_LENGTH" | "INVALID_METADATA" | "VALIDATION_ERROR" | "STORAGE_NOT_AUTHORIZED" | "UNKNOWN_ERROR" | "FILE_WRITE_ERROR" | "UPLOAD_ID_NOT_FOUND" | "FLOW_OUTPUT_VALIDATION_ERROR" | "FLOW_INPUT_VALIDATION_ERROR" | "CHECKSUM_MISMATCH" | "MIMETYPE_MISMATCH" | "UNSUPPORTED_CHECKSUM_ALGORITHM";
+/**
+ * Catalog of all predefined errors in the Uploadista system.
+ *
+ * Maps error codes to their HTTP status codes and default error messages.
+ * This centralized catalog ensures consistent error handling across all
+ * Uploadista packages and adapters.
+ *
+ * Each error entry contains:
+ * - `status`: HTTP status code (400-500 range)
+ * - `body`: Human-readable error message
+ *
+ * @example
+ * ```typescript
+ * // Access a specific error definition
+ * const fileNotFound = ERROR_CATALOG.FILE_NOT_FOUND;
+ * console.log(fileNotFound.status); // 404
+ * console.log(fileNotFound.body);   // "The file for this url was not found\n"
+ *
+ * // Use with UploadistaError
+ * const error = UploadistaError.fromCode("FILE_NOT_FOUND");
+ * ```
+ */
+export declare const ERROR_CATALOG: Readonly<Record<UploadistaErrorCode, {
+    status: number;
+    body: string;
+}>>;
+declare const UploadistaError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "UploadistaError";
+} & Readonly<A>;
+/**
+ * Standard error class for all Uploadista operations.
+ *
+ * UploadistaError provides a consistent error handling approach across the entire
+ * Uploadista ecosystem. Each error has:
+ * - A typed error code from the ERROR_CATALOG
+ * - An HTTP-compatible status code
+ * - A human-readable error message (body)
+ * - Optional additional details and cause information
+ *
+ * This class integrates with Effect-TS for functional error handling and can be
+ * easily converted to an Effect that fails.
+ *
+ * @example
+ * ```typescript
+ * // Create from error code
+ * const error = UploadistaError.fromCode("FILE_NOT_FOUND");
+ *
+ * // Create with custom details
+ * const customError = UploadistaError.fromCode("FLOW_NODE_ERROR", {
+ *   body: "Failed to process image",
+ *   cause: originalError,
+ *   details: { nodeId: "resize-1", fileId: "abc123" }
+ * });
+ *
+ * // Use with Effect
+ * const effect = customError.toEffect<void>();
+ *
+ * // In an Effect pipeline
+ * return Effect.gen(function* () {
+ *   const file = yield* getFile(id);
+ *   if (!file) {
+ *     return yield* UploadistaError.fromCode("FILE_NOT_FOUND").toEffect();
+ *   }
+ *   return file;
+ * });
+ * ```
+ */
+export declare class UploadistaError extends UploadistaError_base {
+    readonly code: string;
+    readonly status: number;
+    readonly status_code: number;
+    readonly body: string;
+    readonly details?: unknown;
+    constructor({ code, status, body, cause, details, }: {
+        code: UploadistaErrorCode | string;
+        status: number;
+        body: string;
+        cause?: unknown;
+        details?: unknown;
+    });
+    /**
+     * Creates an UploadistaError from a predefined error code.
+     *
+     * This is the primary way to create errors in the Uploadista system. Each error code
+     * has a default status and message defined in ERROR_CATALOG, but these can be overridden
+     * for specific use cases.
+     *
+     * @param code - One of the predefined error codes from UploadistaErrorCode
+     * @param overrides - Optional overrides for the default error properties
+     * @param overrides.status - Custom HTTP status code (overrides the default)
+     * @param overrides.body - Custom error message (overrides the default)
+     * @param overrides.details - Additional structured data about the error
+     * @param overrides.cause - The underlying error that caused this error (for error chaining)
+     *
+     * @returns A new UploadistaError instance
+     *
+     * @example
+     * ```typescript
+     * // Use default error
+     * const error = UploadistaError.fromCode("FILE_NOT_FOUND");
+     *
+     * // Override message
+     * const customError = UploadistaError.fromCode("FILE_NOT_FOUND", {
+     *   body: `File with ID ${fileId} was not found in storage`
+     * });
+     *
+     * // Include cause and details
+     * const detailedError = UploadistaError.fromCode("DATASTORE_NOT_FOUND", {
+     *   cause: storageException,
+     *   details: { storageId: "s3-prod", region: "us-east-1" }
+     * });
+     * ```
+     */
+    static fromCode(code: UploadistaErrorCode, overrides?: Partial<Pick<UploadistaError, "status" | "body">> & {
+        details?: unknown;
+        cause?: unknown;
+    }): UploadistaError;
+    /**
+     * Converts this error to an Effect that immediately fails.
+     *
+     * This method integrates UploadistaError with Effect-TS's error handling system,
+     * allowing errors to be used in Effect pipelines with proper type checking.
+     *
+     * @template T - The success type of the Effect (defaults to never since it always fails)
+     * @returns An Effect that fails with this UploadistaError
+     *
+     * @example
+     * ```typescript
+     * const error = UploadistaError.fromCode("FILE_NOT_FOUND");
+     *
+     * // Use in an Effect pipeline
+     * return Effect.gen(function* () {
+     *   const file = yield* kvStore.get(fileId);
+     *   if (!file) {
+     *     return yield* error.toEffect();
+     *   }
+     *   return file;
+     * });
+     * ```
+     */
+    toEffect<T = never>(): Effect.Effect<T, UploadistaError>;
+}
+/**
+ * Type guard to check if an unknown value is an UploadistaError.
+ *
+ * Useful for error handling when catching errors that might be from
+ * different sources or libraries.
+ *
+ * @param error - The value to check
+ * @returns True if the value is an UploadistaError instance
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await someOperation();
+ * } catch (error) {
+ *   if (isUploadistaError(error)) {
+ *     console.log(`Uploadista error: ${error.code} (${error.status})`);
+ *     console.log(error.body);
+ *   } else {
+ *     console.error("Unknown error:", error);
+ *   }
+ * }
+ * ```
+ */
+export declare function isUploadistaError(error: unknown): error is UploadistaError;
+/**
+ * Creates an Effect that immediately fails with an UploadistaError.
+ *
+ * This is a convenience function that combines error creation with Effect conversion.
+ * It's equivalent to calling `UploadistaError.fromCode(code, overrides).toEffect()`.
+ *
+ * @param code - One of the predefined error codes from UploadistaErrorCode
+ * @param overrides - Optional overrides for the default error properties
+ * @param overrides.status - Custom HTTP status code
+ * @param overrides.body - Custom error message
+ * @param overrides.details - Additional structured data about the error
+ * @param overrides.cause - The underlying error that caused this error
+ *
+ * @returns An Effect that immediately fails with the created UploadistaError
+ *
+ * @example
+ * ```typescript
+ * // In an Effect pipeline
+ * return Effect.gen(function* () {
+ *   const file = yield* kvStore.get(fileId);
+ *   if (!file) {
+ *     return yield* httpFailure("FILE_NOT_FOUND", {
+ *       details: { fileId }
+ *     });
+ *   }
+ *   return file;
+ * });
+ * ```
+ */
+export declare function httpFailure(code: UploadistaErrorCode, overrides?: Partial<Pick<UploadistaError, "status" | "body">> & {
+    details?: unknown;
+    cause?: unknown;
+}): Effect.Effect<never, UploadistaError>;
+export {};
+//# sourceMappingURL=uploadista-error.d.ts.map

package/dist/errors/uploadista-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadista-error.d.ts","sourceRoot":"","sources":["../../src/errors/uploadista-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEtC;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAC3B,gBAAgB,GAChB,SAAS,GACT,qBAAqB,GACrB,kBAAkB,GAClB,sBAAsB,GACtB,sBAAsB,GACtB,kBAAkB,GAClB,qBAAqB,GACrB,iBAAiB,GACjB,qBAAqB,GACrB,gBAAgB,GAChB,iBAAiB,GACjB,oBAAoB,GACpB,gBAAgB,GAChB,qBAAqB,GACrB,gBAAgB,GAChB,gBAAgB,GAChB,uBAAuB,GACvB,mBAAmB,GACnB,uBAAuB,GACvB,gBAAgB,GAChB,kBAAkB,GAClB,kBAAkB,GAClB,wBAAwB,GACxB,eAAe,GACf,kBAAkB,GAClB,qBAAqB,GACrB,8BAA8B,GAC9B,6BAA6B,GAC7B,mBAAmB,GACnB,mBAAmB,GACnB,gCAAgC,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,aAAa,EAAE,QAAQ,CAClC,MAAM,CAAC,mBAAmB,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAmHrD,CAAC;;;;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,qBAAa,eAAgB,SAAQ,oBAAmC;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;gBAEf,EACV,IAAI,EACJ,MAAM,EACN,IAAI,EACJ,KAAK,EACL,OAAO,GACR,EAAE;QACD,IAAI,EAAE,mBAAmB,GAAG,MAAM,CAAC;QACnC,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB;IAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,MAAM,CAAC,QAAQ,CACb,IAAI,EAAE,mBAAmB,EACzB,SAAS,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,eAAe,EAAE,QAAQ,GAAG,MAAM,CAAC,CAAC,GAAG;QAC9D,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB,GACA,eAAe;IAWlB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,QAAQ,CAAC,CAAC,GAAG,KAAK,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,eAAe,CAAC;CAGzD;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,eAAe,CAE1E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,mBAAmB,EACzB,SAAS,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,eAAe,EAAE,QAAQ,GAAG,MAAM,CAAC,CAAC,GAAG;IAC9D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GACA,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,eAAe,CAAC,CAEvC"}

package/dist/errors/uploadista-error.js

@@ -0,0 +1,322 @@
+import { Data, Effect } from "effect";
+/**
+ * Catalog of all predefined errors in the Uploadista system.
+ *
+ * Maps error codes to their HTTP status codes and default error messages.
+ * This centralized catalog ensures consistent error handling across all
+ * Uploadista packages and adapters.
+ *
+ * Each error entry contains:
+ * - `status`: HTTP status code (400-500 range)
+ * - `body`: Human-readable error message
+ *
+ * @example
+ * ```typescript
+ * // Access a specific error definition
+ * const fileNotFound = ERROR_CATALOG.FILE_NOT_FOUND;
+ * console.log(fileNotFound.status); // 404
+ * console.log(fileNotFound.body);   // "The file for this url was not found\n"
+ *
+ * // Use with UploadistaError
+ * const error = UploadistaError.fromCode("FILE_NOT_FOUND");
+ * ```
+ */
+export const ERROR_CATALOG = {
+    MISSING_OFFSET: { status: 403, body: "Upload-Offset header required\n" },
+    ABORTED: { status: 400, body: "Request aborted due to lock acquired" },
+    INVALID_TERMINATION: {
+        status: 400,
+        body: "Cannot terminate an already completed upload",
+    },
+    ERR_LOCK_TIMEOUT: {
+        status: 500,
+        body: "failed to acquire lock before timeout",
+    },
+    INVALID_CONTENT_TYPE: {
+        status: 403,
+        body: "Content-Type header required\n",
+    },
+    DATASTORE_NOT_FOUND: {
+        status: 500,
+        body: "The datastore was not found\n",
+    },
+    UPLOAD_ID_NOT_FOUND: {
+        status: 500,
+        body: "The upload id was not found\n",
+    },
+    FILE_NOT_FOUND: {
+        status: 404,
+        body: "The file for this url was not found\n",
+    },
+    FLOW_NOT_AUTHORIZED: {
+        status: 401,
+        body: "The flow is not authorized\n",
+    },
+    FLOW_NOT_FOUND: {
+        status: 404,
+        body: "The flow was not found\n",
+    },
+    FLOW_STRUCTURE_ERROR: {
+        status: 500,
+        body: "The flow structure is invalid\n",
+    },
+    FLOW_CYCLE_ERROR: {
+        status: 500,
+        body: "The flow contains a cycle\n",
+    },
+    FLOW_NODE_NOT_FOUND: {
+        status: 500,
+        body: "The flow node was not found\n",
+    },
+    FLOW_NODE_ERROR: {
+        status: 500,
+        body: "The flow node failed\n",
+    },
+    FLOW_JOB_NOT_FOUND: {
+        status: 404,
+        body: "The flow job was not found\n",
+    },
+    FLOW_JOB_ERROR: {
+        status: 500,
+        body: "The flow job failed\n",
+    },
+    FLOW_INPUT_VALIDATION_ERROR: {
+        status: 500,
+        body: "The flow input validation failed\n",
+    },
+    FLOW_OUTPUT_VALIDATION_ERROR: {
+        status: 500,
+        body: "The flow output validation failed\n",
+    },
+    INVALID_OFFSET: { status: 409, body: "Upload-Offset conflict\n" },
+    FILE_NO_LONGER_EXISTS: {
+        status: 410,
+        body: "The file for this url no longer exists\n",
+    },
+    FILE_READ_ERROR: {
+        status: 500,
+        body: "Something went wrong reading the file\n",
+    },
+    ERR_SIZE_EXCEEDED: { status: 413, body: "upload's size exceeded\n" },
+    ERR_MAX_SIZE_EXCEEDED: { status: 413, body: "Maximum size exceeded\n" },
+    INVALID_LENGTH: {
+        status: 400,
+        body: "Upload-Length or Upload-Defer-Length header required\n",
+    },
+    INVALID_METADATA: {
+        status: 400,
+        body: "Upload-Metadata is invalid. It MUST consist of one or more comma-separated key-value pairs. The key and value MUST be separated by a space. The key MUST NOT contain spaces and commas and MUST NOT be empty. The key SHOULD be ASCII encoded and the value MUST be Base64 encoded. All keys MUST be unique",
+    },
+    VALIDATION_ERROR: {
+        status: 400,
+        body: "Validation failed\n",
+    },
+    STORAGE_NOT_AUTHORIZED: {
+        status: 401,
+        body: "The storage is not authorized\n",
+    },
+    UNKNOWN_ERROR: {
+        status: 500,
+        body: "Something went wrong with that request\n",
+    },
+    FILE_WRITE_ERROR: {
+        status: 500,
+        body: "Something went wrong receiving the file\n",
+    },
+    CHECKSUM_MISMATCH: {
+        status: 400,
+        body: "The file checksum does not match the provided checksum\n",
+    },
+    MIMETYPE_MISMATCH: {
+        status: 400,
+        body: "The file MIME type does not match the declared type\n",
+    },
+    UNSUPPORTED_CHECKSUM_ALGORITHM: {
+        status: 400,
+        body: "The specified checksum algorithm is not supported\n",
+    },
+};
+/**
+ * Standard error class for all Uploadista operations.
+ *
+ * UploadistaError provides a consistent error handling approach across the entire
+ * Uploadista ecosystem. Each error has:
+ * - A typed error code from the ERROR_CATALOG
+ * - An HTTP-compatible status code
+ * - A human-readable error message (body)
+ * - Optional additional details and cause information
+ *
+ * This class integrates with Effect-TS for functional error handling and can be
+ * easily converted to an Effect that fails.
+ *
+ * @example
+ * ```typescript
+ * // Create from error code
+ * const error = UploadistaError.fromCode("FILE_NOT_FOUND");
+ *
+ * // Create with custom details
+ * const customError = UploadistaError.fromCode("FLOW_NODE_ERROR", {
+ *   body: "Failed to process image",
+ *   cause: originalError,
+ *   details: { nodeId: "resize-1", fileId: "abc123" }
+ * });
+ *
+ * // Use with Effect
+ * const effect = customError.toEffect<void>();
+ *
+ * // In an Effect pipeline
+ * return Effect.gen(function* () {
+ *   const file = yield* getFile(id);
+ *   if (!file) {
+ *     return yield* UploadistaError.fromCode("FILE_NOT_FOUND").toEffect();
+ *   }
+ *   return file;
+ * });
+ * ```
+ */
+export class UploadistaError extends Data.TaggedError("UploadistaError") {
+    code;
+    status;
+    // Keep legacy property names for backward compatibility
+    status_code;
+    body;
+    details;
+    constructor({ code, status, body, cause, details, }) {
+        super();
+        this.name = "UploadistaError";
+        this.code = code;
+        this.status = status;
+        this.status_code = status; // legacy alias
+        this.body = body;
+        this.details = details;
+        if (cause)
+            this.cause = cause;
+    }
+    /**
+     * Creates an UploadistaError from a predefined error code.
+     *
+     * This is the primary way to create errors in the Uploadista system. Each error code
+     * has a default status and message defined in ERROR_CATALOG, but these can be overridden
+     * for specific use cases.
+     *
+     * @param code - One of the predefined error codes from UploadistaErrorCode
+     * @param overrides - Optional overrides for the default error properties
+     * @param overrides.status - Custom HTTP status code (overrides the default)
+     * @param overrides.body - Custom error message (overrides the default)
+     * @param overrides.details - Additional structured data about the error
+     * @param overrides.cause - The underlying error that caused this error (for error chaining)
+     *
+     * @returns A new UploadistaError instance
+     *
+     * @example
+     * ```typescript
+     * // Use default error
+     * const error = UploadistaError.fromCode("FILE_NOT_FOUND");
+     *
+     * // Override message
+     * const customError = UploadistaError.fromCode("FILE_NOT_FOUND", {
+     *   body: `File with ID ${fileId} was not found in storage`
+     * });
+     *
+     * // Include cause and details
+     * const detailedError = UploadistaError.fromCode("DATASTORE_NOT_FOUND", {
+     *   cause: storageException,
+     *   details: { storageId: "s3-prod", region: "us-east-1" }
+     * });
+     * ```
+     */
+    static fromCode(code, overrides) {
+        const base = ERROR_CATALOG[code];
+        return new UploadistaError({
+            code,
+            status: overrides?.status ?? base.status,
+            body: overrides?.body ?? base.body,
+            details: overrides?.details,
+            cause: overrides?.cause,
+        });
+    }
+    /**
+     * Converts this error to an Effect that immediately fails.
+     *
+     * This method integrates UploadistaError with Effect-TS's error handling system,
+     * allowing errors to be used in Effect pipelines with proper type checking.
+     *
+     * @template T - The success type of the Effect (defaults to never since it always fails)
+     * @returns An Effect that fails with this UploadistaError
+     *
+     * @example
+     * ```typescript
+     * const error = UploadistaError.fromCode("FILE_NOT_FOUND");
+     *
+     * // Use in an Effect pipeline
+     * return Effect.gen(function* () {
+     *   const file = yield* kvStore.get(fileId);
+     *   if (!file) {
+     *     return yield* error.toEffect();
+     *   }
+     *   return file;
+     * });
+     * ```
+     */
+    toEffect() {
+        return Effect.fail(this);
+    }
+}
+/**
+ * Type guard to check if an unknown value is an UploadistaError.
+ *
+ * Useful for error handling when catching errors that might be from
+ * different sources or libraries.
+ *
+ * @param error - The value to check
+ * @returns True if the value is an UploadistaError instance
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await someOperation();
+ * } catch (error) {
+ *   if (isUploadistaError(error)) {
+ *     console.log(`Uploadista error: ${error.code} (${error.status})`);
+ *     console.log(error.body);
+ *   } else {
+ *     console.error("Unknown error:", error);
+ *   }
+ * }
+ * ```
+ */
+export function isUploadistaError(error) {
+    return error instanceof UploadistaError;
+}
+/**
+ * Creates an Effect that immediately fails with an UploadistaError.
+ *
+ * This is a convenience function that combines error creation with Effect conversion.
+ * It's equivalent to calling `UploadistaError.fromCode(code, overrides).toEffect()`.
+ *
+ * @param code - One of the predefined error codes from UploadistaErrorCode
+ * @param overrides - Optional overrides for the default error properties
+ * @param overrides.status - Custom HTTP status code
+ * @param overrides.body - Custom error message
+ * @param overrides.details - Additional structured data about the error
+ * @param overrides.cause - The underlying error that caused this error
+ *
+ * @returns An Effect that immediately fails with the created UploadistaError
+ *
+ * @example
+ * ```typescript
+ * // In an Effect pipeline
+ * return Effect.gen(function* () {
+ *   const file = yield* kvStore.get(fileId);
+ *   if (!file) {
+ *     return yield* httpFailure("FILE_NOT_FOUND", {
+ *       details: { fileId }
+ *     });
+ *   }
+ *   return file;
+ * });
+ * ```
+ */
+export function httpFailure(code, overrides) {
+    return UploadistaError.fromCode(code, overrides).toEffect();
+}

package/dist/errors-8i_aMxOE.js

@@ -0,0 +1 @@
+export{};

package/dist/flow/edge.d.ts

@@ -0,0 +1,47 @@
+import type { FlowEdge as EnhancedFlowEdge } from "./types/flow-types";
+/**
+ * Represents a connection between two nodes in a flow, defining the data flow direction.
+ *
+ * Edges connect the output of a source node to the input of a target node,
+ * enabling data to flow through the processing pipeline in a directed acyclic graph (DAG).
+ */
+export type FlowEdge = EnhancedFlowEdge;
+/**
+ * Creates a flow edge connecting two nodes in a processing pipeline.
+ *
+ * Edges define how data flows between nodes. The data output from the source node
+ * becomes the input for the target node. For nodes with multiple inputs/outputs,
+ * ports can be specified to route data to specific connections.
+ *
+ * @param config - Edge configuration
+ * @param config.source - ID of the source node (data originates here)
+ * @param config.target - ID of the target node (data flows to here)
+ * @param config.sourcePort - Optional port name on the source node for multi-output nodes
+ * @param config.targetPort - Optional port name on the target node for multi-input nodes
+ *
+ * @returns A FlowEdge object representing the connection
+ *
+ * @example
+ * ```typescript
+ * // Simple edge connecting two nodes
+ * const edge = createFlowEdge({
+ *   source: "input-1",
+ *   target: "process-1"
+ * });
+ *
+ * // Edge with ports for multi-input/output nodes
+ * const portEdge = createFlowEdge({
+ *   source: "multiplex-1",
+ *   target: "merge-1",
+ *   sourcePort: "out-a",
+ *   targetPort: "in-1"
+ * });
+ * ```
+ */
+export declare function createFlowEdge({ source, target, sourcePort, targetPort, }: {
+    source: string;
+    target: string;
+    sourcePort?: string;
+    targetPort?: string;
+}): FlowEdge;
+//# sourceMappingURL=edge.d.ts.map

package/dist/flow/edge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge.d.ts","sourceRoot":"","sources":["../../src/flow/edge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,IAAI,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEvE;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,gBAAgB,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,cAAc,CAAC,EAC7B,MAAM,EACN,MAAM,EACN,UAAU,EACV,UAAU,GACX,EAAE;IACD,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,QAAQ,CAOX"}

package/dist/flow/edge.js

@@ -0,0 +1,40 @@
+/**
+ * Creates a flow edge connecting two nodes in a processing pipeline.
+ *
+ * Edges define how data flows between nodes. The data output from the source node
+ * becomes the input for the target node. For nodes with multiple inputs/outputs,
+ * ports can be specified to route data to specific connections.
+ *
+ * @param config - Edge configuration
+ * @param config.source - ID of the source node (data originates here)
+ * @param config.target - ID of the target node (data flows to here)
+ * @param config.sourcePort - Optional port name on the source node for multi-output nodes
+ * @param config.targetPort - Optional port name on the target node for multi-input nodes
+ *
+ * @returns A FlowEdge object representing the connection
+ *
+ * @example
+ * ```typescript
+ * // Simple edge connecting two nodes
+ * const edge = createFlowEdge({
+ *   source: "input-1",
+ *   target: "process-1"
+ * });
+ *
+ * // Edge with ports for multi-input/output nodes
+ * const portEdge = createFlowEdge({
+ *   source: "multiplex-1",
+ *   target: "merge-1",
+ *   sourcePort: "out-a",
+ *   targetPort: "in-1"
+ * });
+ * ```
+ */
+export function createFlowEdge({ source, target, sourcePort, targetPort, }) {
+    return {
+        source,
+        target,
+        sourcePort,
+        targetPort,
+    };
+}