@ekairos/dataset 1.22.82-beta.development.0 → 1.22.84-beta.development.0

package/dist/builder/types.d.ts

@@ -1,38 +1,44 @@
 import type { InstaQLParams, ValidQuery } from "@instantdb/core";
 import type { DomainInstantSchema, DomainSchemaResult } from "@ekairos/domain";
 import type { EkairosRuntime, RuntimeForDomain } from "@ekairos/domain/runtime";
-import type { ContextReactor } from "@ekairos/events";
+import type { ContextIdentifier, ContextReactor } from "@ekairos/events";
 import { datasetDomain } from "../schema.js";
-export type DatasetQuerySourceInput<D extends DomainSchemaResult = DomainSchemaResult> = {
+export type DatasetQueryResourceInput<D extends DomainSchemaResult = DomainSchemaResult> = {
     query: InstaQLParams<DomainInstantSchema<D>>;
     title?: string;
     explanation?: string;
     domain: D;
 };
-export type DatasetFileSourceInput = {
+export type DatasetFileResourceInput = {
     fileId: string;
     description?: string;
+    filename?: string;
+    mediaType?: string;
 };
-export type DatasetTextSourceInput = {
+export type DatasetTextResourceInput = {
     text: string;
     mimeType?: string;
     name?: string;
     description?: string;
 };
-export type DatasetExistingSourceInput = {
+export type DatasetExistingResourceInput = {
     datasetId: string;
     description?: string;
 };
-export type DatasetFileSource = {
+export type DatasetContextResourceInput = ContextIdentifier;
+export type DatasetFileResource = {
     kind: "file";
-} & DatasetFileSourceInput;
-export type DatasetTextSource = {
+} & DatasetFileResourceInput;
+export type DatasetTextResource = {
     kind: "text";
-} & DatasetTextSourceInput;
-export type DatasetExistingSource = {
+} & DatasetTextResourceInput;
+export type DatasetExistingResource = {
     kind: "dataset";
-} & DatasetExistingSourceInput;
-export type DatasetSourceInput = DatasetFileSourceInput | DatasetTextSourceInput | DatasetExistingSourceInput | DatasetFileSource | DatasetTextSource | DatasetExistingSource;
+} & DatasetExistingResourceInput;
+export type DatasetContextResource = {
+    kind: "context";
+} & DatasetContextResourceInput;
+export type DatasetResourceInput = DatasetFileResourceInput | DatasetTextResourceInput | DatasetExistingResourceInput | DatasetContextResourceInput | DatasetFileResource | DatasetTextResource | DatasetExistingResource | DatasetContextResource;
 export type DatasetSchemaInput = {
     title?: string;
     description?: string;
@@ -48,9 +54,9 @@ export type DatasetBuildOptions = {
     datasetId?: string;
     durable?: boolean;
 };
-export type InternalSource = DatasetFileSource | DatasetTextSource | DatasetExistingSource | ({
+export type InternalDatasetResource = DatasetFileResource | DatasetTextResource | DatasetExistingResource | DatasetContextResource | ({
     kind: "query";
-} & DatasetQuerySourceInput);
+} & DatasetQueryResourceInput);
 export type DatasetReaderResult = {
     rows: any[];
     cursor: number;
@@ -76,8 +82,8 @@ export type DatasetRuntimeEnv = {
 };
 export type AnyDatasetRuntime = EkairosRuntime<any, any, any>;
 export type DatasetRuntimeHandle<Runtime extends AnyDatasetRuntime> = RuntimeForDomain<Runtime, typeof datasetDomain>;
-export type CompatibleSourceDomain<Runtime extends AnyDatasetRuntime, D extends DomainSchemaResult> = RuntimeForDomain<Runtime, D> extends never ? never : D;
-export type DatasetQuerySourceOptions<D extends DomainSchemaResult, Q extends ValidQuery<Q, DomainInstantSchema<D>>> = {
+export type CompatibleQueryDomain<Runtime extends AnyDatasetRuntime, D extends DomainSchemaResult> = RuntimeForDomain<Runtime, D> extends never ? never : D;
+export type DatasetQueryResourceOptions<D extends DomainSchemaResult, Q extends ValidQuery<Q, DomainInstantSchema<D>>> = {
     query: Q;
     title?: string;
     explanation?: string;
@@ -85,9 +91,10 @@ export type DatasetQuerySourceOptions<D extends DomainSchemaResult, Q extends Va
 export type DatasetBuilderState<Runtime extends AnyDatasetRuntime> = {
     runtime: Runtime;
     env: Runtime["env"] & DatasetRuntimeEnv;
-    sources: InternalSource[];
+    resources: InternalDatasetResource[];
     title?: string;
     sandboxId?: string;
+    contextId?: string;
     outputSchema?: DatasetSchemaInput;
     output: DatasetOutput;
     inferSchema: boolean;
@@ -101,8 +108,7 @@ export type MaterializeRowsParams = {
     sandboxId?: string;
     title?: string;
     instructions?: string;
-    sources: any[];
-    sourceKinds: string[];
+    contextId: string;
     analysis?: any;
     rows: any[];
     schema?: DatasetSchemaInput;
@@ -111,11 +117,12 @@ export type MaterializeRowsParams = {
 };
 export type DatasetBuilder<Runtime extends AnyDatasetRuntime> = {
     readonly datasetId: string;
-    fromFile(source: DatasetFileSourceInput): DatasetBuilder<Runtime>;
-    fromText(source: DatasetTextSourceInput): DatasetBuilder<Runtime>;
-    fromDataset(source: DatasetExistingSourceInput): DatasetBuilder<Runtime>;
-    from(...sources: DatasetSourceInput[]): DatasetBuilder<Runtime>;
-    fromQuery<D extends DomainSchemaResult, Q extends ValidQuery<Q, DomainInstantSchema<D>>>(domain: D & CompatibleSourceDomain<Runtime, D>, source: DatasetQuerySourceOptions<D, Q>): DatasetBuilder<Runtime>;
+    fromFile(resource: DatasetFileResourceInput): DatasetBuilder<Runtime>;
+    fromText(resource: DatasetTextResourceInput): DatasetBuilder<Runtime>;
+    fromDataset(resource: DatasetExistingResourceInput): DatasetBuilder<Runtime>;
+    fromContext(context: DatasetContextResourceInput): DatasetBuilder<Runtime>;
+    from(...resources: DatasetResourceInput[]): DatasetBuilder<Runtime>;
+    fromQuery<D extends DomainSchemaResult, Q extends ValidQuery<Q, DomainInstantSchema<D>>>(domain: D & CompatibleQueryDomain<Runtime, D>, resource: DatasetQueryResourceOptions<D, Q>): DatasetBuilder<Runtime>;
     title(title: string): DatasetBuilder<Runtime>;
     sandbox(input: {
         sandboxId: string;

package/dist/completeDataset.steps.d.ts

@@ -3,8 +3,9 @@ export interface PersistDatasetStepParams {
     sandboxId: string;
     runtime: any;
     summary?: string;
+    outputPath?: string;
 }
-export declare function persistDatasetStep({ runtime, datasetId, sandboxId, summary }: PersistDatasetStepParams): Promise<{
+export declare function persistDatasetStep({ runtime, datasetId, sandboxId, summary, outputPath }: PersistDatasetStepParams): Promise<{
     success: boolean;
     validation?: RowValidationEntry[];
     validationTruncated?: number;
@@ -23,18 +24,18 @@ export declare function persistDatasetStep({ runtime, datasetId, sandboxId, summ
     validation: RowValidationEntry[] | undefined;
     error: string;
     message: string;
-    fileId?: undefined;
-    storagePath?: undefined;
+    records?: undefined;
+    summary?: undefined;
 } | {
     success: boolean;
     status: string;
-    validRows: number;
-    rowRecordCount: number;
-    fileId: string;
-    storagePath: string;
-    message: string;
+    records: number;
+    summary: string;
+    validRows?: undefined;
+    rowRecordCount?: undefined;
     validation?: undefined;
     error?: undefined;
+    message?: undefined;
 }>;
 type RowValidationEntry = {
     index: number;

package/dist/completeDataset.steps.js

@@ -13,14 +13,15 @@ function getAjv() {
     }
     return ajvInstance;
 }
-export async function persistDatasetStep({ runtime, datasetId, sandboxId, summary }) {
+export async function persistDatasetStep({ runtime, datasetId, sandboxId, summary, outputPath }) {
     "use step";
-    const outputPath = getDatasetOutputPath(datasetId);
+    const resolvedOutputPath = outputPath ?? getDatasetOutputPath(datasetId);
+    const storagePath = resolveExecutionStoragePath(resolvedOutputPath, datasetId);
     if (summary) {
         console.log(`[Dataset ${datasetId}] Persisting completed dataset: ${summary}`);
     }
     try {
-        await ensureFileExists(runtime, sandboxId, outputPath);
+        await ensureFileExists(runtime, sandboxId, resolvedOutputPath);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -85,7 +86,7 @@ export async function persistDatasetStep({ runtime, datasetId, sandboxId, summar
     const validationResult = await validateJsonlRows({
         runtime,
         sandboxId,
-        outputPath,
+        outputPath: resolvedOutputPath,
         validator,
         schema: schemaJson,
         datasetId,
@@ -96,7 +97,7 @@ export async function persistDatasetStep({ runtime, datasetId, sandboxId, summar
     const totalValidRows = validationResult.validRowCount ?? 0;
     const rowRecordCount = validationResult.rowRecordCount ?? totalValidRows;
     console.log(`[Dataset ${datasetId}] Reading file content for upload`);
-    const fileRead = await readDatasetSandboxFileStep({ runtime, sandboxId, path: outputPath });
+    const fileRead = await readDatasetSandboxFileStep({ runtime, sandboxId, path: resolvedOutputPath });
     if (!fileRead.contentBase64) {
         console.error(`[Dataset ${datasetId}] Empty file content`);
         return {
@@ -113,6 +114,7 @@ export async function persistDatasetStep({ runtime, datasetId, sandboxId, summar
     const uploadResult = await service.uploadDatasetOutputFile({
         datasetId,
         fileBuffer: Buffer.from(fileRead.contentBase64, "base64"),
+        storagePath,
     });
     if (!uploadResult.ok) {
         console.error(`[Dataset ${datasetId}] File upload failed: ${uploadResult.error}`);
@@ -150,13 +152,18 @@ export async function persistDatasetStep({ runtime, datasetId, sandboxId, summar
     return {
         success: true,
         status: "completed",
-        validRows: totalValidRows,
-        rowRecordCount,
-        fileId: uploadResult.data.fileId,
-        storagePath: uploadResult.data.storagePath,
-        message: "Dataset creation completed and uploaded to storage",
+        records: totalValidRows,
+        summary: summary ?? `Dataset completed with ${totalValidRows} records.`,
     };
 }
+function resolveExecutionStoragePath(outputPath, datasetId) {
+    const normalized = String(outputPath ?? "").replace(/\\/g, "/");
+    const marker = "/tmp/ekairos/contexts/";
+    if (normalized.startsWith(marker)) {
+        return normalized.slice("/tmp/ekairos".length);
+    }
+    return `/dataset/${datasetId}/output.jsonl`;
+}
 async function ensureFileExists(runtime, sandboxId, path) {
     const result = await runDatasetSandboxCommandStep({
         runtime,
@@ -306,7 +313,7 @@ function buildValidationFailureSummary(params) {
 }
 function buildRepairInstructions(summary) {
     const instructions = [
-        "Rewrite output.jsonl using the schema as the source of truth. Do not use source file headers as JSON keys unless they exactly match schema property names.",
+        "Rewrite output.jsonl using the schema as the authority. Do not use input file headers as JSON keys unless they exactly match schema property names.",
         "Each non-empty line must be a JSON object shaped as {\"type\":\"row\",\"data\":{...}}.",
         "Populate every required top-level and nested required path from failureSummary.requiredPaths.",
         "For enum fields, emit exactly one allowed literal from failureSummary.enumConstraints or failureSummary.enumFailures.",

package/dist/completeDataset.tool.d.ts

@@ -2,8 +2,9 @@ interface CompleteDatasetToolParams {
     datasetId: string;
     sandboxId: string;
     runtime: any;
+    outputPath?: string;
 }
-export declare function createCompleteDatasetTool({ datasetId, sandboxId, runtime }: CompleteDatasetToolParams): import("ai").Tool<{
+export declare function createCompleteDatasetTool({ datasetId, sandboxId, runtime, outputPath }: CompleteDatasetToolParams): import("ai").Tool<{
     summary: string;
 }, {
     success: boolean;
@@ -82,18 +83,18 @@ export declare function createCompleteDatasetTool({ datasetId, sandboxId, runtim
     }[] | undefined;
     error: string;
     message: string;
-    fileId?: undefined;
-    storagePath?: undefined;
+    records?: undefined;
+    summary?: undefined;
 } | {
     success: boolean;
     status: string;
-    validRows: number;
-    rowRecordCount: number;
-    fileId: string;
-    storagePath: string;
-    message: string;
+    records: number;
+    summary: string;
+    validRows?: undefined;
+    rowRecordCount?: undefined;
     validation?: undefined;
     error?: undefined;
+    message?: undefined;
 }>;
 export declare function didCompleteDatasetSucceed(event: {
     content?: {

package/dist/completeDataset.tool.js

@@ -1,7 +1,7 @@
 import { tool } from "ai";
 import { z } from "zod";
 import { persistDatasetStep } from "./completeDataset.steps.js";
-export function createCompleteDatasetTool({ datasetId, sandboxId, runtime }) {
+export function createCompleteDatasetTool({ datasetId, sandboxId, runtime, outputPath }) {
     return tool({
         description: "Mark the dataset as completed. Use only when output.jsonl has been successfully generated and is ready for validation.",
         inputSchema: z.object({
@@ -17,6 +17,7 @@ export function createCompleteDatasetTool({ datasetId, sandboxId, runtime }) {
                 datasetId,
                 sandboxId,
                 summary,
+                outputPath,
             });
         },
     });

package/dist/contextWorkspace.d.ts

@@ -0,0 +1,72 @@
+export type ContextWorkspaceFileRole = "input" | "output" | "artifact";
+export type ContextWorkspaceFileInput = {
+    fileId: string;
+    filename?: string;
+    mediaType?: string;
+    role?: ContextWorkspaceFileRole;
+    sourceEventId?: string;
+    sourcePartIndex?: number;
+};
+export type PreparedContextWorkspaceFile = {
+    fileId: string;
+    filename: string;
+    mediaType?: string;
+    role: ContextWorkspaceFileRole;
+    path: string;
+    sourceEventId?: string;
+    sourcePartIndex?: number;
+};
+export type PreparedContextExecutionWorkspace = {
+    contextId: string;
+    executionId: string;
+    sandboxId: string;
+    root: string;
+    contextRoot: string;
+    eventsDir: string;
+    outputDir: string;
+    scriptsDir: string;
+    tmpDir: string;
+    manifestPath: string;
+    files: PreparedContextWorkspaceFile[];
+};
+export declare function getContextWorkspaceBase(): string;
+export declare function getContextExecutionWorkspaceRoot(params: {
+    contextId: string;
+    executionId: string;
+    root?: string;
+}): string;
+export declare function getContextWorkspaceRoot(params: {
+    contextId: string;
+    root?: string;
+}): string;
+export declare function getContextEventsDir(params: {
+    contextId: string;
+    root?: string;
+}): string;
+export declare function getContextExecutionWorkspaceDirs(params: {
+    contextId: string;
+    executionId: string;
+    root?: string;
+}): {
+    root: string;
+    contextRoot: string;
+    eventsDir: string;
+    outputDir: string;
+    scriptsDir: string;
+    tmpDir: string;
+    manifestPath: string;
+};
+export declare function getContextExecutionWorkspaceStandardDirs(params: {
+    contextId: string;
+    executionId: string;
+    root?: string;
+}): string[];
+export declare function extractContextWorkspaceFilesFromEventItems(eventItems: unknown[]): ContextWorkspaceFileInput[];
+export declare function prepareContextExecutionWorkspaceStep(params: {
+    runtime: any;
+    sandboxId: string;
+    contextId: string;
+    executionId: string;
+    files: ContextWorkspaceFileInput[];
+    root?: string;
+}): Promise<PreparedContextExecutionWorkspace>;

package/dist/contextWorkspace.js

@@ -0,0 +1,218 @@
+import { readInstantFileStep } from "./file/steps.js";
+import { runDatasetSandboxCommandStep, writeDatasetSandboxFilesStep, writeDatasetSandboxTextFilesStep, } from "./sandbox/steps.js";
+const CONTEXT_WORKSPACE_BASE = "/tmp/ekairos/contexts";
+const WORKSPACE_MANIFEST_FILE_NAME = "manifest.json";
+function trimTrailingSlash(value) {
+    return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+function sanitizePathSegment(value, fallback) {
+    const parts = String(value ?? "")
+        .trim()
+        .replace(/\\/g, "/")
+        .split("/")
+        .filter(Boolean);
+    const normalized = parts[parts.length - 1]
+        ?.replace(/[^a-zA-Z0-9_.-]/g, "_")
+        .replace(/_+/g, "_")
+        .slice(0, 160);
+    return normalized || fallback;
+}
+function filenameFromContentDisposition(value, fallback) {
+    const raw = String(value ?? "").trim();
+    if (!raw)
+        return fallback;
+    const filenameStar = raw.match(/filename\*=UTF-8''([^;]+)/i)?.[1];
+    if (filenameStar) {
+        return sanitizePathSegment(decodeURIComponent(filenameStar), fallback);
+    }
+    const filename = raw.match(/filename="?([^";]+)"?/i)?.[1];
+    return sanitizePathSegment(filename ?? raw, fallback);
+}
+function resolveContextEventPartDir(params) {
+    const sourceEventId = sanitizePathSegment(params.sourceEventId, "event");
+    const sourcePartIndex = Number.isFinite(params.sourcePartIndex)
+        ? Math.max(0, Math.floor(params.sourcePartIndex))
+        : 0;
+    return `${params.eventsDir}/${sourceEventId}/parts/${sourcePartIndex}`;
+}
+function resolveWorkspaceFilePath(params) {
+    return `${resolveContextEventPartDir(params)}/file`;
+}
+export function getContextWorkspaceBase() {
+    return trimTrailingSlash(CONTEXT_WORKSPACE_BASE);
+}
+export function getContextExecutionWorkspaceRoot(params) {
+    if (params.root)
+        return trimTrailingSlash(params.root);
+    const contextId = sanitizePathSegment(params.contextId, "context");
+    const executionId = sanitizePathSegment(params.executionId, "execution");
+    return `${getContextWorkspaceBase()}/${contextId}/executions/${executionId}`;
+}
+export function getContextWorkspaceRoot(params) {
+    if (params.root)
+        return trimTrailingSlash(params.root);
+    const contextId = sanitizePathSegment(params.contextId, "context");
+    return `${getContextWorkspaceBase()}/${contextId}`;
+}
+export function getContextEventsDir(params) {
+    return `${getContextWorkspaceRoot(params)}/events`;
+}
+export function getContextExecutionWorkspaceDirs(params) {
+    const root = getContextExecutionWorkspaceRoot(params);
+    const contextRoot = getContextWorkspaceRoot(params);
+    const eventsDir = getContextEventsDir(params);
+    return {
+        root,
+        contextRoot,
+        eventsDir,
+        outputDir: `${root}/output`,
+        scriptsDir: `${root}/scripts`,
+        tmpDir: `${root}/tmp`,
+        manifestPath: `${root}/${WORKSPACE_MANIFEST_FILE_NAME}`,
+    };
+}
+export function getContextExecutionWorkspaceStandardDirs(params) {
+    const dirs = getContextExecutionWorkspaceDirs(params);
+    return [dirs.contextRoot, dirs.eventsDir, dirs.root, dirs.outputDir, dirs.scriptsDir, dirs.tmpDir];
+}
+export function extractContextWorkspaceFilesFromEventItems(eventItems) {
+    const files = [];
+    for (const item of eventItems) {
+        const itemRecord = asRecord(item);
+        const parts = Array.isArray(asRecord(itemRecord?.content)?.parts)
+            ? asRecord(itemRecord?.content)?.parts
+            : [];
+        parts.forEach((part, partIndex) => {
+            collectPartFiles(part, {
+                files,
+                sourceEventId: asText(itemRecord?.id),
+                sourcePartIndex: partIndex,
+            });
+        });
+    }
+    return files;
+}
+export async function prepareContextExecutionWorkspaceStep(params) {
+    "use step";
+    const dirs = getContextExecutionWorkspaceDirs(params);
+    const filePartDirs = Array.from(new Set(params.files.map((fileInput) => resolveContextEventPartDir({
+        eventsDir: dirs.eventsDir,
+        sourceEventId: fileInput.sourceEventId ?? fileInput.fileId,
+        sourcePartIndex: fileInput.sourcePartIndex ?? 0,
+    }))));
+    await runDatasetSandboxCommandStep({
+        runtime: params.runtime,
+        sandboxId: params.sandboxId,
+        cmd: "mkdir",
+        args: ["-p", ...getContextExecutionWorkspaceStandardDirs(params), ...filePartDirs],
+    });
+    const preparedFiles = [];
+    for (const fileInput of params.files) {
+        const fileId = String(fileInput.fileId ?? "").trim();
+        if (!fileId)
+            continue;
+        const file = await readInstantFileStep({ runtime: params.runtime, fileId });
+        const filename = sanitizePathSegment(fileInput.filename ??
+            filenameFromContentDisposition(file.contentDisposition, `${fileId}.bin`), `${fileId}.bin`);
+        const path = resolveWorkspaceFilePath({
+            eventsDir: dirs.eventsDir,
+            sourceEventId: fileInput.sourceEventId ?? fileId,
+            sourcePartIndex: fileInput.sourcePartIndex ?? 0,
+        });
+        const metadataPath = `${resolveContextEventPartDir({
+            eventsDir: dirs.eventsDir,
+            sourceEventId: fileInput.sourceEventId ?? fileId,
+            sourcePartIndex: fileInput.sourcePartIndex ?? 0,
+        })}/metadata.json`;
+        await writeDatasetSandboxFilesStep({
+            runtime: params.runtime,
+            sandboxId: params.sandboxId,
+            files: [{ path, contentBase64: file.contentBase64 }],
+        });
+        await writeDatasetSandboxTextFilesStep({
+            runtime: params.runtime,
+            sandboxId: params.sandboxId,
+            files: [
+                {
+                    path: metadataPath,
+                    content: JSON.stringify({
+                        fileId,
+                        filename,
+                        mediaType: fileInput.mediaType,
+                        role: fileInput.role ?? "input",
+                        sourceEventId: fileInput.sourceEventId,
+                        sourcePartIndex: fileInput.sourcePartIndex,
+                    }, null, 2),
+                },
+            ],
+        });
+        preparedFiles.push({
+            fileId,
+            filename,
+            mediaType: fileInput.mediaType,
+            role: fileInput.role ?? "input",
+            path,
+            sourceEventId: fileInput.sourceEventId,
+            sourcePartIndex: fileInput.sourcePartIndex,
+        });
+    }
+    const manifest = {
+        contextId: params.contextId,
+        executionId: params.executionId,
+        sandboxId: params.sandboxId,
+        ...dirs,
+        files: preparedFiles,
+    };
+    await writeDatasetSandboxTextFilesStep({
+        runtime: params.runtime,
+        sandboxId: params.sandboxId,
+        files: [
+            {
+                path: dirs.manifestPath,
+                content: JSON.stringify(manifest, null, 2),
+            },
+        ],
+    });
+    return manifest;
+}
+function collectPartFiles(value, params) {
+    const record = asRecord(value);
+    if (!record)
+        return;
+    if (record.type === "file") {
+        pushFileRecord(record, params);
+        return;
+    }
+    const content = asRecord(record.content);
+    if (!content)
+        return;
+    if (Array.isArray(content.blocks)) {
+        for (const block of content.blocks) {
+            const blockRecord = asRecord(block);
+            if (blockRecord?.type === "file") {
+                pushFileRecord(blockRecord, params);
+            }
+        }
+    }
+}
+function pushFileRecord(record, params) {
+    const fileId = asText(record.fileId);
+    if (!fileId)
+        return;
+    params.files.push({
+        fileId,
+        filename: asText(record.filename),
+        mediaType: asText(record.mediaType),
+        role: "input",
+        sourceEventId: params.sourceEventId,
+        sourcePartIndex: params.sourcePartIndex,
+    });
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function asText(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}

package/dist/dataset.d.ts

@@ -1,3 +1,3 @@
 import type { AnyDatasetRuntime, DatasetBuilder, DatasetBuilderOptions, DatasetRuntimeHandle } from "./builder/types.js";
-export type { AnyDatasetRuntime, CompatibleSourceDomain, DatasetBuilder, DatasetBuilderOptions, DatasetBuildOptions, DatasetBuildResult, DatasetExistingSource, DatasetExistingSourceInput, DatasetFileSource, DatasetFileSourceInput, DatasetMode, DatasetOutput, DatasetQuerySourceInput, DatasetReader, DatasetReaderResult, DatasetRuntimeEnv, DatasetRuntimeHandle, DatasetSchemaInput, DatasetTextSource, DatasetSourceInput, DatasetTextSourceInput, } from "./builder/types.js";
+export type { AnyDatasetRuntime, CompatibleQueryDomain, DatasetBuilder, DatasetBuilderOptions, DatasetBuildOptions, DatasetBuildResult, DatasetExistingResource, DatasetExistingResourceInput, DatasetFileResource, DatasetFileResourceInput, DatasetMode, DatasetOutput, DatasetQueryResourceInput, DatasetReader, DatasetReaderResult, DatasetRuntimeEnv, DatasetRuntimeHandle, DatasetSchemaInput, DatasetTextResource, DatasetResourceInput, DatasetTextResourceInput, } from "./builder/types.js";
 export declare function dataset<Runtime extends AnyDatasetRuntime>(runtime: Runtime & DatasetRuntimeHandle<Runtime>, options?: DatasetBuilderOptions): DatasetBuilder<Runtime>;