@kensio/yulin 1.21.28 → 1.21.30

package/dist/sdk/wire/sim-sdk-wire-bedrock-action.d.ts

@@ -0,0 +1,18 @@
+import type { SimSdkWireRequest, SimSdkWireResponse } from "./sim-sdk-wire.types.js";
+/**
+ * The REST-JSON content type, for bodies and for errors.
+ */
+export declare const simSdkWireBedrockJsonContentType = "application/json";
+/**
+ * How one Bedrock Runtime operation reads its input off a request and writes
+ * its output back.
+ */
+export interface SimSdkWireBedrockAction {
+    readonly commandName: string;
+    input(modelId: string, request: SimSdkWireRequest): unknown;
+    outputResponse(output: unknown): Promise<SimSdkWireResponse>;
+}
+/**
+ * The invocation operations, keyed by the last segment of their path.
+ */
+export declare const simSdkWireBedrockActions: ReadonlyMap<string, SimSdkWireBedrockAction>;

package/dist/sdk/wire/sim-sdk-wire-bedrock-action.js

@@ -0,0 +1,71 @@
+import { simSdkWireConverseInput, simSdkWireInvokeInput, } from "./sim-sdk-wire-bedrock-input.js";
+import { simSdkWireEventStreamBody, simSdkWireEventStreamContentType, } from "./sim-sdk-wire-event-stream.js";
+import { simSdkWireOutputResponse } from "./sim-sdk-wire-response.js";
+/**
+ * The REST-JSON content type, for bodies and for errors.
+ */
+export const simSdkWireBedrockJsonContentType = "application/json";
+/**
+ * The invocation operations, keyed by the last segment of their path.
+ */
+export const simSdkWireBedrockActions = new Map([
+    [
+        "converse",
+        {
+            commandName: "ConverseCommand",
+            input: simSdkWireConverseInput,
+            outputResponse: (output) => Promise.resolve(simSdkWireOutputResponse(output, simSdkWireBedrockJsonContentType)),
+        },
+    ],
+    [
+        "converse-stream",
+        {
+            commandName: "ConverseStreamCommand",
+            input: simSdkWireConverseInput,
+            outputResponse: async (output) => await eventStreamResponse(output.stream, {}),
+        },
+    ],
+    [
+        "invoke",
+        {
+            commandName: "InvokeModelCommand",
+            input: (modelId, request) => simSdkWireInvokeInput(modelId, request, "accept"),
+            outputResponse: invokeModelResponse,
+        },
+    ],
+    [
+        "invoke-with-response-stream",
+        {
+            commandName: "InvokeModelWithResponseStreamCommand",
+            input: (modelId, request) => simSdkWireInvokeInput(modelId, request, "x-amzn-bedrock-accept"),
+            outputResponse: async (output) => {
+                const { body, contentType } = output;
+                return await eventStreamResponse(body, {
+                    "x-amzn-bedrock-content-type": contentType,
+                });
+            },
+        },
+    ],
+]);
+/**
+ * `InvokeModel` answers with the model's own body as it is, labelled with its
+ * content type.
+ */
+function invokeModelResponse(output) {
+    const { body, contentType } = output;
+    return Promise.resolve({
+        statusCode: 200,
+        headers: { "content-type": contentType },
+        body,
+    });
+}
+/**
+ * The streaming operations answer with an event stream body.
+ */
+async function eventStreamResponse(events, headers) {
+    return {
+        statusCode: 200,
+        headers: { "content-type": simSdkWireEventStreamContentType, ...headers },
+        body: await simSdkWireEventStreamBody(events),
+    };
+}

package/dist/sdk/wire/sim-sdk-wire-bedrock-input.d.ts

@@ -0,0 +1,11 @@
+import type { SimSdkWireRequest } from "./sim-sdk-wire.types.js";
+/**
+ * `Converse` and `ConverseStream` send their input as the JSON body, less the
+ * model id the path carries.
+ */
+export declare function simSdkWireConverseInput(modelId: string, request: SimSdkWireRequest): unknown;
+/**
+ * The model invocations send the request body as it is, with every other
+ * member in a header.
+ */
+export declare function simSdkWireInvokeInput(modelId: string, request: SimSdkWireRequest, acceptHeaderName: string): unknown;

package/dist/sdk/wire/sim-sdk-wire-bedrock-input.js

@@ -0,0 +1,45 @@
+import { readSimSdkWireInput } from "./sim-sdk-wire-json.js";
+/**
+ * The Command input members `InvokeModel` and
+ * `InvokeModelWithResponseStream` carry in headers, with the header each one
+ * travels in. The two differ only in where they carry `accept`.
+ *
+ * Every one is read, including the ones the simulation refuses, so that a
+ * request naming a guardrail is refused here as it is through an intercepted
+ * client.
+ */
+const invokeHeaderMembers = [
+    ["contentType", "content-type"],
+    ["trace", "x-amzn-bedrock-trace"],
+    ["guardrailIdentifier", "x-amzn-bedrock-guardrailidentifier"],
+    ["guardrailVersion", "x-amzn-bedrock-guardrailversion"],
+    ["performanceConfigLatency", "x-amzn-bedrock-performanceconfig-latency"],
+    ["serviceTier", "x-amzn-bedrock-service-tier"],
+    ["requestMetadata", "x-amzn-bedrock-request-metadata"],
+];
+/**
+ * `Converse` and `ConverseStream` send their input as the JSON body, less the
+ * model id the path carries.
+ */
+export function simSdkWireConverseInput(modelId, request) {
+    return { ...readSimSdkWireInput(request.body), modelId };
+}
+/**
+ * The model invocations send the request body as it is, with every other
+ * member in a header.
+ */
+export function simSdkWireInvokeInput(modelId, request, acceptHeaderName) {
+    const members = [
+        ...invokeHeaderMembers,
+        ["accept", acceptHeaderName],
+    ].flatMap(([member, headerName]) => {
+        // oxlint-disable-next-line security/detect-object-injection -- this module's own fixed header names.
+        const value = request.headers[headerName];
+        return value === undefined ? [] : [[member, value]];
+    });
+    return {
+        ...Object.fromEntries(members),
+        modelId,
+        ...(request.body.byteLength > 0 && { body: request.body }),
+    };
+}

package/dist/sdk/wire/sim-sdk-wire-bedrock.d.ts

@@ -0,0 +1,10 @@
+import type { SimSdkWireCall } from "./sim-sdk-wire-call.js";
+import type { SimSdkWireRequest } from "./sim-sdk-wire.types.js";
+/**
+ * Read a Bedrock Runtime model invocation, which names its operation and its
+ * model in the path rather than in a header.
+ *
+ * A request counts as one when it was signed for Bedrock, or, unsigned, sent
+ * to a Bedrock Runtime endpoint, and its path is a model invocation.
+ */
+export declare function readSimSdkWireBedrockCall(request: SimSdkWireRequest): SimSdkWireCall | undefined;

package/dist/sdk/wire/sim-sdk-wire-bedrock.js

@@ -0,0 +1,47 @@
+import { simSdkWireBedrockActions, simSdkWireBedrockJsonContentType, } from "./sim-sdk-wire-bedrock-action.js";
+import { readSimSdkWireCredentialScope } from "./sim-sdk-wire-operation.js";
+import { simSdkWireErrorResponse } from "./sim-sdk-wire-response.js";
+/**
+ * The SDK `config.serviceId` of a `BedrockRuntimeClient`.
+ */
+const bedrockRuntimeServiceId = "Bedrock Runtime";
+/**
+ * The SigV4 signing name Bedrock Runtime requests are signed with.
+ */
+const bedrockSigningName = "bedrock";
+/**
+ * The path of a model invocation: `/model/{modelId}/{action}`, where the
+ * model id is URL-encoded and may be a whole ARN.
+ */
+const invocationPathPattern = /^\/model\/(?<modelId>[^/]+)\/(?<action>[a-z-]+)$/;
+/**
+ * Read a Bedrock Runtime model invocation, which names its operation and its
+ * model in the path rather than in a header.
+ *
+ * A request counts as one when it was signed for Bedrock, or, unsigned, sent
+ * to a Bedrock Runtime endpoint, and its path is a model invocation.
+ */
+export function readSimSdkWireBedrockCall(request) {
+    const signingName = readSimSdkWireCredentialScope(request)?.signingName;
+    const isBedrock = signingName === undefined
+        ? request.hostname.startsWith("bedrock-runtime.")
+        : signingName === bedrockSigningName;
+    if (!isBedrock || request.method.toUpperCase() !== "POST") {
+        return undefined;
+    }
+    const groups = invocationPathPattern.exec(request.path.split("?", 1)[0] ?? "")?.groups;
+    const action = simSdkWireBedrockActions.get(groups?.["action"] ?? "");
+    if (groups === undefined || action === undefined) {
+        return undefined;
+    }
+    // A malformed escape fails decoding, which is the service's answer to the
+    // request, so the model id is decoded when the input is read.
+    const encodedModelId = groups["modelId"] ?? "";
+    return {
+        serviceId: bedrockRuntimeServiceId,
+        commandName: action.commandName,
+        input: () => action.input(decodeURIComponent(encodedModelId), request),
+        outputResponse: async (output) => await action.outputResponse(output),
+        errorResponse: (error) => simSdkWireErrorResponse(error, simSdkWireBedrockJsonContentType),
+    };
+}

package/dist/sdk/wire/sim-sdk-wire-call.d.ts

@@ -0,0 +1,30 @@
+import type { SimSdkWireRequest, SimSdkWireResponse } from "./sim-sdk-wire.types.js";
+/**
+ * One wire request read back into the Command it was serialized from, with
+ * the protocol it came in to encode the answer in.
+ */
+export interface SimSdkWireCall {
+    /** The SDK `config.serviceId` of the service the request is addressed to. */
+    readonly serviceId: string;
+    /** The SDK Command class name the request would have been sent as. */
+    readonly commandName: string;
+    /**
+     * The Command input. Reading it can fail on a malformed body, and that
+     * failure is the service's answer to the request, so it is read when the
+     * operation runs.
+     */
+    input(): unknown;
+    /** The response for an output the simulated operation answered with. */
+    outputResponse(output: unknown): Promise<SimSdkWireResponse>;
+    /** The response for an error the simulated operation refused with. */
+    errorResponse(error: unknown): SimSdkWireResponse;
+}
+/**
+ * Read a wire request as the Command it was serialized from.
+ *
+ * Returns undefined for a request no reader here understands. The AWS JSON
+ * protocol services all name their operation in one header. Bedrock Runtime
+ * speaks REST-JSON, with the operation and model in the path, and has a
+ * reader of its own.
+ */
+export declare function readSimSdkWireCall(request: SimSdkWireRequest): SimSdkWireCall | undefined;

package/dist/sdk/wire/sim-sdk-wire-call.js

@@ -0,0 +1,32 @@
+import { readSimSdkWireBedrockCall } from "./sim-sdk-wire-bedrock.js";
+import { readSimSdkWireInput } from "./sim-sdk-wire-json.js";
+import { readSimSdkWireOperation } from "./sim-sdk-wire-operation.js";
+import { simSdkWireErrorResponse, simSdkWireOutputResponse, } from "./sim-sdk-wire-response.js";
+/**
+ * Read a wire request as the Command it was serialized from.
+ *
+ * Returns undefined for a request no reader here understands. The AWS JSON
+ * protocol services all name their operation in one header. Bedrock Runtime
+ * speaks REST-JSON, with the operation and model in the path, and has a
+ * reader of its own.
+ */
+export function readSimSdkWireCall(request) {
+    return readSimSdkWireJsonCall(request) ?? readSimSdkWireBedrockCall(request);
+}
+/**
+ * Read an AWS JSON protocol request, whose body is the Command input and
+ * whose response echoes the protocol version it was sent with.
+ */
+function readSimSdkWireJsonCall(request) {
+    const operation = readSimSdkWireOperation(request);
+    if (operation === undefined) {
+        return undefined;
+    }
+    const contentType = request.headers["content-type"];
+    return {
+        ...operation,
+        input: () => readSimSdkWireInput(request.body),
+        outputResponse: (output) => Promise.resolve(simSdkWireOutputResponse(output, contentType)),
+        errorResponse: (error) => simSdkWireErrorResponse(error, contentType),
+    };
+}

package/dist/sdk/wire/sim-sdk-wire-dispatcher.js

@@ -1,8 +1,7 @@
 import { SimSdkCommandDispatcher } from "../sim-sdk-command-dispatcher.js";
 import { makeSimSdkWireClient, makeSimSdkWireCommand, } from "./sim-sdk-wire-command.js";
-import { readSimSdkWireInput } from "./sim-sdk-wire-json.js";
-import { readSimSdkWireCredentialScope, readSimSdkWireOperation, } from "./sim-sdk-wire-operation.js";
-import { simSdkWireErrorResponse, simSdkWireOutputResponse, } from "./sim-sdk-wire-response.js";
+import { readSimSdkWireCall } from "./sim-sdk-wire-call.js";
+import { readSimSdkWireCredentialScope } from "./sim-sdk-wire-operation.js";
 import { simSdkUnbridgedWireRequest } from "./sim-sdk-wire-unbridged.js";
 /**
  * Dispatches AWS API requests to simulated AWS service operations.
@@ -44,20 +43,19 @@ export class SimSdkWireDispatcher {
      * relies on.
      */
     async dispatch(request, caller) {
-        const operation = readSimSdkWireOperation(request);
-        if (operation === undefined) {
+        const call = readSimSdkWireCall(request);
+        if (call === undefined) {
             throw simSdkUnbridgedWireRequest(request);
         }
         // The operation runs in the Region it was signed for or, unsigned, the
         // Region of the code that sent it.
         const scope = readSimSdkWireCredentialScope(request);
-        const contentType = request.headers["content-type"];
         try {
-            const output = await this.dispatcher.dispatch(makeSimSdkWireCommand(operation.commandName, readSimSdkWireInput(request.body)), makeSimSdkWireClient(operation.serviceId, scope?.regionName ?? this.regionName), undefined, caller);
-            return simSdkWireOutputResponse(output, contentType);
+            const output = await this.dispatcher.dispatch(makeSimSdkWireCommand(call.commandName, call.input()), makeSimSdkWireClient(call.serviceId, scope?.regionName ?? this.regionName), undefined, caller);
+            return await call.outputResponse(output);
         }
         catch (error) {
-            return simSdkWireErrorResponse(error, contentType);
+            return call.errorResponse(error);
         }
     }
 }

package/dist/sdk/wire/sim-sdk-wire-event-stream.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The media type of an AWS event stream response body.
+ */
+export declare const simSdkWireEventStreamContentType = "application/vnd.amazon.eventstream";
+/**
+ * Encode an event stream as the `application/vnd.amazon.eventstream` body an
+ * SDK reads it from.
+ *
+ * Each event is a union with one member set, as an SDK hands it to calling
+ * code (`{ chunk: { bytes } }` or `{ contentBlockDelta: { ... } }`). The
+ * member name is the message's event type, and its value is the JSON payload.
+ *
+ * The whole stream is read before the body is built. A simulated stream has
+ * every event available at once, so sending them together loses nothing.
+ */
+export declare function simSdkWireEventStreamBody(events: AsyncIterable<object>): Promise<Uint8Array>;

package/dist/sdk/wire/sim-sdk-wire-event-stream.js

@@ -0,0 +1,79 @@
+import { crc32 } from "../../util/zip/crc32.js";
+import { simSdkWireJsonBody } from "./sim-sdk-wire-json.js";
+/**
+ * The media type of an AWS event stream response body.
+ */
+export const simSdkWireEventStreamContentType = "application/vnd.amazon.eventstream";
+/**
+ * The header value type code for a string, the only type written here.
+ */
+const stringHeaderType = 7;
+/**
+ * The bytes of the prelude: the total length, the headers length and the
+ * prelude checksum, each four bytes.
+ */
+const preludeLength = 12;
+/**
+ * The bytes of the checksum closing every message.
+ */
+const messageChecksumLength = 4;
+/**
+ * Encode an event stream as the `application/vnd.amazon.eventstream` body an
+ * SDK reads it from.
+ *
+ * Each event is a union with one member set, as an SDK hands it to calling
+ * code (`{ chunk: { bytes } }` or `{ contentBlockDelta: { ... } }`). The
+ * member name is the message's event type, and its value is the JSON payload.
+ *
+ * The whole stream is read before the body is built. A simulated stream has
+ * every event available at once, so sending them together loses nothing.
+ */
+export async function simSdkWireEventStreamBody(events) {
+    const messages = [];
+    for await (const event of events) {
+        const members = Object.entries(event).filter(([, value]) => value !== undefined);
+        for (const [eventType, value] of members) {
+            messages.push(eventMessage(eventType, simSdkWireJsonBody(value)));
+        }
+    }
+    return Buffer.concat(messages);
+}
+/**
+ * Encode one event message.
+ *
+ * The layout is the prelude, the headers, the payload and a CRC-32 of
+ * everything before it. The prelude ends with a CRC-32 of its first eight
+ * bytes.
+ */
+function eventMessage(eventType, payload) {
+    const headers = Buffer.concat([
+        stringHeader(":event-type", eventType),
+        stringHeader(":content-type", "application/json"),
+        stringHeader(":message-type", "event"),
+    ]);
+    const totalLength = preludeLength + headers.length + payload.length + messageChecksumLength;
+    const checksumOffset = totalLength - messageChecksumLength;
+    const message = Buffer.alloc(totalLength);
+    message.writeUInt32BE(totalLength, 0);
+    message.writeUInt32BE(headers.length, 4);
+    message.writeUInt32BE(crc32(message.subarray(0, 8)), 8);
+    headers.copy(message, preludeLength);
+    message.set(payload, preludeLength + headers.length);
+    message.writeUInt32BE(crc32(message.subarray(0, checksumOffset)), checksumOffset);
+    return message;
+}
+/**
+ * Encode one string-valued header: the name length and name, the type code,
+ * and the value length and value.
+ */
+function stringHeader(name, value) {
+    const nameBytes = Buffer.from(name);
+    const valueBytes = Buffer.from(value);
+    const header = Buffer.alloc(4 + nameBytes.length + valueBytes.length);
+    header.writeUInt8(nameBytes.length, 0);
+    nameBytes.copy(header, 1);
+    header.writeUInt8(stringHeaderType, 1 + nameBytes.length);
+    header.writeUInt16BE(valueBytes.length, 2 + nameBytes.length);
+    valueBytes.copy(header, 4 + nameBytes.length);
+    return header;
+}

package/dist/sdk/wire/sim-sdk-wire-unbridged.js

@@ -16,8 +16,8 @@ import { readSimSdkWireCredentialScope } from "./sim-sdk-wire-operation.js";
 export function simSdkUnbridgedWireRequest(request) {
     const service = readSimSdkWireCredentialScope(request)?.signingName ?? request.hostname;
     return new SimSdkUnbridgedWireRequestError(`Cannot answer a request to ${service} from the simulation: a ` +
-        "serialized AWS API request can only be routed for a service using " +
-        "the AWS JSON protocol. Where this is an AWS SDK bundled into " +
+        "serialized AWS API request can only be routed for S3, Bedrock " +
+        "Runtime and the services using the AWS JSON protocol. Where this is an AWS SDK bundled into " +
         "function code, leaving the SDK out of the deployment package puts it " +
         "back on the module interception path, which every simulated service " +
         "is reachable through.");

package/dist/service/athena/engine/sim-athena-array-shims.js

@@ -57,7 +57,7 @@ function joined(array, delimiter, absent) {
  * One element written out.
  *
  * Trino refuses to join an array whose elements are not text, and raising here
- * turns the query down to its declared result instead.
+ * fails the query the same way.
  */
 function scalarText(value) {
     if (typeof value === "string") {

package/dist/service/athena/engine/sim-athena-binary-text.d.ts

@@ -3,8 +3,8 @@ import type { SQLOutputValue } from "node:sqlite";
  * One encoded string read back to bytes, or null where it is null.
  *
  * Trino fails the query over text the encoding cannot carry, and `Buffer` reads
- * as much of it as it can and drops the rest. Raising here turns the query down
- * instead, which is nearer to Trino's answer than bytes nobody wrote.
+ * as much of it as it can and drops the rest. Raising here fails the query the
+ * way Trino does.
  */
 export declare function simAthenaDecodedText(text: string | undefined, encoding: "base64" | "hex"): Uint8Array | null;
 /**

package/dist/service/athena/engine/sim-athena-binary-text.js

@@ -20,8 +20,8 @@ const encodedReplacement = Buffer.from([0xef, 0xbf, 0xbd]);
  * One encoded string read back to bytes, or null where it is null.
  *
  * Trino fails the query over text the encoding cannot carry, and `Buffer` reads
- * as much of it as it can and drops the rest. Raising here turns the query down
- * instead, which is nearer to Trino's answer than bytes nobody wrote.
+ * as much of it as it can and drops the rest. Raising here fails the query the
+ * way Trino does.
  */
 export function simAthenaDecodedText(text, encoding) {
     if (text === undefined) {

package/dist/service/athena/engine/sim-athena-cast-rewrite.d.ts

@@ -0,0 +1,30 @@
+import type { SimAthenaCatalogTable } from "../table/sim-athena-catalog-table.js";
+/**
+ * The shims a cast to `DATE` and to `TIMESTAMP` are handed to.
+ *
+ * The names have the simulator's prefix so that neither can collide with a
+ * Trino function a statement calls itself.
+ */
+export declare const simAthenaDateCast = "sim_athena_cast_date";
+export declare const simAthenaTimestampCast = "sim_athena_cast_timestamp";
+/** The second argument a shim is handed where the value it casts is text. */
+export declare const simAthenaCastSource = "varchar";
+/**
+ * Hand every cast to `DATE` or `TIMESTAMP` in the tree to the engine's shims.
+ *
+ * SQLite gives a column declared `DATE` or `TIMESTAMP` numeric affinity, so a
+ * plain `CAST('2026-08-15' AS DATE)` keeps the leading number and answers
+ * `2026`. Every date function downstream of that cast then reads a year where
+ * it expected a date.
+ *
+ * Trino's one-argument `date(x)` is the cast to `DATE` under another name,
+ * and it goes to the same shim. SQLite's own `date()` answers null over text
+ * that is no date, where Trino fails the cast.
+ *
+ * Trino reads text more strictly than a value already typed as a timestamp,
+ * and the shim is told which it has. A string literal and a column the catalog
+ * declares as text are text. Anything else is taken to be a date or a
+ * timestamp already, since the engine cannot tell the type a function answers
+ * with.
+ */
+export declare function simAthenaRewriteCasts(ast: unknown, tables: readonly SimAthenaCatalogTable[]): void;

package/dist/service/athena/engine/sim-athena-cast-rewrite.js

@@ -0,0 +1,107 @@
+import { asAstNode, isColumnRef, replaceNode, simAthenaAstNodes, simAthenaCalledName, } from "./sim-athena-ast-nodes.js";
+/**
+ * The shims a cast to `DATE` and to `TIMESTAMP` are handed to.
+ *
+ * The names have the simulator's prefix so that neither can collide with a
+ * Trino function a statement calls itself.
+ */
+export const simAthenaDateCast = "sim_athena_cast_date";
+export const simAthenaTimestampCast = "sim_athena_cast_timestamp";
+/** The second argument a shim is handed where the value it casts is text. */
+export const simAthenaCastSource = "varchar";
+/** The shim each cast target goes to. */
+const castShims = new Map([
+    ["DATE", simAthenaDateCast],
+    ["TIMESTAMP", simAthenaTimestampCast],
+]);
+/** The Glue types a column of text is declared with. */
+const textTypes = /^(?:string|varchar|char)\b/iu;
+/**
+ * Hand every cast to `DATE` or `TIMESTAMP` in the tree to the engine's shims.
+ *
+ * SQLite gives a column declared `DATE` or `TIMESTAMP` numeric affinity, so a
+ * plain `CAST('2026-08-15' AS DATE)` keeps the leading number and answers
+ * `2026`. Every date function downstream of that cast then reads a year where
+ * it expected a date.
+ *
+ * Trino's one-argument `date(x)` is the cast to `DATE` under another name,
+ * and it goes to the same shim. SQLite's own `date()` answers null over text
+ * that is no date, where Trino fails the cast.
+ *
+ * Trino reads text more strictly than a value already typed as a timestamp,
+ * and the shim is told which it has. A string literal and a column the catalog
+ * declares as text are text. Anything else is taken to be a date or a
+ * timestamp already, since the engine cannot tell the type a function answers
+ * with.
+ */
+export function simAthenaRewriteCasts(ast, tables) {
+    const textColumns = textColumnsOf(tables);
+    for (const node of simAthenaAstNodes(ast)) {
+        const cast = castOf(node);
+        if (cast !== undefined) {
+            replaceNode(node, {
+                type: "function",
+                name: { name: [{ type: "default", value: cast.shim }] },
+                args: {
+                    type: "expr_list",
+                    value: [cast.value, sourceOf(cast.value, textColumns)],
+                },
+                over: null,
+            });
+        }
+    }
+}
+function castOf(node) {
+    if (node["type"] === "cast") {
+        const shim = castShims.get(targetOf(node["target"]));
+        return shim === undefined ? undefined : { shim, value: node["expr"] };
+    }
+    const values = asAstNode(node["args"])?.["value"];
+    if (node["type"] !== "function" ||
+        simAthenaCalledName(node)?.toLowerCase() !== "date" ||
+        !Array.isArray(values) ||
+        values.length !== 1) {
+        return undefined;
+    }
+    return { shim: simAthenaDateCast, value: values[0] };
+}
+/** The one type a cast names, upper cased, or nothing for anything else. */
+function targetOf(target) {
+    const only = Array.isArray(target) && target.length === 1 ? target[0] : null;
+    const dataType = asAstNode(only)?.["dataType"];
+    return typeof dataType === "string" ? dataType.toUpperCase() : "";
+}
+/** The second argument that tells the shim whether its value is text. */
+function sourceOf(value, textColumns) {
+    const node = asAstNode(value);
+    const isText = node?.["type"] === "single_quote_string" ||
+        (node !== undefined &&
+            isColumnRef(node) &&
+            textColumns.has(node.column.toLowerCase()));
+    return {
+        type: "single_quote_string",
+        value: isText ? simAthenaCastSource : "",
+    };
+}
+/**
+ * Every column name the tables declare as text and as nothing else.
+ *
+ * A name two tables declare with different types is left out, since the
+ * statement could mean either and only text is held to the stricter read.
+ */
+function textColumnsOf(tables) {
+    const text = new Set();
+    const other = new Set();
+    for (const table of tables) {
+        for (const column of [...table.columns, ...table.partitionKeys]) {
+            const name = column.Name.toLowerCase();
+            if (textTypes.test(column.Type ?? "")) {
+                text.add(name);
+            }
+            else {
+                other.add(name);
+            }
+        }
+    }
+    return text.difference(other);
+}

package/dist/service/athena/engine/sim-athena-cast-shims.d.ts

@@ -0,0 +1,12 @@
+import type { DatabaseSync } from "node:sqlite";
+/**
+ * Trino's casts to `DATE` and `TIMESTAMP`, which SQLite cannot do itself.
+ *
+ * SQLite gives both types numeric affinity, so its own cast of
+ * `'2026-08-15'` answers `2026`. The statement's casts are rewritten onto
+ * these shims before it runs, and the rewrite says whether the value is text.
+ *
+ * A value the cast cannot read fails the query with Trino's own message, the
+ * way Athena fails it.
+ */
+export declare function simAthenaInstallCastShims(database: DatabaseSync): void;

package/dist/service/athena/engine/sim-athena-cast-shims.js

@@ -0,0 +1,29 @@
+import { SimAthenaSetUpError } from "../error/sim-athena.error.js";
+import { simAthenaCastSource, simAthenaDateCast, simAthenaTimestampCast, } from "./sim-athena-cast-rewrite.js";
+import { simAthenaCastInstant, simAthenaCastRendered, } from "./sim-athena-cast-text.js";
+import { shimText, simAthenaScalarShim } from "./sim-athena-shim-registry.js";
+/**
+ * Trino's casts to `DATE` and `TIMESTAMP`, which SQLite cannot do itself.
+ *
+ * SQLite gives both types numeric affinity, so its own cast of
+ * `'2026-08-15'` answers `2026`. The statement's casts are rewritten onto
+ * these shims before it runs, and the rewrite says whether the value is text.
+ *
+ * A value the cast cannot read fails the query with Trino's own message, the
+ * way Athena fails it.
+ */
+export function simAthenaInstallCastShims(database) {
+    simAthenaScalarShim(database, simAthenaDateCast, (value, source) => cast(value, source, "date"), "CAST(... AS DATE)");
+    simAthenaScalarShim(database, simAthenaTimestampCast, (value, source) => cast(value, source, "timestamp"), "CAST(... AS TIMESTAMP)");
+}
+function cast(value, source, type) {
+    const text = shimText(value);
+    if (text === undefined) {
+        return null;
+    }
+    const instant = simAthenaCastInstant(text, type, source === simAthenaCastSource);
+    if (instant === undefined) {
+        throw new SimAthenaSetUpError(`Value cannot be cast to ${type}: ${text}`);
+    }
+    return simAthenaCastRendered(instant, type);
+}

package/dist/service/athena/engine/sim-athena-cast-text.d.ts

@@ -0,0 +1,13 @@
+/** The two types a cast in the engine reads a value as. */
+export type SimAthenaCastType = "date" | "timestamp";
+/**
+ * The instant one value names as the cast reads it, or nothing where the cast
+ * fails.
+ *
+ * Text is held to the formats Trino's cast from `varchar` takes. Any other
+ * source is a value some column or function already typed as a date or a
+ * timestamp, written as the ISO-8601 text the engine holds one as.
+ */
+export declare function simAthenaCastInstant(text: string, type: SimAthenaCastType, fromText: boolean): number | undefined;
+/** One instant rendered as Athena renders a value of the type. */
+export declare function simAthenaCastRendered(instant: number, type: SimAthenaCastType): string;