@elaraai/e3-types 1.0.5 → 1.0.7

package/dist/src/index.js

@@ -30,8 +30,12 @@ export { TaskObjectType, } from './task.js';
 export { StructureType, PathSegmentType, TreePathType, treePath, pathToString, parsePath, parseDatasetPath, parsePackageRef, urlPathToTreePath, 
 // Backwards compatibility
 DatasetSchemaType, } from './structure.js';
+// Runner wire types (functions)
+export { RunnerType, runnerToArgv, } from './runner.js';
+// Function objects
+export { FunctionObjectType, } from './function.js';
 // Package objects
-export { PackageDataType, PackageObjectType, 
+export { PackageDataType, PackageObjectType, decodePackageObject, 
 // Backwards compatibility
 PackageDatasetsType, 
 // Package transfer types
@@ -69,7 +73,9 @@ ExecutionHistoryStatusType, ExecutionListItemType,
 // Dataset List
 TreeKindType, ListEntryType, 
 // Dataset Status Detail
-DatasetStatusDetailType, } from './api.js';
+DatasetStatusDetailType, 
+// Function / one-shot execution
+ExecuteLimitsType, DiagnosticType, ExecuteResultType, FunctionCallRequestType, FunctionSignatureType, OneShotRequestType, } from './api.js';
 // Dataflow execution state
 export { TaskStateType, DataflowGraphTaskType, DataflowGraphType, ExecutionEventType, DataflowExecutionStateType, 
 // Dataflow run history

package/dist/src/index.js.map

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

package/dist/src/package.d.ts

@@ -246,9 +246,23 @@ export declare const PackageObjectType: StructType<{
             }>;
         }>>;
     }>;
+    /** Functions defined in this package: name -> FunctionObject hash.
+     *  BEAST2 encodes struct fields positionally in declaration order, so this
+     *  field MUST stay last — never insert between `tasks` and `data`. */
+    readonly functions: DictType<StringType, StringType>;
 }>;
 export type PackageObjectType = typeof PackageObjectType;
 export type PackageObject = ValueTypeOf<typeof PackageObjectType>;
+/**
+ * Decode a `PackageObject` from BEAST2 bytes, tolerating the pre-`functions`
+ * wire format (dual-decode migration).
+ *
+ * Every package-read path — local AND cloud — must use this instead of
+ * `decodeBeast2For(PackageObjectType)` directly, so packages exported before
+ * the `functions` field existed keep decoding. Old bytes decode with
+ * `functions` defaulted to an empty map.
+ */
+export declare function decodePackageObject(data: Uint8Array): PackageObject;
 export declare const PackageTransferInitRequestType: StructType<{
     readonly size: IntegerType;
 }>;

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,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"}
+{"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,EAAmB,MAAM,eAAe,CAAC;AAInI;;;;;;;;;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;;;;;;;;;;;;IA6CvE;;0EAEsE;;EAEtE,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC;AAEzD,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAelE;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,aAAa,CAWnE;AAMD,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,7 @@
  * - **Structure**: The shape of the data tree
  * - **Task**: A computation with input/output paths (stored separately)
  */
-import { StructType, StringType, IntegerType, VariantType, NullType, DictType } from '@elaraai/east';
+import { StructType, StringType, IntegerType, VariantType, NullType, DictType, decodeBeast2For } from '@elaraai/east';
 import { DatasetRefType } from './dataset-ref.js';
 import { StructureType } from './structure.js';
 /**
@@ -65,7 +65,45 @@ export const PackageObjectType = StructType({
     tasks: DictType(StringType, StringType),
     /** Data structure and initial values */
     data: PackageDataType,
+    /** Functions defined in this package: name -> FunctionObject hash.
+     *  BEAST2 encodes struct fields positionally in declaration order, so this
+     *  field MUST stay last — never insert between `tasks` and `data`. */
+    functions: DictType(StringType, StringType),
 });
+/**
+ * The pre-`functions` package object wire shape, kept only so
+ * {@link decodePackageObject} can read packages exported before functions
+ * existed.
+ */
+const LegacyPackageObjectType = StructType({
+    tasks: DictType(StringType, StringType),
+    data: PackageDataType,
+});
+const decodeCurrent = decodeBeast2For(PackageObjectType);
+const decodeLegacy = decodeBeast2For(LegacyPackageObjectType);
+/**
+ * Decode a `PackageObject` from BEAST2 bytes, tolerating the pre-`functions`
+ * wire format (dual-decode migration).
+ *
+ * Every package-read path — local AND cloud — must use this instead of
+ * `decodeBeast2For(PackageObjectType)` directly, so packages exported before
+ * the `functions` field existed keep decoding. Old bytes decode with
+ * `functions` defaulted to an empty map.
+ */
+export function decodePackageObject(data) {
+    try {
+        return decodeCurrent(data);
+    }
+    catch (err) {
+        try {
+            const legacy = decodeLegacy(data);
+            return { tasks: legacy.tasks, data: legacy.data, functions: new Map() };
+        }
+        catch {
+            throw err; // neither shape — surface the current-format error
+        }
+    }
+}
 // =============================================================================
 // Package Transfer Types
 // =============================================================================

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

package/dist/src/runner.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Runner wire types for e3 functions.
+ *
+ * `RunnerType` is the wire image of the SDK's `Runner` union (minus its
+ * `custom` raw-argv runtime — see the security note below). It pins the
+ * executable to a known runtime for every tag, so a function call can never
+ * name its own executable; only platform flags vary.
+ *
+ * A `platforms` entry is just a `-p <name>` flag on the wire; the SDK's
+ * `Platform<Known> | { custom }` distinction is authoring sugar that
+ * collapses to a string.
+ */
+import { VariantType, StructType, ArrayType, StringType, ValueTypeOf } from '@elaraai/east';
+/**
+ * Wire representation of a runner — shared by tasks and functions
+ * (symmetric: both carry `runner: RunnerType`).
+ *
+ * The known-runtime tags name a runtime binary; `platforms` are passed as
+ * `-p` flags. `custom` carries a raw argv prefix: for functions it is the
+ * executed command (the standard `-i/-o/<ir>` suffix is appended, so the
+ * command must speak the runner CLI convention); for tasks it is routing
+ * metadata only — a task's `commandIr` remains authoritative for execution.
+ * Package authors can already execute arbitrary commands via custom tasks,
+ * so `custom` grants no capability that tasks don't have.
+ */
+export declare const RunnerType: VariantType<{
+    readonly east_node: StructType<{
+        readonly platforms: ArrayType<StringType>;
+    }>;
+    readonly east_py: StructType<{
+        readonly platforms: ArrayType<StringType>;
+    }>;
+    readonly east_c: StructType<{
+        readonly platforms: ArrayType<StringType>;
+    }>;
+    readonly custom: StructType<{
+        readonly command: ArrayType<StringType>;
+    }>;
+}>;
+export type RunnerType = typeof RunnerType;
+export type RunnerValue = ValueTypeOf<typeof RunnerType>;
+/**
+ * Resolve a {@link RunnerType} value to the argv prefix (the wire-value
+ * analogue of the SDK's `runnerToCommand`). Lives in e3-types so both
+ * e3-core (local) and the cloud execution kernel import the one resolver.
+ *
+ * Variant tags use underscores (`east_node`) mapped to the binary name
+ * (`east-node`) here.
+ */
+export declare function runnerToArgv(r: RunnerValue): string[];
+//# sourceMappingURL=runner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/runner.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5F;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;EAKrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC;AAE3C,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,OAAO,UAAU,CAAC,CAAC;AAMzD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE,CAOrD"}

package/dist/src/runner.js

@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Runner wire types for e3 functions.
+ *
+ * `RunnerType` is the wire image of the SDK's `Runner` union (minus its
+ * `custom` raw-argv runtime — see the security note below). It pins the
+ * executable to a known runtime for every tag, so a function call can never
+ * name its own executable; only platform flags vary.
+ *
+ * A `platforms` entry is just a `-p <name>` flag on the wire; the SDK's
+ * `Platform<Known> | { custom }` distinction is authoring sugar that
+ * collapses to a string.
+ */
+import { VariantType, StructType, ArrayType, StringType } from '@elaraai/east';
+/**
+ * Wire representation of a runner — shared by tasks and functions
+ * (symmetric: both carry `runner: RunnerType`).
+ *
+ * The known-runtime tags name a runtime binary; `platforms` are passed as
+ * `-p` flags. `custom` carries a raw argv prefix: for functions it is the
+ * executed command (the standard `-i/-o/<ir>` suffix is appended, so the
+ * command must speak the runner CLI convention); for tasks it is routing
+ * metadata only — a task's `commandIr` remains authoritative for execution.
+ * Package authors can already execute arbitrary commands via custom tasks,
+ * so `custom` grants no capability that tasks don't have.
+ */
+export const RunnerType = VariantType({
+    east_node: StructType({ platforms: ArrayType(StringType) }),
+    east_py: StructType({ platforms: ArrayType(StringType) }),
+    east_c: StructType({ platforms: ArrayType(StringType) }),
+    custom: StructType({ command: ArrayType(StringType) }),
+});
+function flags(platforms) {
+    return platforms.flatMap((p) => ['-p', p]);
+}
+/**
+ * Resolve a {@link RunnerType} value to the argv prefix (the wire-value
+ * analogue of the SDK's `runnerToCommand`). Lives in e3-types so both
+ * e3-core (local) and the cloud execution kernel import the one resolver.
+ *
+ * Variant tags use underscores (`east_node`) mapped to the binary name
+ * (`east-node`) here.
+ */
+export function runnerToArgv(r) {
+    switch (r.type) {
+        case 'east_node': return ['east-node', 'run', ...flags(r.value.platforms)];
+        case 'east_py': return ['east-py', 'run', ...flags(r.value.platforms)];
+        case 'east_c': return ['east-c', 'run', ...flags(r.value.platforms)];
+        case 'custom': return [...r.value.command];
+    }
+}
+//# sourceMappingURL=runner.js.map

package/dist/src/runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.js","sourceRoot":"","sources":["../../src/runner.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAe,MAAM,eAAe,CAAC;AAE5F;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,WAAW,CAAC;IACpC,SAAS,EAAE,UAAU,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;IAC3D,OAAO,EAAI,UAAU,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;IAC3D,MAAM,EAAK,UAAU,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;IAC3D,MAAM,EAAK,UAAU,CAAC,EAAE,OAAO,EAAE,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;CAC1D,CAAC,CAAC;AAKH,SAAS,KAAK,CAAC,SAAmB;IAChC,OAAO,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;AAC7C,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAAC,CAAc;IACzC,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;QACf,KAAK,WAAW,CAAC,CAAC,OAAO,CAAC,WAAW,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;QAC3E,KAAK,SAAS,CAAC,CAAG,OAAO,CAAC,SAAS,EAAI,KAAK,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;QAC3E,KAAK,QAAQ,CAAC,CAAI,OAAO,CAAC,QAAQ,EAAK,KAAK,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;QAC3E,KAAK,QAAQ,CAAC,CAAI,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAChD,CAAC;AACH,CAAC"}

package/dist/src/task.d.ts

@@ -64,6 +64,28 @@ export declare const TaskObjectType: StructType<{
     readonly kind: OptionType<StringType>;
     /** Opaque extension metadata (beast2-encoded). Interpreted by the kind-specific consumer. */
     readonly metadata: OptionType<BlobType>;
+    /**
+     * The task's runner, as routing metadata (symmetric with
+     * FunctionObject.runner). For `custom` runners, `commandIr` remains
+     * authoritative for execution — the wire command is informational.
+     *
+     * NOTE: added as a hard cutover (no dual decoder) — packages exported by
+     * older SDKs must be re-exported.
+     */
+    readonly runner: import("@elaraai/east").VariantType<{
+        readonly east_node: StructType<{
+            readonly platforms: ArrayType<StringType>;
+        }>;
+        readonly east_py: StructType<{
+            readonly platforms: ArrayType<StringType>;
+        }>;
+        readonly east_c: StructType<{
+            readonly platforms: ArrayType<StringType>;
+        }>;
+        readonly custom: StructType<{
+            readonly command: ArrayType<StringType>;
+        }>;
+    }>;
 }>;
 export type TaskObjectType = typeof TaskObjectType;
 export type TaskObject = ValueTypeOf<typeof TaskObjectType>;

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

@@ -1 +1 @@
-{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../src/task.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAGrG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,cAAc;IACzB,kFAAkF;;IAElF,uEAAuE;;;;IAEvE,sEAAsE;;;;IAEtE,sFAAsF;;IAEtF,6FAA6F;;EAE7F,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC;AAEnD,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC"}
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../src/task.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAIrG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,cAAc;IACzB,kFAAkF;;IAElF,uEAAuE;;;;IAEvE,sEAAsE;;;;IAEtE,sFAAsF;;IAEtF,6FAA6F;;IAE7F;;;;;;;OAOG;;;;;;;;;;;;;;;EAEH,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC;AAEnD,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/src/task.js

@@ -16,6 +16,7 @@
  */
 import { StructType, StringType, ArrayType, BlobType, OptionType } from '@elaraai/east';
 import { TreePathType } from './structure.js';
+import { RunnerType } from './runner.js';
 /**
  * Task object stored in the object store.
  *
@@ -61,5 +62,14 @@ export const TaskObjectType = StructType({
     kind: OptionType(StringType),
     /** Opaque extension metadata (beast2-encoded). Interpreted by the kind-specific consumer. */
     metadata: OptionType(BlobType),
+    /**
+     * The task's runner, as routing metadata (symmetric with
+     * FunctionObject.runner). For `custom` runners, `commandIr` remains
+     * authoritative for execution — the wire command is informational.
+     *
+     * NOTE: added as a hard cutover (no dual decoder) — packages exported by
+     * older SDKs must be re-exported.
+     */
+    runner: RunnerType,
 });
 //# sourceMappingURL=task.js.map

package/dist/src/task.js.map

@@ -1 +1 @@
-{"version":3,"file":"task.js","sourceRoot":"","sources":["../../src/task.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAe,MAAM,eAAe,CAAC;AACrG,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,UAAU,CAAC;IACvC,kFAAkF;IAClF,SAAS,EAAE,UAAU;IACrB,uEAAuE;IACvE,MAAM,EAAE,SAAS,CAAC,YAAY,CAAC;IAC/B,sEAAsE;IACtE,MAAM,EAAE,YAAY;IACpB,sFAAsF;IACtF,IAAI,EAAE,UAAU,CAAC,UAAU,CAAC;IAC5B,6FAA6F;IAC7F,QAAQ,EAAE,UAAU,CAAC,QAAQ,CAAC;CAC/B,CAAC,CAAC"}
+{"version":3,"file":"task.js","sourceRoot":"","sources":["../../src/task.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAe,MAAM,eAAe,CAAC;AACrG,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,UAAU,CAAC;IACvC,kFAAkF;IAClF,SAAS,EAAE,UAAU;IACrB,uEAAuE;IACvE,MAAM,EAAE,SAAS,CAAC,YAAY,CAAC;IAC/B,sEAAsE;IACtE,MAAM,EAAE,YAAY;IACpB,sFAAsF;IACtF,IAAI,EAAE,UAAU,CAAC,UAAU,CAAC;IAC5B,6FAA6F;IAC7F,QAAQ,EAAE,UAAU,CAAC,QAAQ,CAAC;IAC9B;;;;;;;OAOG;IACH,MAAM,EAAE,UAAU;CACnB,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elaraai/e3-types",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Shared type definitions for e3 (East Execution Engine)",
   "type": "module",
   "main": "dist/src/index.js",
@@ -18,7 +18,7 @@
     "directory": "libs/e3/packages/e3-types"
   },
   "peerDependencies": {
-    "@elaraai/east": "1.0.5"
+    "@elaraai/east": "1.0.7"
   },
   "devDependencies": {
     "@typescript-eslint/eslint-plugin": "^8.47.0",

package/src/api.ts

@@ -35,6 +35,7 @@ import {
 } from '@elaraai/east';
 
 import { StructureType, TreePathType } from './structure.js';
+import { RunnerType } from './runner.js';
 
 // =============================================================================
 // Error Types
@@ -723,6 +724,92 @@ export const DatasetStatusDetailType = StructType({
   size: OptionType(IntegerType),
 });
 
+// =============================================================================
+// Function / one-shot execution types
+// =============================================================================
+// Shared by the named-function path AND one-shot execution. The result of a
+// call is an in-memory, bounded value returned inline — never promoted to a
+// durable artifact.
+
+/**
+ * Execution limits for a function/one-shot call.
+ *
+ * @property timeoutMs - Wall-clock limit; over it the call is killed and returns `timed_out`
+ * @property maxResultBytes - Inline result cap; over it the call returns `too_large`
+ * @property maxLogBytes - Per-stream stdout/stderr tail cap
+ */
+export const ExecuteLimitsType = StructType({
+  timeoutMs:      OptionType(IntegerType),
+  maxResultBytes: OptionType(IntegerType),
+  maxLogBytes:    OptionType(IntegerType),
+});
+
+/**
+ * A diagnostic attached to an `invalid` call outcome.
+ */
+export const DiagnosticType = StructType({
+  message:  StringType,
+  filename: OptionType(StringType),
+  line:     OptionType(IntegerType),
+  column:   OptionType(IntegerType),
+});
+
+/**
+ * The terminal result of a function/one-shot call.
+ *
+ * - `success`: beast2-encoded result value; decode with the function's `outputType`
+ * - `failed`: process exited non-zero (see stderr)
+ * - `invalid`: signature/IR error; nothing ran
+ * - `too_large`: result over `maxResultBytes`; deploy a task and read it with `datasetGet`
+ * - `timed_out`: exceeded `timeoutMs` / the server's sync deadline guard
+ */
+export const ExecuteResultType = StructType({
+  outcome: VariantType({
+    success:   StructType({ value: BlobType }),
+    failed:    StructType({ exitCode: IntegerType }),
+    invalid:   StructType({ diagnostics: ArrayType(DiagnosticType) }),
+    too_large: StructType({ bytes: IntegerType, limit: IntegerType }),
+    timed_out: StructType({ ms: IntegerType }),
+  }),
+  stdout: StringType,
+  stderr: StringType,
+  stdoutTruncated: BooleanType,
+  stderrTruncated: BooleanType,
+});
+
+/** Named function call. Positional args, one beast2-encoded value per param. */
+export const FunctionCallRequestType = StructType({
+  args:   ArrayType(BlobType),
+  runner: OptionType(RunnerType),       // optional override; only the known runtimes
+  limits: OptionType(ExecuteLimitsType),
+});
+
+/** A function signature, returned by `describe` so dynamic callers can encode args. */
+export const FunctionSignatureType = StructType({
+  name:       StringType,
+  inputTypes: ArrayType(EastTypeType),
+  outputType: EastTypeType,
+  runner:     RunnerType,
+});
+
+/**
+ * One-shot execution request: run an anonymous function whose IR is supplied
+ * at call time, optionally bound to existing workspace datasets, returning
+ * the result inline and persisting nothing.
+ *
+ * SECURITY: one-shot evaluates a caller-supplied IR — remote code execution
+ * with the server's authority. Gate behind an elevated role.
+ */
+export const OneShotRequestType = StructType({
+  bodyIr: BlobType,                       // anonymous EastIR, not deployed
+  args:   ArrayType(VariantType({         // each arg: an inline value OR a live dataset
+    value:   BlobType,
+    dataset: TreePathType,                // workspace-scoped; resolved + pinned by content hash at launch
+  })),
+  runner: RunnerType,
+  limits: OptionType(ExecuteLimitsType),
+});
+
 // =============================================================================
 // Value type aliases
 // =============================================================================
@@ -761,3 +848,9 @@ export type ExecutionListItem = ValueTypeOf<typeof ExecutionListItemType>;
 export type TreeKind = ValueTypeOf<typeof TreeKindType>;
 export type ListEntry = ValueTypeOf<typeof ListEntryType>;
 export type DatasetStatusDetail = ValueTypeOf<typeof DatasetStatusDetailType>;
+export type ExecuteLimits = ValueTypeOf<typeof ExecuteLimitsType>;
+export type Diagnostic = ValueTypeOf<typeof DiagnosticType>;
+export type ExecuteResult = ValueTypeOf<typeof ExecuteResultType>;
+export type FunctionCallRequest = ValueTypeOf<typeof FunctionCallRequestType>;
+export type FunctionSignature = ValueTypeOf<typeof FunctionSignatureType>;
+export type OneShotRequest = ValueTypeOf<typeof OneShotRequestType>;

package/src/function.ts

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+
+/**
+ * Function object types for e3.
+ *
+ * An `e3.function` is a named, typed function stored in a package and
+ * invoked by name with argument values over the CLI and HTTP API. Unlike
+ * a task it is not wired to datasets, not part of the dataflow graph, and
+ * triggers no recomputation.
+ *
+ * The function object stores its signature explicitly so `describe` and
+ * arity/type validation work from the small function object without
+ * loading the IR bundle, and so dynamic callers (CLI literal parsing,
+ * non-TS clients) have the types they need to encode arguments.
+ */
+
+import { StructType, StringType, ArrayType, EastTypeType, ValueTypeOf } from '@elaraai/east';
+import { RunnerType } from './runner.js';
+
+/**
+ * Function object stored in the object store, referenced by name from
+ * `PackageObject.functions`.
+ */
+export const FunctionObjectType = StructType({
+  /** Hash of the encoded EastIR bundle (encodeEastIR), like a task's commandIr object. */
+  bodyIr: StringType,
+  /** Positional parameter types — the IR's signature, surfaced for arity/type
+   *  validation and `describe` without decoding the whole IR. */
+  inputTypes: ArrayType(EastTypeType),
+  /** Return type — used to decode the result `value` blob client-side. */
+  outputType: EastTypeType,
+  /** Author-chosen runtime; resolved to argv by runnerToArgv. One of the known
+   *  runtime tags — there is no raw-argv runner for functions. */
+  runner: RunnerType,
+});
+export type FunctionObjectType = typeof FunctionObjectType;
+
+export type FunctionObject = ValueTypeOf<typeof FunctionObjectType>;

package/src/index.ts

@@ -67,12 +67,26 @@ export {
   type DatasetSchema,
 } from './structure.js';
 
+// Runner wire types (functions)
+export {
+  RunnerType,
+  type RunnerValue,
+  runnerToArgv,
+} from './runner.js';
+
+// Function objects
+export {
+  FunctionObjectType,
+  type FunctionObject,
+} from './function.js';
+
 // Package objects
 export {
   PackageDataType,
   type PackageData,
   PackageObjectType,
   type PackageObject,
+  decodePackageObject,
   // Backwards compatibility
   PackageDatasetsType,
   type PackageDatasets,
@@ -203,6 +217,13 @@ export {
   ListEntryType,
   // Dataset Status Detail
   DatasetStatusDetailType,
+  // Function / one-shot execution
+  ExecuteLimitsType,
+  DiagnosticType,
+  ExecuteResultType,
+  FunctionCallRequestType,
+  FunctionSignatureType,
+  OneShotRequestType,
   // Type aliases
   type Error,
   type RepositoryStatus,
@@ -238,6 +259,12 @@ export {
   type TreeKind,
   type ListEntry,
   type DatasetStatusDetail,
+  type ExecuteLimits,
+  type Diagnostic,
+  type ExecuteResult,
+  type FunctionCallRequest,
+  type FunctionSignature,
+  type OneShotRequest,
 } from './api.js';
 
 // Dataflow execution state

package/src/package.ts

@@ -15,7 +15,7 @@
  * - **Task**: A computation with input/output paths (stored separately)
  */
 
-import { StructType, StringType, IntegerType, VariantType, NullType, DictType, ValueTypeOf } from '@elaraai/east';
+import { StructType, StringType, IntegerType, VariantType, NullType, DictType, ValueTypeOf, decodeBeast2For } from '@elaraai/east';
 import { DatasetRefType } from './dataset-ref.js';
 import { StructureType } from './structure.js';
 
@@ -77,11 +77,50 @@ export const PackageObjectType = StructType({
   tasks: DictType(StringType, StringType),
   /** Data structure and initial values */
   data: PackageDataType,
+  /** Functions defined in this package: name -> FunctionObject hash.
+   *  BEAST2 encodes struct fields positionally in declaration order, so this
+   *  field MUST stay last — never insert between `tasks` and `data`. */
+  functions: DictType(StringType, StringType),
 });
 export type PackageObjectType = typeof PackageObjectType;
 
 export type PackageObject = ValueTypeOf<typeof PackageObjectType>;
 
+/**
+ * The pre-`functions` package object wire shape, kept only so
+ * {@link decodePackageObject} can read packages exported before functions
+ * existed.
+ */
+const LegacyPackageObjectType = StructType({
+  tasks: DictType(StringType, StringType),
+  data: PackageDataType,
+});
+
+const decodeCurrent = decodeBeast2For(PackageObjectType);
+const decodeLegacy = decodeBeast2For(LegacyPackageObjectType);
+
+/**
+ * Decode a `PackageObject` from BEAST2 bytes, tolerating the pre-`functions`
+ * wire format (dual-decode migration).
+ *
+ * Every package-read path — local AND cloud — must use this instead of
+ * `decodeBeast2For(PackageObjectType)` directly, so packages exported before
+ * the `functions` field existed keep decoding. Old bytes decode with
+ * `functions` defaulted to an empty map.
+ */
+export function decodePackageObject(data: Uint8Array): PackageObject {
+  try {
+    return decodeCurrent(data);
+  } catch (err) {
+    try {
+      const legacy = decodeLegacy(data);
+      return { tasks: legacy.tasks, data: legacy.data, functions: new Map() };
+    } catch {
+      throw err; // neither shape — surface the current-format error
+    }
+  }
+}
+
 // =============================================================================
 // Package Transfer Types
 // =============================================================================