deepline 0.1.59 → 0.1.60

package/dist/cli/index.js

@@ -220,10 +220,10 @@ function resolveConfig(options) {
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.59",
+  version: "0.1.60",
   apiContract: "2026-05-play-bootstrap-dataset-summary",
   supportPolicy: {
-    latest: "0.1.59",
+    latest: "0.1.60",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }

package/dist/cli/index.mjs

@@ -197,10 +197,10 @@ function resolveConfig(options) {
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.59",
+  version: "0.1.60",
   apiContract: "2026-05-play-bootstrap-dataset-summary",
   supportPolicy: {
-    latest: "0.1.59",
+    latest: "0.1.60",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }

package/dist/index.d.mts

@@ -1803,6 +1803,10 @@ type PlayDatasetWorkProgressSummary = {
     };
 };
 type PlayDatasetInput<T> = ReadonlyArray<T> | Iterable<T> | AsyncIterable<T> | PlayDataset<T>;
+type PlayDatasetTransformOptions = {
+    key?: string;
+    sourceLabel?: string | null;
+};
 /**
  * Durable handle for rows produced by `ctx.csv(...)` or `ctx.map(...).run()`.
  *
@@ -1832,6 +1836,10 @@ interface PlayDataset<T> extends AsyncIterable<T> {
     count(): Promise<number>;
     /** Preview rows. */
     peek(limit?: number): Promise<T[]>;
+    map<U>(mapper: (row: T, index: number) => U | Promise<U>, options?: PlayDatasetTransformOptions): PlayDataset<U>;
+    filter(predicate: (row: T, index: number) => boolean | Promise<boolean>, options?: PlayDatasetTransformOptions): PlayDataset<T>;
+    slice(start?: number, end?: number, options?: PlayDatasetTransformOptions): PlayDataset<T>;
+    take(limit: number, options?: PlayDatasetTransformOptions): PlayDataset<T>;
     /**
      * Explicit escape hatch for bounded result sets.
      * Large datasets should flow by handle through Neon-backed storage, not

package/dist/index.d.ts

@@ -1803,6 +1803,10 @@ type PlayDatasetWorkProgressSummary = {
     };
 };
 type PlayDatasetInput<T> = ReadonlyArray<T> | Iterable<T> | AsyncIterable<T> | PlayDataset<T>;
+type PlayDatasetTransformOptions = {
+    key?: string;
+    sourceLabel?: string | null;
+};
 /**
  * Durable handle for rows produced by `ctx.csv(...)` or `ctx.map(...).run()`.
  *
@@ -1832,6 +1836,10 @@ interface PlayDataset<T> extends AsyncIterable<T> {
     count(): Promise<number>;
     /** Preview rows. */
     peek(limit?: number): Promise<T[]>;
+    map<U>(mapper: (row: T, index: number) => U | Promise<U>, options?: PlayDatasetTransformOptions): PlayDataset<U>;
+    filter(predicate: (row: T, index: number) => boolean | Promise<boolean>, options?: PlayDatasetTransformOptions): PlayDataset<T>;
+    slice(start?: number, end?: number, options?: PlayDatasetTransformOptions): PlayDataset<T>;
+    take(limit: number, options?: PlayDatasetTransformOptions): PlayDataset<T>;
     /**
      * Explicit escape hatch for bounded result sets.
      * Large datasets should flow by handle through Neon-backed storage, not

package/dist/index.js

@@ -232,10 +232,10 @@ function resolveConfig(options) {
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.59",
+  version: "0.1.60",
   apiContract: "2026-05-play-bootstrap-dataset-summary",
   supportPolicy: {
-    latest: "0.1.59",
+    latest: "0.1.60",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }

package/dist/index.mjs

@@ -170,10 +170,10 @@ function resolveConfig(options) {
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.59",
+  version: "0.1.60",
   apiContract: "2026-05-play-bootstrap-dataset-summary",
   supportPolicy: {
-    latest: "0.1.59",
+    latest: "0.1.60",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }

package/dist/repo/sdk/src/release.ts

@@ -50,10 +50,10 @@ export type SdkRelease = {
 };
 
 export const SDK_RELEASE = {
-  version: '0.1.59',
+  version: '0.1.60',
   apiContract: '2026-05-play-bootstrap-dataset-summary',
   supportPolicy: {
-    latest: '0.1.59',
+    latest: '0.1.60',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
   },

package/dist/repo/shared_libs/plays/dataset.ts

@@ -55,6 +55,11 @@ export type PlayDatasetInput<T> =
   | AsyncIterable<T>
   | PlayDataset<T>;
 
+export type PlayDatasetTransformOptions = {
+  key?: string;
+  sourceLabel?: string | null;
+};
+
 /**
  * Durable handle for rows produced by `ctx.csv(...)` or `ctx.map(...).run()`.
  *
@@ -84,6 +89,20 @@ export interface PlayDataset<T> extends AsyncIterable<T> {
   count(): Promise<number>;
   /** Preview rows. */
   peek(limit?: number): Promise<T[]>;
+  map<U>(
+    mapper: (row: T, index: number) => U | Promise<U>,
+    options?: PlayDatasetTransformOptions,
+  ): PlayDataset<U>;
+  filter(
+    predicate: (row: T, index: number) => boolean | Promise<boolean>,
+    options?: PlayDatasetTransformOptions,
+  ): PlayDataset<T>;
+  slice(
+    start?: number,
+    end?: number,
+    options?: PlayDatasetTransformOptions,
+  ): PlayDataset<T>;
+  take(limit: number, options?: PlayDatasetTransformOptions): PlayDataset<T>;
   /**
    * Explicit escape hatch for bounded result sets.
    * Large datasets should flow by handle through Neon-backed storage, not
@@ -113,6 +132,21 @@ type PlayDatasetResolvers<T> = {
   iterate: () => AsyncIterable<T>;
 };
 
+type PlayDatasetTransform<T, U = T> =
+  | {
+      kind: 'map';
+      mapper: (row: T, index: number) => U | Promise<U>;
+    }
+  | {
+      kind: 'filter';
+      predicate: (row: T, index: number) => boolean | Promise<boolean>;
+    }
+  | {
+      kind: 'slice';
+      start?: number;
+      end?: number;
+    };
+
 function resolveMaterializeLimitCap(): number {
   const raw = process.env.DEEPLINE_PLAY_DATASET_MATERIALIZE_LIMIT;
   const parsed = raw ? Number(raw) : NaN;
@@ -216,6 +250,40 @@ class DeferredPlayDataset<T> implements PlayDataset<T> {
     return await this.resolvers.peek(limit);
   }
 
+  map<U>(
+    mapper: (row: T, index: number) => U | Promise<U>,
+    options?: PlayDatasetTransformOptions,
+  ): PlayDataset<U> {
+    return createTransformedPlayDataset(this, { kind: 'map', mapper }, options);
+  }
+
+  filter(
+    predicate: (row: T, index: number) => boolean | Promise<boolean>,
+    options?: PlayDatasetTransformOptions,
+  ): PlayDataset<T> {
+    return createTransformedPlayDataset(
+      this,
+      { kind: 'filter', predicate },
+      options,
+    );
+  }
+
+  slice(
+    start?: number,
+    end?: number,
+    options?: PlayDatasetTransformOptions,
+  ): PlayDataset<T> {
+    return createTransformedPlayDataset(
+      this,
+      { kind: 'slice', start, end },
+      options,
+    );
+  }
+
+  take(limit: number, options?: PlayDatasetTransformOptions): PlayDataset<T> {
+    return this.slice(0, limit, options);
+  }
+
   async materialize(limit?: number): Promise<T[]> {
     const requestedLimit =
       limit !== undefined ? Math.max(0, Math.floor(limit)) : undefined;
@@ -268,6 +336,136 @@ class DeferredPlayDataset<T> implements PlayDataset<T> {
   }
 }
 
+function normalizeSliceBounds(input: {
+  start?: number;
+  end?: number;
+  count: number;
+}): { start: number; end: number } {
+  const count = Math.max(0, Math.floor(input.count));
+  const rawStart = input.start ?? 0;
+  const rawEnd = input.end ?? count;
+  const startInteger = Number.isFinite(rawStart) ? Math.trunc(rawStart) : 0;
+  const endInteger = Number.isFinite(rawEnd) ? Math.trunc(rawEnd) : count;
+  const start =
+    startInteger < 0
+      ? Math.max(count + startInteger, 0)
+      : Math.min(startInteger, count);
+  const end =
+    endInteger < 0
+      ? Math.max(count + endInteger, 0)
+      : Math.min(endInteger, count);
+  return { start, end: Math.max(start, end) };
+}
+
+function transformDatasetId(input: {
+  source: PlayDataset<unknown>;
+  kind: string;
+  key?: string;
+}): string {
+  const key = input.key?.trim();
+  return key
+    ? `${input.source.datasetId}:${input.kind}:${key}`
+    : `${input.source.datasetId}:${input.kind}`;
+}
+
+function createTransformedPlayDataset<T, U>(
+  source: PlayDataset<T>,
+  transform: PlayDatasetTransform<T, U>,
+  options?: PlayDatasetTransformOptions,
+): PlayDataset<U> {
+  const sourceLabel =
+    options?.sourceLabel ??
+    `${source.sourceLabel ?? source.tableNamespace ?? source.datasetId}.${transform.kind}`;
+
+  const iterate = async function* (): AsyncIterable<U> {
+    if (transform.kind === 'slice') {
+      const bounds = normalizeSliceBounds({
+        start: transform.start,
+        end: transform.end,
+        count: await source.count(),
+      });
+      let index = 0;
+      for await (const row of source) {
+        if (index >= bounds.end) break;
+        if (index >= bounds.start) {
+          yield row as unknown as U;
+        }
+        index += 1;
+      }
+      return;
+    }
+
+    let inputIndex = 0;
+    let outputIndex = 0;
+    for await (const row of source) {
+      if (transform.kind === 'filter') {
+        if (await transform.predicate(row, inputIndex)) {
+          yield row as unknown as U;
+          outputIndex += 1;
+        }
+      } else {
+        yield await transform.mapper(row, outputIndex);
+        outputIndex += 1;
+      }
+      inputIndex += 1;
+    }
+  };
+
+  const collect = async (limit?: number): Promise<U[]> => {
+    const rows: U[] = [];
+    const boundedLimit =
+      limit === undefined ? undefined : Math.max(0, Math.floor(limit));
+    if (boundedLimit === 0) return rows;
+    for await (const row of iterate()) {
+      rows.push(row);
+      if (boundedLimit !== undefined && rows.length >= boundedLimit) break;
+    }
+    return rows;
+  };
+
+  const count = async (): Promise<number> => {
+    if (transform.kind === 'map') return await source.count();
+    if (transform.kind === 'slice') {
+      const bounds = normalizeSliceBounds({
+        start: transform.start,
+        end: transform.end,
+        count: await source.count(),
+      });
+      return Math.max(0, bounds.end - bounds.start);
+    }
+    let total = 0;
+    for await (const _row of iterate()) {
+      void _row;
+      total += 1;
+    }
+    return total;
+  };
+
+  return createDeferredPlayDataset({
+    datasetKind: source.datasetKind,
+    datasetId: transformDatasetId({
+      source: source as PlayDataset<unknown>,
+      kind: transform.kind,
+      key: options?.key,
+    }),
+    count: 0,
+    backing: source.backing,
+    sourceLabel,
+    tableNamespace: options?.key ?? null,
+    resolvers: {
+      count,
+      peek: async (limit) => collect(limit),
+      materialize: async (limit) => collect(limit),
+      iterate: () =>
+        ({
+          async *[Symbol.asyncIterator]() {
+            yield* iterate();
+          },
+        }) as AsyncIterable<U>,
+    },
+  });
+}
+
 export function createDeferredPlayDataset<T>(input: {
   datasetKind: PlayDatasetKind;
   datasetId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.1.59",
+  "version": "0.1.60",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {