@elaraai/e3-types 0.0.2-beta.5 → 0.0.2-beta.50

package/dist/src/package.d.ts

@@ -13,7 +13,7 @@
  * - **Structure**: The shape of the data tree
  * - **Task**: A computation with input/output paths (stored separately)
  */
-import { StructType, StringType, DictType, ValueTypeOf } from '@elaraai/east';
+import { StructType, StringType, IntegerType, VariantType, NullType, DictType, ValueTypeOf } from '@elaraai/east';
 /**
  * Data configuration in a package.
  *
@@ -22,112 +22,122 @@ import { StructType, StringType, DictType, ValueTypeOf } from '@elaraai/east';
  *
  * @remarks
  * - `structure`: Defines which paths are datasets vs trees (recursive)
- * - `value`: Hash of the root tree object in the object store
- *
- * @example
- * ```ts
- * const data: PackageData = {
- *   structure: variant('struct', new Map([
- *     ['inputs', variant('struct', new Map([
- *       ['sales', variant('value', variant('Array', variant('Integer', null)))],
- *     ]))],
- *     ['tasks', variant('struct', new Map([
- *       ['process', variant('struct', new Map([
- *         ['function_ir', variant('value', ...)],
- *         ['output', variant('value', variant('Integer', null))],
- *       ]))],
- *     ]))],
- *   ])),
- *   value: 'abc123...',  // Hash of initial tree
- * };
- * ```
+ * - `refs`: Per-dataset refs mapping refPath to DatasetRef (replaces old root tree hash)
  */
 export declare const PackageDataType: StructType<{
     /** Structure defining tree shape (what's a group vs dataset) */
-    structure: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
-        value: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
-            Never: import("@elaraai/east").NullType;
-            Null: import("@elaraai/east").NullType;
-            Boolean: import("@elaraai/east").NullType;
-            Integer: import("@elaraai/east").NullType;
-            Float: import("@elaraai/east").NullType;
-            String: import("@elaraai/east").NullType;
-            DateTime: import("@elaraai/east").NullType;
-            Blob: import("@elaraai/east").NullType;
-            Ref: import("@elaraai/east").RecursiveTypeMarker;
-            Array: import("@elaraai/east").RecursiveTypeMarker;
-            Set: import("@elaraai/east").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("@elaraai/east").RecursiveTypeMarker;
-                value: import("@elaraai/east").RecursiveTypeMarker;
-            }>;
-            Struct: import("@elaraai/east").ArrayType<StructType<{
-                name: StringType;
-                type: import("@elaraai/east").RecursiveTypeMarker;
-            }>>;
-            Variant: import("@elaraai/east").ArrayType<StructType<{
-                name: StringType;
-                type: import("@elaraai/east").RecursiveTypeMarker;
+    readonly structure: import("@elaraai/east").RecursiveType<VariantType<{
+        readonly value: StructType<{
+            readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: import("@elaraai/east").ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: import("@elaraai/east").ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: IntegerType;
+                readonly Function: StructType<{
+                    readonly inputs: import("@elaraai/east").ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: import("@elaraai/east").ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
             }>>;
-            Recursive: import("@elaraai/east").IntegerType;
-            Function: StructType<{
-                inputs: import("@elaraai/east").ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
-                output: import("@elaraai/east").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: import("@elaraai/east").ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
-                output: import("@elaraai/east").RecursiveTypeMarker;
-            }>;
-        }>>;
-        struct: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+            readonly writable: import("@elaraai/east").BooleanType;
+        }>;
+        readonly struct: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+    }>>;
+    /** Per-dataset refs: refPath (e.g. "inputs/greeting") -> DatasetRef */
+    readonly refs: DictType<StringType, VariantType<{
+        readonly unassigned: NullType;
+        readonly null: StructType<{
+            readonly versions: DictType<StringType, StringType>;
+        }>;
+        readonly value: StructType<{
+            readonly hash: StringType;
+            readonly versions: DictType<StringType, StringType>;
+        }>;
     }>>;
-    /** Hash of the root tree object containing initial/default values */
-    value: StringType;
 }>;
 export type PackageDataType = typeof PackageDataType;
 export type PackageData = ValueTypeOf<typeof PackageDataType>;
 /** @deprecated Use PackageDataType instead */
 export declare const PackageDatasetsType: StructType<{
     /** Structure defining tree shape (what's a group vs dataset) */
-    structure: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
-        value: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
-            Never: import("@elaraai/east").NullType;
-            Null: import("@elaraai/east").NullType;
-            Boolean: import("@elaraai/east").NullType;
-            Integer: import("@elaraai/east").NullType;
-            Float: import("@elaraai/east").NullType;
-            String: import("@elaraai/east").NullType;
-            DateTime: import("@elaraai/east").NullType;
-            Blob: import("@elaraai/east").NullType;
-            Ref: import("@elaraai/east").RecursiveTypeMarker;
-            Array: import("@elaraai/east").RecursiveTypeMarker;
-            Set: import("@elaraai/east").RecursiveTypeMarker;
-            Dict: StructType<{
-                key: import("@elaraai/east").RecursiveTypeMarker;
-                value: import("@elaraai/east").RecursiveTypeMarker;
-            }>;
-            Struct: import("@elaraai/east").ArrayType<StructType<{
-                name: StringType;
-                type: import("@elaraai/east").RecursiveTypeMarker;
-            }>>;
-            Variant: import("@elaraai/east").ArrayType<StructType<{
-                name: StringType;
-                type: import("@elaraai/east").RecursiveTypeMarker;
+    readonly structure: import("@elaraai/east").RecursiveType<VariantType<{
+        readonly value: StructType<{
+            readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: import("@elaraai/east").ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: import("@elaraai/east").ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: IntegerType;
+                readonly Function: StructType<{
+                    readonly inputs: import("@elaraai/east").ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: import("@elaraai/east").ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
             }>>;
-            Recursive: import("@elaraai/east").IntegerType;
-            Function: StructType<{
-                inputs: import("@elaraai/east").ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
-                output: import("@elaraai/east").RecursiveTypeMarker;
-            }>;
-            AsyncFunction: StructType<{
-                inputs: import("@elaraai/east").ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
-                output: import("@elaraai/east").RecursiveTypeMarker;
-            }>;
-        }>>;
-        struct: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+            readonly writable: import("@elaraai/east").BooleanType;
+        }>;
+        readonly struct: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+    }>>;
+    /** Per-dataset refs: refPath (e.g. "inputs/greeting") -> DatasetRef */
+    readonly refs: DictType<StringType, VariantType<{
+        readonly unassigned: NullType;
+        readonly null: StructType<{
+            readonly versions: DictType<StringType, StringType>;
+        }>;
+        readonly value: StructType<{
+            readonly hash: StringType;
+            readonly versions: DictType<StringType, StringType>;
+        }>;
     }>>;
-    /** Hash of the root tree object containing initial/default values */
-    value: StringType;
 }>;
 /** @deprecated Use PackageData instead */
 export type PackageDatasetsType = PackageDataType;
@@ -153,58 +163,149 @@ export type PackageDatasets = PackageData;
  *   tasks: new Map([['process', 'abc123...']]),  // hash of TaskObject
  *   data: {
  *     structure: variant('struct', new Map([...])),
- *     value: 'def456...',  // hash of root tree
+ *     refs: new Map([['inputs/sales', variant('value', { hash: 'def456...', versions: new Map() })]]),
  *   },
  * };
  * ```
  */
 export declare const PackageObjectType: StructType<{
     /** Tasks defined in this package: name -> task object hash */
-    tasks: DictType<StringType, StringType>;
+    readonly tasks: DictType<StringType, StringType>;
     /** Data structure and initial values */
-    data: StructType<{
+    readonly data: StructType<{
         /** Structure defining tree shape (what's a group vs dataset) */
-        structure: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
-            value: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
-                Never: import("@elaraai/east").NullType;
-                Null: import("@elaraai/east").NullType;
-                Boolean: import("@elaraai/east").NullType;
-                Integer: import("@elaraai/east").NullType;
-                Float: import("@elaraai/east").NullType;
-                String: import("@elaraai/east").NullType;
-                DateTime: import("@elaraai/east").NullType;
-                Blob: import("@elaraai/east").NullType;
-                Ref: import("@elaraai/east").RecursiveTypeMarker;
-                Array: import("@elaraai/east").RecursiveTypeMarker;
-                Set: import("@elaraai/east").RecursiveTypeMarker;
-                Dict: StructType<{
-                    key: import("@elaraai/east").RecursiveTypeMarker;
-                    value: import("@elaraai/east").RecursiveTypeMarker;
-                }>;
-                Struct: import("@elaraai/east").ArrayType<StructType<{
-                    name: StringType;
-                    type: import("@elaraai/east").RecursiveTypeMarker;
-                }>>;
-                Variant: import("@elaraai/east").ArrayType<StructType<{
-                    name: StringType;
-                    type: import("@elaraai/east").RecursiveTypeMarker;
+        readonly structure: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly value: StructType<{
+                readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: NullType;
+                    readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Dict: StructType<{
+                        readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Struct: import("@elaraai/east").ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Variant: import("@elaraai/east").ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Recursive: IntegerType;
+                    readonly Function: StructType<{
+                        readonly inputs: import("@elaraai/east").ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly AsyncFunction: StructType<{
+                        readonly inputs: import("@elaraai/east").ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
                 }>>;
-                Recursive: import("@elaraai/east").IntegerType;
-                Function: StructType<{
-                    inputs: import("@elaraai/east").ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
-                    output: import("@elaraai/east").RecursiveTypeMarker;
-                }>;
-                AsyncFunction: StructType<{
-                    inputs: import("@elaraai/east").ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
-                    output: import("@elaraai/east").RecursiveTypeMarker;
-                }>;
-            }>>;
-            struct: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+                readonly writable: import("@elaraai/east").BooleanType;
+            }>;
+            readonly struct: DictType<StringType, import("@elaraai/east").RecursiveTypeMarker>;
+        }>>;
+        /** Per-dataset refs: refPath (e.g. "inputs/greeting") -> DatasetRef */
+        readonly refs: DictType<StringType, VariantType<{
+            readonly unassigned: NullType;
+            readonly null: StructType<{
+                readonly versions: DictType<StringType, StringType>;
+            }>;
+            readonly value: StructType<{
+                readonly hash: StringType;
+                readonly versions: DictType<StringType, StringType>;
+            }>;
         }>>;
-        /** Hash of the root tree object containing initial/default values */
-        value: StringType;
     }>;
 }>;
 export type PackageObjectType = typeof PackageObjectType;
 export type PackageObject = ValueTypeOf<typeof PackageObjectType>;
+export declare const PackageTransferInitRequestType: StructType<{
+    readonly size: IntegerType;
+}>;
+export type PackageTransferInitRequest = ValueTypeOf<typeof PackageTransferInitRequestType>;
+export declare const PackageTransferInitResponseType: StructType<{
+    readonly id: StringType;
+    readonly uploadUrl: StringType;
+}>;
+export type PackageTransferInitResponse = ValueTypeOf<typeof PackageTransferInitResponseType>;
+export declare const PackageJobResponseType: StructType<{
+    readonly id: StringType;
+}>;
+export type PackageJobResponse = ValueTypeOf<typeof PackageJobResponseType>;
+export declare const PackageImportResultType: StructType<{
+    readonly name: StringType;
+    readonly version: StringType;
+    readonly packageHash: StringType;
+    readonly objectCount: IntegerType;
+}>;
+export type PackageImportResult = ValueTypeOf<typeof PackageImportResultType>;
+export declare const PackageExportResultType: StructType<{
+    readonly downloadUrl: StringType;
+    readonly size: IntegerType;
+}>;
+export type PackageExportResult = ValueTypeOf<typeof PackageExportResultType>;
+export declare const PackageImportProgressType: VariantType<{
+    readonly pending: NullType;
+    readonly downloading: NullType;
+    readonly importing: StructType<{
+        readonly objectsProcessed: IntegerType;
+    }>;
+}>;
+export type PackageImportProgress = ValueTypeOf<typeof PackageImportProgressType>;
+export declare const PackageImportStatusType: VariantType<{
+    readonly processing: VariantType<{
+        readonly pending: NullType;
+        readonly downloading: NullType;
+        readonly importing: StructType<{
+            readonly objectsProcessed: IntegerType;
+        }>;
+    }>;
+    readonly completed: StructType<{
+        readonly name: StringType;
+        readonly version: StringType;
+        readonly packageHash: StringType;
+        readonly objectCount: IntegerType;
+    }>;
+    readonly failed: StructType<{
+        readonly message: StringType;
+    }>;
+}>;
+export type PackageImportStatus = ValueTypeOf<typeof PackageImportStatusType>;
+export declare const PackageExportProgressType: VariantType<{
+    readonly pending: NullType;
+    readonly exporting: StructType<{
+        readonly objectsProcessed: IntegerType;
+    }>;
+    readonly uploading: NullType;
+}>;
+export type PackageExportProgress = ValueTypeOf<typeof PackageExportProgressType>;
+export declare const PackageExportStatusType: VariantType<{
+    readonly processing: VariantType<{
+        readonly pending: NullType;
+        readonly exporting: StructType<{
+            readonly objectsProcessed: IntegerType;
+        }>;
+        readonly uploading: NullType;
+    }>;
+    readonly completed: StructType<{
+        readonly downloadUrl: StringType;
+        readonly size: IntegerType;
+    }>;
+    readonly failed: StructType<{
+        readonly message: StringType;
+    }>;
+}>;
+export type PackageExportStatus = ValueTypeOf<typeof PackageExportStatusType>;
 //# sourceMappingURL=package.d.ts.map

package/dist/src/package.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"package.d.ts","sourceRoot":"","sources":["../../src/package.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG9E;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,eAAe;IAC1B,gEAAgE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEhE,qEAAqE;;EAErE,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC;AAErD,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,OAAO,eAAe,CAAC,CAAC;AAG9D,8CAA8C;AAC9C,eAAO,MAAM,mBAAmB;IAX9B,gEAAgE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEhE,qEAAqE;;EASrB,CAAC;AACnD,0CAA0C;AAC1C,MAAM,MAAM,mBAAmB,GAAG,eAAe,CAAC;AAClD,0CAA0C;AAC1C,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,iBAAiB;IAC5B,8DAA8D;;IAE9D,wCAAwC;;QA7CxC,gEAAgE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAEhE,qEAAqE;;;EA6CrE,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC;AAEzD,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC"}
+{"version":3,"file":"package.d.ts","sourceRoot":"","sources":["../../src/package.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAIlH;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe;IAC1B,gEAAgE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEhE,uEAAuE;;;;;;;;;;;EAEvE,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC;AAErD,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,OAAO,eAAe,CAAC,CAAC;AAG9D,8CAA8C;AAC9C,eAAO,MAAM,mBAAmB;IAX9B,gEAAgE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEhE,uEAAuE;;;;;;;;;;;EASvB,CAAC;AACnD,0CAA0C;AAC1C,MAAM,MAAM,mBAAmB,GAAG,eAAe,CAAC;AAClD,0CAA0C;AAC1C,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,iBAAiB;IAC5B,8DAA8D;;IAE9D,wCAAwC;;QA7CxC,gEAAgE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAEhE,uEAAuE;;;;;;;;;;;;EA6CvE,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC;AAEzD,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAMlE,eAAO,MAAM,8BAA8B;;EAEzC,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,WAAW,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAE5F,eAAO,MAAM,+BAA+B;;;EAG1C,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,WAAW,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAE9F,eAAO,MAAM,sBAAsB;;EAEjC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE5E,eAAO,MAAM,uBAAuB;;;;;EAKlC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,WAAW,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E,eAAO,MAAM,uBAAuB;;;EAGlC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,WAAW,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E,eAAO,MAAM,yBAAyB;;;;;;EAIpC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,WAAW,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAElF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;EAMlC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,WAAW,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E,eAAO,MAAM,yBAAyB;;;;;;EAIpC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,WAAW,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAElF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;EAMlC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,WAAW,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/src/package.js

@@ -13,7 +13,8 @@
  * - **Structure**: The shape of the data tree
  * - **Task**: A computation with input/output paths (stored separately)
  */
-import { StructType, StringType, DictType } from '@elaraai/east';
+import { StructType, StringType, IntegerType, VariantType, NullType, DictType } from '@elaraai/east';
+import { DatasetRefType } from './dataset-ref.js';
 import { StructureType } from './structure.js';
 /**
  * Data configuration in a package.
@@ -23,31 +24,13 @@ import { StructureType } from './structure.js';
  *
  * @remarks
  * - `structure`: Defines which paths are datasets vs trees (recursive)
- * - `value`: Hash of the root tree object in the object store
- *
- * @example
- * ```ts
- * const data: PackageData = {
- *   structure: variant('struct', new Map([
- *     ['inputs', variant('struct', new Map([
- *       ['sales', variant('value', variant('Array', variant('Integer', null)))],
- *     ]))],
- *     ['tasks', variant('struct', new Map([
- *       ['process', variant('struct', new Map([
- *         ['function_ir', variant('value', ...)],
- *         ['output', variant('value', variant('Integer', null))],
- *       ]))],
- *     ]))],
- *   ])),
- *   value: 'abc123...',  // Hash of initial tree
- * };
- * ```
+ * - `refs`: Per-dataset refs mapping refPath to DatasetRef (replaces old root tree hash)
  */
 export const PackageDataType = StructType({
     /** Structure defining tree shape (what's a group vs dataset) */
     structure: StructureType,
-    /** Hash of the root tree object containing initial/default values */
-    value: StringType,
+    /** Per-dataset refs: refPath (e.g. "inputs/greeting") -> DatasetRef */
+    refs: DictType(StringType, DatasetRefType),
 });
 // Backwards compatibility alias
 /** @deprecated Use PackageDataType instead */
@@ -72,7 +55,7 @@ export const PackageDatasetsType = PackageDataType;
  *   tasks: new Map([['process', 'abc123...']]),  // hash of TaskObject
  *   data: {
  *     structure: variant('struct', new Map([...])),
- *     value: 'def456...',  // hash of root tree
+ *     refs: new Map([['inputs/sales', variant('value', { hash: 'def456...', versions: new Map() })]]),
  *   },
  * };
  * ```
@@ -83,4 +66,51 @@ export const PackageObjectType = StructType({
     /** Data structure and initial values */
     data: PackageDataType,
 });
+// =============================================================================
+// Package Transfer Types
+// =============================================================================
+export const PackageTransferInitRequestType = StructType({
+    size: IntegerType,
+});
+export const PackageTransferInitResponseType = StructType({
+    id: StringType,
+    uploadUrl: StringType,
+});
+export const PackageJobResponseType = StructType({
+    id: StringType,
+});
+export const PackageImportResultType = StructType({
+    name: StringType,
+    version: StringType,
+    packageHash: StringType,
+    objectCount: IntegerType,
+});
+export const PackageExportResultType = StructType({
+    downloadUrl: StringType,
+    size: IntegerType,
+});
+export const PackageImportProgressType = VariantType({
+    pending: NullType,
+    downloading: NullType,
+    importing: StructType({ objectsProcessed: IntegerType }),
+});
+export const PackageImportStatusType = VariantType({
+    processing: PackageImportProgressType,
+    completed: PackageImportResultType,
+    failed: StructType({
+        message: StringType,
+    }),
+});
+export const PackageExportProgressType = VariantType({
+    pending: NullType,
+    exporting: StructType({ objectsProcessed: IntegerType }),
+    uploading: NullType,
+});
+export const PackageExportStatusType = VariantType({
+    processing: PackageExportProgressType,
+    completed: PackageExportResultType,
+    failed: StructType({
+        message: StringType,
+    }),
+});
 //# sourceMappingURL=package.js.map

package/dist/src/package.js.map

@@ -1 +1 @@
-{"version":3,"file":"package.js","sourceRoot":"","sources":["../../src/package.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAe,MAAM,eAAe,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;IACxC,gEAAgE;IAChE,SAAS,EAAE,aAAa;IACxB,qEAAqE;IACrE,KAAK,EAAE,UAAU;CAClB,CAAC,CAAC;AAKH,gCAAgC;AAChC,8CAA8C;AAC9C,MAAM,CAAC,MAAM,mBAAmB,GAAG,eAAe,CAAC;AAMnD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;IAC1C,8DAA8D;IAC9D,KAAK,EAAE,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IACvC,wCAAwC;IACxC,IAAI,EAAE,eAAe;CACtB,CAAC,CAAC"}
+{"version":3,"file":"package.js","sourceRoot":"","sources":["../../src/package.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAe,MAAM,eAAe,CAAC;AAClH,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/C;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;IACxC,gEAAgE;IAChE,SAAS,EAAE,aAAa;IACxB,uEAAuE;IACvE,IAAI,EAAE,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;CAC3C,CAAC,CAAC;AAKH,gCAAgC;AAChC,8CAA8C;AAC9C,MAAM,CAAC,MAAM,mBAAmB,GAAG,eAAe,CAAC;AAMnD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;IAC1C,8DAA8D;IAC9D,KAAK,EAAE,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IACvC,wCAAwC;IACxC,IAAI,EAAE,eAAe;CACtB,CAAC,CAAC;AAKH,gFAAgF;AAChF,yBAAyB;AACzB,gFAAgF;AAEhF,MAAM,CAAC,MAAM,8BAA8B,GAAG,UAAU,CAAC;IACvD,IAAI,EAAE,WAAW;CAClB,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,+BAA+B,GAAG,UAAU,CAAC;IACxD,EAAE,EAAE,UAAU;IACd,SAAS,EAAE,UAAU;CACtB,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,sBAAsB,GAAG,UAAU,CAAC;IAC/C,EAAE,EAAE,UAAU;CACf,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,uBAAuB,GAAG,UAAU,CAAC;IAChD,IAAI,EAAE,UAAU;IAChB,OAAO,EAAE,UAAU;IACnB,WAAW,EAAE,UAAU;IACvB,WAAW,EAAE,WAAW;CACzB,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,uBAAuB,GAAG,UAAU,CAAC;IAChD,WAAW,EAAE,UAAU;IACvB,IAAI,EAAE,WAAW;CAClB,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,yBAAyB,GAAG,WAAW,CAAC;IACnD,OAAO,EAAE,QAAQ;IACjB,WAAW,EAAE,QAAQ;IACrB,SAAS,EAAE,UAAU,CAAC,EAAE,gBAAgB,EAAE,WAAW,EAAE,CAAC;CACzD,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,uBAAuB,GAAG,WAAW,CAAC;IACjD,UAAU,EAAE,yBAAyB;IACrC,SAAS,EAAE,uBAAuB;IAClC,MAAM,EAAE,UAAU,CAAC;QACjB,OAAO,EAAE,UAAU;KACpB,CAAC;CACH,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,yBAAyB,GAAG,WAAW,CAAC;IACnD,OAAO,EAAE,QAAQ;IACjB,SAAS,EAAE,UAAU,CAAC,EAAE,gBAAgB,EAAE,WAAW,EAAE,CAAC;IACxD,SAAS,EAAE,QAAQ;CACpB,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,uBAAuB,GAAG,WAAW,CAAC;IACjD,UAAU,EAAE,yBAAyB;IACrC,SAAS,EAAE,uBAAuB;IAClC,MAAM,EAAE,UAAU,CAAC;QACjB,OAAO,EAAE,UAAU;KACpB,CAAC;CACH,CAAC,CAAC"}