deepline 0.3.393 → 0.3.394

package/dist/bundling-sources/shared_libs/plays/authoring-contract.ts

@@ -15,6 +15,16 @@ export const LEGACY_PLAY_AUTHORING_CONTRACT_EDITION = 1 as const;
 // Edition 11 readers retain every CSV source row. Promote this writer in the
 // follow-up PR after those readers are deployed everywhere.
 export const PLAY_AUTHORING_CONTRACT_EDITION = 10 as const;
+export const PLAY_AUTHORING_SLACK_INTERACTIVE_MESSAGE_STRICT_THRESHOLD =
+  10 as const;
+export const EXPLICIT_FRESHNESS_PLAY_AUTHORING_THRESHOLD = 11 as const;
+const EXPLICIT_FRESHNESS_STALE_AFTER_SECONDS_DESCRIPTION = [
+  'Edition 11 requires an explicit choice.',
+  '`0` starts a fresh logical call, though a matching operation receipt may recover that same operation after resume;',
+  '`null` allows indefinite result reuse;',
+  'a positive integer is the maximum result age in seconds.',
+  'Omitted values retain legacy behavior in older editions.',
+].join(' ');
 export const PLAY_AUTHORING_INPUT_SCHEMA_SNAPSHOT_EDITION = 3 as const;
 export const SUPPORTED_PLAY_AUTHORING_CONTRACT_EDITIONS = [
   1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
@@ -98,7 +108,7 @@ const PLAY_AUTHORING_CONTRACT_CHANGELOG_DETAILS = [
   },
   {
     changed:
-      'CSV datasets always use source row identity and process every input occurrence, even when key or rowIdentity: "key" is supplied. Editions 1–10 retain their admitted row identity and completed receipts; non-CSV datasets retain explicit key deduplication.',
+      'Requires explicit freshness and semantic identity for supported durable calls, and gives CSV datasets source-row identity so every input occurrence is processed even when key or rowIdentity: "key" is supplied. Edition 10 retains its list-getter behavior and editions 1–10 retain their admitted CSV identity and completed receipts; non-CSV datasets keep explicit key deduplication.',
     compatibilityOwner: 'Plays Runtime',
     newWritesEnd: null,
     readerRemoval: null,
@@ -141,7 +151,7 @@ export const PLAY_AUTHORING_RUNTIME_CAPABILITIES = [
     capability: 'Web Crypto',
     surface: '`crypto.subtle`',
     contract:
-      'WebCrypto is available for standards-based signing, verification, encryption, and key import. Keep private material in `ctx.secrets`; `docs-examples/sdk-v2/github-app-jwt.play.ts` signs an RS256 GitHub App JWT and uses `staleAfterSeconds: 0` for its time-varying auth exchange.',
+      'WebCrypto is available for standards-based signing, verification, encryption, and key import. Keep private material in `ctx.secrets`. `docs-examples/sdk-v2/github-app-jwt.play.ts` is an edition-10 compatibility example; edition 11 allows transient fetches only for read-only methods, so do not copy its credential-returning POST into new source.',
   },
   {
     capability: 'Workspace secrets',
@@ -153,7 +163,7 @@ export const PLAY_AUTHORING_RUNTIME_CAPABILITIES = [
     capability: 'Freshness',
     surface: '`staleAfterSeconds` on durable calls',
     contract:
-      'This is call-receipt freshness: omitted/null reuses forever, zero always executes, and a positive integer is a TTL in seconds. It never changes dataset or request identity.',
+      'New source in edition 11 must choose freshness explicitly. Zero executes a new logical call, a positive integer is a maximum result age in seconds, and null allows indefinite reuse. A completed operation receipt separately recovers the same intended operation after resume.',
   },
 ] as const;
 
@@ -1040,7 +1050,7 @@ export type PlayAuthoringStepOptions<Row, Value = unknown> = {
   /** Legacy error-recompute flag accepted for older authored Plays. */
   readonly recomputeOnError?: boolean;
   /** Legacy cell staleness metadata accepted for older authored Plays. */
-  readonly staleAfterSeconds?: number;
+  readonly staleAfterSeconds?: DurableCallStaleAfterSeconds;
 };
 
 /** Explicitly mark a step program as a provider fallback waterfall. */
@@ -1104,7 +1114,7 @@ export type PlayAuthoringStepProgramStep<TContext> = {
   readonly name: string;
   readonly recompute?: boolean;
   readonly recomputeOnError?: boolean;
-  readonly staleAfterSeconds?: number;
+  readonly staleAfterSeconds?: DurableCallStaleAfterSeconds;
   readonly resolver:
     | PlayAuthoringStepResolver<Record<string, unknown>, unknown, TContext>
     | PlayAuthoringConditionalStepResolver<
@@ -1146,7 +1156,7 @@ export type PlayAuthoringDatasetDefinitionOptions<InputRow extends object> = {
 export type PlayAuthoringDatasetRunOptions<InputRow extends object> = {
   description?: string;
   key?: PlayAuthoringDatasetRowKey<InputRow>;
-  /** CSV defaults to source row identity. Use key only for intentional deduplication. */
+  /** Edition 11 CSVs always use source-row identity; key-based deduplication remains for non-CSV inputs and earlier editions. */
   rowIdentity?: 'source_row' | 'key';
   onRowError?: 'isolate' | 'fail';
   mode?: 'upsert' | 'net_new';
@@ -1359,8 +1369,10 @@ export type PlayAuthoringRuntimeStepOptions = {
 /**
  * Durable freshness for one `ctx.fetch` call. The key identifies the request;
  * `staleAfterSeconds` controls when that completed request may be reused across
- * Play runs. Omit it (or pass `null`) to reuse indefinitely, pass `0` to
- * execute on every new run, or pass a positive number of seconds for a TTL.
+ * Play runs. Edition 11 requires an explicit choice: `null` reuses indefinitely,
+ * `0` executes on every new run, and a positive whole number sets the maximum
+ * result age. Retained results are supported only for read methods (GET, HEAD,
+ * OPTIONS); mutating methods require `0`. Transient calls do not retain results.
  *
  * Use this for polling or periodically refreshing one external resource. It
  * does not change dataset row identity.
@@ -1368,7 +1380,7 @@ export type PlayAuthoringRuntimeStepOptions = {
  */
 export type PlayAuthoringFetchOptions = {
   staleAfterSeconds?: DurableCallStaleAfterSeconds;
-  /** Run through Deepline's guarded outbound path without retaining a response receipt or checkpoint. Use this for short-lived credential exchanges or other response data that should stay in the running Play only. */
+  /** Run through Deepline's guarded outbound path without retaining a response receipt or checkpoint. Edition 11 permits transient fetches only for GET, HEAD, and OPTIONS. */
   transient?: boolean;
 };
 
@@ -1446,6 +1458,8 @@ export class CtxFetchHttpError extends Error {
 }
 
 export type PlayAuthoringCustomerDbQueryOptions = {
+  id?: string;
+  staleAfterSeconds?: 0;
   maxRows?: number;
   timeoutMs?: number;
 };
@@ -1571,7 +1585,10 @@ export interface PlayAuthoringRuntimeContext<
     key: string,
     toolId: string,
     input: Record<string, unknown>,
-    options?: { description?: string },
+    options?: {
+      description?: string;
+      staleAfterSeconds?: DurableCallStaleAfterSeconds;
+    },
   ): Promise<
     TListGetter extends 'array'
       ? BasicToolExecuteResult<TOutput>
@@ -1602,7 +1619,7 @@ export interface PlayAuthoringRuntimeContext<
   ): Promise<T>;
 
   /**
-   * Execute a guarded HTTP request. By default, completed responses are durably reused; `staleAfterSeconds` governs only that completed call receipt, never dataset/request identity. Failed requests do not publish completed cache entries. A headers timeout leaves an upstream write's outcome unknown and does not establish whether its body was sent. The transport does not automatically retry that timed-out write, but a later invocation can execute it again. Mutating requests require provider-supported idempotency with the same key retained across retries and replay. Deadlines are platform-controlled; callers may cancel through `init.signal`. Pass `{ transient: true }` for short-lived credential exchanges or other response data that must not be retained in a receipt or checkpoint. Edition 5+ throws `CtxFetchHttpError` for non-2xx; catch it only when the Play intentionally recovers, otherwise let it fail the Play. Editions 1–4 retain their previous response projections.
+   * Execute a guarded HTTP request. Edition 11 requires an explicit freshness choice; only GET, HEAD, and OPTIONS can retain completed responses. Mutating methods must use `staleAfterSeconds: 0`; the choice governs only the completed call receipt, never dataset/request identity. Failed requests do not publish completed cache entries. A headers timeout leaves an upstream write's outcome unknown and does not establish whether its body was sent. The transport does not automatically retry that timed-out write, but a later invocation can execute it again. Mutating requests require provider-supported idempotency with the same key retained across retries and replay. Deadlines are platform-controlled; callers may cancel through `init.signal`. Pass `{ transient: true }` only on GET, HEAD, and OPTIONS when the response must not be retained in a receipt or checkpoint; edition 11 rejects transient writes. Edition 5+ throws `CtxFetchHttpError` for non-2xx; catch it only when the Play intentionally recovers, otherwise let it fail the Play. Editions 1–4 retain their previous response projections.
    *
    * @sdkReference runtime 170 ctx.fetch(key, url, init)
    */
@@ -2273,8 +2290,7 @@ export const PLAY_AUTHORING_FIELD_REGISTRY = {
     required: false,
     resolution: 'runtime-allowed',
     issueCode: 'play_authoring_durable_policy_invalid',
-    description:
-      '`0` always executes; `null`/omitted never expires; a positive integer is a TTL in seconds.',
+    description: EXPLICIT_FRESHNESS_STALE_AFTER_SECONDS_DESCRIPTION,
     errorMessage:
       'staleAfterSeconds must be null, 0 (always execute), or a positive whole number of seconds.',
   },
@@ -2547,7 +2563,7 @@ export const PLAY_AUTHORING_FIELD_REGISTRY = {
     resolution: 'static-when-present',
     issueCode: 'play_authoring_dataset_option_invalid',
     description:
-      'Select source_row to process every input occurrence. CSV datasets default to source_row in edition 11; earlier editions retain key identity. Select key only to intentionally deduplicate business keys.',
+      'Edition 11 CSV inputs always use source-row occurrence identity, even with rowIdentity: key; key-based deduplication remains available for non-CSV inputs and editions 1–10.',
     errorMessage: 'ctx.dataset run rowIdentity must be "source_row" or "key".',
   },
   'ctx.dataset.run.onRowError': {
@@ -2646,8 +2662,7 @@ export const PLAY_AUTHORING_FIELD_REGISTRY = {
     required: false,
     resolution: 'runtime-dynamic',
     issueCode: 'play_authoring_durable_policy_invalid',
-    description:
-      'Checkpoint freshness: null/omitted never expires, 0 always executes.',
+    description: EXPLICIT_FRESHNESS_STALE_AFTER_SECONDS_DESCRIPTION,
     errorMessage:
       'staleAfterSeconds must be null, 0 (always execute), or a positive whole number of seconds.',
   },
@@ -2681,8 +2696,7 @@ export const PLAY_AUTHORING_FIELD_REGISTRY = {
     required: false,
     resolution: 'runtime-dynamic',
     issueCode: 'play_authoring_durable_policy_invalid',
-    description:
-      'Fetch freshness: null/omitted never expires, 0 always executes.',
+    description: EXPLICIT_FRESHNESS_STALE_AFTER_SECONDS_DESCRIPTION,
     errorMessage:
       'staleAfterSeconds must be null, 0 (always execute), or a positive whole number of seconds.',
   },
@@ -2936,6 +2950,39 @@ export const PLAY_AUTHORING_FIELD_REGISTRY = {
     errorMessage:
       'ctx.customerDb.query statement must be a non-empty SQL string. Deprecated SqlQuery objects cannot contain parameter values.',
   },
+  'ctx.customerDb.query.options.id': {
+    schema: Type.String({ pattern: '\\S' }),
+    fixtures: {
+      valid: 'customer-report-read',
+      invalid: '',
+      absent: undefined,
+      unresolved: { expression: 'operationId' },
+      edition1: 'query',
+    },
+    referenceType: 'string',
+    required: true,
+    resolution: 'runtime-dynamic',
+    issueCode: 'play_authoring_tool_request_invalid',
+    description: 'Stable operation identity for Customer DB query recovery.',
+    errorMessage:
+      'ctx.customerDb.query options.id must be a non-empty stable string.',
+  },
+  'ctx.customerDb.query.options.staleAfterSeconds': {
+    schema: Type.Literal(0),
+    fixtures: {
+      valid: 0,
+      invalid: 1,
+      absent: undefined,
+      unresolved: { expression: 'ttl' },
+      edition1: 0,
+    },
+    referenceType: 'number | null',
+    required: false,
+    resolution: 'runtime-dynamic',
+    issueCode: 'play_authoring_durable_policy_invalid',
+    description: 'Customer DB queries always execute with freshness 0.',
+    errorMessage: 'Customer DB queries must use staleAfterSeconds: 0.',
+  },
   'ctx.customerDb.query.options.maxRows': {
     schema: Type.Integer({ minimum: 1 }),
     fixtures: {
@@ -3337,13 +3384,13 @@ export const PLAY_AUTHORING_CLOUD_TYPE_DECLARATIONS = [
   'export type DatasetColumnRunInput<Row, Value> = { readonly row: Row; readonly ctx: DeeplinePlayRuntimeContext; readonly index: number; readonly previousCell?: PreviousCell<Value> };',
   'export type DatasetColumnDefinition<Row, Value> = { readonly run: (input: DatasetColumnRunInput<Row, Value>) => Value | Promise<Value>; readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean> };',
   "export type ConditionalStepResolver<Row, Value, Else = null> = { readonly kind: 'conditional'; readonly when: (row: Row, index: number) => boolean | Promise<boolean>; readonly run: StepResolver<Row, Value>; readonly elseValue: Else; else<ValueElse>(value: ValueElse): ConditionalStepResolver<Row, Value, ValueElse>; };",
-  'export type StepOptions<Row, Value = unknown> = { readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean>; readonly recompute?: boolean; readonly recomputeOnError?: boolean; readonly staleAfterSeconds?: number };',
+  'export type StepOptions<Row, Value = unknown> = { readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean>; readonly recompute?: boolean; readonly recomputeOnError?: boolean; readonly staleAfterSeconds?: DurableCallStaleAfterSeconds };',
   'export type StepProgramOptions = { readonly continueOnProviderUnavailable?: boolean };',
   "export type StepProgram<Input, Output, Return = Output> = { readonly kind: 'steps'; readonly steps: readonly PlayStepProgramStep[]; readonly returnResolver?: StepResolver<Output, Return>; readonly continueOnProviderUnavailable?: boolean; readonly __inputType?: (input: Input) => void; step<Name extends string, Value>(name: Name, resolver: StepResolver<Output, Value> | ConditionalStepResolver<Output, Value> | StepProgramResolver<Output, Value>): StepProgram<Input, Output & Record<Name, Value>, Return>; step<Name extends string, Value>(name: Name, resolver: StepResolver<Output, Value> | StepProgramResolver<Output, Value>, options: StepOptions<Output, Value>): StepProgram<Input, Output & Record<Name, Value | null>, Return>; return<Value>(resolver: StepResolver<Output, Value>): StepProgram<Input, Output, Value>; };",
   "export type StepProgramResolver<Input, Return> = { readonly kind: 'steps'; readonly steps: readonly PlayStepProgramStep[]; readonly returnResolver?: StepResolver<never, Return>; readonly __inputType?: (input: Input) => void };",
   "export type RunnableStepProgram<Input, Return> = Pick<StepProgram<Input, never, Return>, 'kind' | 'steps' | 'returnResolver' | '__inputType'>;",
   "export type RunnableColumnStepProgram<Return> = Pick<StepProgramResolver<unknown, Return>, 'kind' | 'steps' | 'returnResolver'>;",
-  'export type PlayStepProgramStep = { readonly name: string; readonly recompute?: boolean; readonly recomputeOnError?: boolean; readonly staleAfterSeconds?: number; readonly resolver: StepResolver<Record<string, unknown>, unknown> | ConditionalStepResolver<Record<string, unknown>, unknown> | StepProgramResolver<Record<string, unknown>, unknown> };',
+  'export type PlayStepProgramStep = { readonly name: string; readonly recompute?: boolean; readonly recomputeOnError?: boolean; readonly staleAfterSeconds?: DurableCallStaleAfterSeconds; readonly resolver: StepResolver<Record<string, unknown>, unknown> | ConditionalStepResolver<Record<string, unknown>, unknown> | StepProgramResolver<Record<string, unknown>, unknown> };',
   'export type ColumnResolver<Row, Value> = StepResolver<Row, Value> | ConditionalStepResolver<Row, Value> | RunnableColumnStepProgram<Value>;',
   'export type StepProgramOutput<TProgram> = TProgram extends StepProgram<unknown, infer Output, unknown> ? Output : never;',
   'export type DatasetRowKey<InputRow extends object> = (keyof InputRow & string) | readonly (keyof InputRow & string)[] | ((row: InputRow, index: number) => string | number | readonly unknown[]);',
@@ -3368,8 +3415,8 @@ export const PLAY_AUTHORING_CLOUD_TYPE_DECLARATIONS = [
   '  readonly run: { readonly id: string };',
   `  runSteps<TInput extends Record<string, unknown>, TOutput>(program: RunnableStepProgram<TInput, TOutput>, input: TInput, options?: { description?: ${cloudReferenceType('ctx.runSteps.options.description')} }): Promise<TOutput>;`,
   '  tools: { execute<K extends string>(request: ToolExecutionRequest<K>): Promise<ToolExecutionOutput<K>> };',
-  `  customerDb: { query<TRow extends Record<string, unknown> = Record<string, unknown>>(statement: SqlQuery, options?: { maxRows?: ${cloudReferenceType('ctx.customerDb.query.options.maxRows')}; timeoutMs?: ${cloudReferenceType('ctx.customerDb.query.options.timeoutMs')} }): Promise<TRow[]> };`,
-  `  tool<K extends string>(key: ${cloudReferenceType('ctx.tool.key')}, toolId: K, input: ${cloudReferenceType('ctx.tool.input')}, options?: { description?: ${cloudReferenceType('ctx.tool.options.description')} }): Promise<ToolExecutionOutput<K>>;`,
+  `  customerDb: { query<TRow extends Record<string, unknown> = Record<string, unknown>>(statement: SqlQuery, options?: { id?: ${cloudReferenceType('ctx.customerDb.query.options.id')}; staleAfterSeconds?: ${cloudReferenceType('ctx.customerDb.query.options.staleAfterSeconds')}; maxRows?: ${cloudReferenceType('ctx.customerDb.query.options.maxRows')}; timeoutMs?: ${cloudReferenceType('ctx.customerDb.query.options.timeoutMs')} }): Promise<TRow[]> };`,
+  `  tool<K extends string>(key: ${cloudReferenceType('ctx.tool.key')}, toolId: K, input: ${cloudReferenceType('ctx.tool.input')}, options?: { description?: ${cloudReferenceType('ctx.tool.options.description')}; staleAfterSeconds?: DurableCallStaleAfterSeconds }): Promise<ToolExecutionOutput<K>>;`,
   '  step<T>(id: string, run: () => T | Promise<T>, options?: RuntimeStepOptions): Promise<T>;',
   "  fetch(key: string, url: string | URL, init?: RequestInit & { headers?: HeadersInit & { 'Idempotency-Key'?: string; 'X-Idempotency-Key'?: string }; auth?: SecretAuthInput }, options?: FetchOptions): Promise<PlayFetchResponse>;",
   '  secrets: { get(name: string): SecretPromise; bearer(secret: string | SecretPromise | SecretHandle): SecretAuth; header(header: string, secret: string | SecretPromise | SecretHandle): SecretAuth };',

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

@@ -270,7 +270,7 @@ class PlayCoreStepProgram<Input, Output, ReturnValue> implements StepProgram<
           ...(options?.recomputeOnError === true
             ? { recomputeOnError: true }
             : {}),
-          ...(typeof options?.staleAfterSeconds === 'number'
+          ...(options?.staleAfterSeconds !== undefined
             ? { staleAfterSeconds: options.staleAfterSeconds }
             : {}),
           resolver: stepResolver as PlayStepProgramStep['resolver'],

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

@@ -40,6 +40,24 @@ export type ToolResultExecutionMetadata = {
   /** Canonical saved result identity; receiptKey may name a transport alias. */
   resultReceiptKey?: string;
   attachedToReceiptKey?: string;
+  /** Freshness and operation recovery are independent of provider idempotency. */
+  freshness?: CallFreshnessMetadata;
+  /** Time the live result completed, retained unchanged through recovery. */
+  completedAt?: number;
+};
+
+export type CallFreshnessMetadata = {
+  requestedStaleAfterSeconds: number | null;
+  effectiveStaleAfterSeconds: number | null;
+  source:
+    | 'executed'
+    | 'operation_recovery'
+    | 'reusable_result'
+    | 'live_observation';
+  resultAgeMs: number;
+  completedAt: number;
+  operationReceiptKey?: string;
+  unavailableReason?: string;
 };
 
 export type ToolResultTargetMetadata = {

package/dist/cli/auth-IHKISLJQ.js

@@ -0,0 +1,39 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk354JCXA2js = require('./chunk-354JCXA2.js');
+require('./chunk-KGNTKMRG.js');
+require('./chunk-CS6RAIVY.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-7P5AA3SN.js');
+require('./chunk-6YAUMG27.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunk354JCXA2js.EXIT_WORKSPACE_MISMATCH; exports.authStatusLine = _chunk354JCXA2js.authStatusLine; exports.clearPendingClaim = _chunk354JCXA2js.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunk354JCXA2js.clearSatisfiedPendingClaim; exports.handleRegister = _chunk354JCXA2js.handleRegister; exports.handleStatus = _chunk354JCXA2js.handleStatus; exports.handleWait = _chunk354JCXA2js.handleWait; exports.httpJson = _chunk354JCXA2js.httpJson; exports.readPendingAuthClaim = _chunk354JCXA2js.readPendingAuthClaim; exports.readStatusBanner = _chunk354JCXA2js.readStatusBanner; exports.registerAuthCommands = _chunk354JCXA2js.registerAuthCommands; exports.reportSetupCompleted = _chunk354JCXA2js.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunk354JCXA2js.resolvePendingAuthClaimForResume; exports.statusBannerLine = _chunk354JCXA2js.statusBannerLine;

package/dist/cli/{auth-5PXHA232.mjs → auth-OSXDAVCF.mjs}

@@ -13,12 +13,12 @@ import {
   reportSetupCompleted,
   resolvePendingAuthClaimForResume,
   statusBannerLine
-} from "./chunk-FQ6VHPW4.mjs";
-import "./chunk-5PRVMXKB.mjs";
-import "./chunk-LMMEAMA7.mjs";
+} from "./chunk-MFB2VKBO.mjs";
+import "./chunk-NR3DFKNF.mjs";
+import "./chunk-FJGW5GXU.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import "./chunk-NXGCO4JB.mjs";
-import "./chunk-LZPCDB7U.mjs";
+import "./chunk-TJI2EN6K.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {