deepline 0.1.243 → 0.1.244

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/map-latency-profile.ts

@@ -1,90 +0,0 @@
-type ToolTrace = {
-  phase: string;
-  ms?: number;
-  extra?: Record<string, unknown>;
-};
-
-type Totals = Record<string, number>;
-
-function add(totals: Totals, key: string, ms: number | undefined): void {
-  if (typeof ms !== 'number' || !Number.isFinite(ms) || ms < 0) return;
-  totals[key] = (totals[key] ?? 0) + ms;
-}
-
-/**
- * Opt-in map profiler. It aggregates in memory and produces one terminal
- * trace, so normal runs do not pay per-row/per-tool telemetry cost.
- */
-export class MapLatencyProfile {
-  private readonly phaseWorkMs: Totals = {};
-  private readonly toolWorkMs: Totals = {};
-  private readonly counts: Totals = {};
-
-  constructor(
-    readonly enabled: boolean,
-    private readonly mapName: string,
-    private readonly startedAtMs: number,
-  ) {}
-
-  recordPhase(phase: string, ms: number, count = 1): void {
-    if (!this.enabled) return;
-    add(this.phaseWorkMs, phase, ms);
-    this.counts[`${phase}_count`] =
-      (this.counts[`${phase}_count`] ?? 0) + count;
-  }
-
-  recordRowQueue(ms: number): void {
-    this.recordPhase('row_slot_queue', ms);
-  }
-
-  recordRowExecution(ms: number): void {
-    this.recordPhase('row_execution', ms);
-  }
-
-  recordToolTrace(trace: ToolTrace): void {
-    if (!this.enabled) return;
-    switch (trace.phase) {
-      case 'runner.tool.request':
-        add(this.toolWorkMs, 'request_end_to_end', trace.ms);
-        this.counts.tool_requests = (this.counts.tool_requests ?? 0) + 1;
-        break;
-      case 'runner.tool.drain':
-        add(this.toolWorkMs, 'drain', trace.ms);
-        this.counts.tool_drains = (this.counts.tool_drains ?? 0) + 1;
-        break;
-      case 'runner.tool.group':
-        add(this.toolWorkMs, 'group', trace.ms);
-        this.counts.tool_groups = (this.counts.tool_groups ?? 0) + 1;
-        break;
-      case 'runner.tool.receipt_prepare':
-        add(this.toolWorkMs, 'receipt_prepare', trace.ms);
-        break;
-      case 'runner.tool.admission':
-        add(this.toolWorkMs, 'admission_wait', trace.ms);
-        break;
-      case 'runner.tool.provider':
-        add(this.toolWorkMs, 'provider_execute', trace.ms);
-        break;
-      case 'runner.tool.receipt_complete':
-        add(this.toolWorkMs, 'receipt_complete', trace.ms);
-        break;
-      default:
-        return;
-    }
-  }
-
-  summary(endedAtMs: number, input: { chunks: number; rows: number }) {
-    return {
-      mapName: this.mapName,
-      mapWallMs: Math.max(0, endedAtMs - this.startedAtMs),
-      chunks: input.chunks,
-      rows: input.rows,
-      // These are summed work durations. They can exceed mapWallMs when rows
-      // or provider calls overlap; the terminal trace must not mislabel them
-      // as a wall-clock decomposition.
-      phaseWorkMs: this.phaseWorkMs,
-      toolWorkMs: this.toolWorkMs,
-      counts: this.counts,
-    };
-  }
-}

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/output-datasets.ts

@@ -1,475 +0,0 @@
-import {
-  normalizePlayNameForSheet,
-  normalizeTableNamespace,
-  POSTGRES_IDENTIFIER_MAX_LENGTH,
-  sha256Hex,
-} from '../../../../shared_libs/plays/row-identity';
-import {
-  createDeferredPlayDataset,
-  isPlayDataset,
-  isSerializedPlayDataset,
-  type SerializedPlayDataset,
-} from '../../../../shared_libs/plays/dataset';
-
-export type OutputDatasetRow = Record<string, unknown>;
-
-export type PromotedOutputDataset = {
-  path: string;
-  tableNamespace: string;
-  rows: OutputDatasetRow[];
-  handle: unknown;
-};
-
-export type ProjectedResultDatasetHandle = {
-  path: string;
-  tableNamespace: string;
-  datasetKind: 'csv' | 'map' | null;
-  handle: unknown;
-};
-
-type ProjectTerminalResultOptions = {
-  playName?: string | null;
-  reservedTableNamespaces?: Iterable<string>;
-};
-
-type DatasetFactory = (input: {
-  path: string;
-  tableNamespace: string;
-  rows: OutputDatasetRow[];
-}) => unknown;
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-
-function isDatasetLike(value: unknown): boolean {
-  if (!isRecord(value)) return false;
-  return (
-    typeof value.datasetId === 'string' &&
-    typeof value.count === 'function' &&
-    typeof value.peek === 'function' &&
-    typeof value.toJSON === 'function'
-  );
-}
-
-function datasetMetadata(value: unknown): Record<string, unknown> | null {
-  if (!isDatasetLike(value)) return null;
-  try {
-    const metadata = (value as { toJSON(): unknown }).toJSON();
-    return isRecord(metadata) ? metadata : null;
-  } catch {
-    return null;
-  }
-}
-
-function datasetCountFromMetadata(
-  metadata: Record<string, unknown> | null,
-): number {
-  return typeof metadata?.count === 'number' && Number.isFinite(metadata.count)
-    ? Math.max(0, Math.floor(metadata.count))
-    : 0;
-}
-
-function datasetPreviewFromMetadata(
-  metadata: Record<string, unknown> | null,
-): OutputDatasetRow[] {
-  return Array.isArray(metadata?.preview)
-    ? metadata.preview.filter(isRecord).map((row) => ({ ...row }))
-    : [];
-}
-
-function isRowArray(
-  value: unknown,
-  path: readonly string[],
-): value is OutputDatasetRow[] {
-  if (!Array.isArray(value)) return false;
-  if (value.length === 0) return isLikelyRowOutputPath(path);
-  return value.every(isRecord);
-}
-
-const NON_ROW_ARRAY_OUTPUT_KEYS = new Set([
-  'actions',
-  'columns',
-  'errors',
-  'logs',
-  'messages',
-  'next',
-  'preview',
-  'render',
-  'steps',
-  'warnings',
-]);
-
-function isLikelyRowOutputPath(path: readonly string[]): boolean {
-  if (path.length === 0) return true;
-  let leaf = '';
-  try {
-    leaf = normalizeTableNamespace(path.at(-1) ?? '');
-  } catch {
-    return false;
-  }
-  if (NON_ROW_ARRAY_OUTPUT_KEYS.has(leaf)) return false;
-  return /(^|_)(rows?|results?|records?|items?|leads?|people|contacts?|companies|accounts?)(_|$)/.test(
-    leaf,
-  );
-}
-
-function tableNamespaceForPath(path: readonly string[]): string {
-  const raw = path.length > 0 ? path.join('_') : 'rows';
-  try {
-    return normalizeTableNamespace(raw);
-  } catch {
-    const hash = sha256Hex(raw).slice(0, 10);
-    const leaf = path.at(-1) ?? 'rows';
-    let prefix = 'rows';
-    try {
-      prefix = normalizeTableNamespace(leaf).slice(0, 52) || 'rows';
-    } catch {
-      prefix = 'rows';
-    }
-    return normalizeTableNamespace(`${prefix}_${hash}`);
-  }
-}
-
-const MIN_GENERATED_RESULT_NAMESPACE_LENGTH = 9;
-
-function maxTableNamespaceLengthForPlay(playName: string | null | undefined) {
-  if (!playName) {
-    return POSTGRES_IDENTIFIER_MAX_LENGTH;
-  }
-  let playNameLength: number;
-  try {
-    playNameLength = normalizePlayNameForSheet(playName).length;
-  } catch {
-    throw new Error(
-      `Play name ${JSON.stringify(
-        playName,
-      )} cannot be used to create generated result dataset table names. ` +
-        'Shorten the play name or use only identifier-safe characters.',
-    );
-  }
-  const maxLength = POSTGRES_IDENTIFIER_MAX_LENGTH - playNameLength - 1;
-  if (maxLength < MIN_GENERATED_RESULT_NAMESPACE_LENGTH) {
-    throw new Error(
-      `Play name ${JSON.stringify(
-        playName,
-      )} leaves only ${maxLength} characters for generated result dataset table names. ` +
-        `Shorten the play name so result datasets have at least ${MIN_GENERATED_RESULT_NAMESPACE_LENGTH} characters of namespace budget.`,
-    );
-  }
-  return maxLength;
-}
-
-function boundTableNamespace(
-  value: string,
-  hashInput: string,
-  maxLength: number,
-): string {
-  const normalized = normalizeTableNamespace(value);
-  if (normalized.length <= maxLength) {
-    return normalized;
-  }
-
-  const hash = sha256Hex(hashInput).slice(0, 10);
-  if (maxLength <= 12) {
-    return normalizeTableNamespace(`r${hash}`.slice(0, maxLength));
-  }
-
-  const suffix = `_${hash}`;
-  const prefix = normalized.slice(0, maxLength - suffix.length) || 'r';
-  return normalizeTableNamespace(`${prefix}${suffix}`);
-}
-
-function resultTableNamespaceForPath(
-  path: readonly string[],
-  maxLength: number,
-): string {
-  const base = tableNamespaceForPath(path);
-  const raw = `result_${base}`;
-  const hashInput = path.join('.') || 'rows';
-  try {
-    return boundTableNamespace(raw, hashInput, maxLength);
-  } catch {
-    const hash = sha256Hex(path.join('.')).slice(0, 10);
-    return boundTableNamespace(
-      `result_${base.slice(0, 45)}_${hash}`,
-      hashInput,
-      maxLength,
-    );
-  }
-}
-
-function seedUsedNamespaces(
-  namespaces: Iterable<string> | undefined,
-): Set<string> {
-  const usedNamespaces = new Set<string>();
-  for (const namespace of namespaces ?? []) {
-    try {
-      usedNamespaces.add(normalizeTableNamespace(namespace));
-    } catch {
-      // Ignore malformed historical metadata; result datasets still get a
-      // result-prefixed namespace and local collision disambiguation.
-    }
-  }
-  return usedNamespaces;
-}
-
-function disambiguateTableNamespace(
-  tableNamespace: string,
-  path: readonly string[],
-  usedNamespaces: Set<string>,
-  maxLength: number,
-): string {
-  if (!usedNamespaces.has(tableNamespace)) {
-    usedNamespaces.add(tableNamespace);
-    return tableNamespace;
-  }
-
-  const hash = sha256Hex(path.join('.')).slice(0, 10);
-  let candidate = boundTableNamespace(
-    `${tableNamespace}_${hash}`,
-    `${path.join('.')}:collision`,
-    maxLength,
-  );
-  let suffix = 2;
-  while (usedNamespaces.has(candidate)) {
-    candidate = boundTableNamespace(
-      `${tableNamespace}_${hash}_${suffix}`,
-      `${path.join('.')}:collision:${suffix}`,
-      maxLength,
-    );
-    suffix += 1;
-  }
-  usedNamespaces.add(candidate);
-  return candidate;
-}
-
-function collectExistingDatasetTableNamespaces(value: unknown): Set<string> {
-  const namespaces = new Set<string>();
-  const seen = new WeakSet<object>();
-
-  const addNamespace = (namespace: unknown) => {
-    if (typeof namespace !== 'string' || !namespace) return;
-    try {
-      namespaces.add(normalizeTableNamespace(namespace));
-    } catch {
-      // Historical malformed namespaces should not block generated result
-      // names. The original handle/envelope remains unchanged.
-    }
-  };
-
-  const visit = (candidate: unknown, depth: number): void => {
-    if (depth > 20 || candidate == null || typeof candidate !== 'object') {
-      return;
-    }
-    if (seen.has(candidate)) return;
-    seen.add(candidate);
-    if (isSerializedPlayDataset(candidate)) {
-      addNamespace(candidate.tableNamespace);
-      return;
-    }
-    if (isDatasetLike(candidate)) {
-      addNamespace(datasetMetadata(candidate)?.tableNamespace);
-      return;
-    }
-    if (Array.isArray(candidate)) {
-      for (const entry of candidate) visit(entry, depth + 1);
-      return;
-    }
-    for (const child of Object.values(candidate as Record<string, unknown>)) {
-      visit(child, depth + 1);
-    }
-  };
-
-  visit(value, 0);
-  return namespaces;
-}
-
-export function projectTerminalResultDatasets(
-  value: unknown,
-  createDataset: DatasetFactory,
-  options: ProjectTerminalResultOptions = {},
-): {
-  result: unknown;
-  datasets: PromotedOutputDataset[];
-  handles: ProjectedResultDatasetHandle[];
-} {
-  const datasets: PromotedOutputDataset[] = [];
-  const handles: ProjectedResultDatasetHandle[] = [];
-  const seen = new WeakMap<object, unknown>();
-  const seenHandles = new WeakSet<object>();
-  const projectedHandles = new WeakMap<object, unknown>();
-  const usedNamespaces = seedUsedNamespaces(options.reservedTableNamespaces);
-  for (const namespace of collectExistingDatasetTableNamespaces(value)) {
-    usedNamespaces.add(namespace);
-  }
-  const maxTableNamespaceLength = maxTableNamespaceLengthForPlay(
-    options.playName,
-  );
-
-  const projectHandle = (handle: unknown, path: readonly string[]): unknown => {
-    if (!isRecord(handle)) return handle;
-    const existingProjection = projectedHandles.get(handle);
-    if (existingProjection) return existingProjection;
-    const metadata = datasetMetadata(handle);
-    let projectedHandle: unknown = handle;
-    let tableNamespace =
-      typeof metadata?.tableNamespace === 'string' && metadata.tableNamespace
-        ? metadata.tableNamespace
-        : null;
-    if (!tableNamespace && isPlayDataset<OutputDatasetRow>(handle)) {
-      const resolvedPath = path.length > 0 ? path : ['rows'];
-      tableNamespace = disambiguateTableNamespace(
-        resultTableNamespaceForPath(resolvedPath, maxTableNamespaceLength),
-        resolvedPath,
-        usedNamespaces,
-        maxTableNamespaceLength,
-      );
-      projectedHandle = createDeferredPlayDataset({
-        datasetKind: 'csv',
-        datasetId:
-          typeof metadata?.datasetId === 'string'
-            ? metadata.datasetId
-            : `csv:${tableNamespace}`,
-        count: datasetCountFromMetadata(metadata),
-        previewRows: datasetPreviewFromMetadata(metadata),
-        sourceLabel:
-          typeof metadata?.sourceLabel === 'string'
-            ? metadata.sourceLabel
-            : null,
-        tableNamespace,
-        resolvers: {
-          count: () => handle.count(),
-          peek: (limit) => handle.peek(limit),
-          materialize: (limit) => handle.materialize(limit),
-          iterate: () =>
-            ({
-              async *[Symbol.asyncIterator]() {
-                yield* handle;
-              },
-            }) as AsyncIterable<OutputDatasetRow>,
-        },
-      });
-    }
-    projectedHandles.set(handle, projectedHandle);
-    if (!tableNamespace || seenHandles.has(projectedHandle as object)) {
-      return projectedHandle;
-    }
-    try {
-      usedNamespaces.add(normalizeTableNamespace(tableNamespace));
-    } catch {
-      // Existing dataset handles can carry historical namespaces. Keep the
-      // handle, but do not let a malformed namespace poison new result names.
-    }
-    seenHandles.add(projectedHandle as object);
-    const projectedMetadata =
-      projectedHandle === handle ? metadata : datasetMetadata(projectedHandle);
-    const datasetKind =
-      projectedMetadata?.datasetKind === 'csv' ||
-      projectedMetadata?.datasetKind === 'map'
-        ? projectedMetadata.datasetKind
-        : null;
-    handles.push({
-      path: path.length > 0 ? path.join('.') : 'rows',
-      tableNamespace,
-      datasetKind,
-      handle: projectedHandle,
-    });
-    return projectedHandle;
-  };
-
-  const promoteRows = (
-    rows: OutputDatasetRow[],
-    path: readonly string[],
-  ): unknown => {
-    const resolvedPath = path.length > 0 ? path.join('.') : 'rows';
-    const tableNamespace = disambiguateTableNamespace(
-      resultTableNamespaceForPath(path, maxTableNamespaceLength),
-      path,
-      usedNamespaces,
-      maxTableNamespaceLength,
-    );
-    const handle = createDataset({
-      path: resolvedPath,
-      tableNamespace,
-      rows,
-    });
-    datasets.push({
-      path: resolvedPath,
-      tableNamespace,
-      rows,
-      handle,
-    });
-    projectHandle(handle, path);
-    return handle;
-  };
-
-  const visit = (
-    candidate: unknown,
-    path: string[],
-    depth: number,
-  ): unknown => {
-    if (depth > 20 || candidate == null) return candidate;
-    if (isDatasetLike(candidate)) {
-      return projectHandle(candidate, path);
-    }
-    if (isSerializedPlayDataset(candidate)) {
-      return candidate;
-    }
-    if (isLikelyRowOutputPath(path) && isRowArray(candidate, path)) {
-      return promoteRows(candidate, path.length > 0 ? path : ['rows']);
-    }
-    if (Array.isArray(candidate)) {
-      return candidate.map((entry, index) =>
-        visit(entry, [...path, String(index)], depth + 1),
-      );
-    }
-    if (!isRecord(candidate)) return candidate;
-    const cached = seen.get(candidate);
-    if (cached) return cached;
-    const out: Record<string, unknown> = {};
-    seen.set(candidate, out);
-    for (const [key, child] of Object.entries(candidate)) {
-      out[key] = visit(child, [...path, key], depth + 1);
-    }
-    return out;
-  };
-
-  return {
-    result: visit(value, [], 0),
-    datasets,
-    handles,
-  };
-}
-
-type SerializedDatasetHydrator = (
-  dataset: SerializedPlayDataset<Record<string, unknown>>,
-) => unknown;
-
-export function hydrateSerializedResultDatasets(
-  value: unknown,
-  hydrateDataset: SerializedDatasetHydrator,
-): unknown {
-  const seen = new WeakMap<object, unknown>();
-
-  function visit(candidate: unknown, depth: number): unknown {
-    if (depth > 20 || candidate == null) return candidate;
-    if (isSerializedPlayDataset<Record<string, unknown>>(candidate)) {
-      return hydrateDataset(candidate);
-    }
-    if (Array.isArray(candidate)) {
-      return candidate.map((entry) => visit(entry, depth + 1));
-    }
-    if (!isRecord(candidate)) return candidate;
-    const cached = seen.get(candidate);
-    if (cached) return cached;
-    const out: Record<string, unknown> = {};
-    seen.set(candidate, out);
-    for (const [key, child] of Object.entries(candidate)) {
-      out[key] = visit(child, depth + 1);
-    }
-    return out;
-  }
-
-  return visit(value, 0);
-}