@kensio/yulin 1.20.13 → 1.20.14

package/dist/service/apigatewayv2/cfn/stage/sim-cfn-http-api-stage-creator.js

@@ -16,15 +16,13 @@ export class SimCfnHttpApiStageCreator {
     /**
      * Create a stage from an AWS::ApiGatewayV2::Stage Resource.
      */
-    async create(resource, properties) {
+    async create(resource, properties, options) {
         const stageProperties = new SimCfnHttpApiStageProperties({
             resource,
             properties,
         });
         const apiId = stageProperties.apiId();
-        const created = await this.apiGatewayV2.createStage({
-            input: stageProperties.createStageInput(),
-        });
+        const created = await this.apiGatewayV2.createStage({ input: stageProperties.createStageInput() }, options);
         const stage = this.apiGatewayV2
             .findApi(apiId)
             ?.stages.find(created.StageName);

package/dist/service/apigatewayv2/serve/sim-api-gateway-v2-router.js

@@ -1,4 +1,5 @@
 import { SimAws } from "../../aws/sim-aws.js";
+import { simScopeIamAuthZ } from "../../iam/authorize/sim-iam-region-auth-z.js";
 /**
  * Routes a served HTTP API request to the API behind it, and an integration to
  * the function behind that.
@@ -45,7 +46,7 @@ export class SimApiGatewayV2Router {
      */
     iamFor(api) {
         const { accountId, regionName } = api.accountRegionScope;
-        return this.simAws.accountRegionScope(accountId, regionName).iam();
+        return simScopeIamAuthZ(this.simAws.accountRegionScope(accountId, regionName));
     }
     /**
      * Find the function an integration invokes, and the IAM deciding whether it
@@ -77,6 +78,8 @@ export class SimApiGatewayV2Router {
         const target = scope
             .lambda()
             .getSimFunctionTarget(lambdaUri.functionName, lambdaUri.qualifier);
-        return target === undefined ? undefined : { ...target, iam: scope.iam() };
+        return target === undefined
+            ? undefined
+            : { ...target, iam: simScopeIamAuthZ(scope) };
     }
 }

package/dist/service/apigatewayv2/sim-api-gateway-v2-commands.d.ts

@@ -1,6 +1,6 @@
 import { type BackgroundScheduler } from "../../util/background/background.js";
 import type { SimAwsAccountRegionScope } from "../aws/sim-aws-account-region-scope.js";
-import { type SimIamInterServiceAuthZ } from "../iam/authorize/sim-iam-inter-service-auth-z.js";
+import type { SimIamInterServiceAuthZ } from "../iam/authorize/sim-iam-inter-service-auth-z.js";
 import { type SimHttpApiJwtIssuerKeys } from "./api/authorizer/sim-http-api-jwt-issuer-keys.js";
 import { SimHttpApiStore } from "./api/sim-http-api-store.js";
 import { SimHttpApiDomainStore } from "./domain/sim-http-api-domain-store.js";

package/dist/service/apigatewayv2/sim-api-gateway-v2-commands.js

@@ -1,6 +1,6 @@
 import { BackgroundTasks, } from "../../util/background/background.js";
 import { simAwsAccountRegionScopeFactory } from "../aws/sim-aws-account-region-scope.factory.js";
-import { SimIamAllowAllAuth, } from "../iam/authorize/sim-iam-inter-service-auth-z.js";
+import { simIamInRegion } from "../iam/authorize/sim-iam-region-auth-z.js";
 import { SimHttpApiNoJwtIssuerKeys, } from "./api/authorizer/sim-http-api-jwt-issuer-keys.js";
 import { SimHttpApiStore } from "./api/sim-http-api-store.js";
 import { SimHttpApiDomainStore } from "./domain/sim-http-api-domain-store.js";
@@ -38,7 +38,8 @@ export class SimApiGatewayV2Commands {
     apiMappings;
     background;
     constructor(properties = {}) {
-        const { accountRegionScope = simAwsAccountRegionScopeFactory.make(), iam = new SimIamAllowAllAuth(), background = new BackgroundTasks(), registry = new SimHttpApiRegistry(), domainRegistry = new SimHttpApiDomainRegistry(), jwtIssuerKeys = new SimHttpApiNoJwtIssuerKeys(), } = properties;
+        const { accountRegionScope = simAwsAccountRegionScopeFactory.make(), background = new BackgroundTasks(), registry = new SimHttpApiRegistry(), domainRegistry = new SimHttpApiDomainRegistry(), jwtIssuerKeys = new SimHttpApiNoJwtIssuerKeys(), } = properties;
+        const iam = simIamInRegion(properties.iam, accountRegionScope.regionName);
         const authorizer = new SimApiGatewayV2Authorizer({
             iam,
             accountRegionScope,

package/dist/service/athena/cfn/named-query/sim-cfn-athena-named-query-creator.d.ts

@@ -2,6 +2,7 @@ import type { SimCfnResource } from "../../../cloudformation/resource/sim-cfn-re
 import type { SimCfnTemplateValueRecord } from "../../../cloudformation/template/value/sim-cfn-template-value.js";
 import type { SimAthenaNamedQuery } from "../../named-query/sim-athena-named-query.js";
 import type { SimAthena } from "../../sim-athena.js";
+import type { SimCfnResourceCallerOptions } from "../../../cloudformation/resource/caller/sim-cfn-resource-caller-options.js";
 interface SimCfnAthenaNamedQueryCreatorProperties {
     readonly athena: SimAthena;
 }
@@ -20,10 +21,10 @@ export declare class SimCfnAthenaNamedQueryCreator {
     /**
      * Create the named query a Resource declares.
      */
-    create(resource: SimCfnResource, properties: SimCfnTemplateValueRecord): Promise<SimAthenaNamedQuery>;
+    create(resource: SimCfnResource, properties: SimCfnTemplateValueRecord, options?: SimCfnResourceCallerOptions): Promise<SimAthenaNamedQuery>;
     /**
      * Delete the named query a Resource created.
      */
-    delete(namedQuery: SimAthenaNamedQuery): Promise<void>;
+    delete(namedQuery: SimAthenaNamedQuery, options?: SimCfnResourceCallerOptions): Promise<void>;
 }
 export {};

package/dist/service/athena/cfn/named-query/sim-cfn-athena-named-query-creator.js

@@ -19,7 +19,7 @@ export class SimCfnAthenaNamedQueryCreator {
     /**
      * Create the named query a Resource declares.
      */
-    async create(resource, properties) {
+    async create(resource, properties, options) {
         const read = new SimCfnAthenaNamedQueryProperties({
             resource,
             properties,
@@ -27,7 +27,7 @@ export class SimCfnAthenaNamedQueryCreator {
         read.recordIgnoredProperties();
         const input = read.createInput();
         return await simCfnAthenaResourceCreation(athenaNamedQueryResourceType, resource.logicalId, async () => {
-            const created = await this.athena.createNamedQuery({ input });
+            const created = await this.athena.createNamedQuery({ input }, options);
             const namedQuery = this.athena
                 .namedQueries()
                 .find((candidate) => candidate.namedQueryId === created.NamedQueryId);
@@ -39,9 +39,7 @@ export class SimCfnAthenaNamedQueryCreator {
     /**
      * Delete the named query a Resource created.
      */
-    async delete(namedQuery) {
-        await this.athena.deleteNamedQuery({
-            input: { NamedQueryId: namedQuery.namedQueryId },
-        });
+    async delete(namedQuery, options) {
+        await this.athena.deleteNamedQuery({ input: { NamedQueryId: namedQuery.namedQueryId } }, options);
     }
 }

package/dist/service/athena/cfn/sim-athena-cfn-resource-factory.d.ts

@@ -1,5 +1,5 @@
 import type { SimCfnServiceResourceFactory } from "../../cloudformation/resource/factory/sim-cfn-resource-factory.type.js";
-import type { SimCfnResource, SimCloudFormationResourceCreateContext } from "../../cloudformation/resource/sim-cfn-resource.js";
+import type { SimCfnResource, SimCloudFormationResourceCreateContext, SimCloudFormationResourceDeleteContext } from "../../cloudformation/resource/sim-cfn-resource.js";
 import type { SimAthena } from "../sim-athena.js";
 interface SimAthenaCfnResourceFactoryProperties {
     readonly athena: SimAthena;
@@ -22,7 +22,7 @@ export declare class SimAthenaCfnResourceFactory implements SimCfnServiceResourc
     /**
      * Delete a simulated Athena resource created from a CloudFormation Resource.
      */
-    delete(resourceTypeName: string, resource: SimCfnResource): Promise<void>;
+    delete(resourceTypeName: string, resource: SimCfnResource, context: SimCloudFormationResourceDeleteContext): Promise<void>;
     private handler;
 }
 export {};

package/dist/service/athena/cfn/sim-athena-cfn-resource-factory.js

@@ -1,4 +1,5 @@
 import { assertDefined } from "../../../util/type-guard/defined.js";
+import { simCfnResourceCallerOptions, } from "../../cloudformation/resource/caller/sim-cfn-resource-caller-options.js";
 import { SimCfnAthenaNamedQueryCreator } from "./named-query/sim-cfn-athena-named-query-creator.js";
 import { athenaNamedQueryResourceTypeName, athenaWorkGroupResourceTypeName, } from "./sim-cfn-athena-resource-types.js";
 import { SimCfnAthenaWorkGroupCreator } from "./work-group/sim-cfn-athena-work-group-creator.js";
@@ -29,13 +30,13 @@ export class SimAthenaCfnResourceFactory {
      * Create a simulated Athena resource from a CloudFormation Resource.
      */
     async create(resourceTypeName, resource, context) {
-        return await this.handler(resourceTypeName, "").create(resource, context.resolvedProperties ?? resource.properties);
+        return await this.handler(resourceTypeName, "").create(resource, context.resolvedProperties ?? resource.properties, simCfnResourceCallerOptions(context.caller));
     }
     /**
      * Delete a simulated Athena resource created from a CloudFormation Resource.
      */
-    async delete(resourceTypeName, resource) {
-        await this.handler(resourceTypeName, " deletion").delete(resource);
+    async delete(resourceTypeName, resource, context) {
+        await this.handler(resourceTypeName, " deletion").delete(resource, simCfnResourceCallerOptions(context.caller));
     }
     handler(resourceTypeName, operationSuffix) {
         const handler = this.#handlers.get(resourceTypeName);
@@ -53,9 +54,9 @@ export class SimAthenaCfnResourceFactory {
  */
 function handler(creator, described) {
     return {
-        create: async (resource, properties) => await creator.create(resource, properties),
-        delete: async (resource) => {
-            await creator.delete(created(resource, described));
+        create: async (resource, properties, options) => await creator.create(resource, properties, options),
+        delete: async (resource, options) => {
+            await creator.delete(created(resource, described), options);
         },
     };
 }

package/dist/service/athena/cfn/work-group/sim-cfn-athena-work-group-creator.d.ts

@@ -2,6 +2,7 @@ import type { SimCfnResource } from "../../../cloudformation/resource/sim-cfn-re
 import type { SimCfnTemplateValueRecord } from "../../../cloudformation/template/value/sim-cfn-template-value.js";
 import type { SimAthena } from "../../sim-athena.js";
 import type { SimAthenaWorkGroup } from "../../workgroup/sim-athena-work-group.js";
+import type { SimCfnResourceCallerOptions } from "../../../cloudformation/resource/caller/sim-cfn-resource-caller-options.js";
 interface SimCfnAthenaWorkGroupCreatorProperties {
     readonly athena: SimAthena;
 }
@@ -19,14 +20,14 @@ export declare class SimCfnAthenaWorkGroupCreator {
     /**
      * Create the workgroup a Resource declares.
      */
-    create(resource: SimCfnResource, properties: SimCfnTemplateValueRecord): Promise<SimAthenaWorkGroup>;
+    create(resource: SimCfnResource, properties: SimCfnTemplateValueRecord, options?: SimCfnResourceCallerOptions): Promise<SimAthenaWorkGroup>;
     /**
      * Delete the workgroup a Resource created.
      *
      * Deleted recursively, so a workgroup the stack also gave named queries goes
      * with them rather than failing the stack deletion.
      */
-    delete(workGroup: SimAthenaWorkGroup): Promise<void>;
+    delete(workGroup: SimAthenaWorkGroup, options?: SimCfnResourceCallerOptions): Promise<void>;
     private applyState;
     private read;
 }

package/dist/service/athena/cfn/work-group/sim-cfn-athena-work-group-creator.js

@@ -19,7 +19,7 @@ export class SimCfnAthenaWorkGroupCreator {
     /**
      * Create the workgroup a Resource declares.
      */
-    async create(resource, properties) {
+    async create(resource, properties, options) {
         const read = this.read(resource, properties);
         read.recordIgnoredProperties();
         const input = read.createInput();
@@ -31,8 +31,8 @@ export class SimCfnAthenaWorkGroupCreator {
              * to be refused while there is still nothing to leave behind.
              */
             const state = workGroupStateFrom(read.state());
-            await this.athena.createWorkGroup({ input });
-            await this.applyState(String(input.Name), state);
+            await this.athena.createWorkGroup({ input }, options);
+            await this.applyState(String(input.Name), state, options);
             const workGroup = this.athena.findWorkGroup(String(input.Name));
             assertDefined(workGroup, `sim Athena workgroup ${String(input.Name)} after CloudFormation ` +
                 `creation`);
@@ -45,18 +45,14 @@ export class SimCfnAthenaWorkGroupCreator {
      * Deleted recursively, so a workgroup the stack also gave named queries goes
      * with them rather than failing the stack deletion.
      */
-    async delete(workGroup) {
-        await this.athena.deleteWorkGroup({
-            input: { WorkGroup: workGroup.name, RecursiveDeleteOption: true },
-        });
+    async delete(workGroup, options) {
+        await this.athena.deleteWorkGroup({ input: { WorkGroup: workGroup.name, RecursiveDeleteOption: true } }, options);
     }
-    async applyState(name, state) {
+    async applyState(name, state, options) {
         if (state === undefined) {
             return;
         }
-        await this.athena.updateWorkGroup({
-            input: { WorkGroup: name, State: state },
-        });
+        await this.athena.updateWorkGroup({ input: { WorkGroup: name, State: state } }, options);
     }
     read(resource, properties) {
         return new SimCfnAthenaWorkGroupProperties({ resource, properties });

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

@@ -1,11 +1,16 @@
 import type { DatabaseSync } from "node:sqlite";
 /**
- * Trino's two approximate aggregates, computed exactly.
+ * Trino's two approximate aggregates, computed exactly, and the exact count
+ * behind `count(DISTINCT <expression>)`.
  *
- * Real Athena answers both from a sketch and this answers from the values
- * themselves, so the simulation is the more accurate of the two. At the scale
- * a test seeds that difference cannot show, and the alternative is a query
- * that refuses to run at all.
+ * Real Athena answers the approximate pair from a sketch and this answers from
+ * the values themselves, so the simulation is the more accurate of the two. At
+ * the scale a test seeds that difference cannot show, and the alternative is a
+ * query that refuses to run at all.
+ *
+ * `count_distinct` is nobody's function to write. It is what the SQL rewrite
+ * turns `count(DISTINCT <expression>)` into, because the parser's Athena
+ * grammar takes a column after `DISTINCT` and nothing else.
  *
  * The state travels as JSON because SQLite carries an aggregate's accumulator
  * as one of its own values rather than as an object.

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

@@ -1,26 +1,29 @@
+import { countDistinctShim } from "./sim-athena-count-distinct.js";
+import { countedDistinctValues, noDistinctValues, withDistinctValue, } from "./sim-athena-distinct-values.js";
 /**
- * Trino's two approximate aggregates, computed exactly.
+ * Trino's two approximate aggregates, computed exactly, and the exact count
+ * behind `count(DISTINCT <expression>)`.
  *
- * Real Athena answers both from a sketch and this answers from the values
- * themselves, so the simulation is the more accurate of the two. At the scale
- * a test seeds that difference cannot show, and the alternative is a query
- * that refuses to run at all.
+ * Real Athena answers the approximate pair from a sketch and this answers from
+ * the values themselves, so the simulation is the more accurate of the two. At
+ * the scale a test seeds that difference cannot show, and the alternative is a
+ * query that refuses to run at all.
+ *
+ * `count_distinct` is nobody's function to write. It is what the SQL rewrite
+ * turns `count(DISTINCT <expression>)` into, because the parser's Athena
+ * grammar takes a column after `DISTINCT` and nothing else.
  *
  * The state travels as JSON because SQLite carries an aggregate's accumulator
  * as one of its own values rather than as an object.
  */
 export function simAthenaInstallAggregateShims(database) {
-    database.aggregate("approx_distinct", {
-        start: "[]",
-        step: (accumulator, value) => {
-            const seen = new Set(JSON.parse(accumulator));
-            if (value !== null) {
-                seen.add(typeof value === "bigint" ? String(value) : value);
-            }
-            return JSON.stringify([...seen]);
-        },
-        result: (accumulator) => JSON.parse(accumulator).length,
-    });
+    for (const name of ["approx_distinct", countDistinctShim]) {
+        database.aggregate(name, {
+            start: noDistinctValues,
+            step: withDistinctValue,
+            result: countedDistinctValues,
+        });
+    }
     database.aggregate("approx_percentile", {
         start: () => JSON.stringify({ values: [], percentile: 0.5 }),
         step: (accumulator, value, at) => {

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

@@ -0,0 +1,16 @@
+import type { DatabaseSync } from "node:sqlite";
+/**
+ * Trino's hashing functions and the encodings that carry bytes in and out of
+ * them.
+ *
+ * A `varbinary` is held as a SQLite blob, so a digest travels as bytes the way
+ * it does in Athena and a `to_hex` around it reads the same. Trino refuses text
+ * where a `varbinary` is wanted and SQLite has no analysis to refuse it with,
+ * so a column reaching one of these without a `to_utf8` around it is hashed as
+ * its UTF-8 bytes.
+ *
+ * `spooky_hash_v2_32` and `spooky_hash_v2_64` are absent. Nothing an access log
+ * query reaches for spells either, and a name registered for one would have to
+ * carry a third hash written out by hand.
+ */
+export declare function simAthenaInstallBinaryShims(database: DatabaseSync): void;

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

@@ -0,0 +1,49 @@
+import { createHash } from "node:crypto";
+import { crc32 } from "node:zlib";
+import { simAthenaMurmur3 } from "./sim-athena-murmur3.js";
+import { simAthenaDecodedText, simAthenaFromUtf8, } from "./sim-athena-binary-text.js";
+import { shimBytes, shimText, simAthenaScalarShim, } from "./sim-athena-shim-registry.js";
+import { simAthenaXxHash64 } from "./sim-athena-xxhash64.js";
+/** The `node:crypto` digest each Trino hashing function is spelled with. */
+const digests = new Map([
+    ["md5", "md5"],
+    ["sha1", "sha1"],
+    ["sha256", "sha256"],
+    ["sha512", "sha512"],
+]);
+/**
+ * Trino's hashing functions and the encodings that carry bytes in and out of
+ * them.
+ *
+ * A `varbinary` is held as a SQLite blob, so a digest travels as bytes the way
+ * it does in Athena and a `to_hex` around it reads the same. Trino refuses text
+ * where a `varbinary` is wanted and SQLite has no analysis to refuse it with,
+ * so a column reaching one of these without a `to_utf8` around it is hashed as
+ * its UTF-8 bytes.
+ *
+ * `spooky_hash_v2_32` and `spooky_hash_v2_64` are absent. Nothing an access log
+ * query reaches for spells either, and a name registered for one would have to
+ * carry a third hash written out by hand.
+ */
+export function simAthenaInstallBinaryShims(database) {
+    for (const [name, algorithm] of digests) {
+        simAthenaScalarShim(database, name, (value) => overBytes(value, (bytes) => new Uint8Array(createHash(algorithm).update(bytes).digest())));
+    }
+    simAthenaScalarShim(database, "xxhash64", (value) => overBytes(value, simAthenaXxHash64));
+    simAthenaScalarShim(database, "murmur3", (value) => overBytes(value, simAthenaMurmur3));
+    simAthenaScalarShim(database, "crc32", (value) => overBytes(value, (bytes) => crc32(bytes)));
+    simAthenaScalarShim(database, "to_hex", (value) => overBytes(value, (bytes) => Buffer.from(bytes).toString("hex").toUpperCase()));
+    simAthenaScalarShim(database, "to_base64", (value) => overBytes(value, (bytes) => Buffer.from(bytes).toString("base64")));
+    simAthenaScalarShim(database, "from_hex", (value) => simAthenaDecodedText(shimText(value), "hex"));
+    simAthenaScalarShim(database, "from_base64", (value) => simAthenaDecodedText(shimText(value), "base64"));
+    simAthenaScalarShim(database, "to_utf8", (value) => {
+        const text = shimText(value);
+        return text === undefined ? null : new TextEncoder().encode(text);
+    });
+    simAthenaScalarShim(database, "from_utf8", (...values) => simAthenaFromUtf8(shimBytes(values.at(0)), values));
+}
+/** One binary function over its argument, answering null where it is null. */
+function overBytes(value, read) {
+    const bytes = shimBytes(value);
+    return bytes === undefined ? null : read(bytes);
+}

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

@@ -0,0 +1,21 @@
+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.
+ */
+export declare function simAthenaDecodedText(text: string | undefined, encoding: "base64" | "hex"): Uint8Array | null;
+/**
+ * Bytes read back as text, with whatever was no UTF-8 replaced.
+ *
+ * Trino writes `U+FFFD` where a call named no replacement, which is what a
+ * decoder writes anyway. A call naming one has that written instead, and the
+ * replacement has to be a single character or empty, as Trino's does.
+ *
+ * Bytes carrying `U+FFFD` of their own leave nothing to tell the two apart
+ * once the decoder has run, so a call naming a replacement over those raises
+ * rather than replacing text that was never broken.
+ */
+export declare function simAthenaFromUtf8(bytes: Uint8Array | undefined, values: readonly SQLOutputValue[]): string | null;

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

@@ -0,0 +1,87 @@
+import { SimAthenaSetUpError } from "../error/sim-athena.error.js";
+import { isExplicitNull } from "./sim-athena-shim-registry.js";
+/** What each encoding will read back, in either case and padded or not. */
+const shapes = new Map([
+    ["hex", /^[\dA-Fa-f]*$/u],
+    ["base64", /^[\d+/A-Za-z]*={0,2}$/u],
+]);
+/** Whether the length of this text is one the encoding could have written. */
+const lengths = new Map([
+    ["hex", (text) => text.length % 2 === 0],
+    ["base64", isBase64Length],
+]);
+/** One character or none, counted in code points the way Trino counts them. */
+const oneCharacter = /^.?$/u;
+/** The character a UTF-8 decoder writes where the bytes were no UTF-8. */
+const replacementCharacter = "\u{FFFD}";
+/** The bytes that encode that character, which are valid UTF-8 themselves. */
+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.
+ */
+export function simAthenaDecodedText(text, encoding) {
+    if (text === undefined) {
+        return null;
+    }
+    const read = shapes.get(encoding)?.test(text) === true &&
+        lengths.get(encoding)?.(text) === true;
+    if (!read) {
+        throw new SimAthenaSetUpError(`from_${encoding} takes ${encoding} text`);
+    }
+    return new Uint8Array(Buffer.from(text, encoding));
+}
+/**
+ * Whether base64 of this length decodes, padding and all.
+ *
+ * Base64 carries three bytes in every four characters, and a length one over a
+ * multiple of four is a length no encoder could have written. Padding fills the
+ * last four out, so text carrying any has to be a multiple of four long.
+ * `Buffer` takes `A=` and `AAAA=` and answers with bytes nobody wrote.
+ */
+function isBase64Length(text) {
+    let padding = 0;
+    while (text.charAt(text.length - padding - 1) === "=") {
+        padding += 1;
+    }
+    const body = text.length - padding;
+    return body % 4 !== 1 && (padding === 0 || text.length % 4 === 0);
+}
+/**
+ * Bytes read back as text, with whatever was no UTF-8 replaced.
+ *
+ * Trino writes `U+FFFD` where a call named no replacement, which is what a
+ * decoder writes anyway. A call naming one has that written instead, and the
+ * replacement has to be a single character or empty, as Trino's does.
+ *
+ * Bytes carrying `U+FFFD` of their own leave nothing to tell the two apart
+ * once the decoder has run, so a call naming a replacement over those raises
+ * rather than replacing text that was never broken.
+ */
+export function simAthenaFromUtf8(bytes, values) {
+    if (bytes === undefined) {
+        return null;
+    }
+    const decoded = new TextDecoder().decode(bytes);
+    if (values.length < 2) {
+        return decoded;
+    }
+    if (isExplicitNull(values, 1)) {
+        return null;
+    }
+    const replacement = replacementFor(bytes, values);
+    return decoded.replaceAll(replacementCharacter, () => replacement);
+}
+function replacementFor(bytes, values) {
+    const replacement = String(values.at(1));
+    if (!oneCharacter.test(replacement)) {
+        throw new SimAthenaSetUpError("from_utf8 takes a replacement of one character or none");
+    }
+    if (Buffer.from(bytes).includes(encodedReplacement)) {
+        throw new SimAthenaSetUpError("from_utf8 cannot tell a replacement character it decoded from one the bytes carried");
+    }
+    return replacement;
+}

package/dist/service/athena/engine/sim-athena-count-distinct.d.ts

@@ -0,0 +1,15 @@
+/** The name the rewrite calls, which the aggregate shims register. */
+export declare const countDistinctShim = "count_distinct";
+/**
+ * `count(DISTINCT <expression>)`, written as a call the parser will take.
+ *
+ * The parser's Athena grammar takes a column after `DISTINCT` and nothing else,
+ * so `count(DISTINCT concat(a, b))` is refused outright and the whole query
+ * falls back. SQLite takes the same expression happily, and so does Athena, so
+ * the gap is the grammar rather than the engine.
+ *
+ * A plain column is left alone, since that already parses and SQLite counts it
+ * natively. Everything else becomes a call to one aggregate of the simulator's
+ * own, which counts the distinct values the same way.
+ */
+export declare function simAthenaCountDistinct(sql: string): string;

package/dist/service/athena/engine/sim-athena-count-distinct.js

@@ -0,0 +1,103 @@
+/** The name the rewrite calls, which the aggregate shims register. */
+export const countDistinctShim = "count_distinct";
+/** Where one `count(DISTINCT` opens, however the statement spaced it. */
+const opening = /\bcount\s*\(\s*DISTINCT\b/giu;
+/** One name in a column reference, quoted or bare. */
+const namePart = /^(?:"[^"]*"|[A-Za-z_]\w*)$/u;
+/**
+ * `count(DISTINCT <expression>)`, written as a call the parser will take.
+ *
+ * The parser's Athena grammar takes a column after `DISTINCT` and nothing else,
+ * so `count(DISTINCT concat(a, b))` is refused outright and the whole query
+ * falls back. SQLite takes the same expression happily, and so does Athena, so
+ * the gap is the grammar rather than the engine.
+ *
+ * A plain column is left alone, since that already parses and SQLite counts it
+ * natively. Everything else becomes a call to one aggregate of the simulator's
+ * own, which counts the distinct values the same way.
+ */
+export function simAthenaCountDistinct(sql) {
+    const quoted = quotedPositions(sql);
+    let rewritten = "";
+    let read = 0;
+    opening.lastIndex = 0;
+    for (let match = opening.exec(sql); match !== null; match = opening.exec(sql)) {
+        const closes = closingParenthesis(sql, opening.lastIndex, quoted);
+        if (closes === undefined || quoted.at(match.index) === true) {
+            continue;
+        }
+        const argument = sql.slice(opening.lastIndex, closes).trim();
+        if (isColumnReference(argument)) {
+            continue;
+        }
+        rewritten += `${sql.slice(read, match.index)}${countDistinctShim}(${argument})`;
+        read = closes + 1;
+        opening.lastIndex = read;
+    }
+    return rewritten + sql.slice(read);
+}
+/**
+ * Whether this argument is a column the grammar would have taken as it stands.
+ *
+ * A quoted name carrying a dot of its own reads here as two names and fails
+ * this. The call is then rewritten, and the rewrite answers the same way.
+ */
+function isColumnReference(argument) {
+    return argument.split(".").every((part) => namePart.test(part.trim()));
+}
+/**
+ * Whether the character at each position sits inside quotes.
+ *
+ * Both of SQL's quotes are tracked. A single quote opens a string literal and a
+ * double quote opens a delimited identifier, and either is free to carry the
+ * text of a call. Rewriting inside a literal would change the value a
+ * comparison is made against, and rewriting inside an identifier would name a
+ * different column.
+ *
+ * SQL escapes a quote inside either by doubling it, which reads here as one
+ * quoted run ending and another starting. The positions in between land the
+ * same way whichever reading is taken.
+ */
+function quotedPositions(sql) {
+    const inside = [];
+    let quote;
+    for (const character of quotableCharacters(sql)) {
+        if (quote === undefined && (character === "'" || character === '"')) {
+            quote = character;
+        }
+        else if (quote === character) {
+            quote = undefined;
+        }
+        inside.push(quote !== undefined);
+    }
+    return inside;
+}
+/** Each character of the statement, by position rather than by code point. */
+function* quotableCharacters(sql) {
+    for (let at = 0; at < sql.length; at += 1) {
+        yield sql.charAt(at);
+    }
+}
+/**
+ * Where the parenthesis that opened this call closes, or nothing where the
+ * statement never closes it.
+ *
+ * Depth is counted so that a call carrying calls of its own is read whole, and
+ * a parenthesis inside quotes is passed over so that it is not counted.
+ */
+function closingParenthesis(sql, from, quoted) {
+    let depth = 0;
+    for (let at = from; at < sql.length; at += 1) {
+        const character = quoted.at(at) === true ? "" : sql.charAt(at);
+        if (character === "(") {
+            depth += 1;
+        }
+        else if (character === ")") {
+            if (depth === 0) {
+                return at;
+            }
+            depth -= 1;
+        }
+    }
+    return undefined;
+}

package/dist/service/athena/engine/sim-athena-distinct-values.d.ts

@@ -0,0 +1,19 @@
+import type { SQLOutputValue } from "node:sqlite";
+/**
+ * The values one aggregate has seen, as SQLite will carry them between rows.
+ *
+ * SQLite holds an accumulator as one of its own values rather than as an
+ * object, so the set travels as the JSON text of its keys.
+ */
+export type SimAthenaDistinctValues = string;
+/** An empty accumulator, which is what an aggregate over no rows answers from. */
+export declare const noDistinctValues: SimAthenaDistinctValues;
+/**
+ * This value with one more added, where it is not null.
+ *
+ * Trino and SQLite both leave a null out of a distinct count, so a null row
+ * adds nothing.
+ */
+export declare function withDistinctValue(accumulator: SimAthenaDistinctValues, value: SQLOutputValue): SimAthenaDistinctValues;
+/** How many distinct values this accumulator saw. */
+export declare function countedDistinctValues(accumulator: SimAthenaDistinctValues): number;