deepline 0.1.301 → 0.1.303

package/dist/bundling-sources/shared_libs/plays/bundling/index.ts

@@ -28,10 +28,13 @@ import type {
   PlayRuntimeFeature,
 } from '../artifact-types';
 import { buildPlayContractCompatibility } from '../contracts';
+import type { ToolExecutionErrorSchemaVersion } from '../../tool-execution-error';
 import { validatePlaySourceFilesHaveNoInlineSecrets } from '../secret-guardrails';
 import { MAX_PLAY_BUNDLE_BYTES } from './limits';
 
-const PLAY_BUNDLE_CACHE_VERSION = 25;
+// The authored tool-error schema is part of the artifact bytes. Do not reuse a
+// local bundle cached before compatibility selection entered graph analysis.
+const PLAY_BUNDLE_CACHE_VERSION = 27;
 const PLAY_ARTIFACT_CACHE_DIR = join(
   tmpdir(),
   `deepline-play-artifacts-v${PLAY_BUNDLE_CACHE_VERSION}`,
@@ -152,6 +155,7 @@ type SourceGraphAnalysis = {
   importPolicy: PlayImportPolicy;
   playName: string | null;
   playDescription: string | null;
+  toolErrorSchemaVersion: ToolExecutionErrorSchemaVersion | null;
   importedPlayDependencies: ImportedPlayDependency[];
 };
 
@@ -501,6 +505,8 @@ type PlayMetadataExtractionContext = {
 type ExtractedPlayMetadata = {
   name: string | null;
   description: string | null;
+  toolErrorSchemaVersion: ToolExecutionErrorSchemaVersion | null;
+  toolErrorSchemaVersionUnknown: boolean;
 };
 
 const TypeScriptParser = Parser.extend(
@@ -795,9 +801,13 @@ function staticStringFromExpression(
 }
 
 function propertyNameFromKey(property: AstNode): string | null {
-  if (property.computed) return null;
   const key = isAstNode(property.key) ? property.key : null;
   if (!key) return null;
+  if (property.computed) {
+    return key.type === 'Literal' && typeof key.value === 'string'
+      ? key.value
+      : null;
+  }
   if (key.type === 'Identifier' && typeof key.name === 'string') {
     return key.name;
   }
@@ -826,6 +836,109 @@ function objectExpressionFromNode(
   );
 }
 
+type StaticPropertyResolution =
+  | { kind: 'absent' }
+  | { kind: 'found'; value: AstNode }
+  | { kind: 'unknown' };
+
+function resolveStaticProperty(
+  node: AstNode | null | undefined,
+  propertyName: string,
+  context: PlayMetadataExtractionContext,
+  ancestors = new Set<AstNode>(),
+): StaticPropertyResolution {
+  if (!node) return { kind: 'absent' };
+  const object = objectExpressionFromNode(node, context);
+  if (!object) return { kind: 'unknown' };
+  if (ancestors.has(object)) return { kind: 'unknown' };
+  const nextAncestors = new Set(ancestors).add(object);
+
+  let resolution: StaticPropertyResolution = { kind: 'absent' };
+  for (const property of astArray(object.properties)) {
+    if (property.type === 'SpreadElement') {
+      const spreadResolution = resolveStaticProperty(
+        isAstNode(property.argument) ? property.argument : null,
+        propertyName,
+        context,
+        nextAncestors,
+      );
+      if (spreadResolution.kind !== 'absent') {
+        resolution = spreadResolution;
+      }
+      continue;
+    }
+    if (property.type !== 'Property') continue;
+    const resolvedPropertyName = propertyNameFromKey(property);
+    if (resolvedPropertyName !== propertyName) {
+      if (property.computed && resolvedPropertyName === null) {
+        resolution = { kind: 'unknown' };
+      }
+      continue;
+    }
+    const propertyValue = property.shorthand ? property.key : property.value;
+    resolution = isAstNode(propertyValue)
+      ? { kind: 'found', value: propertyValue }
+      : { kind: 'unknown' };
+  }
+  return resolution;
+}
+
+function staticNumberFromExpression(
+  node: AstNode | null | undefined,
+  context: PlayMetadataExtractionContext,
+  seen = new Set<string>(),
+): number | null {
+  const expression = unwrapStaticExpression(node);
+  if (!expression) return null;
+  if (expression.type === 'Literal' && typeof expression.value === 'number') {
+    return expression.value;
+  }
+
+  const identifier = getIdentifierName(expression);
+  if (!identifier || seen.has(identifier)) return null;
+  seen.add(identifier);
+  return staticNumberFromExpression(
+    context.declarations.get(identifier),
+    context,
+    seen,
+  );
+}
+
+function toolErrorSchemaVersionFromOptions(
+  node: AstNode | null | undefined,
+  context: PlayMetadataExtractionContext,
+): ToolExecutionErrorSchemaVersion | null | undefined {
+  const directCompatibility = resolveStaticProperty(
+    node,
+    'compatibility',
+    context,
+  );
+  if (directCompatibility.kind === 'unknown') return null;
+
+  const bindings = resolveStaticProperty(node, 'bindings', context);
+  if (bindings.kind === 'unknown') return null;
+  const bindingCompatibility =
+    bindings.kind === 'found'
+      ? resolveStaticProperty(bindings.value, 'compatibility', context)
+      : ({ kind: 'absent' } satisfies StaticPropertyResolution);
+  if (bindingCompatibility.kind === 'unknown') return null;
+
+  const compatibility =
+    directCompatibility.kind === 'found'
+      ? directCompatibility
+      : bindingCompatibility;
+  if (compatibility.kind === 'absent') return undefined;
+  const schema = resolveStaticProperty(
+    compatibility.value,
+    'toolErrorSchemaVersion',
+    context,
+  );
+  if (schema.kind !== 'found') return null;
+  const schemaVersion = staticNumberFromExpression(schema.value, context);
+  if (schemaVersion === 0 || schemaVersion === 1) return schemaVersion;
+  return null;
+}
+
 function stringPropertyFromObjectExpression(
   node: AstNode | null | undefined,
   propertyName: string,
@@ -895,12 +1008,16 @@ function playMetadataFromDefinePlayCall(
 
   const args = astArray(expression.arguments);
   const firstArg = args[0] ?? null;
+  const isObjectForm =
+    args.length === 1 || objectExpressionFromNode(firstArg, context) !== null;
   const objectName = stringPropertyFromObjectExpression(
     firstArg,
     'id',
     context,
   );
-  const name = objectName ?? staticStringFromExpression(firstArg, context);
+  const name = isObjectForm
+    ? objectName
+    : staticStringFromExpression(firstArg, context);
 
   let description =
     stringPropertyFromObjectExpression(firstArg, 'description', context) ??
@@ -913,8 +1030,27 @@ function playMetadataFromDefinePlayCall(
     );
   }
 
-  if (!name && !description) return null;
-  return { name, description };
+  const options = isObjectForm ? firstArg : (args[2] ?? null);
+  const toolErrorSchemaVersion = toolErrorSchemaVersionFromOptions(
+    options,
+    context,
+  );
+  const toolErrorSchemaVersionUnknown = toolErrorSchemaVersion === null;
+
+  if (
+    !name &&
+    !description &&
+    toolErrorSchemaVersion === undefined &&
+    !toolErrorSchemaVersionUnknown
+  ) {
+    return null;
+  }
+  return {
+    name,
+    description,
+    toolErrorSchemaVersion: toolErrorSchemaVersion ?? null,
+    toolErrorSchemaVersionUnknown,
+  };
 }
 
 function resolveExportExpression(
@@ -1397,14 +1533,18 @@ async function analyzeSourceGraph(
         .sort((left, right) => left.filePath.localeCompare(right.filePath)),
     }),
   );
-  const playName =
-    extractDefinedPlayNameForExport(sourceCode, exportName) ??
-    (exportName === 'default' ? extractDefinedPlayName(sourceCode) : null);
-  const playDescription =
-    extractDefinedPlayDescriptionForExport(sourceCode, exportName) ??
+  const metadata =
+    extractDefinedPlayMetadata(sourceCode, exportName) ??
     (exportName === 'default'
-      ? extractDefinedPlayDescription(sourceCode)
+      ? extractDefinedPlayMetadata(sourceCode, null)
       : null);
+  if (metadata?.toolErrorSchemaVersionUnknown) {
+    throw new Error(
+      'definePlay compatibility.toolErrorSchemaVersion must be the static literal 0 or 1.',
+    );
+  }
+  const playName = metadata?.name ?? null;
+  const playDescription = metadata?.description ?? null;
 
   return {
     sourceCode,
@@ -1424,6 +1564,7 @@ async function analyzeSourceGraph(
     },
     playName,
     playDescription,
+    toolErrorSchemaVersion: metadata?.toolErrorSchemaVersion ?? null,
     importedPlayDependencies: [...importedPlayDependencies.values()].sort(
       (left, right) => left.filePath.localeCompare(right.filePath),
     ),
@@ -1672,6 +1813,10 @@ export async function bundlePlayFile(
           entryFile: absolutePath,
           sourceHash: analysis.sourceHash,
           importPolicy: analysis.importPolicy,
+          compatibility: buildPlayContractCompatibility({
+            toolErrorSchemaVersion:
+              analysis.toolErrorSchemaVersion ?? undefined,
+          }),
           cacheHit: true,
         },
         sourceCode: analysis.sourceCode,
@@ -1736,7 +1881,9 @@ export async function bundlePlayFile(
       bundledCode: executableCode,
       sourceMap: normalizedSourceMap,
       importPolicy: analysis.importPolicy,
-      compatibility: buildPlayContractCompatibility(),
+      compatibility: buildPlayContractCompatibility({
+        toolErrorSchemaVersion: analysis.toolErrorSchemaVersion ?? undefined,
+      }),
       generatedAt: Date.now(),
       cacheHit: false,
     };

package/dist/bundling-sources/shared_libs/plays/contracts.ts

@@ -1,3 +1,11 @@
+import {
+  LEGACY_TOOL_EXECUTION_ERROR_SCHEMA_VERSION,
+  SUPPORTED_TOOL_EXECUTION_ERROR_SCHEMA_VERSIONS,
+  TOOL_EXECUTION_ERROR_SCHEMA_VERSION,
+  type ToolExecutionErrorSchemaVersion,
+} from '../tool-execution-error';
+import { CURRENT_PLAY_ARTIFACT_CONTRACT_VERSION } from './artifact-contract-version';
+
 export type PlayContractSource = 'ad_hoc' | 'draft' | 'published';
 
 export type PlayRuntimeFeature =
@@ -7,7 +15,7 @@ export type PlayRuntimeFeature =
   | 'packaged_files';
 
 export const PLAY_PUBLIC_API_VERSION = 1;
-export const PLAY_ARTIFACT_VERSION = 1;
+export const PLAY_ARTIFACT_VERSION = CURRENT_PLAY_ARTIFACT_CONTRACT_VERSION;
 export const PLAY_MIN_RUNNER_VERSION = 1;
 export const PLAY_RUNTIME_FEATURES: PlayRuntimeFeature[] = [
   'artifact_storage',
@@ -22,10 +30,68 @@ export type PlayContractCompatibilitySnapshot = {
   minRunnerVersion: number;
   runtimeFeatures: PlayRuntimeFeature[];
   runtimeBackend?: string | null;
+  /** Missing preserves the legacy contract used by artifacts stored before this field existed. */
+  toolErrorSchemaVersion?: ToolExecutionErrorSchemaVersion;
 };
 
+export type NormalizedPlayContractCompatibilitySnapshot =
+  PlayContractCompatibilitySnapshot & {
+    toolErrorSchemaVersion: ToolExecutionErrorSchemaVersion;
+  };
+
+export class UnsupportedPlayToolErrorSchemaVersionError extends Error {
+  constructor(value: unknown) {
+    super(
+      `Unsupported Play tool error schema version ${String(value)}. Supported versions: ${SUPPORTED_TOOL_EXECUTION_ERROR_SCHEMA_VERSIONS.join(', ')}.`,
+    );
+    this.name = 'UnsupportedPlayToolErrorSchemaVersionError';
+  }
+}
+
+export class InvalidPlayContractCompatibilityError extends Error {
+  constructor() {
+    super('Play artifact compatibility must be an object.');
+    this.name = 'InvalidPlayContractCompatibilityError';
+  }
+}
+
+/**
+ * Normalize the artifact-pinned compatibility facts without regenerating them.
+ * A missing field is the historical production contract, not an opt-in to the
+ * current runtime behavior.
+ */
+export function normalizePlayContractCompatibility(
+  compatibility: PlayContractCompatibilitySnapshot | null | undefined,
+): NormalizedPlayContractCompatibilitySnapshot {
+  if (
+    !compatibility ||
+    typeof compatibility !== 'object' ||
+    Array.isArray(compatibility)
+  ) {
+    throw new InvalidPlayContractCompatibilityError();
+  }
+  const toolErrorSchemaVersion =
+    compatibility.toolErrorSchemaVersion ??
+    LEGACY_TOOL_EXECUTION_ERROR_SCHEMA_VERSION;
+  if (
+    !SUPPORTED_TOOL_EXECUTION_ERROR_SCHEMA_VERSIONS.includes(
+      toolErrorSchemaVersion as ToolExecutionErrorSchemaVersion,
+    )
+  ) {
+    throw new UnsupportedPlayToolErrorSchemaVersionError(
+      toolErrorSchemaVersion,
+    );
+  }
+  return {
+    ...compatibility,
+    toolErrorSchemaVersion:
+      toolErrorSchemaVersion as ToolExecutionErrorSchemaVersion,
+  };
+}
+
 export function buildPlayContractCompatibility(input?: {
   runtimeBackend?: string | null;
+  toolErrorSchemaVersion?: ToolExecutionErrorSchemaVersion;
 }): PlayContractCompatibilitySnapshot {
   return {
     apiVersion: PLAY_PUBLIC_API_VERSION,
@@ -33,6 +99,8 @@ export function buildPlayContractCompatibility(input?: {
     minRunnerVersion: PLAY_MIN_RUNNER_VERSION,
     runtimeFeatures: [...PLAY_RUNTIME_FEATURES],
     runtimeBackend: input?.runtimeBackend ?? null,
+    toolErrorSchemaVersion:
+      input?.toolErrorSchemaVersion ?? TOOL_EXECUTION_ERROR_SCHEMA_VERSION,
   };
 }