deepline 0.3.409 → 0.3.410

package/dist/bundling-sources/shared_libs/plays/enrich-play-compiler.ts

@@ -56,6 +56,8 @@ export type EnrichCompiledConfig = {
 };
 
 export type EnrichPlaySourceOptions = {
+  /** Current CLI authoring emits fresh logical operations; legacy callers keep their source format. */
+  explicitFreshness?: boolean;
   playName?: string;
   mapName?: string;
   forceAliases?: Iterable<string>;
@@ -139,6 +141,7 @@ function renderExecuteStep(
   command: EnrichStepCommand,
   options: {
     force: boolean;
+    explicitFreshness?: boolean;
     precheck?: string;
     legacyEnvelope?: boolean;
     inlineRunJavascript?: boolean;
@@ -172,7 +175,8 @@ function renderExecuteStep(
   const description = command.description
     ? `,\n      description: ${stringLiteral(command.description)}`
     : '';
-  const force = options.force ? `,\n    force: true` : '';
+  const force =
+    options.force && !options.explicitFreshness ? `,\n    force: true` : '';
   const legacyEnvelope = options.legacyEnvelope
     ? `,\n    legacyEnvelope: true`
     : '';
@@ -256,6 +260,7 @@ function renderIdiomaticExecuteStep(
   command: EnrichStepCommand,
   options: {
     force: boolean;
+    explicitFreshness?: boolean;
     precheck?: string;
     nativeRunIf?: boolean;
   },
@@ -287,8 +292,11 @@ function renderIdiomaticExecuteStep(
     `    id: ${callId},`,
     `    tool: ${tool},`,
     `    input: ${input} as any,`,
+    ...(options.explicitFreshness ? [`    staleAfterSeconds: 0,`] : []),
     `    description: ${stringLiteral((command.description ?? '').trim() || `Run ${command.alias} via ${command.tool}.`)},`,
-    ...(options.force ? [`      force: true,`] : []),
+    ...(options.force && !options.explicitFreshness
+      ? [`      force: true,`]
+      : []),
     `  });`,
     `  __dlAssertSuccessfulToolResult(result);`,
     `  return ${extraction};`,
@@ -300,6 +308,7 @@ function renderPlayStep(
   command: EnrichStepCommand,
   options: {
     force: boolean;
+    explicitFreshness?: boolean;
     precheck?: string;
     legacyEnvelope?: boolean;
     nativeRunIf?: boolean;
@@ -334,7 +343,9 @@ function renderPlayStep(
           // Enrich validates and normalizes this payload against the certified
           // prebuilt contract before code generation. The attachment retains
           // its concrete input type, while generated payloads are records.
-          `    await __dlRunInlinePlay(${inlineHandler}, stepCtx, payload as never, ${options.force});`,
+          options.explicitFreshness
+            ? `    await __dlRunInlinePlay_${inline!.sourceHash.slice(0, 16)}(stepCtx, payload as never, ${options.force});`
+            : `    await __dlRunInlinePlay(${inlineHandler}, stepCtx, payload as never, ${options.force});`,
         ]
       : [
           `    await stepCtx.runPlay(${callId}, ${playRef}, payload, {`,
@@ -554,6 +565,7 @@ function renderWaterfallColumns(
   forceAliases: Set<string>,
   inlineRunJavascript: boolean,
   idiomaticGetters: boolean,
+  explicitFreshness: boolean,
 ): string[] {
   const activeChildren = command.commands.filter(
     (nested): nested is EnrichStepCommand =>
@@ -587,6 +599,7 @@ function renderWaterfallColumns(
         nested.alias,
         renderExecuteStep(nested, {
           force,
+          explicitFreshness,
           precheck,
           legacyEnvelope: Boolean(nested.extract_js),
           inlineRunJavascript,
@@ -657,6 +670,7 @@ export function compileEnrichConfigToPlaySource(
           forceAliases,
           inlineRunJavascript,
           idiomaticGetters,
+          options.explicitFreshness === true,
         ),
       );
       return;
@@ -671,6 +685,7 @@ export function compileEnrichConfigToPlaySource(
         command.alias,
         renderExecuteStep(command, {
           force,
+          explicitFreshness: options.explicitFreshness,
           inlineRunJavascript,
           idiomaticGetters,
           nativeRunIf: Boolean(runIfSource),
@@ -705,24 +720,45 @@ export function compileEnrichConfigToPlaySource(
     : 'Prepare CSV rows for enrichment.';
   const playOptionsSource = [
     `description: ${stringLiteral(generatedDescription)}`,
+    ...(options.explicitFreshness === true
+      ? [`compatibility: { authoringContract: 'explicit-freshness' }`]
+      : []),
     ...(options.maxCreditsPerRun === undefined
       ? []
       : [`billing: { maxCreditsPerRun: ${String(options.maxCreditsPerRun)} }`]),
   ].join(', ');
 
+  const legacyInlineHelper = options.explicitFreshness
+    ? []
+    : [
+        `function __dlRunInlinePlay<TContext, TInput, TOutput>(handler: (ctx: TContext, input: TInput) => Promise<TOutput>, scope: TContext, payload: TInput, force: boolean): Promise<TOutput> {`,
+        `  if (!force) return handler(scope, payload);`,
+        `  const runtimeScope = scope as TContext & { __deeplineRunWithForcedTools?: <T>(run: () => Promise<T>) => Promise<T> };`,
+        `  if (typeof runtimeScope.__deeplineRunWithForcedTools !== 'function') {`,
+        `    throw new Error('This runtime does not support forced certified inline play execution.');`,
+        `  }`,
+        `  return runtimeScope.__deeplineRunWithForcedTools(() => handler(scope, payload));`,
+        `}`,
+        ``,
+      ];
   const body = [
-    `function __dlRunInlinePlay<TContext, TInput, TOutput>(handler: (ctx: TContext, input: TInput) => Promise<TOutput>, scope: TContext, payload: TInput, force: boolean): Promise<TOutput> {`,
-    `  if (!force) return handler(scope, payload);`,
-    `  const runtimeScope = scope as TContext & { __deeplineRunWithForcedTools?: <T>(run: () => Promise<T>) => Promise<T> };`,
-    `  if (typeof runtimeScope.__deeplineRunWithForcedTools !== 'function') {`,
-    `    throw new Error('This runtime does not support forced certified inline play execution.');`,
-    `  }`,
-    `  return runtimeScope.__deeplineRunWithForcedTools(() => handler(scope, payload));`,
-    `}`,
-    ``,
+    ...legacyInlineHelper,
     ...inlineHandlers.flatMap((inline) => [
       `const __dlInlinePlay_${inline.sourceHash.slice(0, 16)} = ${inline.functionExpressionSource};`,
       ``,
+      ...(options.explicitFreshness
+        ? [
+            `async function __dlRunInlinePlay_${inline.sourceHash.slice(0, 16)}(scope: Parameters<typeof __dlInlinePlay_${inline.sourceHash.slice(0, 16)}>[0], payload: Parameters<typeof __dlInlinePlay_${inline.sourceHash.slice(0, 16)}>[1], force: boolean): Promise<unknown> {`,
+            `  if (!force) return __dlInlinePlay_${inline.sourceHash.slice(0, 16)}(scope, payload);`,
+            `  const runtimeScope = scope as typeof scope & { __deeplineRunWithForcedTools?: <T>(run: () => Promise<T>) => Promise<T> };`,
+            `  if (typeof runtimeScope.__deeplineRunWithForcedTools !== 'function') {`,
+            `    throw new Error('This runtime does not support forced certified inline play execution.');`,
+            `  }`,
+            `  return runtimeScope.__deeplineRunWithForcedTools(() => __dlInlinePlay_${inline.sourceHash.slice(0, 16)}(scope, payload));`,
+            `}`,
+            ``,
+          ]
+        : []),
     ]),
     `export default definePlay(${stringLiteral(playName)}, async (ctx, input: EnrichInput) => {`,
     `  const sourceRows = await ctx.csv<Record<string, unknown>>(input.file);`,
@@ -751,8 +787,11 @@ export function compileEnrichConfigToPlaySource(
   // legacy extraction preamble. Tree-shake it to only the helpers the body
   // actually uses (plus their transitive deps) so the emitted play is clean.
   const helpers = idiomaticGetters
-    ? selectUsedHelpers(helperSource(), body.join('\n'))
-    : helperSource();
+    ? selectUsedHelpers(
+        helperSource(options.explicitFreshness),
+        body.join('\n'),
+      )
+    : helperSource(options.explicitFreshness);
   const typeImports = idiomaticGetters
     ? inlineTypeImports
     : [...new Set([...inlineTypeImports, 'DeeplinePlayRuntimeContext'])].sort();
@@ -828,7 +867,7 @@ function selectUsedHelpers(
     .join('\n\n');
 }
 
-function helperSource(): string {
+function helperSource(explicitFreshness = false): string {
   return [
     `function __dlWholeNumber(value: unknown, fallback: number): number {`,
     `  const numeric = Number(value);`,
@@ -1555,8 +1594,11 @@ function helperSource(): string {
     `    id: input.callId,`,
     `    tool: input.tool,`,
     `    input: payload,`,
+    ...(explicitFreshness ? [`    staleAfterSeconds: 0,`] : []),
     `    ...(input.description ? { description: input.description } : {}),`,
-    `    ...(input.force ? { force: true } : {}),`,
+    ...(explicitFreshness
+      ? []
+      : [`    ...(input.force ? { force: true } : {}),`]),
     `  });`,
     `  __dlAssertSuccessfulToolResult(result);`,
     `  return __dlExtract(input.alias, result, input.row, input.extract, Boolean(input.legacyEnvelope));`,

package/dist/bundling-sources/shared_libs/plays/fetch-http-error.ts

@@ -0,0 +1,50 @@
+import type { PlayAuthoringFetchResponse } from './authoring-contract';
+
+/**
+ * Edition 5+ `ctx.fetch` error for a non-2xx response. Its full readable body is secret-redacted; editions 1–4 retain `PlayFetchResponse { ok: false }`.
+ *
+ * @sdkReference runtime 178 CtxFetchHttpError
+ */
+export class CtxFetchHttpError extends Error {
+  /**
+   * Play source and the runtime are separately bundled. Recognize the stable
+   * public error code so `instanceof` works across that boundary as well.
+   */
+  static [Symbol.hasInstance](value: unknown): boolean {
+    return (
+      value !== null &&
+      typeof value === 'object' &&
+      (value as { code?: unknown }).code === 'CTX_FETCH_HTTP_ERROR'
+    );
+  }
+
+  /** Stable machine-readable HTTP-failure code. */
+  readonly code = 'CTX_FETCH_HTTP_ERROR' as const;
+  /** Upstream HTTP status. */
+  readonly status: number;
+  /** Upstream HTTP status text. */
+  readonly statusText: string;
+  /** Final response URL after redirects. */
+  readonly url: string;
+  /** Secret-redacted response headers. */
+  readonly headers: Record<string, string>;
+  /** Complete secret-redacted response body. */
+  readonly bodyText: string;
+  /** Eagerly parsed secret-redacted JSON, or null. */
+  readonly json: unknown | null;
+
+  /** Build the error from the durable response record. */
+  constructor(readonly response: PlayAuthoringFetchResponse) {
+    const body = response.bodyText || 'empty response body';
+    super(
+      `ctx.fetch(${response.url}) returned HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ''}: ${body}`,
+    );
+    this.name = 'CtxFetchHttpError';
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.url = response.url;
+    this.headers = response.headers;
+    this.bodyText = response.bodyText;
+    this.json = response.json;
+  }
+}

package/dist/bundling-sources/shared_libs/plays/source-authoring-edition.ts

@@ -0,0 +1,351 @@
+import {
+  PLAY_AUTHORING_CONTRACT_EDITION,
+  PlayAuthoringFieldValidationError,
+  validatePlayAuthoringField,
+  type PlayAuthoringContractEdition,
+} from './authoring-contract';
+import { isDefinePlayCall } from './play-exports';
+import { astArray, isAstNode, type AstNode } from './ts-ast';
+
+export type PlaySourceAuthoringEdition =
+  | { kind: 'absent' }
+  | { kind: 'value'; value: unknown }
+  | { kind: 'unknown' };
+
+type Property =
+  | { kind: 'absent' }
+  | { kind: 'found'; value: AstNode }
+  | { kind: 'unknown' };
+
+function unwrap(node: AstNode | null): AstNode | null {
+  let current = node;
+  while (
+    current &&
+    [
+      'TSAsExpression',
+      'TSSatisfiesExpression',
+      'TSTypeAssertion',
+      'TSNonNullExpression',
+      'ParenthesizedExpression',
+    ].includes(current.type)
+  ) {
+    current = isAstNode(current.expression) ? current.expression : null;
+  }
+  return current;
+}
+
+function identifier(node: unknown): string | null {
+  return isAstNode(node) &&
+    node.type === 'Identifier' &&
+    typeof node.name === 'string'
+    ? node.name
+    : null;
+}
+
+/** Shared source selection and final-property semantics; no bundle compiler. */
+export function extractPlaySourceAuthoringEdition(
+  ast: AstNode,
+  exportName: string | null = null,
+): {
+  marker: PlaySourceAuthoringEdition;
+  localExport: boolean;
+  definition?: AstNode;
+} {
+  const declarations = new Map<string, AstNode | null>();
+  const exports = new Map<string, AstNode>();
+  const legacyExports = new Map<string, AstNode>();
+  const definitions: AstNode[] = [];
+  const defineAliases = new Set<string>();
+  const record = (statement: AstNode, exported: boolean) => {
+    for (const declaration of astArray(statement.declarations)) {
+      const name = identifier(declaration.id);
+      const initializer = isAstNode(declaration.init) ? declaration.init : null;
+      if (!name) continue;
+      // A mutable option/alias is unresolved. Historical direct Play bindings
+      // are still recognizable, as they are in the existing metadata adapters.
+      declarations.set(
+        name,
+        statement.kind === 'const' || isDefinePlayCall(initializer)
+          ? initializer
+          : null,
+      );
+      if (initializer && isDefinePlayCall(initializer))
+        definitions.push(initializer);
+      if (exported) exports.set(name, { type: 'Identifier', name });
+    }
+  };
+  for (const statement of astArray(ast.body)) {
+    if (statement.type === 'ImportDeclaration') {
+      for (const specifier of astArray(statement.specifiers)) {
+        if (
+          specifier.type === 'ImportSpecifier' &&
+          ['definePlay', 'defineWorkflow'].includes(
+            identifier(specifier.imported) ?? '',
+          )
+        ) {
+          const name = identifier(specifier.local);
+          if (name) defineAliases.add(name);
+        }
+      }
+    }
+    if (statement.type === 'VariableDeclaration') record(statement, false);
+    if (
+      statement.type === 'ExportDefaultDeclaration' &&
+      isAstNode(statement.declaration)
+    ) {
+      exports.set('default', statement.declaration);
+    }
+    if (
+      statement.type === 'TSExportAssignment' &&
+      isAstNode(statement.expression)
+    ) {
+      legacyExports.set('default', statement.expression);
+    }
+    if (statement.type === 'ExportNamedDeclaration') {
+      if (isAstNode(statement.source) || statement.exportKind === 'type')
+        continue;
+      if (
+        isAstNode(statement.declaration) &&
+        statement.declaration.type === 'VariableDeclaration'
+      ) {
+        record(statement.declaration, true);
+      }
+      for (const specifier of astArray(statement.specifiers)) {
+        if (specifier.exportKind === 'type') continue;
+        const local = identifier(specifier.local);
+        const exported =
+          identifier(specifier.exported) ??
+          (isAstNode(specifier.exported) &&
+          specifier.exported.type === 'Literal' &&
+          typeof specifier.exported.value === 'string'
+            ? specifier.exported.value
+            : null);
+        if (local && exported)
+          exports.set(exported, { type: 'Identifier', name: local });
+      }
+    }
+    if (
+      statement.type === 'ExpressionStatement' &&
+      isAstNode(statement.expression) &&
+      statement.expression.type === 'AssignmentExpression'
+    ) {
+      const left = isAstNode(statement.expression.left)
+        ? statement.expression.left
+        : null;
+      const right = isAstNode(statement.expression.right)
+        ? statement.expression.right
+        : null;
+      if (left?.type === 'MemberExpression' && !left.computed && right) {
+        const object = isAstNode(left.object) ? left.object : null;
+        if (
+          identifier(object) === 'module' &&
+          identifier(left.property) === 'exports'
+        ) {
+          legacyExports.set('default', right);
+        } else if (
+          identifier(object) === 'exports' &&
+          identifier(left.property) === 'default'
+        ) {
+          legacyExports.set('default', right);
+        }
+      }
+    }
+  }
+  const resolve = (
+    node: AstNode | null,
+    seen = new Set<string>(),
+  ): AstNode | null => {
+    const value = unwrap(node);
+    if (value?.type === 'UnaryExpression' && value.operator === 'void') {
+      const operand = unwrap(isAstNode(value.argument) ? value.argument : null);
+      if (operand?.type === 'Literal')
+        return { type: 'Literal', value: undefined };
+    }
+    const name = identifier(value);
+    if (!name) return value;
+    if (name === 'undefined' && !declarations.has(name))
+      return { type: 'Literal', value: undefined };
+    if (seen.has(name)) return null;
+    return resolve(declarations.get(name) ?? null, new Set(seen).add(name));
+  };
+  const staticKey = (node: AstNode | null): string | null => {
+    const value = resolve(node);
+    if (
+      value?.type === 'Literal' &&
+      (typeof value.value === 'string' || typeof value.value === 'number')
+    ) {
+      return String(value.value);
+    }
+    if (
+      value?.type === 'TemplateLiteral' &&
+      astArray(value.expressions).length === 0
+    ) {
+      const quasi = astArray(value.quasis)[0];
+      const cooked =
+        quasi?.value && typeof quasi.value === 'object'
+          ? (quasi.value as { cooked?: unknown }).cooked
+          : null;
+      return typeof cooked === 'string' ? cooked : null;
+    }
+    return null;
+  };
+  const property = (
+    node: AstNode | null,
+    key: string,
+    ancestors = new Set<AstNode>(),
+  ): Property => {
+    if (!node) return { kind: 'absent' };
+    const object = resolve(node);
+    if (object?.type === 'Literal' && object.value == null)
+      return { kind: 'absent' };
+    if (object?.type !== 'ObjectExpression' || ancestors.has(object))
+      return { kind: 'unknown' };
+    const next = new Set(ancestors).add(object);
+    for (const entry of astArray(object.properties).reverse()) {
+      if (entry.type === 'SpreadElement') {
+        const spread = property(
+          isAstNode(entry.argument) ? entry.argument : null,
+          key,
+          next,
+        );
+        if (spread.kind !== 'absent') return spread;
+        continue;
+      }
+      if (entry.type !== 'Property') return { kind: 'unknown' };
+      const name = entry.computed
+        ? staticKey(isAstNode(entry.key) ? entry.key : null)
+        : (identifier(entry.key) ??
+          staticKey(isAstNode(entry.key) ? entry.key : null));
+      if (name === null) return { kind: 'unknown' };
+      if (name !== key) continue;
+      if (entry.kind !== 'init' || entry.method) return { kind: 'unknown' };
+      return isAstNode(entry.value)
+        ? { kind: 'found', value: entry.value }
+        : { kind: 'unknown' };
+    }
+    return { kind: 'absent' };
+  };
+  const callMarker = (call: AstNode): Property => {
+    const args = astArray(call.arguments);
+    const first = resolve(args[0] ?? null);
+    const objectForm = first?.type === 'ObjectExpression' || args.length === 1;
+    const options = objectForm ? (args[0] ?? null) : (args[2] ?? null);
+    const direct = property(options, 'compatibility');
+    let compatibility = direct;
+    // definePlay uses whole-object nullish precedence, never merges bindings.
+    if (
+      direct.kind === 'absent' ||
+      (direct.kind === 'found' &&
+        resolve(direct.value)?.type === 'Literal' &&
+        resolve(direct.value)?.value == null)
+    ) {
+      const bindings = objectForm
+        ? property(options, 'bindings')
+        : ({ kind: 'absent' } as Property);
+      compatibility =
+        bindings.kind === 'found'
+          ? property(bindings.value, 'compatibility')
+          : bindings;
+    }
+    return compatibility.kind === 'found'
+      ? property(compatibility.value, 'authoringContract')
+      : compatibility;
+  };
+  const reachesMarker = (
+    node: AstNode | null,
+    seen = new Set<AstNode>(),
+  ): boolean => {
+    const value = resolve(node);
+    if (!value || seen.has(value)) return false;
+    seen.add(value);
+    // A handler's nested child declaration does not declare its parent edition.
+    if (
+      [
+        'FunctionExpression',
+        'ArrowFunctionExpression',
+        'FunctionDeclaration',
+      ].includes(value.type)
+    )
+      return false;
+    if (
+      (isDefinePlayCall(value) ||
+        (value.type === 'CallExpression' &&
+          defineAliases.has(identifier(value.callee) ?? ''))) &&
+      callMarker(value).kind !== 'absent'
+    )
+      return true;
+    return Object.values(value).some((child) =>
+      isAstNode(child)
+        ? reachesMarker(child, seen)
+        : Array.isArray(child) &&
+          astArray(child).some((entry) => reachesMarker(entry, seen)),
+    );
+  };
+  const requested = exportName ?? 'default';
+  const local = exports.get(requested);
+  const expression = resolve(
+    local ??
+      legacyExports.get(requested) ??
+      (exportName === null ? (definitions[0] ?? null) : null),
+  );
+  if (!expression || expression.type !== 'CallExpression') {
+    return {
+      marker: {
+        kind:
+          (local && !expression) || reachesMarker(expression)
+            ? 'unknown'
+            : 'absent',
+      },
+      localExport: false,
+    };
+  }
+  const recognized = isDefinePlayCall(expression);
+  const marker = callMarker(expression);
+  if (!recognized && marker.kind === 'absent' && reachesMarker(expression)) {
+    return { marker: { kind: 'unknown' }, localExport: false };
+  }
+  if (marker.kind !== 'found') return { marker, localExport: Boolean(local) };
+  // Historical wrappers remain unmarked. An explicit marker on a wrapper or
+  // imported helper alias cannot silently downgrade to legacy behavior.
+  if (!recognized) return { marker: { kind: 'unknown' }, localExport: false };
+  const value = resolve(marker.value);
+  return {
+    marker:
+      value?.type === 'Literal'
+        ? { kind: 'value', value: value.value }
+        : { kind: 'unknown' },
+    localExport: Boolean(local),
+    definition: expression,
+  };
+}
+
+/** Source defaults and stored snapshot defaults are deliberately independent. */
+export function resolvePlaySourceAuthoringContractEdition(
+  marker: PlaySourceAuthoringEdition,
+  pinnedEdition?: PlayAuthoringContractEdition,
+): PlayAuthoringContractEdition {
+  if (marker.kind === 'unknown') {
+    throw new PlayAuthoringFieldValidationError(
+      'compatibility.authoringContract',
+      'play_authoring_binding_invalid',
+      'compatibility.authoringContract must be statically resolvable; declare "explicit-freshness" to opt into explicit freshness.',
+    );
+  }
+  if (marker.kind === 'absent')
+    return pinnedEdition ?? PLAY_AUTHORING_CONTRACT_EDITION;
+  validatePlayAuthoringField('compatibility.authoringContract', marker.value);
+  if (
+    pinnedEdition !== undefined &&
+    pinnedEdition !== 10 &&
+    pinnedEdition !== PLAY_AUTHORING_CONTRACT_EDITION
+  ) {
+    throw new PlayAuthoringFieldValidationError(
+      'compatibility.authoringContract',
+      'play_authoring_binding_invalid',
+      `The source explicit-freshness contract requires authoringContractEdition ${PLAY_AUTHORING_CONTRACT_EDITION}; artifact-pinned edition 10 remains valid only for an already-published artifact.`,
+    );
+  }
+  // Keep already-published edition-10 artifacts on their admitted contract.
+  // Newly authored marked source adopts the current strict writer edition.
+  return pinnedEdition === 10 ? 10 : PLAY_AUTHORING_CONTRACT_EDITION;
+}

package/dist/bundling-sources/shared_libs/plays/tool-list-getter-mode.ts

@@ -0,0 +1,9 @@
+import type { PlayAuthoringContractEdition } from './authoring-contract';
+export type { PlayAuthoringContractEdition } from './authoring-contract';
+
+/** CLI presentation shares getter policy without initializing Play schemas. */
+export function playToolListGetterMode(
+  edition: PlayAuthoringContractEdition | undefined = undefined,
+): 'dataset' | 'array' {
+  return edition === undefined || edition >= 10 ? 'array' : 'dataset';
+}

package/dist/bundling-sources/shared_libs/plays/tool-result-types.ts

@@ -299,7 +299,7 @@ export type ToolExecuteResultAccessors<
  * Provider data: `toolResponse.rawV2`; metadata: `toolResponse.meta`.
  * Single-value getters: `extractedValues.<name>.get()`; lists: `extractedLists.<name>.get()`.
  *
- * Prefer declared getters. New Plays (edition 10) receive ordinary arrays from
+ * Prefer declared getters. Edition 10 and later Plays receive ordinary arrays from
  * list `.get()` synchronously; persist explicitly with ctx.dataset. Lazy or
  * incomplete lists throw: use readList(result, path) for explicit dataset access.
  * Provider pagination requires a separate request; getters never fetch it.

package/dist/cli/{auth-5HIIACF7.mjs → auth-LLXLIILR.mjs}

@@ -13,13 +13,13 @@ import {
   reportSetupCompleted,
   resolvePendingAuthClaimForResume,
   statusBannerLine
-} from "./chunk-FHPCKULR.mjs";
-import "./chunk-JRAVVJ3T.mjs";
-import "./chunk-2PRO2JTX.mjs";
-import "./chunk-YHPYUZZX.mjs";
+} from "./chunk-PZSLPBDA.mjs";
+import "./chunk-5V5Y37BC.mjs";
+import "./chunk-RFB25DSQ.mjs";
+import "./chunk-MAMVGOSC.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-NXGCO4JB.mjs";
-import "./chunk-TQNHMWUR.mjs";
+import "./chunk-E4IXDAZI.mjs";
+import "./chunk-2YR7BIIC.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {

package/dist/cli/auth-UG4WOYGL.js

@@ -0,0 +1,40 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkFZJAM576js = require('./chunk-FZJAM576.js');
+require('./chunk-NF4V5DTY.js');
+require('./chunk-FVLNYDI4.js');
+require('./chunk-NPBJI7RE.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-PPDBRJRW.js');
+require('./chunk-5UUQAGJS.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunkFZJAM576js.EXIT_WORKSPACE_MISMATCH; exports.authStatusLine = _chunkFZJAM576js.authStatusLine; exports.clearPendingClaim = _chunkFZJAM576js.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunkFZJAM576js.clearSatisfiedPendingClaim; exports.handleRegister = _chunkFZJAM576js.handleRegister; exports.handleStatus = _chunkFZJAM576js.handleStatus; exports.handleWait = _chunkFZJAM576js.handleWait; exports.httpJson = _chunkFZJAM576js.httpJson; exports.readPendingAuthClaim = _chunkFZJAM576js.readPendingAuthClaim; exports.readStatusBanner = _chunkFZJAM576js.readStatusBanner; exports.registerAuthCommands = _chunkFZJAM576js.registerAuthCommands; exports.reportSetupCompleted = _chunkFZJAM576js.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunkFZJAM576js.resolvePendingAuthClaimForResume; exports.statusBannerLine = _chunkFZJAM576js.statusBannerLine;