@kensio/yulin 1.21.22 → 1.21.24

package/dist/service/wafv2/statement/sim-waf-rule-refusals.js

@@ -1,16 +1,17 @@
 import { SimWafInvalidParameterException, SimWafUnsimulatedInputException, } from "../error/sim-wafv2.error.js";
 /**
- * Refuse something in a rule that real WAFv2 takes and this simulation does
+ * Stop compiling a rule at something real WAFv2 takes and this simulation does
  * not.
  *
- * Every refusal names the rule and what in it was refused, because a web ACL
- * is a list of rules that all look alike from the outside and the name is the
- * only thing that says which one to go and look at.
+ * `SimWafRule.compile` catches it and holds the rule unevaluated, with this
+ * message as the reason the web ACL reports. The message names the rule and
+ * what in it was left out, because a web ACL is a list of rules that all look
+ * alike from the outside and the name is the only thing that says which one to
+ * go and look at.
  */
 export function refuseSimWafRuleInput(ruleName, refused, reason) {
     throw new SimWafUnsimulatedInputException(`Rule ${ruleName} uses ${refused}, which Yulin does not simulate: ` +
-        `${reason}. A web ACL that accepted a rule it cannot evaluate would ` +
-        `allow a request AWS blocks.`);
+        `${reason}. The rule is held and claims no request.`);
 }
 /**
  * Refuse a rule real WAFv2 would refuse too.

package/dist/service/wafv2/statement/sim-waf-statement.d.ts

@@ -19,8 +19,8 @@ export interface SimWafStatementScope {
  * Turn one statement into the matcher a rule evaluates a request with.
  *
  * Compiling happens when the web ACL is written rather than when a request
- * arrives, which is what lets `CreateWebACL` refuse a statement kind it cannot
- * evaluate. It also means a rule does no parsing per request: what a request
- * meets is a closure over what the rule already worked out.
+ * arrives, which is where a statement kind Yulin cannot evaluate is found and
+ * its rule held unevaluated. It also means a rule does no parsing per request:
+ * what a request meets is a closure over what the rule already worked out.
  */
 export declare function compileSimWafStatement(statement: SimWafStatementInput | undefined, scope: SimWafStatementScope): SimWafMatcher;

package/dist/service/wafv2/statement/sim-waf-statement.js

@@ -11,9 +11,9 @@ import { refuseUnsimulatedSimWafStatement } from "./sim-waf-unsimulated-statemen
  * Turn one statement into the matcher a rule evaluates a request with.
  *
  * Compiling happens when the web ACL is written rather than when a request
- * arrives, which is what lets `CreateWebACL` refuse a statement kind it cannot
- * evaluate. It also means a rule does no parsing per request: what a request
- * meets is a closure over what the rule already worked out.
+ * arrives, which is where a statement kind Yulin cannot evaluate is found and
+ * its rule held unevaluated. It also means a rule does no parsing per request:
+ * what a request meets is a closure over what the rule already worked out.
  */
 export function compileSimWafStatement(statement, scope) {
     const { ruleName } = scope;

package/dist/service/wafv2/statement/sim-waf-statement.type.d.ts

@@ -16,9 +16,9 @@ export interface SimWafFieldStatementInput {
 /**
  * Minimal structural WAFv2 Statement.
  *
- * The kinds Yulin refuses are declared alongside the ones it evaluates, so a
- * rule that uses one is refused by name rather than read as a rule with no
- * statement in it.
+ * The kinds Yulin does not evaluate are declared alongside the ones it does,
+ * so a rule that uses one is held and reported by name rather than read as a
+ * rule with no statement in it.
  *
  * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/wafv2/Interface/Statement/
  */

package/dist/service/wafv2/statement/sim-waf-unsimulated-statement.js

@@ -6,7 +6,7 @@ const undocumentedDetection = "AWS does not document the detection it runs, so a
     "agree with real WAF by coincidence or not at all";
 /**
  * The statement kinds real WAFv2 evaluates and this simulation does not, and
- * why each of them is refused rather than deferred.
+ * why a rule using one is held unevaluated.
  */
 const refusedStatements = new Map([
     ["IPSetReferenceStatement", oneClientAddress],

package/dist/service/wafv2/web-acl/sim-waf-association-config.d.ts

@@ -1,10 +1,11 @@
+import type { SimWafUnsimulatedPart } from "../resource/sim-waf-unsimulated-part.js";
 /**
  * A resource type whose body inspection limit a web ACL can set.
  *
  * Real WAF keys `AssociationConfig.RequestBody` by resource type, and these
- * three are the ones a web ACL goes in front of here. `APP_RUNNER_SERVICE` and
- * `VERIFIED_ACCESS_INSTANCE` are keys AWS takes for resources this simulation
- * has no association for.
+ * three are the ones a request reaches a web ACL through here. `APP_RUNNER_SERVICE`
+ * and `VERIFIED_ACCESS_INSTANCE` are keys AWS takes for resources a web ACL
+ * can be associated with and no simulated request passes through.
  */
 export type SimWafBodyInspectionResourceType = "CLOUDFRONT" | "API_GATEWAY" | "COGNITO_USER_POOL";
 /**
@@ -12,8 +13,8 @@ export type SimWafBodyInspectionResourceType = "CLOUDFRONT" | "API_GATEWAY" | "C
  * `AssociationConfig`.
  *
  * CloudFront, API Gateway and Cognito all default to 16 KB. A load balancer
- * and an AppSync API are fixed at 8 KB, and a web ACL cannot be put in front
- * of either one here.
+ * and an AppSync API are fixed at 8 KB, and no simulated request reaches a web
+ * ACL through either one.
  */
 export declare const simWafBodyInspectionLimitBytes = 16384;
 /**
@@ -40,9 +41,15 @@ export declare class SimWafBodyInspectionLimits {
     private constructor();
     /**
      * Read the limits an `AssociationConfig` sets, refusing anything WAF would
-     * refuse and anything this simulation cannot apply.
+     * refuse.
      */
     static read(input: SimWafAssociationConfigInput | undefined): SimWafBodyInspectionLimits;
+    /**
+     * The limits set for resource types no simulated request passes through.
+     *
+     * Each is checked as WAF checks it and held, and applies to nothing.
+     */
+    get unsimulated(): readonly SimWafUnsimulatedPart[];
     /**
      * How many bytes of a body a request reaching one resource type is inspected
      * for.
@@ -50,5 +57,5 @@ export declare class SimWafBodyInspectionLimits {
      * A request evaluated against a web ACL that no resource holds names no
      * resource type, and reads the default.
      */
-    bytesFor(resourceType: SimWafBodyInspectionResourceType | undefined): number;
+    bytesFor(resourceType: string | undefined): number;
 }

package/dist/service/wafv2/web-acl/sim-waf-association-config.js

@@ -1,11 +1,12 @@
-import { SimWafInvalidParameterException, SimWafUnsimulatedInputException, } from "../error/sim-wafv2.error.js";
+import { SimWafInvalidParameterException } from "../error/sim-wafv2.error.js";
+import { unsimulatedSimWafBodyLimits } from "./sim-waf-unsimulated-body-limit.js";
 /**
  * How much of a request body WAF reads for a resource type given no
  * `AssociationConfig`.
  *
  * CloudFront, API Gateway and Cognito all default to 16 KB. A load balancer
- * and an AppSync API are fixed at 8 KB, and a web ACL cannot be put in front
- * of either one here.
+ * and an AppSync API are fixed at 8 KB, and no simulated request reaches a web
+ * ACL through either one.
  */
 export const simWafBodyInspectionLimitBytes = 16_384;
 /**
@@ -17,11 +18,6 @@ const inspectionLimits = new Map([
     ["KB_48", 49_152],
     ["KB_64", 65_536],
 ]);
-const simulatedResourceTypes = [
-    "CLOUDFRONT",
-    "API_GATEWAY",
-    "COGNITO_USER_POOL",
-];
 /**
  * How much of a request body a web ACL's rules read, by resource type.
  *
@@ -36,15 +32,21 @@ export class SimWafBodyInspectionLimits {
     }
     /**
      * Read the limits an `AssociationConfig` sets, refusing anything WAF would
-     * refuse and anything this simulation cannot apply.
+     * refuse.
      */
     static read(input) {
-        const configured = Object.entries(input?.RequestBody ?? {});
-        const limits = new Map();
-        for (const [resourceType, config] of configured) {
-            limits.set(simulatedResourceType(resourceType), inspectionLimit(resourceType, config));
-        }
-        return new SimWafBodyInspectionLimits(limits);
+        return new SimWafBodyInspectionLimits(new Map(Object.entries(input?.RequestBody ?? {}).map(([resourceType, config]) => [
+            resourceType,
+            inspectionLimit(resourceType, config),
+        ])));
+    }
+    /**
+     * The limits set for resource types no simulated request passes through.
+     *
+     * Each is checked as WAF checks it and held, and applies to nothing.
+     */
+    get unsimulated() {
+        return unsimulatedSimWafBodyLimits(this.limits.keys());
     }
     /**
      * How many bytes of a body a request reaching one resource type is inspected
@@ -60,18 +62,6 @@ export class SimWafBodyInspectionLimits {
         return this.limits.get(resourceType) ?? simWafBodyInspectionLimitBytes;
     }
 }
-/**
- * Hold a `RequestBody` key to the resource types this simulation associates.
- */
-function simulatedResourceType(resourceType) {
-    const simulated = simulatedResourceTypes.find((candidate) => candidate === resourceType);
-    if (simulated === undefined) {
-        throw new SimWafUnsimulatedInputException(`AssociationConfig sets the body inspection limit for ${resourceType} ` +
-            `resources, and ${simulatedResourceTypes.join(" and ")} are the ` +
-            `types a web ACL goes in front of in Yulin`);
-    }
-    return simulated;
-}
 /**
  * Read one resource type's `DefaultSizeInspectionLimit`.
  *

package/dist/service/wafv2/web-acl/sim-waf-rule.d.ts

@@ -4,17 +4,29 @@ import type { SimWafRuleInput, SimWafRuleScope } from "./sim-waf-rule.type.js";
 /**
  * One rule of a web ACL, compiled so a request can be evaluated against it.
  *
- * The statement is turned into an evaluator when the web ACL is written, which
- * is what lets a rule Yulin cannot evaluate be refused at that point rather
- * than silently letting requests past later on.
+ * The statement is turned into an evaluator when the web ACL is written. A
+ * rule using something Yulin does not simulate is held all the same, as a
+ * rule that claims no request, and says why in `unsimulatedReason`. The web
+ * ACL reports it from there.
  */
 export declare class SimWafRule {
     #private;
     readonly name: string;
     readonly priority: number;
+    /**
+     * Why this rule claims no request, when it uses something Yulin does not
+     * simulate.
+     *
+     * AWS would evaluate it. A request it would have claimed goes on to the
+     * next rule here.
+     */
+    readonly unsimulatedReason: string | undefined;
     private constructor();
     /**
      * Compile one rule as it was written.
+     *
+     * Input WAFv2 itself would refuse is refused here too. A rule using
+     * something only Yulin leaves out compiles to one that claims nothing.
      */
     static compile(input: SimWafRuleInput, scope: SimWafRuleScope): SimWafRule;
     /**

package/dist/service/wafv2/web-acl/sim-waf-rule.js

@@ -1,16 +1,32 @@
+import { SimWafUnsimulatedInputException } from "../error/sim-wafv2.error.js";
 import { refuseUnsimulatedSimWafRuleInput, requiredSimWafRuleName, requiredSimWafRulePriority, } from "./sim-waf-rule-input.js";
 import { simWafRuleLabels } from "./sim-waf-rule-labels.js";
 import { compileSimWafRuleEvaluator } from "./sim-waf-rule-evaluator.js";
+/**
+ * What a rule held without being evaluated does with every request.
+ */
+function claimsNothing() {
+    // A held rule claims no request, so every request goes on to the next rule.
+}
 /**
  * One rule of a web ACL, compiled so a request can be evaluated against it.
  *
- * The statement is turned into an evaluator when the web ACL is written, which
- * is what lets a rule Yulin cannot evaluate be refused at that point rather
- * than silently letting requests past later on.
+ * The statement is turned into an evaluator when the web ACL is written. A
+ * rule using something Yulin does not simulate is held all the same, as a
+ * rule that claims no request, and says why in `unsimulatedReason`. The web
+ * ACL reports it from there.
  */
 export class SimWafRule {
     name;
     priority;
+    /**
+     * Why this rule claims no request, when it uses something Yulin does not
+     * simulate.
+     *
+     * AWS would evaluate it. A request it would have claimed goes on to the
+     * next rule here.
+     */
+    unsimulatedReason;
     #labels;
     #evaluate;
     constructor(properties) {
@@ -18,19 +34,39 @@ export class SimWafRule {
         this.priority = properties.priority;
         this.#labels = properties.labels;
         this.#evaluate = properties.evaluate;
+        this.unsimulatedReason = properties.unsimulatedReason;
     }
     /**
      * Compile one rule as it was written.
+     *
+     * Input WAFv2 itself would refuse is refused here too. A rule using
+     * something only Yulin leaves out compiles to one that claims nothing.
      */
     static compile(input, scope) {
         const name = requiredSimWafRuleName(input.Name);
-        refuseUnsimulatedSimWafRuleInput(input, name);
-        return new SimWafRule({
-            name,
-            priority: requiredSimWafRulePriority(input.Priority, name),
-            labels: simWafRuleLabels(input.RuleLabels, name),
-            evaluate: compileSimWafRuleEvaluator(input, name, scope),
-        });
+        const priority = requiredSimWafRulePriority(input.Priority, name);
+        const labels = simWafRuleLabels(input.RuleLabels, name);
+        try {
+            refuseUnsimulatedSimWafRuleInput(input, name);
+            return new SimWafRule({
+                name,
+                priority,
+                labels,
+                evaluate: compileSimWafRuleEvaluator(input, name, scope),
+            });
+        }
+        catch (error) {
+            if (!(error instanceof SimWafUnsimulatedInputException)) {
+                throw error;
+            }
+            return new SimWafRule({
+                name,
+                priority,
+                labels,
+                evaluate: claimsNothing,
+                unsimulatedReason: error.message,
+            });
+        }
     }
     /**
      * What this rule does with a request, which is nothing when it does not

package/dist/service/wafv2/web-acl/sim-waf-statement-capacity.d.ts

@@ -2,9 +2,9 @@ import type { SimWafStatementInput } from "../statement/sim-waf-statement.type.j
 /**
  * What the statements that inspect a request cost.
  *
- * Only the kinds this simulation evaluates are counted. Every other kind is
- * refused where the rule is written, so a web ACL that has rules to add up
- * cannot hold one. Doubling the base cost for a JSON body never applies here
- * for the same reason.
+ * Only the kinds this simulation evaluates are counted. A rule using any
+ * other kind is held unevaluated and contributes nothing, so a web ACL holding
+ * one reports less than AWS would charge. Doubling the base cost for a JSON
+ * body never applies here for the same reason.
  */
 export declare function simWafMatchCapacity(statement: SimWafStatementInput): number;

package/dist/service/wafv2/web-acl/sim-waf-statement-capacity.js

@@ -19,10 +19,10 @@ const textTransformationCost = 10;
 /**
  * What the statements that inspect a request cost.
  *
- * Only the kinds this simulation evaluates are counted. Every other kind is
- * refused where the rule is written, so a web ACL that has rules to add up
- * cannot hold one. Doubling the base cost for a JSON body never applies here
- * for the same reason.
+ * Only the kinds this simulation evaluates are counted. A rule using any
+ * other kind is held unevaluated and contributes nothing, so a web ACL holding
+ * one reports less than AWS would charge. Doubling the base cost for a JSON
+ * body never applies here for the same reason.
  */
 export function simWafMatchCapacity(statement) {
     return (byteMatchCapacity(statement.ByteMatchStatement) +

package/dist/service/wafv2/web-acl/sim-waf-unsimulated-body-limit.d.ts

@@ -0,0 +1,6 @@
+import type { SimWafUnsimulatedPart } from "../resource/sim-waf-unsimulated-part.js";
+/**
+ * What the body inspection limits a web ACL sets leave out, one part per
+ * resource type no simulated request passes through.
+ */
+export declare function unsimulatedSimWafBodyLimits(resourceTypes: Iterable<string>): readonly SimWafUnsimulatedPart[];

package/dist/service/wafv2/web-acl/sim-waf-unsimulated-body-limit.js

@@ -0,0 +1,23 @@
+/**
+ * The resource types a simulated request reaches a web ACL through.
+ */
+const simulatedResourceTypes = new Set([
+    "CLOUDFRONT",
+    "API_GATEWAY",
+    "COGNITO_USER_POOL",
+]);
+/**
+ * What the body inspection limits a web ACL sets leave out, one part per
+ * resource type no simulated request passes through.
+ */
+export function unsimulatedSimWafBodyLimits(resourceTypes) {
+    return [...resourceTypes]
+        .filter((resourceType) => !simulatedResourceTypes.has(resourceType))
+        .map((resourceType) => ({
+        part: `AssociationConfig.RequestBody.${resourceType}`,
+        reason: `AssociationConfig sets the body inspection limit for ` +
+            `${resourceType} resources, and ` +
+            `${[...simulatedResourceTypes].join(" and ")} are the types a ` +
+            `simulated request reaches a web ACL through`,
+    }));
+}

package/dist/service/wafv2/web-acl/sim-waf-web-acl-capacity.js

@@ -59,8 +59,8 @@ function nestedCapacity(statement) {
  *
  * A group is fixed at the capacity its owner gave it, and a scope-down
  * statement is charged on top. A group this simulation does not carry
- * contributes nothing, which cannot happen through a compiled web ACL: naming
- * one is refused where the rule is written.
+ * contributes nothing, so a web ACL holding one reports less than AWS would
+ * charge.
  */
 function managedGroupCapacity(statement) {
     const named = statement.ManagedRuleGroupStatement;

package/dist/service/wafv2/web-acl/sim-waf-web-acl-configuration.d.ts

@@ -13,6 +13,11 @@ export interface SimWafWebAclConfiguration {
     readonly visibilityConfig?: unknown;
     readonly description?: string | undefined;
     readonly associationConfig?: SimWafAssociationConfigInput | undefined;
+    /**
+     * The members held as written and not acted on, such as `CaptchaConfig`,
+     * keyed by the name the API gives them.
+     */
+    readonly heldMembers?: Readonly<Record<string, unknown>> | undefined;
 }
 /**
  * Read the action a request no rule claims is given.

package/dist/service/wafv2/web-acl/sim-waf-web-acl.d.ts

@@ -1,7 +1,7 @@
 import { type SimWafDecision } from "../evaluate/sim-waf-decision.js";
 import type { SimWafInspectedRequest } from "../evaluate/sim-waf-inspected-request.js";
 import { SimWafResource, type SimWafResourceProperties } from "../resource/sim-waf-resource.js";
-import { type SimWafBodyInspectionResourceType } from "./sim-waf-association-config.js";
+import type { SimWafUnsimulatedPart } from "../resource/sim-waf-unsimulated-part.js";
 import type { SimWafWebAclRuleScope } from "./sim-waf-rule.type.js";
 import { type SimWafWebAclConfiguration } from "./sim-waf-web-acl-configuration.js";
 interface SimWafWebAclProperties extends SimWafResourceProperties, SimWafWebAclRuleScope {
@@ -33,6 +33,14 @@ export declare class SimWafWebAcl extends SimWafResource {
      * What this web ACL's rules add up to in capacity units.
      */
     get capacity(): number;
+    /**
+     * What this web ACL was written with and the simulation does not act on.
+     *
+     * A rule listed here claims no request, a member is held and does nothing,
+     * and a body inspection limit applies to no request. `GetWebACL` returns
+     * every one of them as written.
+     */
+    get unsimulated(): readonly SimWafUnsimulatedPart[];
     /**
      * What this web ACL was last written with, as the API reports it.
      */
@@ -42,6 +50,7 @@ export declare class SimWafWebAcl extends SimWafResource {
      *
      * The rules are compiled before anything is replaced, so a web ACL that
      * refuses an update keeps the rules it had rather than being left with none.
+     * The tags stay as they were created, since UpdateWebACL takes none.
      */
     reconfigure(configuration: SimWafWebAclConfiguration, lockToken: string | undefined): void;
     /**
@@ -51,7 +60,7 @@ export declare class SimWafWebAcl extends SimWafResource {
      * `AssociationConfig` raises it per resource type, and a web ACL written
      * without one reads the 16 KB default everything it protects has.
      */
-    bodyInspectionLimitBytes(resourceType: SimWafBodyInspectionResourceType | undefined): number;
+    bodyInspectionLimitBytes(resourceType: string | undefined): number;
     /**
      * Decide what happens to one request.
      */

package/dist/service/wafv2/web-acl/sim-waf-web-acl.js

@@ -1,7 +1,8 @@
 import { simWafDecision, } from "../evaluate/sim-waf-decision.js";
 import { simWafEvaluateRules } from "../evaluate/sim-waf-evaluate-rules.js";
+import { unsimulatedSimWafWebAclMembers } from "../command/web-acl/sim-wafv2-unsimulated-web-acl-input.js";
 import { SimWafResource, } from "../resource/sim-waf-resource.js";
-import { SimWafBodyInspectionLimits, } from "./sim-waf-association-config.js";
+import { SimWafBodyInspectionLimits } from "./sim-waf-association-config.js";
 import { compileSimWafWebAclRules } from "./sim-waf-rules.js";
 import { simWafWebAclCapacity } from "./sim-waf-web-acl-capacity.js";
 import { readSimWafDefaultAction, } from "./sim-waf-web-acl-configuration.js";
@@ -49,6 +50,23 @@ export class SimWafWebAcl extends SimWafResource {
     get capacity() {
         return this.#capacity;
     }
+    /**
+     * What this web ACL was written with and the simulation does not act on.
+     *
+     * A rule listed here claims no request, a member is held and does nothing,
+     * and a body inspection limit applies to no request. `GetWebACL` returns
+     * every one of them as written.
+     */
+    get unsimulated() {
+        return [
+            ...this.#rules.flatMap(({ name, unsimulatedReason }) => unsimulatedReason === undefined
+                ? []
+                : [{ part: `Rules.${name}`, reason: unsimulatedReason }]),
+            ...unsimulatedSimWafWebAclMembers(this.#configuration.heldMembers ?? {}),
+            ...this.#bodyInspectionLimits.unsimulated,
+            ...super.unsimulated,
+        ];
+    }
     /**
      * What this web ACL was last written with, as the API reports it.
      */
@@ -60,6 +78,7 @@ export class SimWafWebAcl extends SimWafResource {
      *
      * The rules are compiled before anything is replaced, so a web ACL that
      * refuses an update keeps the rules it had rather than being left with none.
+     * The tags stay as they were created, since UpdateWebACL takes none.
      */
     reconfigure(configuration, lockToken) {
         const defaultAction = readSimWafDefaultAction(configuration);

package/docs/services/athena/README.md

@@ -486,7 +486,7 @@ Every ascending sort is emitted carrying `NULLS LAST`, because Trino orders null
 direction it sorts and SQLite orders them first ascending. Both were cases where a query answered
 differently while still succeeding, which is the failure that costs the most to find.
 
-### Flattening an array or a map
+### Flattening an array, a map or a split value
 
 `UNNEST` runs. An array or a map column is held as its JSON text, and SQLite reads that with
 `json_each`, so a statement flattening one returns a row per element the way Athena does.
@@ -505,6 +505,22 @@ falls back rather than reading a scalar as a collection.
 One flattening per statement is what this covers, joined with `CROSS JOIN`. A second `UNNEST`, a
 `LEFT JOIN UNNEST`, a `SELECT *` beside one, and a position taken from a map all fall back.
 
+A table with no array column in it can still be flattened. `split` answers an array, and an `UNNEST`
+over the call cuts one stored string into a row per part. This is how a packed access log row is
+read, since Glue builds a log table's columns from what the delivery was configured with.
+
+```sql
+SELECT t.part
+FROM rainlytics.logs
+CROSS JOIN UNNEST(split(url_extract_parameter(cs_uri_stem || '?' || cs_uri_query, 'b'), ';'))
+  AS t(part)
+```
+
+Splitting an empty value answers one empty part, as it does on Trino. A row whose value is null
+answers no parts at all and drops out, the way an empty array column does. The call is what says the
+value is a collection (an expression has no schema entry to read). `split` and `slice` are the two
+calls the flattening reaches, and any other expression under an `UNNEST` falls back.
+
 ### The functions a statement can call
 
 SQLite carries a much smaller function library than Trino, and the engine fills the gap for the ones
@@ -516,7 +532,7 @@ its declared result.
 | Date and time | `current_date`, `current_timestamp`, `date_add`, `date_diff`, `date_trunc`, `date_format`, `at_timezone`, `from_unixtime`, `to_unixtime`, `from_iso8601_timestamp`, `from_iso8601_date`, `to_iso8601` |
 | JSON          | `json_extract`, `json_extract_scalar`, `json_parse`, `json_size`                                                                                                                                      |
 | Array and map | `array_agg`, `cardinality`, `contains`, `element_at`, `array_join`, `slice`                                                                                                                           |
-| String        | `regexp_like`, `regexp_extract`, `regexp_replace`, `split_part`, `strpos`                                                                                                                             |
+| String        | `regexp_like`, `regexp_extract`, `regexp_replace`, `split`, `split_part`, `strpos`                                                                                                                    |
 | Binary        | `md5`, `sha1`, `sha256`, `sha512`, `xxhash64`, `murmur3`, `crc32`, `to_hex`, `from_hex`, `to_base64`, `from_base64`, `to_utf8`, `from_utf8`                                                           |
 | URL           | `url_extract_host`, `url_extract_path`, `url_extract_protocol`, `url_extract_port`, `url_extract_query`, `url_extract_fragment`, `url_extract_parameter`, `url_decode`, `url_encode`                  |
 | Approximate   | `approx_distinct`, `approx_percentile`                                                                                                                                                                |
@@ -992,6 +1008,7 @@ own and authorizes work on one against the workgroup it belongs to. This asks th
 - `StartQueryExecution`, `GetQueryExecution`, `GetQueryResults` and `StopQueryExecution`
 - A `SELECT` run for real over JSON lines and CSV objects in simulated S3, answered by SQLite
 - `UNNEST` over an array or a map column, with `WITH ORDINALITY` where a query wants the position
+- `UNNEST` over a `split` or a `slice` call, flattening one stored string into a row per part
 - Trino's date, JSON, array, string and URL functions, with `current_timestamp` reading the
   simulated clock
 - Declared results, matched on the query text, ahead of the engine for one statement and behind it
@@ -1027,6 +1044,8 @@ Current documented limitations:
   gives a map's keys rather than its positions.
 - `UNNEST` over a `ROW` or a struct array falls back. The element needs field access and the
   flattened column is JSON text here.
+- `UNNEST` over an expression reaches `split` and `slice`. The engine reads the call to decide that
+  a value is a collection, and a call to anything else falls back.
 - The Trino function library reaches as far as the table under
   [the functions a statement can call](#the-functions-a-statement-can-call). A query reaching for
   anything else Trino has and SQLite lacks falls back.