@kensio/yulin 1.21.28 → 1.21.30

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

@@ -0,0 +1,66 @@
+// Both patterns below are anchored at each end with every quantifier bounded,
+// so there is nothing in either to backtrack over.
+// oxlint-disable security/detect-unsafe-regex
+import { simAthenaInstant } from "./sim-athena-timestamp-text.js";
+/**
+ * What Trino's cast from `varchar` to `DATE` reads, once the text is trimmed.
+ *
+ * A time of day is refused. `CAST('2026-08-15 10:00:00' AS DATE)` fails on
+ * Athena, and only a timestamp value loses its time to a cast.
+ */
+const varcharDate = /^(\d{4})-(\d{1,2})-(\d{1,2})$/u;
+/**
+ * What Trino's cast from `varchar` to `TIMESTAMP` reads.
+ *
+ * The time follows a space. A `T` between the date and the time fails the
+ * cast on Athena, and so does a zone, which belongs to `TIMESTAMP WITH TIME
+ * ZONE`.
+ */
+const varcharTimestamp = /^(\d{4})-(\d{1,2})-(\d{1,2})(?: (\d{1,2}):(\d{1,2})(?::(\d{1,2})(?:\.(\d{1,12}))?)?)?$/u;
+/**
+ * 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 function simAthenaCastInstant(text, type, fromText) {
+    if (!fromText) {
+        return simAthenaInstant(text);
+    }
+    const fields = type === "date"
+        ? varcharDate.exec(text.trim())
+        : varcharTimestamp.exec(text);
+    return fields === null ? undefined : instantOf(fields);
+}
+/** One instant rendered as Athena renders a value of the type. */
+export function simAthenaCastRendered(instant, type) {
+    const iso = new Date(instant).toISOString();
+    return type === "date"
+        ? iso.slice(0, 10)
+        : iso.slice(0, 23).replace("T", " ");
+}
+/**
+ * The instant a matched value names, where every field is in range.
+ *
+ * `Date.UTC` rolls the 30th of February over into March, and Trino refuses
+ * it. Each field is checked against its calendar before anything is built.
+ * A fraction rounds to the millisecond, which is the precision Athena gives a
+ * `TIMESTAMP` with none written.
+ */
+function instantOf(fields) {
+    const [year, month, day, hour, minute, second] = Array.from({ length: 6 }, (_, index) => Number(fields[index + 1] ?? 0));
+    const lastDay = new Date(Date.UTC(year, month, 0)).getUTCDate();
+    if (month < 1 ||
+        month > 12 ||
+        day < 1 ||
+        day > lastDay ||
+        hour > 23 ||
+        minute > 59 ||
+        second > 59) {
+        return undefined;
+    }
+    const milliseconds = Math.round(Number(`0.${fields[7] ?? "0"}`) * 1000);
+    return Date.UTC(year, month - 1, day, hour, minute, second, milliseconds);
+}

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

@@ -57,8 +57,7 @@ function isNumeric(value) {
  * One argument as the text it orders by.
  *
  * A `varbinary` orders by its bytes in Trino, and nothing written out here
- * orders the same way. A call over one raises and the query falls back to its
- * declared result.
+ * orders the same way. A call over one raises and the query fails.
  */
 function comparableText(value) {
     if (value instanceof Uint8Array) {

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

@@ -2,10 +2,9 @@ import type { DatabaseSync } from "node:sqlite";
 /**
  * Trino's date arithmetic, over ISO-8601 text.
  *
- * Each of these raises rather than guessing where it cannot answer faithfully.
- * A unit outside the ones Trino names and a value that is no ISO-8601 timestamp
- * both land there, and the engine turns the query down and lets the declared
- * result answer. A shim answering a null instead would be a wrong answer
- * wearing the shape of a right one.
+ * Each of these raises where it cannot answer faithfully. A unit outside the
+ * ones Trino names and a value that is no ISO-8601 timestamp both land there,
+ * and the engine fails the query with the reason. A shim answering a null
+ * would be a wrong answer wearing the shape of a right one.
  */
 export declare function simAthenaInstallDateArithmeticShims(database: DatabaseSync): void;

package/dist/service/athena/engine/sim-athena-date-arithmetic-shims.js

@@ -6,11 +6,10 @@ import { simAthenaInstant, simAthenaRenderLike, } from "./sim-athena-timestamp-t
 /**
  * Trino's date arithmetic, over ISO-8601 text.
  *
- * Each of these raises rather than guessing where it cannot answer faithfully.
- * A unit outside the ones Trino names and a value that is no ISO-8601 timestamp
- * both land there, and the engine turns the query down and lets the declared
- * result answer. A shim answering a null instead would be a wrong answer
- * wearing the shape of a right one.
+ * Each of these raises where it cannot answer faithfully. A unit outside the
+ * ones Trino names and a value that is no ISO-8601 timestamp both land there,
+ * and the engine fails the query with the reason. A shim answering a null
+ * would be a wrong answer wearing the shape of a right one.
  */
 export function simAthenaInstallDateArithmeticShims(database) {
     simAthenaScalarShim(database, "date_add", (unit, value, timestamp) => {
@@ -47,13 +46,7 @@ function unitOf(value) {
         ? unit
         : raise(`${unit} is no date unit the engine reads`);
 }
-/**
- * Turn the query down.
- *
- * A shim that cannot answer faithfully raises, and the engine catches it and
- * lets the declared result answer. Answering a null instead would be a wrong
- * answer wearing the shape of a right one.
- */
+/** Fail the query, saying why the shim could not answer. */
 function raise(reason) {
     throw new SimAthenaSetUpError(reason);
 }
@@ -63,8 +56,7 @@ function raise(reason) {
  * Trino answers with a timestamp carrying the zone. There is nowhere to put one
  * here, so the answer is the wall clock alone, with any `Z` the value arrived
  * with taken off. A `Z` left on would say UTC over a time that is no longer in
- * it. A zone nobody has heard of raises out of `Intl`, and the query falls
- * back.
+ * it. A zone nobody has heard of raises out of `Intl`, and the query fails.
  */
 function inZone(at, zone) {
     if (at === undefined || zone === undefined) {

package/dist/service/athena/engine/sim-athena-date-units.d.ts

@@ -3,7 +3,7 @@
  *
  * A shim answering a unit it does not know would be answering wrongly, so the
  * ones here are the whole of what `date_add` and `date_diff` take. Anything
- * else raises, and the engine turns the query down.
+ * else raises, and the query fails.
  */
 export declare function isDateUnit(unit: string): boolean;
 /**

package/dist/service/athena/engine/sim-athena-date-units.js

@@ -19,7 +19,7 @@ const calendarUnits = new Map([
  *
  * A shim answering a unit it does not know would be answering wrongly, so the
  * ones here are the whole of what `date_add` and `date_diff` take. Anything
- * else raises, and the engine turns the query down.
+ * else raises, and the query fails.
  */
 export function isDateUnit(unit) {
     return clockUnits.has(unit) || calendarUnits.has(unit);

package/dist/service/athena/engine/sim-athena-engine-answer.d.ts

@@ -10,7 +10,12 @@ export interface SimAthenaEngineAnswer {
     readonly result: SimAthenaResolvedResult | undefined;
     /** What the engine could not do, where it turned the query down. */
     readonly turnedDown: string | undefined;
-    /** Why Athena refuses the statement, where the engine found it invalid. */
+    /**
+     * Why the query fails whether or not the engine is strict.
+     *
+     * That is a statement Athena refuses, or one the engine ran and could not
+     * evaluate.
+     */
     readonly rejected: string | undefined;
 }
 /** One answer the engine ran for real. */
@@ -18,11 +23,11 @@ export declare function simAthenaEngineAnswered(result: SimAthenaResolvedResult)
 /** One query the engine turned down, and why. */
 export declare function simAthenaEngineTurnedDown(turnedDown: string): SimAthenaEngineAnswer;
 /**
- * One statement Athena refuses, and why.
+ * One statement that fails whatever mode the engine is in, and why.
  *
- * The engine ran nothing. A query that reaches this fails whether or not the
- * engine is strict, since the alternative is a green test on SQL the service
- * rejects.
+ * Athena refusing the statement is one reason, and the alternative there is a
+ * green test on SQL the service rejects. A function shim refusing a value is
+ * the other, and the alternative there is a query losing every row in silence.
  */
 export declare function simAthenaEngineRejected(rejected: string): SimAthenaEngineAnswer;
 /** An engine nobody turned on, which has no opinion about the query. */

package/dist/service/athena/engine/sim-athena-engine-answer.js

@@ -7,11 +7,11 @@ export function simAthenaEngineTurnedDown(turnedDown) {
     return { result: undefined, turnedDown, rejected: undefined };
 }
 /**
- * One statement Athena refuses, and why.
+ * One statement that fails whatever mode the engine is in, and why.
  *
- * The engine ran nothing. A query that reaches this fails whether or not the
- * engine is strict, since the alternative is a green test on SQL the service
- * rejects.
+ * Athena refusing the statement is one reason, and the alternative there is a
+ * green test on SQL the service rejects. A function shim refusing a value is
+ * the other, and the alternative there is a query losing every row in silence.
  */
 export function simAthenaEngineRejected(rejected) {
     return { result: undefined, turnedDown: undefined, rejected };

package/dist/service/athena/engine/sim-athena-engine-run.d.ts

@@ -29,5 +29,9 @@ export interface SimAthenaEngineRun {
  *
  * Each of them carries a reason out, which a strict engine fails the query
  * with.
+ *
+ * A function shim refusing one of the statement's values is the exception. The
+ * engine ran the statement and could not evaluate it, and the query fails
+ * whether or not the engine is strict.
  */
 export declare function simAthenaEngineRun(run: SimAthenaEngineRun): Promise<SimAthenaEngineAnswer>;

package/dist/service/athena/engine/sim-athena-engine-run.js

@@ -1,6 +1,7 @@
-import { simAthenaEngineAnswered, simAthenaEngineTurnedDown, } from "./sim-athena-engine-answer.js";
-import { simAthenaRunFailure } from "./sim-athena-turn-down.js";
+import { simAthenaEngineAnswered, simAthenaEngineRejected, simAthenaEngineTurnedDown, } from "./sim-athena-engine-answer.js";
+import { simAthenaRunFailure, simAthenaUnevaluable, } from "./sim-athena-turn-down.js";
 import { simAthenaEngineResult } from "./sim-athena-engine-result.js";
+import { SimAthenaShimRefusal } from "./sim-athena-shim-refusal.js";
 import { simAthenaSqliteDatabase } from "./sim-athena-sqlite-database.js";
 import { simAthenaLoadedTables } from "./sim-athena-loaded-tables.js";
 /**
@@ -15,6 +16,10 @@ import { simAthenaLoadedTables } from "./sim-athena-loaded-tables.js";
  *
  * Each of them carries a reason out, which a strict engine fails the query
  * with.
+ *
+ * A function shim refusing one of the statement's values is the exception. The
+ * engine ran the statement and could not evaluate it, and the query fails
+ * whether or not the engine is strict.
  */
 export async function simAthenaEngineRun(run) {
     try {
@@ -41,6 +46,9 @@ export async function simAthenaEngineRun(run) {
         }
     }
     catch (error) {
+        if (error instanceof SimAthenaShimRefusal) {
+            return simAthenaEngineRejected(simAthenaUnevaluable(error));
+        }
         return simAthenaEngineTurnedDown(simAthenaRunFailure(error));
     }
 }

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

@@ -28,8 +28,8 @@ function matches(value, pattern) {
  *
  * Trino counts the groups from one and calls the whole match zero, which is
  * what a regular expression counts them as anywhere. Trino also refuses a group
- * the pattern has not got, and raising here turns the query down rather than
- * letting a negative index quietly count back from the end.
+ * the pattern has not got, and raising here fails the query where a negative
+ * index would quietly count back from the end.
  */
 function extracted(value, pattern, group) {
     if (!Number.isSafeInteger(group) || group < 0) {

package/dist/service/athena/engine/sim-athena-shim-refusal.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A Trino function shim that could not answer for one value.
+ *
+ * Each shim raises where it cannot answer faithfully, such as a date function
+ * handed text that is no timestamp. SQLite hands the error back out of the
+ * statement unchanged, and this class is how the engine tells it apart from
+ * SQLite refusing the statement itself.
+ *
+ * The engine fails the query on one of these whether or not it is strict. The
+ * statement parsed and SQLite ran it, so falling back would answer a query the
+ * engine had taken on with rows a declaration wrote for some other purpose,
+ * often no rows at all.
+ */
+export declare class SimAthenaShimRefusal extends Error {
+    readonly name = "SimAthenaShimRefusal";
+    constructor(described: string, cause: unknown);
+}

package/dist/service/athena/engine/sim-athena-shim-refusal.js

@@ -0,0 +1,22 @@
+/**
+ * A Trino function shim that could not answer for one value.
+ *
+ * Each shim raises where it cannot answer faithfully, such as a date function
+ * handed text that is no timestamp. SQLite hands the error back out of the
+ * statement unchanged, and this class is how the engine tells it apart from
+ * SQLite refusing the statement itself.
+ *
+ * The engine fails the query on one of these whether or not it is strict. The
+ * statement parsed and SQLite ran it, so falling back would answer a query the
+ * engine had taken on with rows a declaration wrote for some other purpose,
+ * often no rows at all.
+ */
+export class SimAthenaShimRefusal extends Error {
+    name = "SimAthenaShimRefusal";
+    constructor(described, cause) {
+        const reason = cause instanceof Error ? cause.message : String(cause);
+        super(`${described} could not answer for this statement's values. ${reason}`, {
+            cause,
+        });
+    }
+}

package/dist/service/athena/engine/sim-athena-shim-registry.d.ts

@@ -7,8 +7,12 @@ export type SimAthenaScalarShim = (...values: SQLOutputValue[]) => SQLInputValue
  * Every shim takes any number of arguments, because SQLite checks the count
  * against the JavaScript function's own arity otherwise and a Trino function
  * with an optional argument would stop resolving.
+ *
+ * Anything the shim raises comes back out as a `SimAthenaShimRefusal` naming
+ * the function as a statement wrote it, which fails the query. `described`
+ * is that name where it differs from the one registered.
  */
-export declare function simAthenaScalarShim(database: DatabaseSync, name: string, implementation: SimAthenaScalarShim): void;
+export declare function simAthenaScalarShim(database: DatabaseSync, name: string, implementation: SimAthenaScalarShim, described?: string): void;
 /**
  * Whether an optional argument was written as an explicit `NULL`.
  *

package/dist/service/athena/engine/sim-athena-shim-registry.js

@@ -1,12 +1,24 @@
+import { SimAthenaShimRefusal } from "./sim-athena-shim-refusal.js";
 /**
  * Register one Trino scalar function on this database.
  *
  * Every shim takes any number of arguments, because SQLite checks the count
  * against the JavaScript function's own arity otherwise and a Trino function
  * with an optional argument would stop resolving.
+ *
+ * Anything the shim raises comes back out as a `SimAthenaShimRefusal` naming
+ * the function as a statement wrote it, which fails the query. `described`
+ * is that name where it differs from the one registered.
  */
-export function simAthenaScalarShim(database, name, implementation) {
-    database.function(name, { varargs: true, deterministic: true }, (...values) => withEmptyBytes(implementation(...values)));
+export function simAthenaScalarShim(database, name, implementation, described = name) {
+    database.function(name, { varargs: true, deterministic: true }, (...values) => {
+        try {
+            return withEmptyBytes(implementation(...values));
+        }
+        catch (error) {
+            throw new SimAthenaShimRefusal(described, error);
+        }
+    });
 }
 /**
  * One answer, with an empty `varbinary` written so that SQLite keeps it.

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

@@ -1,6 +1,7 @@
 import { simAthenaInstallAggregateShims } from "./sim-athena-aggregate-shims.js";
 import { simAthenaInstallArrayShims } from "./sim-athena-array-shims.js";
 import { simAthenaInstallBinaryShims } from "./sim-athena-binary-shims.js";
+import { simAthenaInstallCastShims } from "./sim-athena-cast-shims.js";
 import { simAthenaInstallClockShims } from "./sim-athena-clock-shims.js";
 import { simAthenaInstallComparisonShims } from "./sim-athena-comparison-shims.js";
 import { simAthenaInstallDateArithmeticShims } from "./sim-athena-date-arithmetic-shims.js";
@@ -22,6 +23,7 @@ export function simAthenaInstallShims(database, startedAt) {
     simAthenaInstallClockShims(database, startedAt);
     simAthenaInstallDateShims(database);
     simAthenaInstallDateArithmeticShims(database);
+    simAthenaInstallCastShims(database);
     simAthenaInstallJsonShims(database);
     simAthenaInstallJsonDocumentShims(database);
     simAthenaInstallArrayShims(database);

package/dist/service/athena/engine/sim-athena-sql-translation.d.ts

@@ -1,28 +1,6 @@
 import type { SimAthenaCatalogTable } from "../table/sim-athena-catalog-table.js";
 import type { SimAthenaSqlParser } from "./sim-athena-parser-module.js";
-/** One statement translated for SQLite, or why it was not. */
-export type SimAthenaTranslatedSql = {
-    readonly sql: string;
-    /**
-     * The decimal places each result column was rounded to, by position.
-     *
-     * Read here because the syntax tree is the only place that knows, and
-     * the tree is gone by the time the answer is rendered.
-     */
-    readonly scales: ReadonlyMap<number, number>;
-    readonly turnedDown: undefined;
-    readonly rejected: undefined;
-} | {
-    readonly sql: undefined;
-    readonly scales: undefined;
-    readonly turnedDown: string;
-    readonly rejected: undefined;
-} | {
-    readonly sql: undefined;
-    readonly scales: undefined;
-    readonly turnedDown: undefined;
-    readonly rejected: string;
-};
+import { type SimAthenaTranslatedSql } from "./sim-athena-translated-sql.js";
 interface SimAthenaSqlTranslationRequest {
     readonly parser: SimAthenaSqlParser;
     readonly athenaSql: string;

package/dist/service/athena/engine/sim-athena-sql-translation.js

@@ -1,7 +1,9 @@
 import { simAthenaSqlForParser, simAthenaSqlForSqlite, } from "./sim-athena-sql-rewrites.js";
 import { simAthenaUnparsedStatement, simAthenaUnrewrittenUnnest, simAthenaUnwrittenStatement, } from "./sim-athena-turn-down.js";
 import { simAthenaRejectedStatement } from "./sim-athena-rejected-statement.js";
+import { simAthenaRewriteCasts } from "./sim-athena-cast-rewrite.js";
 import { simAthenaRoundScales } from "./sim-athena-round-scales.js";
+import { simAthenaRejectedSql, simAthenaTranslated, simAthenaTurnedDownSql, } from "./sim-athena-translated-sql.js";
 import { simAthenaRewriteUnnest } from "./sim-athena-unnest-rewrite.js";
 /**
  * One Athena statement written back out for SQLite, or why it is not.
@@ -26,16 +28,11 @@ export function simAthenaSqliteSql(request) {
         ast = parser.astify(read.sql, { database: "athena" });
     }
     catch {
-        return turnedDown(simAthenaUnparsedStatement);
+        return simAthenaTurnedDownSql(simAthenaUnparsedStatement);
     }
     const rejected = simAthenaRejectedStatement(ast);
     if (rejected !== undefined) {
-        return {
-            sql: undefined,
-            scales: undefined,
-            turnedDown: undefined,
-            rejected,
-        };
+        return simAthenaRejectedSql(rejected);
     }
     try {
         if (!simAthenaRewriteUnnest({
@@ -43,27 +40,15 @@ export function simAthenaSqliteSql(request) {
             ordinality: read.ordinality,
             tables: request.tables,
         })) {
-            return turnedDown(simAthenaUnrewrittenUnnest);
+            return simAthenaTurnedDownSql(simAthenaUnrewrittenUnnest);
         }
+        simAthenaRewriteCasts(ast, request.tables);
         // Read before the tree is written back out, since the rewrites above can
         // move a select item and the scale travels by position.
         const scales = simAthenaRoundScales(ast);
-        return {
-            sql: simAthenaSqlForSqlite(parser.sqlify(ast, { database: "sqlite" })),
-            scales,
-            turnedDown: undefined,
-            rejected: undefined,
-        };
+        return simAthenaTranslated(simAthenaSqlForSqlite(parser.sqlify(ast, { database: "sqlite" })), scales);
     }
     catch {
-        return turnedDown(simAthenaUnwrittenStatement);
+        return simAthenaTurnedDownSql(simAthenaUnwrittenStatement);
     }
 }
-function turnedDown(reason) {
-    return {
-        sql: undefined,
-        scales: undefined,
-        turnedDown: reason,
-        rejected: undefined,
-    };
-}

package/dist/service/athena/engine/sim-athena-translated-sql.d.ts

@@ -0,0 +1,29 @@
+/** One statement translated for SQLite, or why it was not. */
+export type SimAthenaTranslatedSql = {
+    readonly sql: string;
+    /**
+     * The decimal places each result column was rounded to, by position.
+     *
+     * Read here because the syntax tree is the only place that knows, and
+     * the tree is gone by the time the answer is rendered.
+     */
+    readonly scales: ReadonlyMap<number, number>;
+    readonly turnedDown: undefined;
+    readonly rejected: undefined;
+} | {
+    readonly sql: undefined;
+    readonly scales: undefined;
+    readonly turnedDown: string;
+    readonly rejected: undefined;
+} | {
+    readonly sql: undefined;
+    readonly scales: undefined;
+    readonly turnedDown: undefined;
+    readonly rejected: string;
+};
+/** One statement written out for SQLite, with the scales read off its tree. */
+export declare function simAthenaTranslated(sql: string, scales: ReadonlyMap<number, number>): SimAthenaTranslatedSql;
+/** One statement the engine turned down, and why. */
+export declare function simAthenaTurnedDownSql(turnedDown: string): SimAthenaTranslatedSql;
+/** One statement Athena refuses, and why. */
+export declare function simAthenaRejectedSql(rejected: string): SimAthenaTranslatedSql;

package/dist/service/athena/engine/sim-athena-translated-sql.js

@@ -0,0 +1,12 @@
+/** One statement written out for SQLite, with the scales read off its tree. */
+export function simAthenaTranslated(sql, scales) {
+    return { sql, scales, turnedDown: undefined, rejected: undefined };
+}
+/** One statement the engine turned down, and why. */
+export function simAthenaTurnedDownSql(turnedDown) {
+    return { sql: undefined, scales: undefined, turnedDown, rejected: undefined };
+}
+/** One statement Athena refuses, and why. */
+export function simAthenaRejectedSql(rejected) {
+    return { sql: undefined, scales: undefined, turnedDown: undefined, rejected };
+}

package/dist/service/athena/engine/sim-athena-turn-down.d.ts

@@ -14,6 +14,13 @@ export declare const simAthenaUnrewrittenUnnest = "The simulated Athena query en
 export declare const simAthenaUnwrittenStatement = "The simulated Athena query engine cannot write this statement back out for SQLite.";
 /** Whatever went wrong while the tables were loaded or the statement ran. */
 export declare function simAthenaRunFailure(error: unknown): string;
+/**
+ * A function shim that could not answer for one of the statement's values.
+ *
+ * This fails the query whether or not the engine is strict, so the reason
+ * points at the one declaration that still answers it.
+ */
+export declare function simAthenaUnevaluable(refusal: Error): string;
 /**
  * One table the engine has no reader for.
  *

package/dist/service/athena/engine/sim-athena-turn-down.js

@@ -21,6 +21,17 @@ export function simAthenaRunFailure(error) {
     const message = error instanceof Error ? error.message : String(error);
     return `${engine} could not answer this statement. ${message}`;
 }
+/**
+ * A function shim that could not answer for one of the statement's values.
+ *
+ * This fails the query whether or not the engine is strict, so the reason
+ * points at the one declaration that still answers it.
+ */
+export function simAthenaUnevaluable(refusal) {
+    return (`${engine} cannot evaluate this statement. ${refusal.message} ` +
+        `Declare what this exact query answers with through results() to answer ` +
+        `it without the engine.`);
+}
 /**
  * One table the engine has no reader for.
  *

package/dist/service/athena/result/sim-athena-query-answer.d.ts

@@ -51,7 +51,8 @@ interface SimAthenaQueryAnswerRequest {
  *
  * A statement Athena refuses fails whichever mode the engine is in. That is
  * SQL the service would never have run, and falling back would leave the query
- * green on it.
+ * green on it. So does a statement the engine ran and could not evaluate,
+ * where falling back to the default would answer with no rows at all.
  */
 export declare function simAthenaQueryAnswer(request: SimAthenaQueryAnswerRequest): Promise<SimAthenaQueryAnswer>;
 export {};

package/dist/service/athena/result/sim-athena-query-answer.js

@@ -18,7 +18,8 @@ import { simAthenaStrictRefusal } from "../engine/sim-athena-turn-down.js";
  *
  * A statement Athena refuses fails whichever mode the engine is in. That is
  * SQL the service would never have run, and falling back would leave the query
- * green on it.
+ * green on it. So does a statement the engine ran and could not evaluate,
+ * where falling back to the default would answer with no rows at all.
  */
 export async function simAthenaQueryAnswer(request) {
     const forQuery = request.results.declaredForQuery(request.queryString);

package/dist/service/athena/sim-athena-snapshot-table.fixture.d.ts

@@ -0,0 +1,10 @@
+import { type SimAthenaEngineSimulation } from "./sim-athena-engine.fixture.js";
+/**
+ * A table of snapshots partitioned by a string `day`, with the engine on and
+ * a default declaration that a fallback would answer with.
+ *
+ * `taken_at` is a Glue `timestamp` written as ISO-8601 with a `T` and a `Z`.
+ * `noted_at` is a `string` holding a timestamp the way Trino's cast from text
+ * reads one.
+ */
+export declare function aSnapshotSimulation(): Promise<SimAthenaEngineSimulation>;

package/dist/service/athena/sim-athena-snapshot-table.fixture.js

@@ -0,0 +1,39 @@
+import { aCatalogTable, anEngineSimulation, aSeededJson, } from "./sim-athena-engine.fixture.js";
+/**
+ * A table of snapshots partitioned by a string `day`, with the engine on and
+ * a default declaration that a fallback would answer with.
+ *
+ * `taken_at` is a Glue `timestamp` written as ISO-8601 with a `T` and a `Z`.
+ * `noted_at` is a `string` holding a timestamp the way Trino's cast from text
+ * reads one.
+ */
+export async function aSnapshotSimulation() {
+    const simulation = await anEngineSimulation();
+    aCatalogTable(simulation.simAws, {
+        name: "snapshots",
+        columns: [
+            { Name: "sku", Type: "string" },
+            { Name: "taken_at", Type: "timestamp" },
+            { Name: "noted_at", Type: "string" },
+        ],
+        partitionKeys: [{ Name: "day", Type: "string" }],
+    });
+    await aSeededJson(simulation.simAws, "snapshots/day=2026-08-15/part-0.json", [
+        {
+            sku: "bolt",
+            taken_at: "2026-08-15T23:30:00Z",
+            noted_at: "2026-08-15 10:00:00",
+        },
+        {
+            sku: "nut",
+            taken_at: "2026-08-14T08:00:00Z",
+            noted_at: "2026-08-14 09:15:00.5",
+        },
+    ]);
+    await simulation.simAws.athena().engine().enable();
+    simulation.simAws
+        .athena()
+        .results()
+        .byDefault({ columns: ["fallback"], rows: [["declared"]] });
+    return simulation;
+}

package/dist/service/bedrock/command/authorize/sim-bedrock-authorizer.js

@@ -24,9 +24,13 @@ export class SimBedrockAuthorizer {
             caller: options.caller,
         });
         if (decision.isDenied) {
-            throw new SimBedrockAccessDeniedException(`User: ${this.callerIdentifier.format(decision.caller.principal)} is ` +
-                `not authorized to perform: ${action} on resource: ${resource} ` +
-                `because no identity-based policy allows the ${action} action`);
+            // A service control policy denial names the policy, as other services'
+            // denials do.
+            const reason = decision.denialReason ??
+                `because no identity-based policy allows the ${action} action`;
+            const caller = this.callerIdentifier.format(decision.caller.principal);
+            throw new SimBedrockAccessDeniedException(`User: ${caller} is not authorized to perform: ${action} on ` +
+                `resource: ${resource} ${reason}`);
         }
         return decision.caller;
     }

package/dist/service/lambda/function/code/vm/sdk/sim-sdk-lambda-vm-module-provider.d.ts

@@ -42,8 +42,8 @@ export declare class SimSdkLambdaVmModuleProvider implements SimLambdaVmSdkModul
     private readonly providedModules;
     constructor(properties: SimSdkLambdaVmModuleProviderProperties);
     /**
-     * Provide an intercepted AWS SDK package or HTTP transport module, or
-     * undefined for other specifiers.
+     * Provide an intercepted AWS SDK package or HTTP or HTTP/2 transport
+     * module, or undefined for other specifiers.
      */
     provideModule(specifier: string): unknown;
     /**