@workerstack/testing 0.0.0-stage → 0.31.0

package/dist/api/runtime/checks/core/run.d.ts

@@ -0,0 +1,26 @@
+import { type Outcome } from "../../finding.ts";
+import type { Check } from "./check.ts";
+import { type WriteContext } from "./context.ts";
+import { type Plan } from "./plan.ts";
+/** What a check that reads the entity's listing needs, on an entity that has none. */
+export declare const NEEDS_LIST = "a list operation";
+/**
+ * The salts one check draws on one entity: the check's place in the registry, the entity's in the
+ * model, and a count. Two check runs never share one, by construction, and a run draws the same
+ * sequence every time.
+ */
+export declare function checkSalts(checkIndex: number, entityIndex: number): () => string;
+/** The check's plan on the entity; a check that reads the listing cannot plan on an entity without one. */
+export declare function planOn(check: Check, ctx: WriteContext): Plan<unknown>;
+/** Runs a check its plan let through; a check that reads the listing stands down on an entity without one. */
+export declare function runOn(check: Check, ctx: WriteContext, plan: unknown): Promise<Outcome>;
+/** Plans a check and, when it applies, runs it — what the scheduler does, for one check. */
+export declare function runCheck(check: Check, ctx: WriteContext): Promise<Outcome>;
+/**
+ * What a check whose plan cannot run needed: the query parameters the list does not declare, when
+ * their absence is what stopped it; else what the plan says; else the check's own needs.
+ */
+export declare function planNeeds(check: Check, ctx: WriteContext, planned: {
+    needs?: string;
+}): string;
+//# sourceMappingURL=run.d.ts.map

package/dist/api/runtime/checks/core/run.js

@@ -0,0 +1,65 @@
+import { emptyCapabilities } from "../../../spec/query/merge.js";
+import { describeWithheld, queryOver, restoreWithheld } from "../../../spec/query/sendable.js";
+import { standDown } from "../../finding.js";
+import { resolvedCaps } from "../query/capabilities.js";
+import { isListed } from "./context.js";
+import { cannot } from "./plan.js";
+/** What a check that reads the entity's listing needs, on an entity that has none. */
+export const NEEDS_LIST = "a list operation";
+/**
+ * The salts one check draws on one entity: the check's place in the registry, the entity's in the
+ * model, and a count. Two check runs never share one, by construction, and a run draws the same
+ * sequence every time.
+ */
+export function checkSalts(checkIndex, entityIndex) {
+    let drawn = 0;
+    return () => `${checkIndex}.${entityIndex}.${(drawn++).toString(36)}`;
+}
+/** The check's plan on the entity; a check that reads the listing cannot plan on an entity without one. */
+export function planOn(check, ctx) {
+    if (check.lists !== true)
+        return check.plan(ctx);
+    return isListed(ctx) ? check.plan(ctx) : cannot(NEEDS_LIST);
+}
+/** Runs a check its plan let through; a check that reads the listing stands down on an entity without one. */
+export function runOn(check, ctx, plan) {
+    if (check.lists !== true)
+        return check.run(ctx, plan);
+    return isListed(ctx) ? check.run(ctx, plan) : Promise.resolve(standDown(NEEDS_LIST));
+}
+/** Plans a check and, when it applies, runs it — what the scheduler does, for one check. */
+export async function runCheck(check, ctx) {
+    const planned = planOn(check, ctx);
+    if (!planned.ok)
+        return standDown(planNeeds(check, ctx, planned));
+    return runOn(check, ctx, planned.value);
+}
+/**
+ * What a check whose plan cannot run needed: the query parameters the list does not declare, when
+ * their absence is what stopped it; else what the plan says; else the check's own needs.
+ */
+export function planNeeds(check, ctx, planned) {
+    return withheldNeeds(check, ctx) ?? planned.needs ?? check.needs ?? "an unstated precondition";
+}
+/**
+ * The parameters a plan that cannot run is missing, when their absence is what stopped it: the
+ * plan applies once the withheld capabilities are put back. Each is tried alone first, so the
+ * reason names only what this check needed; one needing several together names them all. Planned
+ * as the scheduler plans (`planOn`): a check that reads the listing, on an entity without one,
+ * still needs the list, whatever was withheld.
+ */
+function withheldNeeds(check, ctx) {
+    const withheld = ctx.withheld ?? [];
+    const applies = (back) => planOn(check, restored(ctx, back)).ok;
+    if (withheld.length === 0 || !applies(withheld))
+        return undefined;
+    const alone = withheld.filter((item) => applies([item]));
+    return describeWithheld(alone.length === 0 ? withheld : alone);
+}
+function restored(ctx, back) {
+    /* An entity with no list holds no capabilities of its own; `planOn` still says it needs one. */
+    const current = isListed(ctx) ? resolvedCaps(ctx) : emptyCapabilities();
+    const capabilities = restoreWithheld(current, back);
+    return { ...ctx, capabilities, query: queryOver(ctx.query, capabilities) };
+}
+//# sourceMappingURL=run.js.map

package/dist/api/runtime/checks/families/composition/plans.d.ts

@@ -0,0 +1,35 @@
+import { type Record_ } from "../../../world/records.ts";
+import type { CheckContext, Listed } from "../../core/context.ts";
+import { type Plan } from "../../core/plan.ts";
+/** A filter selecting a proper subset of the cohort, and the record it was built from. */
+export interface Subset {
+    field: string;
+    target: Record_;
+    term: Record<string, string>;
+}
+/**
+ * A field, and a value on it, selecting a *proper subset* of the cohort: more than one record so
+ * there is something to reorder or project, and fewer than all so a dropped predicate is visible
+ * as a change in membership. A value matching everything would make the filtered and unfiltered
+ * sets identical, and a composition check would pass whatever the backend did.
+ */
+export declare function subsetPlan(ctx: Listed): Plan<Subset>;
+/** A proper-subset filter and a search token that overlap without nesting. */
+export declare function overlapPlan(ctx: Listed): Plan<Subset & {
+    token: string;
+}>;
+/** A sparse fieldset of the identity and one other selectable field. */
+export declare function projectionBeside(ctx: Listed): {
+    extra: string;
+    projection: Record<string, string>;
+} | null;
+/** `projectionBeside` as a plan: it stands down when the select grammar cannot write a fieldset. */
+export declare function projectionPlan(ctx: Listed): Plan<{
+    extra: string;
+    projection: Record<string, string>;
+}>;
+/** The sparse fieldset `requested` as a plan: it stands down, unexplained, when no select can write it. */
+export declare function selectionPlan(ctx: Listed, requested: readonly string[]): Plan<Record<string, string>>;
+/** A sortable field other than `field` and the identity, else the identity. */
+export declare function sortFieldBeside(ctx: CheckContext, field: string): string;
+//# sourceMappingURL=plans.d.ts.map

package/dist/api/runtime/checks/families/composition/plans.js

@@ -0,0 +1,147 @@
+import { filterTerm } from "../../../../spec/conventions/filter.js";
+import { selectTerm } from "../../../../spec/conventions/select.js";
+import { idOf } from "../../../world/records.js";
+import { cannot, ready } from "../../core/plan.js";
+import { conv } from "../../query/capabilities.js";
+import { ids } from "../../sets/list.js";
+/**
+ * A field, and a value on it, selecting a *proper subset* of the cohort: more than one record so
+ * there is something to reorder or project, and fewer than all so a dropped predicate is visible
+ * as a change in membership. A value matching everything would make the filtered and unfiltered
+ * sets identical, and a composition check would pass whatever the backend did.
+ */
+export function subsetPlan(ctx) {
+    const picked = properSubsetFilter(ctx);
+    if (picked === null)
+        return cannot("a filterable value shared by several cohort records but not all of them");
+    const term = filterTerm(conv(ctx), { field: picked.field, op: "eq", value: String(picked.target[picked.field]) });
+    return term === null
+        ? cannot(`a filter grammar that can express equality on "${picked.field}"`)
+        : ready({ ...picked, term });
+}
+/** A proper-subset filter and a search token that overlap without nesting. */
+export function overlapPlan(ctx) {
+    const picked = overlappingFilterAndSearch(ctx);
+    if (picked === null)
+        return cannot("a filterable value and a search token that overlap without nesting");
+    const term = filterTerm(conv(ctx), { field: picked.field, op: "eq", value: String(picked.target[picked.field]) });
+    return term === null
+        ? cannot(`a filter grammar that can express equality on "${picked.field}"`)
+        : ready({ ...picked, term });
+}
+/** A sparse fieldset of the identity and one other selectable field. */
+export function projectionBeside(ctx) {
+    const extra = (ctx.query?.selectable ?? []).find((name) => name !== ctx.identity) ?? ctx.identity;
+    const projection = selectTerm(conv(ctx), [ctx.identity, extra], ctx.entityName);
+    return projection === null ? null : { extra, projection };
+}
+/** `projectionBeside` as a plan: it stands down when the select grammar cannot write a fieldset. */
+export function projectionPlan(ctx) {
+    const projected = projectionBeside(ctx);
+    return projected === null ? cannot("a select grammar that can express a sparse fieldset") : ready(projected);
+}
+/** The sparse fieldset `requested` as a plan: it stands down, unexplained, when no select can write it. */
+export function selectionPlan(ctx, requested) {
+    const projection = selectTerm(conv(ctx), requested, ctx.entityName);
+    return projection === null ? cannot() : ready(projection);
+}
+/** A sortable field other than `field` and the identity, else the identity. */
+export function sortFieldBeside(ctx, field) {
+    return (ctx.query?.sortable ?? []).find((name) => name !== field && name !== ctx.identity) ?? ctx.identity;
+}
+/** A filterable field whose value selects a proper subset of the cohort. */
+function properSubsetFilter(ctx) {
+    for (const candidate of ctx.query?.filterable ?? []) {
+        if (candidate === ctx.identity)
+            continue;
+        const values = ctx.records.map((record) => JSON.stringify(record[candidate]));
+        const match = ctx.records.find((record) => {
+            if (record[candidate] === null || record[candidate] === undefined)
+                return false;
+            const count = values.filter((v) => v === JSON.stringify(record[candidate])).length;
+            return count > 1 && count < ctx.records.length;
+        });
+        if (match !== undefined)
+            return { field: candidate, target: match };
+    }
+    return null;
+}
+/**
+ * A filter value and a search token that overlap without nesting, so dropping either axis
+ * changes the intersection.
+ */
+function overlappingFilterAndSearch(ctx) {
+    if (ctx.query === null)
+        return null;
+    const searchable = ctx.query.searchable;
+    for (const candidate of ctx.query.filterable) {
+        if (candidate === ctx.identity)
+            continue;
+        const groups = new Map();
+        for (const record of ctx.records) {
+            if (record[candidate] === null || record[candidate] === undefined)
+                continue;
+            const key = JSON.stringify(record[candidate]);
+            const group = groups.get(key) ?? [];
+            group.push(record);
+            groups.set(key, group);
+        }
+        for (const group of groups.values()) {
+            if (group.length <= 1 || group.length >= ctx.records.length)
+                continue;
+            const found = overlappingSearchToken(ctx, searchable, new Set(ids(group, ctx.identity)));
+            if (found === null)
+                continue;
+            /* A group of more than one record has a first. */
+            return { field: candidate, target: group[0], token: found };
+        }
+    }
+    return null;
+}
+/**
+ * A search token that overlaps a filtered set without nesting — each side matches something
+ * the other does not, so dropping either axis changes the intersection.
+ */
+function overlappingSearchToken(ctx, fields, filterIds) {
+    if (fields.length === 0)
+        return null;
+    const matches = (token) => {
+        const needle = token.toLowerCase();
+        const hit = new Set();
+        for (const record of ctx.records) {
+            if (fields.some((field) => String(record[field] ?? "")
+                .toLowerCase()
+                .includes(needle))) {
+                const key = idOf(record, ctx.identity);
+                if (key !== undefined)
+                    hit.add(key);
+            }
+        }
+        return hit;
+    };
+    const candidates = [];
+    for (const record of ctx.records) {
+        for (const name of fields) {
+            const value = record[name];
+            if (typeof value !== "string" || value.length < 2)
+                continue;
+            candidates.push(value);
+            if (value.length >= 3)
+                candidates.push(value.slice(0, 3));
+            for (const word of value.split(/\s+/)) {
+                if (word.length >= 2)
+                    candidates.push(word);
+            }
+        }
+    }
+    for (const token of candidates) {
+        const searchIds = matches(token);
+        const inter = [...searchIds].filter((id) => filterIds.has(id)).length;
+        const onlySearch = [...searchIds].filter((id) => !filterIds.has(id)).length;
+        const onlyFilter = [...filterIds].filter((id) => !searchIds.has(id)).length;
+        if (inter > 0 && onlySearch > 0 && onlyFilter > 0)
+            return token;
+    }
+    return null;
+}
+//# sourceMappingURL=plans.js.map

package/dist/api/runtime/checks/families/composition/query-axes-compose.d.ts

@@ -0,0 +1,19 @@
+import type { Check } from "../../core/check.ts";
+import { type Subset } from "./plans.ts";
+/**
+ * Query axes must compose: a filter and a sort applied together must agree with each applied alone.
+ *
+ * Every other query check exercises one axis in isolation, and that is where the isolation stops
+ * being realistic. Real backends break at the *combination*: adding a sort changes which index the
+ * planner picks and the filter stops being applied; a cursor is resolved before the filter, so page
+ * two leaks rows the predicate excluded; a count is computed on the unfiltered set the moment an
+ * order is present. Each of those passes a suite that only ever tests one axis at a time.
+ *
+ * The property asserted is compositional, so it needs no ground truth: filtering then sorting must
+ * yield exactly the same *set* as filtering alone — reordered, but never a different membership.
+ * A sort is not a predicate, and it must not behave as one.
+ */
+export declare const queryAxesCompose: Check<Subset & {
+    sortField: string;
+}>;
+//# sourceMappingURL=query-axes-compose.d.ts.map

package/dist/api/runtime/checks/families/composition/query-axes-compose.js

@@ -0,0 +1,89 @@
+import { defineCheck } from "../../core/define.js";
+import { sortTerm } from "../../../../spec/conventions/sort.js";
+import { ASSERTED } from "../../../finding.js";
+import { cannot, ready } from "../../core/plan.js";
+import { subjectsOf } from "../../planning/subjects.js";
+import { conv, filterable, pageSize } from "../../query/capabilities.js";
+import { collectSet, unlessMoved } from "../../sets/compare.js";
+import { ids } from "../../sets/list.js";
+import { sortFieldBeside, subsetPlan } from "./plans.js";
+/**
+ * Query axes must compose: a filter and a sort applied together must agree with each applied alone.
+ *
+ * Every other query check exercises one axis in isolation, and that is where the isolation stops
+ * being realistic. Real backends break at the *combination*: adding a sort changes which index the
+ * planner picks and the filter stops being applied; a cursor is resolved before the filter, so page
+ * two leaks rows the predicate excluded; a count is computed on the unfiltered set the moment an
+ * order is present. Each of those passes a suite that only ever tests one axis at a time.
+ *
+ * The property asserted is compositional, so it needs no ground truth: filtering then sorting must
+ * yield exactly the same *set* as filtering alone — reordered, but never a different membership.
+ * A sort is not a predicate, and it must not behave as one.
+ */
+export const queryAxesCompose = defineCheck({
+    plan: (ctx) => {
+        if (!filterable(ctx) || conv(ctx).order === undefined || ctx.records.length <= 2)
+            return cannot();
+        if ((ctx.query?.sortable.length ?? 0) === 0)
+            return cannot();
+        const subset = subsetPlan(ctx);
+        return subset.ok ? ready({ ...subset.value, sortField: sortFieldBeside(ctx, subset.value.field) }) : subset;
+    },
+    dependsOn: [
+        "query.filter-selects-from-whole-set",
+        "list.read-after-write",
+        /* Each axis has to work alone before "they disagree when combined" means anything. */
+        "filter.equality-selects-exactly-one",
+        "sort.order-is-applied",
+        "select.projection-honored",
+        /* Both sides are gathered by walking pages, so a walk that skips or repeats records
+         * changes the membership being compared for reasons unrelated to composition. */
+        "pagination.page-walk-covers-set",
+    ],
+    id: "query.axes-compose",
+    lists: true,
+    needs: "a filterable field, a sortable field, and more than two records",
+    subjects: subjectsOf.list,
+    async run(ctx, { field, sortField, term }) {
+        const conventions = conv(ctx);
+        const limit = pageSize(ctx);
+        /*
+         * Both sides gathered across pages. Comparing single pages would compare two *windows* of
+         * the same set — a sorted page and an unsorted one legitimately hold different records once
+         * the set is larger than one page, and the difference would be read as a dropped filter.
+         */
+        const filtered = await collectSet(ctx, limit, term);
+        const both = await collectSet(ctx, limit, term, {
+            order: sortTerm(conventions, { direction: "desc", field: sortField }),
+        });
+        if (filtered === null || both === null) {
+            return ctx.findings.unresolved(this.id, ctx.entityName, "combining a filter with a sort was rejected, so the two cannot be compared");
+        }
+        if (!filtered.complete || !both.complete) {
+            return ctx.findings.unresolved(this.id, ctx.entityName, "the filtered set is larger than the walk covers, so the two runs cannot be compared as whole sets");
+        }
+        const alone = new Set(ids(filtered.items, ctx.identity));
+        const combined = new Set(ids(both.items, ctx.identity));
+        const missing = [...alone].filter((id) => !combined.has(id));
+        const extra = [...combined].filter((id) => !alone.has(id));
+        if (missing.length === 0 && extra.length === 0)
+            return ASSERTED;
+        const moved = await unlessMoved(ctx, this.id, {
+            reads: [filtered, both],
+            terms: [{ query: term }, { order: sortTerm(conventions, { direction: "desc", field: sortField }), query: term }],
+        });
+        if (moved !== null)
+            return moved;
+        return ctx.findings.backend(this.id, ctx.entityName, {
+            summary: "adding a sort changes which records a filter returns",
+            detail: `filter on "${field}" alone matched ${alone.size} record(s); the same filter with ` +
+                `order=${sortField} desc matched ${combined.size}. ` +
+                (missing.length > 0 ? `Dropped: ${missing.slice(0, 3).join(", ")}. ` : "") +
+                (extra.length > 0 ? `Appeared: ${extra.slice(0, 3).join(", ")}. ` : "") +
+                "Ordering must reorder a result, never change its membership — a filter that only " +
+                "holds while unsorted is one an index or query plan is silently dropping.",
+            evidence: [filtered.last.exchange, both.last.exchange],
+        });
+    },
+});
+//# sourceMappingURL=query-axes-compose.js.map

package/dist/api/runtime/checks/families/composition/query-filter-and-select-compose.d.ts

@@ -0,0 +1,20 @@
+import type { Check } from "../../core/check.ts";
+import { type Subset } from "./plans.ts";
+/**
+ * A filter and a sparse fieldset must compose: projecting columns must never change which
+ * records match.
+ *
+ * The failure this catches is a query builder that projects first and then cannot apply a
+ * predicate to a column it just omitted, or that takes a different path the moment `fields=` is
+ * present and forgets the WHERE. Each axis is correct alone — the filter returns the right set,
+ * the select returns the right columns — and together the filter silently vanishes.
+ *
+ * The oracle is the same compositional property as `queryAxesCompose`: the filter alone
+ * and the same filter with a select must return the same **set**. Identity is always requested
+ * so the two sides remain comparable.
+ */
+export declare const filterAndSelectCompose: Check<Subset & {
+    extra: string;
+    projection: Record<string, string>;
+}>;
+//# sourceMappingURL=query-filter-and-select-compose.d.ts.map

package/dist/api/runtime/checks/families/composition/query-filter-and-select-compose.js

@@ -0,0 +1,83 @@
+import { defineCheck } from "../../core/define.js";
+import { ASSERTED } from "../../../finding.js";
+import { andThen, cannot, ready } from "../../core/plan.js";
+import { subjectsOf } from "../../planning/subjects.js";
+import { conv, filterable, pageSize } from "../../query/capabilities.js";
+import { collectSet, unlessMoved } from "../../sets/compare.js";
+import { ids } from "../../sets/list.js";
+import { projectionPlan, subsetPlan } from "./plans.js";
+/**
+ * A filter and a sparse fieldset must compose: projecting columns must never change which
+ * records match.
+ *
+ * The failure this catches is a query builder that projects first and then cannot apply a
+ * predicate to a column it just omitted, or that takes a different path the moment `fields=` is
+ * present and forgets the WHERE. Each axis is correct alone — the filter returns the right set,
+ * the select returns the right columns — and together the filter silently vanishes.
+ *
+ * The oracle is the same compositional property as `queryAxesCompose`: the filter alone
+ * and the same filter with a select must return the same **set**. Identity is always requested
+ * so the two sides remain comparable.
+ */
+export const filterAndSelectCompose = defineCheck({
+    plan: (ctx) => {
+        if (!filterable(ctx) || conv(ctx).select === undefined || ctx.records.length <= 2)
+            return cannot();
+        return andThen(subsetPlan(ctx), (subset) => andThen(projectionPlan(ctx), (projected) => ready({ ...subset, ...projected })));
+    },
+    dependsOn: [
+        "query.filter-selects-from-whole-set",
+        "list.read-after-write",
+        "create.persists-submitted-fields",
+        "filter.equality-selects-exactly-one",
+        /* If select is accepted and ignored, both sides still carry every column and the
+         * membership comparison remains well-defined — but a backend that has stopped honoring
+         * select at all may also have stopped taking the code path this check is probing. */
+        "select.projection-honored",
+        "pagination.page-walk-covers-set",
+    ],
+    id: "query.filter-and-select-compose",
+    lists: true,
+    needs: "a filterable field, a select parameter, and more than two records",
+    subjects: subjectsOf.list,
+    async run(ctx, { extra, field, projection, term }) {
+        const limit = pageSize(ctx);
+        const filtered = await collectSet(ctx, limit, term);
+        const both = await collectSet(ctx, limit, { ...term, ...projection });
+        if (filtered === null || both === null) {
+            return ctx.findings.unresolved(this.id, ctx.entityName, "combining a filter with a select was rejected, so the two cannot be compared");
+        }
+        if (!filtered.complete || !both.complete) {
+            return ctx.findings.unresolved(this.id, ctx.entityName, "the filtered set is larger than the walk covers, so the two runs cannot be compared as whole sets");
+        }
+        const alone = new Set(ids(filtered.items, ctx.identity));
+        const combined = new Set(ids(both.items, ctx.identity));
+        /* A projection that omitted the identity makes membership unobservable — that is a
+         * missing column, not a changed set, and select.projection-honored already owns it. */
+        if (both.items.some((item) => item[ctx.identity] === undefined)) {
+            return ctx.findings.unresolved(this.id, ctx.entityName, "the projected page omitted the identity field, so the two sets cannot be compared");
+        }
+        const missing = [...alone].filter((id) => !combined.has(id));
+        const extraIds = [...combined].filter((id) => !alone.has(id));
+        if (missing.length === 0 && extraIds.length === 0)
+            return ASSERTED;
+        const moved = await unlessMoved(ctx, this.id, {
+            reads: [filtered, both],
+            terms: [{ query: term }, { query: { ...term, ...projection } }],
+        });
+        if (moved !== null)
+            return moved;
+        return ctx.findings.backend(this.id, ctx.entityName, {
+            summary: "adding a select changes which records a filter returns",
+            detail: `filter on "${field}" alone matched ${alone.size} record(s); the same filter with ` +
+                `select=${[ctx.identity, extra].join(",")} matched ${combined.size}. ` +
+                (missing.length > 0 ? `Dropped: ${missing.slice(0, 3).join(", ")}. ` : "") +
+                (extraIds.length > 0 ? `Appeared: ${extraIds.slice(0, 3).join(", ")}. ` : "") +
+                "A projection must change which columns come back, never which rows — a filter " +
+                "that only holds while every column is selected is one a query plan is dropping " +
+                "once it has to name the columns.",
+            evidence: [filtered.last.exchange, both.last.exchange],
+        });
+    },
+});
+//# sourceMappingURL=query-filter-and-select-compose.js.map

package/dist/api/runtime/checks/families/composition/query-filter-search-select-compose.d.ts

@@ -0,0 +1,12 @@
+import type { Check } from "../../core/check.ts";
+import { type Subset } from "./plans.ts";
+/**
+ * A filter, a search and a select must compose: projecting columns must not change the
+ * intersection of filter and search.
+ */
+export declare const filterSearchSelectCompose: Check<Subset & {
+    token: string;
+    extra: string;
+    projection: Record<string, string>;
+}>;
+//# sourceMappingURL=query-filter-search-select-compose.d.ts.map

package/dist/api/runtime/checks/families/composition/query-filter-search-select-compose.js

@@ -0,0 +1,81 @@
+import { defineCheck } from "../../core/define.js";
+import { ASSERTED } from "../../../finding.js";
+import { andThen, ready, when } from "../../core/plan.js";
+import { subjectsOf } from "../../planning/subjects.js";
+import { conv, filterable, pageSize, q } from "../../query/capabilities.js";
+import { collectSet, unlessMoved } from "../../sets/compare.js";
+import { ids } from "../../sets/list.js";
+import { overlapPlan, projectionPlan } from "./plans.js";
+/**
+ * A filter, a search and a select must compose: projecting columns must not change the
+ * intersection of filter and search.
+ */
+export const filterSearchSelectCompose = defineCheck({
+    plan: (ctx) => andThen(when(filterable(ctx) &&
+        conv(ctx).search !== undefined &&
+        conv(ctx).select !== undefined &&
+        (ctx.query?.searchable.length ?? 0) > 0 &&
+        ctx.records.length > 2), () => andThen(overlapPlan(ctx), (overlap) => andThen(projectionPlan(ctx), (projected) => ready({ ...overlap, ...projected })))),
+    dependsOn: [
+        "list.read-after-write",
+        "create.persists-submitted-fields",
+        "filter.equality-selects-exactly-one",
+        "search.q-narrows-result",
+        "select.projection-honored",
+        "pagination.page-walk-covers-set",
+        "query.search-and-filter-compose",
+        "query.filter-and-select-compose",
+        "query.filter-selects-from-whole-set",
+    ],
+    id: "query.filter-search-select-compose",
+    lists: true,
+    needs: "a filterable field, a search parameter, a select parameter, and more than two records",
+    subjects: subjectsOf.list,
+    async run(ctx, { extra, field, projection, term, token }) {
+        const limit = pageSize(ctx);
+        const pair = await collectSet(ctx, limit, {
+            ...term,
+            ...q(ctx, { search: token }),
+        });
+        const triple = await collectSet(ctx, limit, {
+            ...term,
+            ...q(ctx, { search: token }),
+            ...projection,
+        });
+        if (pair === null || triple === null) {
+            return ctx.findings.unresolved(this.id, ctx.entityName, "combining a filter, a search and a select was rejected");
+        }
+        if (!pair.complete || !triple.complete) {
+            return ctx.findings.unresolved(this.id, ctx.entityName, "a side of the comparison is larger than the walk covers");
+        }
+        if (triple.items.some((item) => item[ctx.identity] === undefined)) {
+            return ctx.findings.unresolved(this.id, ctx.entityName, "the projected page omitted the identity field, so the two sets cannot be compared");
+        }
+        const expected = new Set(ids(pair.items, ctx.identity));
+        const got = new Set(ids(triple.items, ctx.identity));
+        const missing = [...expected].filter((id) => !got.has(id));
+        const extraIds = [...got].filter((id) => !expected.has(id));
+        if (missing.length === 0 && extraIds.length === 0)
+            return ASSERTED;
+        const moved = await unlessMoved(ctx, this.id, {
+            reads: [pair, triple],
+            terms: [
+                { query: { ...term, ...q(ctx, { search: token }) } },
+                { query: { ...term, ...q(ctx, { search: token }), ...projection } },
+            ],
+        });
+        if (moved !== null)
+            return moved;
+        return ctx.findings.backend(this.id, ctx.entityName, {
+            summary: "adding a select changes which records a filter and a search return",
+            detail: `filter on "${field}" with q=${JSON.stringify(token)} matched ${expected.size}; ` +
+                `the same request with select=${[ctx.identity, extra].join(",")} matched ${got.size}. ` +
+                (missing.length > 0 ? `Dropped: ${missing.slice(0, 3).join(", ")}. ` : "") +
+                (extraIds.length > 0 ? `Appeared: ${extraIds.slice(0, 3).join(", ")}. ` : "") +
+                "A projection must change columns, never the intersection a filter and a search " +
+                "already agreed on.",
+            evidence: [pair.last.exchange, triple.last.exchange],
+        });
+    },
+});
+//# sourceMappingURL=query-filter-search-select-compose.js.map

package/dist/api/runtime/checks/families/composition/query-filter-search-sort-compose.d.ts

@@ -0,0 +1,14 @@
+import type { Check } from "../../core/check.ts";
+import { type Subset } from "./plans.ts";
+/**
+ * A filter, a search and a sort must compose: the intersection of filter and search must not
+ * change when a sort is added.
+ *
+ * The search-index path that also tries to honor an ORDER BY is a common place to drop the
+ * structured predicate. Pairwise, filter+search and filter+sort both hold; together they do not.
+ */
+export declare const filterSearchSortCompose: Check<Subset & {
+    token: string;
+    sortField: string;
+}>;
+//# sourceMappingURL=query-filter-search-sort-compose.d.ts.map