@elaraai/east-node-io 0.0.1-beta.0 → 0.0.1-beta.10

package/README.md

@@ -218,3 +218,41 @@ This project is licensed under the GNU Affero General Public License v3.0 - see
 - **Transfer**: `basic-ftp`, `ssh2-sftp-client`
 - **NoSQL**: `ioredis`, `mongodb`
 - **Format**: `xlsx` for Excel file processing
+
+
+### Ecosystem
+
+- **[East Node](https://github.com/elaraai/east-node)**: Node.js platform functions for I/O, databases, and system operations. Connect East programs to filesystems, SQL/NoSQL databases, cloud storage, and network services.
+  - [@elaraai/east-node-std](https://www.npmjs.com/package/@elaraai/east-node-std): Filesystem, console, HTTP fetch, crypto, random distributions, timestamps
+  - [@elaraai/east-node-io](https://www.npmjs.com/package/@elaraai/east-node-io): SQLite, PostgreSQL, MySQL, MongoDB, S3, FTP, SFTP
+  - [@elaraai/east-node-cli](https://www.npmjs.com/package/@elaraai/east-node-cli): CLI for running East IR programs in Node.js
+
+- **[East Python](https://github.com/elaraai/east-py)**: Python runtime and platform functions for data science and machine learning. Execute East programs with access to optimization solvers, gradient boosting, neural networks, and model explainability.
+  - [@elaraai/east-py-datascience](https://www.npmjs.com/package/@elaraai/east-py-datascience): TypeScript types for optimization, gradient boosting, neural networks, explainability
+
+- **[East UI](https://github.com/elaraai/east-ui)**: East types and expressions for building dashboards and interactive layouts. Define UIs as data structures that render consistently across React, web, and other environments.
+  - [@elaraai/east-ui](https://www.npmjs.com/package/@elaraai/east-ui): 50+ typed UI components for layouts, forms, charts, tables, dialogs
+  - [@elaraai/east-ui-components](https://www.npmjs.com/package/@elaraai/east-ui-components): React renderer with Chakra UI styling
+
+- **[e3 - East Execution Engine](https://github.com/elaraai/e3)**: Durable execution engine for running East pipelines at scale. Features Git-like content-addressable storage, automatic memoization, task queuing, and real-time monitoring.
+  - [@elaraai/e3](https://www.npmjs.com/package/@elaraai/e3): SDK for authoring e3 packages with typed tasks and pipelines
+  - [@elaraai/e3-core](https://www.npmjs.com/package/@elaraai/e3-core): Git-like object store, task queue, result caching
+  - [@elaraai/e3-types](https://www.npmjs.com/package/@elaraai/e3-types): Shared type definitions for e3 packages
+  - [@elaraai/e3-cli](https://www.npmjs.com/package/@elaraai/e3-cli): `e3 init`, `e3 run`, `e3 logs` commands for managing and monitoring tasks
+  - [@elaraai/e3-api-client](https://www.npmjs.com/package/@elaraai/e3-api-client): HTTP client for remote e3 servers
+  - [@elaraai/e3-api-server](https://www.npmjs.com/package/@elaraai/e3-api-server): REST API server for e3 repositories
+
+## Links
+
+- **Website**: [https://elaraai.com/](https://elaraai.com/)
+- **East Repository**: [https://github.com/elaraai/East](https://github.com/elaraai/East)
+- **Issues**: [https://github.com/elaraai/east-node/issues](https://github.com/elaraai/east-node/issues)
+- **Email**: support@elara.ai
+
+## About Elara
+
+East is developed by [Elara AI Pty Ltd](https://elaraai.com/), an AI-powered platform that creates economic digital twins of businesses that optimize performance. Elara combines business objectives, decisions and data to help organizations make data-driven decisions across operations, purchasing, sales and customer engagement, and project and investment planning. East powers the computational layer of Elara solutions, enabling the expression of complex business logic and data in a simple, type-safe and portable language.
+
+---
+
+*Developed by [Elara AI Pty Ltd](https://elaraai.com/)*

package/dist/compression/gzip.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Gzip compression platform functions for East Node IO.
+ *
+ * Provides gzip compression and decompression operations for East programs,
+ * enabling efficient data compression using the gzip format (RFC 1952).
+ *
+ * @packageDocumentation
+ */
+import { BlobType } from "@elaraai/east";
+import type { PlatformFunction } from "@elaraai/east/internal";
+/**
+ * Compresses data using gzip compression.
+ *
+ * Applies gzip compression (RFC 1952) to binary data, producing a compressed
+ * blob that can be decompressed with {@link gzip_decompress}. The compression
+ * level can be controlled via options (0-9, where 0 is no compression and 9
+ * is maximum compression).
+ *
+ * This is a platform function for the East language, enabling gzip compression
+ * in East programs running on Node.js.
+ *
+ * @param data - Uncompressed data to compress
+ * @param options - Compression options (level)
+ * @returns Compressed data as gzip blob
+ *
+ * @throws {EastError} When compression fails due to:
+ * - Invalid compression level (location: "gzip_compress")
+ * - Memory allocation errors (location: "gzip_compress")
+ * - Internal zlib errors (location: "gzip_compress")
+ *
+ * @example
+ * ```ts
+ * import { East, BlobType, StringType } from "@elaraai/east";
+ * import { Compression } from "@elaraai/east-node-io";
+ *
+ * const compressText = East.function([StringType], BlobType, ($, text) => {
+ *     const data = $.let(text.encodeUtf8());
+ *     const options = $.let({
+ *         level: { tag: "some", value: 9n },
+ *     });
+ *     const compressed = $.let(Compression.Gzip.compress(data, options));
+ *     return $.return(compressed);
+ * });
+ *
+ * const compiled = East.compileAsync(compressText.toIR(), Compression.Gzip.Implementation);
+ * const result = await compiled("Hello, World!");  // Compressed gzip blob
+ * ```
+ *
+ * @remarks
+ * - Uses Node.js built-in zlib for compression
+ * - Default compression level is 6 if not specified
+ * - Level 0 stores data without compression
+ * - Higher levels (7-9) provide better compression but are slower
+ * - All operations are asynchronous (use East.compileAsync)
+ */
+export declare const gzip_compress: import("@elaraai/east").AsyncPlatformDefinition<[BlobType, import("@elaraai/east").StructType<{
+    level: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+}>], BlobType>;
+/**
+ * Decompresses gzip-compressed data.
+ *
+ * Decompresses data that was compressed using gzip (RFC 1952), restoring the
+ * original uncompressed data. The input must be valid gzip format.
+ *
+ * This is a platform function for the East language, enabling gzip decompression
+ * in East programs running on Node.js.
+ *
+ * @param compressed - Gzip-compressed data
+ * @returns Decompressed original data
+ *
+ * @throws {EastError} When decompression fails due to:
+ * - Invalid gzip format (location: "gzip_decompress")
+ * - Corrupted compressed data (location: "gzip_decompress")
+ * - Memory allocation errors (location: "gzip_decompress")
+ * - Internal zlib errors (location: "gzip_decompress")
+ *
+ * @example
+ * ```ts
+ * import { East, BlobType, StringType } from "@elaraai/east";
+ * import { Compression } from "@elaraai/east-node-io";
+ *
+ * const decompressText = East.function([BlobType], StringType, ($, compressed) => {
+ *     const decompressed = $.let(Compression.Gzip.decompress(compressed));
+ *     const text = $.let(decompressed.decodeUtf8());
+ *     return $.return(text);
+ * });
+ *
+ * const compiled = East.compileAsync(decompressText.toIR(), Compression.Gzip.Implementation);
+ * const result = await compiled(compressedBlob);  // "Hello, World!"
+ * ```
+ *
+ * @remarks
+ * - Uses Node.js built-in zlib for decompression
+ * - Automatically detects gzip header and validates format
+ * - All operations are asynchronous (use East.compileAsync)
+ */
+export declare const gzip_decompress: import("@elaraai/east").AsyncPlatformDefinition<[BlobType], BlobType>;
+/**
+ * Node.js implementation of Gzip platform functions.
+ *
+ * Pass this array to {@link East.compileAsync} to enable gzip compression operations.
+ */
+export declare const GzipImpl: PlatformFunction[];
+//# sourceMappingURL=gzip.d.ts.map

package/dist/compression/gzip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gzip.d.ts","sourceRoot":"","sources":["../../src/compression/gzip.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;GAOG;AAEH,OAAO,EAAQ,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAU/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,eAAO,MAAM,aAAa;;cAA6E,CAAC;AAExG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,eAAe,uEAA8D,CAAC;AAE3F;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,gBAAgB,EA6CtC,CAAC"}

package/dist/compression/gzip.js

@@ -0,0 +1,153 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Gzip compression platform functions for East Node IO.
+ *
+ * Provides gzip compression and decompression operations for East programs,
+ * enabling efficient data compression using the gzip format (RFC 1952).
+ *
+ * @packageDocumentation
+ */
+import { East, BlobType } from "@elaraai/east";
+import { EastError } from "@elaraai/east/internal";
+import { gzip as nodeGzip, gunzip as nodeGunzip } from "node:zlib";
+import { promisify } from "node:util";
+import { GzipOptionsType } from "./types.js";
+// Promisify zlib functions
+const gzipAsync = promisify(nodeGzip);
+const gunzipAsync = promisify(nodeGunzip);
+/**
+ * Compresses data using gzip compression.
+ *
+ * Applies gzip compression (RFC 1952) to binary data, producing a compressed
+ * blob that can be decompressed with {@link gzip_decompress}. The compression
+ * level can be controlled via options (0-9, where 0 is no compression and 9
+ * is maximum compression).
+ *
+ * This is a platform function for the East language, enabling gzip compression
+ * in East programs running on Node.js.
+ *
+ * @param data - Uncompressed data to compress
+ * @param options - Compression options (level)
+ * @returns Compressed data as gzip blob
+ *
+ * @throws {EastError} When compression fails due to:
+ * - Invalid compression level (location: "gzip_compress")
+ * - Memory allocation errors (location: "gzip_compress")
+ * - Internal zlib errors (location: "gzip_compress")
+ *
+ * @example
+ * ```ts
+ * import { East, BlobType, StringType } from "@elaraai/east";
+ * import { Compression } from "@elaraai/east-node-io";
+ *
+ * const compressText = East.function([StringType], BlobType, ($, text) => {
+ *     const data = $.let(text.encodeUtf8());
+ *     const options = $.let({
+ *         level: { tag: "some", value: 9n },
+ *     });
+ *     const compressed = $.let(Compression.Gzip.compress(data, options));
+ *     return $.return(compressed);
+ * });
+ *
+ * const compiled = East.compileAsync(compressText.toIR(), Compression.Gzip.Implementation);
+ * const result = await compiled("Hello, World!");  // Compressed gzip blob
+ * ```
+ *
+ * @remarks
+ * - Uses Node.js built-in zlib for compression
+ * - Default compression level is 6 if not specified
+ * - Level 0 stores data without compression
+ * - Higher levels (7-9) provide better compression but are slower
+ * - All operations are asynchronous (use East.compileAsync)
+ */
+export const gzip_compress = East.asyncPlatform("gzip_compress", [BlobType, GzipOptionsType], BlobType);
+/**
+ * Decompresses gzip-compressed data.
+ *
+ * Decompresses data that was compressed using gzip (RFC 1952), restoring the
+ * original uncompressed data. The input must be valid gzip format.
+ *
+ * This is a platform function for the East language, enabling gzip decompression
+ * in East programs running on Node.js.
+ *
+ * @param compressed - Gzip-compressed data
+ * @returns Decompressed original data
+ *
+ * @throws {EastError} When decompression fails due to:
+ * - Invalid gzip format (location: "gzip_decompress")
+ * - Corrupted compressed data (location: "gzip_decompress")
+ * - Memory allocation errors (location: "gzip_decompress")
+ * - Internal zlib errors (location: "gzip_decompress")
+ *
+ * @example
+ * ```ts
+ * import { East, BlobType, StringType } from "@elaraai/east";
+ * import { Compression } from "@elaraai/east-node-io";
+ *
+ * const decompressText = East.function([BlobType], StringType, ($, compressed) => {
+ *     const decompressed = $.let(Compression.Gzip.decompress(compressed));
+ *     const text = $.let(decompressed.decodeUtf8());
+ *     return $.return(text);
+ * });
+ *
+ * const compiled = East.compileAsync(decompressText.toIR(), Compression.Gzip.Implementation);
+ * const result = await compiled(compressedBlob);  // "Hello, World!"
+ * ```
+ *
+ * @remarks
+ * - Uses Node.js built-in zlib for decompression
+ * - Automatically detects gzip header and validates format
+ * - All operations are asynchronous (use East.compileAsync)
+ */
+export const gzip_decompress = East.asyncPlatform("gzip_decompress", [BlobType], BlobType);
+/**
+ * Node.js implementation of Gzip platform functions.
+ *
+ * Pass this array to {@link East.compileAsync} to enable gzip compression operations.
+ */
+export const GzipImpl = [
+    gzip_compress.implement(async (data, options) => {
+        try {
+            // Extract compression level (default to 6)
+            const level = options.level.type === "some"
+                ? Number(options.level.value)
+                : 6;
+            // Validate level
+            if (level < 0 || level > 9) {
+                throw new EastError(`Invalid compression level: ${level}. Must be 0-9.`, {
+                    location: { filename: "gzip_compress", line: 0n, column: 0n }
+                });
+            }
+            // Compress using zlib
+            const compressed = await gzipAsync(data, { level });
+            return new Uint8Array(compressed);
+        }
+        catch (err) {
+            if (err instanceof EastError)
+                throw err;
+            throw new EastError(`Gzip compression failed: ${err.message}`, {
+                location: { filename: "gzip_compress", line: 0n, column: 0n },
+                cause: err
+            });
+        }
+    }),
+    gzip_decompress.implement(async (compressed) => {
+        try {
+            // Decompress using zlib
+            const decompressed = await gunzipAsync(compressed);
+            return new Uint8Array(decompressed);
+        }
+        catch (err) {
+            if (err instanceof EastError)
+                throw err;
+            throw new EastError(`Gzip decompression failed: ${err.message}`, {
+                location: { filename: "gzip_decompress", line: 0n, column: 0n },
+                cause: err
+            });
+        }
+    }),
+];
+//# sourceMappingURL=gzip.js.map

package/dist/compression/gzip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gzip.js","sourceRoot":"","sources":["../../src/compression/gzip.ts"],"names":[],"mappings":"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"}

package/dist/compression/index.d.ts

@@ -0,0 +1,308 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Compression platform functions for East Node IO.
+ *
+ * Provides functions for compressing and decompressing data using various
+ * formats like gzip, zip, and tar.
+ *
+ * @example
+ * ```ts
+ * import { East, BlobType, StringType } from "@elaraai/east";
+ * import { Compression } from "@elaraai/east-node-io";
+ *
+ * const compressText = East.function([StringType], BlobType, ($, text) => {
+ *     const data = $.let(text.encodeUtf8());
+ *     const options = $.let({
+ *         level: { tag: "some", value: 9n },
+ *     });
+ *     const compressed = $.let(Compression.Gzip.compress(data, options));
+ *     return $.return(compressed);
+ * });
+ *
+ * const compiled = East.compileAsync(compressText.toIR(), Compression.Gzip.Implementation);
+ * await compiled("Hello, World!");  // Compressed gzip blob
+ * ```
+ *
+ * @packageDocumentation
+ */
+export * from "./types.js";
+export { gzip_compress, gzip_decompress, GzipImpl } from "./gzip.js";
+export { zip_compress, zip_decompress, ZipImpl } from "./zip.js";
+export { tar_create, tar_extract, TarImpl } from "./tar.js";
+/**
+ * Compression platform functions grouped by compression type.
+ *
+ * Provides organized access to compression-specific operations for compressing
+ * and decompressing data in East programs.
+ *
+ * @example
+ * ```ts
+ * import { East, BlobType, StringType } from "@elaraai/east";
+ * import { Compression } from "@elaraai/east-node-io";
+ *
+ * const compressAndDecompress = East.function([StringType], StringType, ($, text) => {
+ *     const data = $.let(text.encodeUtf8());
+ *     const options = $.let({
+ *         level: { tag: "some", value: 9n },
+ *     });
+ *
+ *     const compressed = $.let(Compression.Gzip.compress(data, options));
+ *     const decompressed = $.let(Compression.Gzip.decompress(compressed));
+ *     const result = $.let(decompressed.decodeUtf8());
+ *     return $.return(result);
+ * });
+ *
+ * const compiled = East.compileAsync(compressAndDecompress.toIR(), Compression.Gzip.Implementation);
+ * await compiled("Hello, World!");  // "Hello, World!"
+ * ```
+ */
+export declare const Compression: {
+    /**
+     * Gzip compression operations.
+     *
+     * Provides functions for compressing and decompressing data using gzip (RFC 1952).
+     */
+    readonly Gzip: {
+        /**
+         * Compresses data using gzip compression.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, StringType } from "@elaraai/east";
+         * import { Compression } from "@elaraai/east-node-io";
+         *
+         * const compressText = East.function([StringType], BlobType, ($, text) => {
+         *     const data = $.let(text.encodeUtf8());
+         *     const options = $.let({
+         *         level: { tag: "some", value: 9n },
+         *     });
+         *     const compressed = $.let(Compression.Gzip.compress(data, options));
+         *     return $.return(compressed);
+         * });
+         *
+         * const compiled = East.compileAsync(compressText.toIR(), Compression.Gzip.Implementation);
+         * await compiled("Hello, World!");
+         * ```
+         */
+        readonly compress: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").BlobType, import("@elaraai/east").StructType<{
+            level: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+        }>], import("@elaraai/east").BlobType>;
+        /**
+         * Decompresses gzip-compressed data.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, StringType } from "@elaraai/east";
+         * import { Compression } from "@elaraai/east-node-io";
+         *
+         * const decompressText = East.function([BlobType], StringType, ($, compressed) => {
+         *     const decompressed = $.let(Compression.Gzip.decompress(compressed));
+         *     const text = $.let(decompressed.decodeUtf8());
+         *     return $.return(text);
+         * });
+         *
+         * const compiled = East.compileAsync(decompressText.toIR(), Compression.Gzip.Implementation);
+         * await compiled(compressedBlob);
+         * ```
+         */
+        readonly decompress: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").BlobType], import("@elaraai/east").BlobType>;
+        /**
+         * Node.js implementation of Gzip platform functions.
+         *
+         * Pass this to {@link East.compileAsync} to enable gzip operations.
+         */
+        readonly Implementation: import("@elaraai/east/internal").PlatformFunction[];
+        /**
+         * Type definitions for Gzip operations.
+         */
+        readonly Types: {
+            /**
+             * Compression level (0-9).
+             */
+            readonly Level: import("@elaraai/east").IntegerType;
+            /**
+             * Gzip compression options.
+             */
+            readonly Options: import("@elaraai/east").StructType<{
+                level: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            }>;
+        };
+    };
+    /**
+     * ZIP archive operations.
+     *
+     * Provides functions for creating and extracting ZIP archives with multiple files.
+     */
+    readonly Zip: {
+        /**
+         * Creates a ZIP archive from a list of files.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, StringType } from "@elaraai/east";
+         * import { Compression } from "@elaraai/east-node-io";
+         *
+         * const createZip = East.function([StringType, StringType], BlobType, ($, file1, file2) => {
+         *     const entries = $.let([
+         *         { name: "file1.txt", data: file1.encodeUtf8() },
+         *         { name: "file2.txt", data: file2.encodeUtf8() },
+         *     ]);
+         *     const options = $.let({
+         *         level: { tag: "some", value: 9n },
+         *     });
+         *     const zipBlob = $.let(Compression.Zip.compress(entries, options));
+         *     return $.return(zipBlob);
+         * });
+         *
+         * const compiled = East.compileAsync(createZip.toIR(), Compression.Zip.Implementation);
+         * await compiled("Hello", "World");
+         * ```
+         */
+        readonly compress: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            name: import("@elaraai/east").StringType;
+            data: import("@elaraai/east").BlobType;
+        }>>, import("@elaraai/east").StructType<{
+            level: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+        }>], import("@elaraai/east").BlobType>;
+        /**
+         * Extracts files from a ZIP archive.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, DictType, StringType } from "@elaraai/east";
+         * import { Compression } from "@elaraai/east-node-io";
+         *
+         * const extractZip = East.function([BlobType], DictType(StringType, BlobType), ($, zipBlob) => {
+         *     const files = $.let(Compression.Zip.decompress(zipBlob));
+         *     return $.return(files);
+         * });
+         *
+         * const compiled = East.compileAsync(extractZip.toIR(), Compression.Zip.Implementation);
+         * await compiled(zipBlob);
+         * ```
+         */
+        readonly decompress: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").BlobType], import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").BlobType>>;
+        /**
+         * Node.js implementation of ZIP platform functions.
+         *
+         * Pass this to {@link East.compileAsync} to enable ZIP operations.
+         */
+        readonly Implementation: import("@elaraai/east/internal").PlatformFunction[];
+        /**
+         * Type definitions for ZIP operations.
+         */
+        readonly Types: {
+            /**
+             * Compression level (0-9).
+             */
+            readonly Level: import("@elaraai/east").IntegerType;
+            /**
+             * ZIP compression options.
+             */
+            readonly Options: import("@elaraai/east").StructType<{
+                level: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            }>;
+            /**
+             * Entry in a ZIP archive.
+             */
+            readonly Entry: import("@elaraai/east").StructType<{
+                name: import("@elaraai/east").StringType;
+                data: import("@elaraai/east").BlobType;
+            }>;
+            /**
+             * List of entries for creating a ZIP archive.
+             */
+            readonly Entries: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+                name: import("@elaraai/east").StringType;
+                data: import("@elaraai/east").BlobType;
+            }>>;
+            /**
+             * Extracted files from a ZIP archive.
+             */
+            readonly Extracted: import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").BlobType>;
+        };
+    };
+    /**
+     * TAR archive operations.
+     *
+     * Provides functions for creating and extracting TAR archives (without compression).
+     */
+    readonly Tar: {
+        /**
+         * Creates a TAR archive from a list of files.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, StringType } from "@elaraai/east";
+         * import { Compression } from "@elaraai/east-node-io";
+         *
+         * const createTar = East.function([StringType, StringType], BlobType, ($, file1, file2) => {
+         *     const entries = $.let([
+         *         { name: "file1.txt", data: file1.encodeUtf8() },
+         *         { name: "file2.txt", data: file2.encodeUtf8() },
+         *     ]);
+         *     const tarBlob = $.let(Compression.Tar.create(entries));
+         *     return $.return(tarBlob);
+         * });
+         *
+         * const compiled = East.compileAsync(createTar.toIR(), Compression.Tar.Implementation);
+         * await compiled("Hello", "World");
+         * ```
+         */
+        readonly create: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            name: import("@elaraai/east").StringType;
+            data: import("@elaraai/east").BlobType;
+        }>>], import("@elaraai/east").BlobType>;
+        /**
+         * Extracts files from a TAR archive.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, DictType, StringType } from "@elaraai/east";
+         * import { Compression } from "@elaraai/east-node-io";
+         *
+         * const extractTar = East.function([BlobType], DictType(StringType, BlobType), ($, tarBlob) => {
+         *     const files = $.let(Compression.Tar.extract(tarBlob));
+         *     return $.return(files);
+         * });
+         *
+         * const compiled = East.compileAsync(extractTar.toIR(), Compression.Tar.Implementation);
+         * await compiled(tarBlob);
+         * ```
+         */
+        readonly extract: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").BlobType], import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").BlobType>>;
+        /**
+         * Node.js implementation of TAR platform functions.
+         *
+         * Pass this to {@link East.compileAsync} to enable TAR operations.
+         */
+        readonly Implementation: import("@elaraai/east/internal").PlatformFunction[];
+        /**
+         * Type definitions for TAR operations.
+         */
+        readonly Types: {
+            /**
+             * Entry in a TAR archive.
+             */
+            readonly Entry: import("@elaraai/east").StructType<{
+                name: import("@elaraai/east").StringType;
+                data: import("@elaraai/east").BlobType;
+            }>;
+            /**
+             * List of entries for creating a TAR archive.
+             */
+            readonly Entries: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+                name: import("@elaraai/east").StringType;
+                data: import("@elaraai/east").BlobType;
+            }>>;
+            /**
+             * Extracted files from a TAR archive.
+             */
+            readonly Extracted: import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").BlobType>;
+        };
+    };
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/compression/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAGH,cAAc,YAAY,CAAC;AAG3B,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACjE,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAmB5D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,WAAW;IACpB;;;;OAIG;;QAEC;;;;;;;;;;;;;;;;;;;;WAoBG;;;;QAGH;;;;;;;;;;;;;;;;;WAiBG;;QAGH;;;;WAIG;;QAGH;;WAEG;;YAEC;;eAEG;;YAGH;;eAEG;;;;;;IAKX;;;;OAIG;;QAEC;;;;;;;;;;;;;;;;;;;;;;;WAuBG;;;;;;;QAGH;;;;;;;;;;;;;;;;WAgBG;;QAGH;;;;WAIG;;QAGH;;WAEG;;YAEC;;eAEG;;YAGH;;eAEG;;;;YAGH;;eAEG;;;;;YAGH;;eAEG;;;;;YAGH;;eAEG;;;;IAKX;;;;OAIG;;QAEC;;;;;;;;;;;;;;;;;;;;WAoBG;;;;;QAGH;;;;;;;;;;;;;;;;WAgBG;;QAGH;;;;WAIG;;QAGH;;WAEG;;YAEC;;eAEG;;;;;YAGH;;eAEG;;;;;YAGH;;eAEG;;;;CAIL,CAAC"}