@elaraai/e3-api-client 1.0.84 → 1.0.86

package/dist/src/platform.js

@@ -4,7 +4,7 @@
  */
 import { East, StringType, IntegerType, BlobType, NullType, ArrayType, StructType, } from '@elaraai/east';
 import { EastError } from '@elaraai/east/internal';
-import { TreePathType, WorkspaceStateType, PackageObjectType } from '@elaraai/e3-types';
+import { CallArgType, TreePathType, WorkspaceStateType, PackageObjectType, dataflowForceOption } from '@elaraai/e3-types';
 import { RepositoryStatusType, GcRequestType, GcResultType, FunctionCallRequestType, ExecuteResultType, OneShotRequestType, PackageListItemType, PackageImportResultType, WorkspaceInfoType, WorkspaceStatusResultType, TaskListItemType, TaskDetailsType, DataflowRequestType, DataflowGraphType, DataflowResultType, LogChunkType, } from './types.js';
 import { repoStatus, repoGc, } from './repository.js';
 import { packageList, packageGet, packageImport, packageExport, packageRemove, } from './packages.js';
@@ -88,7 +88,9 @@ LogChunkType);
 // Function / One-shot Platform Functions
 // =============================================================================
 /** Call a named function of a workspace's deployed package, run to
- *  completion, returning the inline ExecuteResult. */
+ *  completion, returning the inline ExecuteResult. An argument is a value, or
+ *  a dataset of the workspace (`CallArg`'s `dataset`), pinned by its hash at
+ *  launch and named in the result's `inputs`. */
 export const platform_function_call = East.asyncPlatform('e3_function_call', [StringType, StringType, StringType, StringType, FunctionCallRequestType, StringType], // url, repo, workspace, fn, request, token
 ExecuteResultType);
 /** Run an anonymous one-shot IR against a workspace: a platform-free one for
@@ -96,319 +98,335 @@ ExecuteResultType);
  *  gives (see `oneShotExecute`). */
 export const platform_one_shot_execute = East.asyncPlatform('e3_one_shot_execute', [StringType, StringType, StringType, OneShotRequestType, StringType], // url, repo, workspace, request, token
 ExecuteResultType);
-// =============================================================================
-// Platform Implementation
-// =============================================================================
-const PlatformImpl = [
-    // Repository
-    platform_repo_status.implement(async (url, repo, token) => {
-        try {
-            return await repoStatus(url, repo, { token });
-        }
-        catch (err) {
-            throw new EastError(`Failed to get repository status: ${err.message}`, {
-                location: [{ filename: 'e3_repo_status', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    platform_repo_gc.implement(async (url, repo, options, token) => {
-        try {
-            return await repoGc(url, repo, options, { token });
-        }
-        catch (err) {
-            throw new EastError(`Failed to run garbage collection: ${err.message}`, {
-                location: [{ filename: 'e3_repo_gc', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    // Packages
-    platform_package_list.implement(async (url, repo, token) => {
-        try {
-            return await packageList(url, repo, { token });
-        }
-        catch (err) {
-            throw new EastError(`Failed to list packages: ${err.message}`, {
-                location: [{ filename: 'e3_package_list', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    platform_package_get.implement(async (url, repo, name, version, token) => {
-        try {
-            return await packageGet(url, repo, name, version, { token });
-        }
-        catch (err) {
-            throw new EastError(`Failed to get package ${name}@${version}: ${err.message}`, {
-                location: [{ filename: 'e3_package_get', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    platform_package_import.implement(async (url, repo, archive, token) => {
-        try {
-            return await packageImport(url, repo, archive, { token });
-        }
-        catch (err) {
-            throw new EastError(`Failed to import package: ${err.message}`, {
-                location: [{ filename: 'e3_package_import', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    platform_package_export.implement(async (url, repo, name, version, token) => {
-        try {
-            return await packageExport(url, repo, name, version, { token });
-        }
-        catch (err) {
-            throw new EastError(`Failed to export package ${name}@${version}: ${err.message}`, {
-                location: [{ filename: 'e3_package_export', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    platform_package_remove.implement(async (url, repo, name, version, token) => {
-        try {
-            await packageRemove(url, repo, name, version, { token });
-            return null;
-        }
-        catch (err) {
-            throw new EastError(`Failed to remove package ${name}@${version}: ${err.message}`, {
-                location: [{ filename: 'e3_package_remove', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    // Workspaces
-    platform_workspace_list.implement(async (url, repo, token) => {
-        try {
-            return await workspaceList(url, repo, { token });
-        }
-        catch (err) {
-            throw new EastError(`Failed to list workspaces: ${err.message}`, {
-                location: [{ filename: 'e3_workspace_list', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    platform_workspace_create.implement(async (url, repo, name, token) => {
-        try {
-            return await workspaceCreate(url, repo, name, { token });
-        }
-        catch (err) {
-            throw new EastError(`Failed to create workspace ${name}: ${err.message}`, {
-                location: [{ filename: 'e3_workspace_create', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    platform_workspace_get.implement(async (url, repo, name, token) => {
-        try {
-            return await workspaceGet(url, repo, name, { token });
-        }
-        catch (err) {
-            throw new EastError(`Failed to get workspace ${name}: ${err.message}`, {
-                location: [{ filename: 'e3_workspace_get', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    platform_workspace_status.implement(async (url, repo, name, token) => {
-        try {
-            return await workspaceStatus(url, repo, name, { token });
-        }
-        catch (err) {
-            throw new EastError(`Failed to get workspace status ${name}: ${err.message}`, {
-                location: [{ filename: 'e3_workspace_status', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    platform_workspace_remove.implement(async (url, repo, name, token) => {
-        try {
-            await workspaceRemove(url, repo, name, { token });
-            return null;
-        }
-        catch (err) {
-            throw new EastError(`Failed to remove workspace ${name}: ${err.message}`, {
-                location: [{ filename: 'e3_workspace_remove', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    platform_workspace_deploy.implement(async (url, repo, name, packageRef, token) => {
-        try {
-            await workspaceDeploy(url, repo, name, packageRef, { token });
-            return null;
-        }
-        catch (err) {
-            throw new EastError(`Failed to deploy ${packageRef} to workspace ${name}: ${err.message}`, {
-                location: [{ filename: 'e3_workspace_deploy', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    platform_workspace_export.implement(async (url, repo, name, token) => {
-        try {
-            return await workspaceExport(url, repo, name, { token });
-        }
-        catch (err) {
-            throw new EastError(`Failed to export workspace ${name}: ${err.message}`, {
-                location: [{ filename: 'e3_workspace_export', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    // Datasets
-    platform_dataset_list.implement(async (url, repo, workspace, token) => {
-        try {
-            return await datasetList(url, repo, workspace, { token });
-        }
-        catch (err) {
-            throw new EastError(`Failed to list datasets in ${workspace}: ${err.message}`, {
-                location: [{ filename: 'e3_dataset_list', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    platform_dataset_list_at.implement(async (url, repo, workspace, path, token) => {
-        try {
-            return await datasetListAt(url, repo, workspace, path, { token });
-        }
-        catch (err) {
-            throw new EastError(`Failed to list datasets at path in ${workspace}: ${err.message}`, {
-                location: [{ filename: 'e3_dataset_list_at', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    platform_dataset_get.implement(async (url, repo, workspace, path, token) => {
-        try {
-            return (await datasetGet(url, repo, workspace, path, { token })).data;
-        }
-        catch (err) {
-            throw new EastError(`Failed to get dataset in ${workspace}: ${err.message}`, {
-                location: [{ filename: 'e3_dataset_get', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    platform_dataset_set.implement(async (url, repo, workspace, path, data, token) => {
-        try {
-            await datasetSet(url, repo, workspace, path, data, { token });
-            return null;
-        }
-        catch (err) {
-            throw new EastError(`Failed to set dataset in ${workspace}: ${err.message}`, {
-                location: [{ filename: 'e3_dataset_set', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    // Tasks
-    platform_task_list.implement(async (url, repo, workspace, token) => {
-        try {
-            return await taskList(url, repo, workspace, { token });
-        }
-        catch (err) {
-            throw new EastError(`Failed to list tasks in ${workspace}: ${err.message}`, {
-                location: [{ filename: 'e3_task_list', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    platform_task_get.implement(async (url, repo, workspace, name, token) => {
-        try {
-            return await taskGet(url, repo, workspace, name, { token });
-        }
-        catch (err) {
-            throw new EastError(`Failed to get task ${name} in ${workspace}: ${err.message}`, {
-                location: [{ filename: 'e3_task_get', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    // Executions
-    platform_dataflow_start.implement(async (url, repo, workspace, options, token) => {
-        try {
-            await dataflowExecuteLaunch(url, repo, workspace, {
-                force: options.force,
-                filter: options.filter.value ?? undefined,
-            }, { token });
-            return null;
-        }
-        catch (err) {
-            throw new EastError(`Failed to start dataflow in ${workspace}: ${err.message}`, {
-                location: [{ filename: 'e3_dataflow_start', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    platform_dataflow_execute.implement(async (url, repo, workspace, options, token) => {
-        try {
-            return await dataflowExecute(url, repo, workspace, {
-                force: options.force,
-                filter: options.filter.value ?? undefined,
-            }, { token });
-        }
-        catch (err) {
-            throw new EastError(`Failed to execute dataflow in ${workspace}: ${err.message}`, {
-                location: [{ filename: 'e3_dataflow_execute', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    platform_dataflow_graph.implement(async (url, repo, workspace, token) => {
-        try {
-            return await dataflowGraph(url, repo, workspace, { token });
-        }
-        catch (err) {
-            throw new EastError(`Failed to get dataflow graph for ${workspace}: ${err.message}`, {
-                location: [{ filename: 'e3_dataflow_graph', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    platform_task_logs.implement(async (url, repo, workspace, task, options, token) => {
-        try {
-            return await taskLogs(url, repo, workspace, task, {
-                stream: options.stream,
-                offset: Number(options.offset),
-                limit: Number(options.limit),
-            }, { token });
-        }
-        catch (err) {
-            throw new EastError(`Failed to get logs for task ${task} in ${workspace}: ${err.message}`, {
-                location: [{ filename: 'e3_task_logs', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    // Functions / one-shot
-    platform_function_call.implement(async (url, repo, workspace, fn, request, token) => {
-        try {
-            return await workspaceFunctionCall(url, repo, workspace, fn, request, { token });
-        }
-        catch (err) {
-            throw new EastError(`Failed to call function ${fn} in ${workspace}: ${err.message}`, {
-                location: [{ filename: 'e3_function_call', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-    platform_one_shot_execute.implement(async (url, repo, workspace, request, token) => {
-        try {
-            return await oneShotExecute(url, repo, workspace, request, { token });
-        }
-        catch (err) {
-            throw new EastError(`Failed to execute one-shot in ${workspace}: ${err.message}`, {
-                location: [{ filename: 'e3_one_shot_execute', line: 0n, column: 0n }],
-                cause: err,
-            });
-        }
-    }),
-];
+/**
+ * The implementations of e3's platform functions, over a given `fetch`.
+ *
+ * @remarks
+ * `Platform.Implementation` is this over the global `fetch`. A host that
+ * answers e3's API itself — e3 running in a page — gives its own, so an East
+ * program that calls these functions reaches that e3.
+ *
+ * @param options - The `fetch` the functions' requests go through
+ * @returns The platform functions, to compile an East program with
+ */
+export function platformImplementation(options = {}) {
+    const { fetch } = options;
+    const requestOptions = (token) => (fetch === undefined ? { token } : { token, fetch });
+    return [
+        // Repository
+        platform_repo_status.implement(async (url, repo, token) => {
+            try {
+                return await repoStatus(url, repo, requestOptions(token));
+            }
+            catch (err) {
+                throw new EastError(`Failed to get repository status: ${err.message}`, {
+                    location: [{ filename: 'e3_repo_status', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        platform_repo_gc.implement(async (url, repo, options, token) => {
+            try {
+                return await repoGc(url, repo, options, requestOptions(token));
+            }
+            catch (err) {
+                throw new EastError(`Failed to run garbage collection: ${err.message}`, {
+                    location: [{ filename: 'e3_repo_gc', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        // Packages
+        platform_package_list.implement(async (url, repo, token) => {
+            try {
+                return await packageList(url, repo, requestOptions(token));
+            }
+            catch (err) {
+                throw new EastError(`Failed to list packages: ${err.message}`, {
+                    location: [{ filename: 'e3_package_list', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        platform_package_get.implement(async (url, repo, name, version, token) => {
+            try {
+                return await packageGet(url, repo, name, version, requestOptions(token));
+            }
+            catch (err) {
+                throw new EastError(`Failed to get package ${name}@${version}: ${err.message}`, {
+                    location: [{ filename: 'e3_package_get', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        platform_package_import.implement(async (url, repo, archive, token) => {
+            try {
+                return await packageImport(url, repo, archive, requestOptions(token));
+            }
+            catch (err) {
+                throw new EastError(`Failed to import package: ${err.message}`, {
+                    location: [{ filename: 'e3_package_import', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        platform_package_export.implement(async (url, repo, name, version, token) => {
+            try {
+                return await packageExport(url, repo, name, version, requestOptions(token));
+            }
+            catch (err) {
+                throw new EastError(`Failed to export package ${name}@${version}: ${err.message}`, {
+                    location: [{ filename: 'e3_package_export', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        platform_package_remove.implement(async (url, repo, name, version, token) => {
+            try {
+                await packageRemove(url, repo, name, version, requestOptions(token));
+                return null;
+            }
+            catch (err) {
+                throw new EastError(`Failed to remove package ${name}@${version}: ${err.message}`, {
+                    location: [{ filename: 'e3_package_remove', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        // Workspaces
+        platform_workspace_list.implement(async (url, repo, token) => {
+            try {
+                return await workspaceList(url, repo, requestOptions(token));
+            }
+            catch (err) {
+                throw new EastError(`Failed to list workspaces: ${err.message}`, {
+                    location: [{ filename: 'e3_workspace_list', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        platform_workspace_create.implement(async (url, repo, name, token) => {
+            try {
+                return await workspaceCreate(url, repo, name, requestOptions(token));
+            }
+            catch (err) {
+                throw new EastError(`Failed to create workspace ${name}: ${err.message}`, {
+                    location: [{ filename: 'e3_workspace_create', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        platform_workspace_get.implement(async (url, repo, name, token) => {
+            try {
+                return await workspaceGet(url, repo, name, requestOptions(token));
+            }
+            catch (err) {
+                throw new EastError(`Failed to get workspace ${name}: ${err.message}`, {
+                    location: [{ filename: 'e3_workspace_get', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        platform_workspace_status.implement(async (url, repo, name, token) => {
+            try {
+                return await workspaceStatus(url, repo, name, requestOptions(token));
+            }
+            catch (err) {
+                throw new EastError(`Failed to get workspace status ${name}: ${err.message}`, {
+                    location: [{ filename: 'e3_workspace_status', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        platform_workspace_remove.implement(async (url, repo, name, token) => {
+            try {
+                await workspaceRemove(url, repo, name, requestOptions(token));
+                return null;
+            }
+            catch (err) {
+                throw new EastError(`Failed to remove workspace ${name}: ${err.message}`, {
+                    location: [{ filename: 'e3_workspace_remove', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        platform_workspace_deploy.implement(async (url, repo, name, packageRef, token) => {
+            try {
+                await workspaceDeploy(url, repo, name, packageRef, requestOptions(token));
+                return null;
+            }
+            catch (err) {
+                throw new EastError(`Failed to deploy ${packageRef} to workspace ${name}: ${err.message}`, {
+                    location: [{ filename: 'e3_workspace_deploy', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        platform_workspace_export.implement(async (url, repo, name, token) => {
+            try {
+                return await workspaceExport(url, repo, name, requestOptions(token));
+            }
+            catch (err) {
+                throw new EastError(`Failed to export workspace ${name}: ${err.message}`, {
+                    location: [{ filename: 'e3_workspace_export', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        // Datasets
+        platform_dataset_list.implement(async (url, repo, workspace, token) => {
+            try {
+                return await datasetList(url, repo, workspace, requestOptions(token));
+            }
+            catch (err) {
+                throw new EastError(`Failed to list datasets in ${workspace}: ${err.message}`, {
+                    location: [{ filename: 'e3_dataset_list', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        platform_dataset_list_at.implement(async (url, repo, workspace, path, token) => {
+            try {
+                return await datasetListAt(url, repo, workspace, path, requestOptions(token));
+            }
+            catch (err) {
+                throw new EastError(`Failed to list datasets at path in ${workspace}: ${err.message}`, {
+                    location: [{ filename: 'e3_dataset_list_at', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        platform_dataset_get.implement(async (url, repo, workspace, path, token) => {
+            try {
+                return (await datasetGet(url, repo, workspace, path, requestOptions(token))).data;
+            }
+            catch (err) {
+                throw new EastError(`Failed to get dataset in ${workspace}: ${err.message}`, {
+                    location: [{ filename: 'e3_dataset_get', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        platform_dataset_set.implement(async (url, repo, workspace, path, data, token) => {
+            try {
+                await datasetSet(url, repo, workspace, path, data, requestOptions(token));
+                return null;
+            }
+            catch (err) {
+                throw new EastError(`Failed to set dataset in ${workspace}: ${err.message}`, {
+                    location: [{ filename: 'e3_dataset_set', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        // Tasks
+        platform_task_list.implement(async (url, repo, workspace, token) => {
+            try {
+                return await taskList(url, repo, workspace, requestOptions(token));
+            }
+            catch (err) {
+                throw new EastError(`Failed to list tasks in ${workspace}: ${err.message}`, {
+                    location: [{ filename: 'e3_task_list', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        platform_task_get.implement(async (url, repo, workspace, name, token) => {
+            try {
+                return await taskGet(url, repo, workspace, name, requestOptions(token));
+            }
+            catch (err) {
+                throw new EastError(`Failed to get task ${name} in ${workspace}: ${err.message}`, {
+                    location: [{ filename: 'e3_task_get', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        // Executions
+        platform_dataflow_start.implement(async (url, repo, workspace, options, token) => {
+            try {
+                await dataflowExecuteLaunch(url, repo, workspace, {
+                    force: dataflowForceOption(options.force),
+                    filter: options.filter.value ?? undefined,
+                }, requestOptions(token));
+                return null;
+            }
+            catch (err) {
+                throw new EastError(`Failed to start dataflow in ${workspace}: ${err.message}`, {
+                    location: [{ filename: 'e3_dataflow_start', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        platform_dataflow_execute.implement(async (url, repo, workspace, options, token) => {
+            try {
+                return await dataflowExecute(url, repo, workspace, {
+                    force: dataflowForceOption(options.force),
+                    filter: options.filter.value ?? undefined,
+                }, requestOptions(token));
+            }
+            catch (err) {
+                throw new EastError(`Failed to execute dataflow in ${workspace}: ${err.message}`, {
+                    location: [{ filename: 'e3_dataflow_execute', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        platform_dataflow_graph.implement(async (url, repo, workspace, token) => {
+            try {
+                return await dataflowGraph(url, repo, workspace, requestOptions(token));
+            }
+            catch (err) {
+                throw new EastError(`Failed to get dataflow graph for ${workspace}: ${err.message}`, {
+                    location: [{ filename: 'e3_dataflow_graph', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        platform_task_logs.implement(async (url, repo, workspace, task, options, token) => {
+            try {
+                // A log chunk, as the platform function has always answered it: the
+                // execution the route names is the route's own
+                const { data, offset, size, totalSize, complete } = await taskLogs(url, repo, workspace, task, {
+                    stream: options.stream,
+                    offset: Number(options.offset),
+                    limit: Number(options.limit),
+                }, requestOptions(token));
+                return { data, offset, size, totalSize, complete };
+            }
+            catch (err) {
+                throw new EastError(`Failed to get logs for task ${task} in ${workspace}: ${err.message}`, {
+                    location: [{ filename: 'e3_task_logs', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        // Functions / one-shot
+        platform_function_call.implement(async (url, repo, workspace, fn, request, token) => {
+            try {
+                return await workspaceFunctionCall(url, repo, workspace, fn, request, requestOptions(token));
+            }
+            catch (err) {
+                throw new EastError(`Failed to call function ${fn} in ${workspace}: ${err.message}`, {
+                    location: [{ filename: 'e3_function_call', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+        platform_one_shot_execute.implement(async (url, repo, workspace, request, token) => {
+            try {
+                return await oneShotExecute(url, repo, workspace, request, requestOptions(token));
+            }
+            catch (err) {
+                throw new EastError(`Failed to execute one-shot in ${workspace}: ${err.message}`, {
+                    location: [{ filename: 'e3_one_shot_execute', line: 0n, column: 0n }],
+                    cause: err,
+                });
+            }
+        }),
+    ];
+}
+const PlatformImpl = platformImplementation();
 // =============================================================================
 // Grouped Export
 // =============================================================================
@@ -447,6 +465,7 @@ export const Platform = {
     functionCall: platform_function_call,
     oneShotExecute: platform_one_shot_execute,
     Implementation: PlatformImpl,
+    implementation: platformImplementation,
     Types: {
         RepositoryStatus: RepositoryStatusType,
         GcRequest: GcRequestType,
@@ -462,6 +481,7 @@ export const Platform = {
         DataflowResult: DataflowResultType,
         LogChunk: LogChunkType,
         LogOptions: LogOptionsType,
+        CallArg: CallArgType,
         FunctionCallRequest: FunctionCallRequestType,
         ExecuteResult: ExecuteResultType,
         OneShotRequest: OneShotRequestType,