rea-agents 3.0.0 → 3.2.0

package/dist/application/EnhancedToolPagination.js

@@ -1,22 +0,0 @@
-import { AnalysisOutputError } from "../domain/errors.js";
-import { parseAddressedPage } from "../domain/hopperValues.js";
-import { err, ok } from "../domain/result.js";
-/** Read all addressed entries while enforcing advancing provider pagination. */
-export const readAllAddressed = async (input) => {
-    const entries = [];
-    let offset = 0;
-    while (true) {
-        const result = await input.call(input.tool, { offset, limit: 500 }, input.signal);
-        if (!result.ok)
-            return result;
-        const page = parseAddressedPage(result.value);
-        if (!page.ok)
-            return page;
-        entries.push(...page.value.items);
-        if (!page.value.hasMore || page.value.nextOffset === null)
-            return ok(entries);
-        if (page.value.nextOffset <= offset)
-            return err(new AnalysisOutputError(input.tool, "provider returned a non-advancing pagination offset"));
-        offset = page.value.nextOffset;
-    }
-};

package/dist/application/EvidenceReferenceResolver.js

@@ -1,26 +0,0 @@
-import { EvidenceReferenceError } from "../domain/errors.js";
-import { err, ok } from "../domain/result.js";
-/** Resolve IDs without accepting the digest-shaped identifier as proof itself. */
-export const resolveEvidenceReferences = (lookup, evidenceIds, expected) => {
-    const records = [];
-    for (const evidenceId of evidenceIds) {
-        const record = lookup?.(evidenceId);
-        if (record === undefined)
-            return err(new EvidenceReferenceError(evidenceId, "missing", expectationDescription(expected), null));
-        if (expected !== undefined) {
-            const operations = expected.filter(({ operation }) => operation === record.operation);
-            if (operations.length === 0)
-                return err(new EvidenceReferenceError(evidenceId, "wrong_operation", unique(expected.map(({ operation }) => operation)).join(" | "), record.operation));
-            if (!operations.some(({ predicate }) => predicate === record.predicate_type))
-                return err(new EvidenceReferenceError(evidenceId, "wrong_predicate", unique(operations.map(({ predicate }) => predicate)).join(" | "), record.predicate_type));
-        }
-        records.push(record);
-    }
-    return ok(records);
-};
-const expectationDescription = (expected) => expected === undefined
-    ? "Evidence in the current authority"
-    : expected
-        .map(({ operation, predicate }) => `${operation}:${predicate}`)
-        .join(" | ");
-const unique = (values) => [...new Set(values)];

package/dist/application/InvestigationWorkspaceStore.js

@@ -1,204 +0,0 @@
-import { lstat, open, readFile, realpath, unlink, } from "node:fs/promises";
-import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
-import writeFileAtomic from "write-file-atomic";
-import { isJsonWithinLimits } from "../domain/jsonLimits.js";
-import { InvestigationWorkspaceError } from "../domain/errors.js";
-import { parseInvestigationWorkspace, serializeInvestigationWorkspace, } from "../domain/investigationWorkspace.js";
-import { err, ok } from "../domain/result.js";
-const investigationWorkspaceCodec = {
-    parse: parseInvestigationWorkspace,
-    serialize: serializeInvestigationWorkspace,
-    validateNext: validateNextRevision,
-};
-/** Read a validated workspace, returning null only when it does not exist. */
-export const readInvestigationWorkspace = async (path, policy) => readRevisionedWorkspace(path, policy, investigationWorkspaceCodec);
-/** Read one root-confined, owner-only revisioned workspace document. */
-export const readRevisionedWorkspace = async (path, policy, codec) => {
-    if (policy.roots.length === 0)
-        return err(new InvestigationWorkspaceError("read", "disabled"));
-    try {
-        const destination = await resolveDestination(path, policy.roots);
-        if (destination === null)
-            return err(new InvestigationWorkspaceError("read", "outside-root"));
-        return await readWorkspaceFile(destination, policy, codec);
-    }
-    catch (cause) {
-        return err(new InvestigationWorkspaceError("read", "io", { cause }));
-    }
-};
-/** Atomically append one CAS-linked workspace revision under an exclusive lock. */
-export const writeInvestigationWorkspace = async (workspace, path, expectedRevision, policy) => writeRevisionedWorkspace(path, policy, {
-    document: workspace,
-    expectedRevision,
-    codec: investigationWorkspaceCodec,
-});
-/** Atomically append one validated CAS-linked revision under an exclusive lock. */
-export const writeRevisionedWorkspace = async (path, policy, input) => {
-    const { document, expectedRevision, codec } = input;
-    if (policy.roots.length === 0)
-        return err(new InvestigationWorkspaceError("update", "disabled"));
-    let encoded;
-    try {
-        encoded = codec.serialize(document);
-    }
-    catch (cause) {
-        return err(new InvestigationWorkspaceError("update", "integrity", { cause }));
-    }
-    const bytes = Buffer.byteLength(encoded, "utf8");
-    if (bytes > policy.maxBytes)
-        return err(new InvestigationWorkspaceError("update", "too-large"));
-    let lock;
-    try {
-        const destination = await resolveDestination(path, policy.roots);
-        if (destination === null)
-            return err(new InvestigationWorkspaceError("update", "outside-root"));
-        const acquired = await acquireLock(destination);
-        if (!acquired.ok)
-            return acquired;
-        lock = acquired.value;
-        const current = await readWorkspaceFile(destination, policy, codec);
-        if (!current.ok)
-            return current;
-        const checked = codec.validateNext(current.value, document, expectedRevision);
-        if (!checked.ok)
-            return checked;
-        await writeFileAtomic(destination, encoded, {
-            encoding: "utf8",
-            mode: 0o600,
-            fsync: true,
-        });
-        return ok({ path: resolve(path), bytes });
-    }
-    catch (cause) {
-        return err(new InvestigationWorkspaceError("update", "io", { cause }));
-    }
-    finally {
-        if (lock !== undefined)
-            await releaseLock(lock);
-    }
-};
-const resolveDestination = async (path, roots) => {
-    const requested = resolve(path);
-    const canonicalParent = await realpath(dirname(requested));
-    const destination = resolve(canonicalParent, basename(requested));
-    for (const configuredRoot of roots) {
-        const root = await realpath(resolve(configuredRoot));
-        const relation = relative(root, destination);
-        if (relation === "" ||
-            (!relation.startsWith("..") && !isAbsolute(relation)))
-            return destination;
-    }
-    return null;
-};
-const readWorkspaceFile = async (destination, policy, codec) => {
-    const stats = await lstat(destination).catch((cause) => {
-        if (isFileNotFound(cause))
-            return undefined;
-        throw cause;
-    });
-    if (stats === undefined)
-        return ok(null);
-    if (!stats.isFile() || stats.isSymbolicLink())
-        return err(new InvestigationWorkspaceError("read", "not-file"));
-    if (stats.size > policy.maxBytes)
-        return err(new InvestigationWorkspaceError("read", "too-large"));
-    const encoded = await readFile(destination);
-    if (encoded.byteLength > policy.maxBytes)
-        return err(new InvestigationWorkspaceError("read", "too-large"));
-    let decoded;
-    try {
-        decoded = JSON.parse(encoded.toString("utf8"));
-    }
-    catch (cause) {
-        return err(new InvestigationWorkspaceError("read", "invalid-json", { cause }));
-    }
-    if (!isJsonWithinLimits(decoded, policy))
-        return err(new InvestigationWorkspaceError("read", "too-large"));
-    try {
-        return ok(codec.parse(decoded));
-    }
-    catch (cause) {
-        return err(new InvestigationWorkspaceError("read", "integrity", { cause }));
-    }
-};
-const acquireLock = async (destination) => {
-    const path = `${destination}.lock`;
-    try {
-        return ok(await createLock(path));
-    }
-    catch (cause) {
-        if (isAlreadyExists(cause) && (await removeStaleLock(path))) {
-            try {
-                return ok(await createLock(path));
-            }
-            catch (retryCause) {
-                return err(new InvestigationWorkspaceError("update", isAlreadyExists(retryCause) ? "locked" : "io", { cause: retryCause }));
-            }
-        }
-        return err(new InvestigationWorkspaceError("update", isAlreadyExists(cause) ? "locked" : "io", { cause }));
-    }
-};
-const createLock = async (path) => {
-    const handle = await open(path, "wx", 0o600);
-    try {
-        await handle.writeFile(`${String(process.pid)}\n`, "utf8");
-        await handle.sync();
-        return { path, handle };
-    }
-    catch (cause) {
-        await handle.close().catch(() => undefined);
-        await unlink(path).catch(() => undefined);
-        throw cause;
-    }
-};
-const removeStaleLock = async (path) => {
-    try {
-        const stats = await lstat(path);
-        if (!stats.isFile() || stats.isSymbolicLink() || stats.size > 32)
-            return false;
-        const encoded = (await readFile(path, "utf8")).trim();
-        if (!/^[1-9][0-9]{0,9}$/u.test(encoded))
-            return false;
-        const pid = Number(encoded);
-        if (processIsAlive(pid))
-            return false;
-        await unlink(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-const processIsAlive = (pid) => {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (cause) {
-        return errorCode(cause) !== "ESRCH";
-    }
-};
-const releaseLock = async (lock) => {
-    await lock.handle.close().catch(() => undefined);
-    await unlink(lock.path).catch(() => undefined);
-};
-function validateNextRevision(current, next, expectedRevision) {
-    if ((current?.revision ?? null) !== expectedRevision)
-        return err(new InvestigationWorkspaceError("update", "revision-conflict"));
-    if (current === null) {
-        return next.revision === 1 && next.previous_revision_digest === null
-            ? ok(null)
-            : err(new InvestigationWorkspaceError("update", "revision-conflict"));
-    }
-    if (current.name !== next.name || current.workspace_id !== next.workspace_id)
-        return err(new InvestigationWorkspaceError("update", "name-conflict"));
-    return next.revision === current.revision + 1 &&
-        next.previous_revision_digest === current.revision_digest
-        ? ok(null)
-        : err(new InvestigationWorkspaceError("update", "revision-conflict"));
-}
-const isFileNotFound = (cause) => errorCode(cause) === "ENOENT";
-const isAlreadyExists = (cause) => errorCode(cause) === "EEXIST";
-const errorCode = (cause) => typeof cause === "object" && cause !== null && "code" in cause
-    ? cause.code
-    : undefined;

package/dist/application/ProcessPairedExperiment.js

@@ -1,72 +0,0 @@
-import { processCaptureCancelled, } from "./ProcessCaptureError.js";
-import { captureProcessScenario } from "./ProcessHarness.js";
-import { compareProcessCaptures } from "../domain/processComparison.js";
-import { PROCESS_COMPARISON_DIMENSIONS } from "../domain/processComparison.js";
-import { analyzeProcessRepeatability, bindProcessScenario, } from "../domain/processPairedExperiment.js";
-import { err, ok } from "../domain/result.js";
-const productionCapturePort = {
-    capture: captureProcessScenario,
-};
-const captureRepeats = async (input) => {
-    const captures = [];
-    for (let index = 0; index < input.repeatCount; index += 1) {
-        if (input.signal?.aborted === true)
-            return err(processCaptureCancelled());
-        const capture = await input.port.capture(input.scenario, input.policy, input.signal);
-        if (!capture.ok)
-            return err(capture.error);
-        captures.push(capture.value);
-    }
-    return ok(captures);
-};
-/** Execute repeatability-first authority/candidate captures under one contract. */
-export const runPairedProcessExperiment = async (experiment, policy, options = {}) => {
-    const port = options.capturePort ?? productionCapturePort;
-    const authorityScenario = bindProcessScenario(experiment.shared_scenario, experiment.authority);
-    const candidateScenario = bindProcessScenario(experiment.shared_scenario, experiment.candidate);
-    const authorityRuns = await captureRepeats({
-        scenario: authorityScenario,
-        repeatCount: experiment.repeat_count,
-        policy,
-        port,
-        ...(options.signal === undefined ? {} : { signal: options.signal }),
-    });
-    if (!authorityRuns.ok)
-        return authorityRuns;
-    const candidateRuns = await captureRepeats({
-        scenario: candidateScenario,
-        repeatCount: experiment.repeat_count,
-        policy,
-        port,
-        ...(options.signal === undefined ? {} : { signal: options.signal }),
-    });
-    if (!candidateRuns.ok)
-        return candidateRuns;
-    const authorityRepeatability = analyzeProcessRepeatability(authorityRuns.value, experiment.required_dimensions);
-    const candidateRepeatability = analyzeProcessRepeatability(candidateRuns.value, experiment.required_dimensions);
-    const stable = authorityRepeatability.stable && candidateRepeatability.stable;
-    const allDimensionsRequired = PROCESS_COMPARISON_DIMENSIONS.every((dimension) => experiment.required_dimensions.includes(dimension));
-    const authorityLatest = authorityRuns.value.at(-1);
-    const candidateLatest = candidateRuns.value.at(-1);
-    const crossSide = stable &&
-        allDimensionsRequired &&
-        authorityLatest !== undefined &&
-        candidateLatest !== undefined
-        ? compareProcessCaptures(authorityLatest, candidateLatest, {
-            maxCaptureAgeMs: experiment.freshness_policy.max_capture_age_ms,
-            ...(options.now === undefined ? {} : { now: options.now }),
-        })
-        : null;
-    return ok({
-        authority_runs: authorityRuns.value,
-        candidate_runs: candidateRuns.value,
-        authority_repeatability: authorityRepeatability,
-        candidate_repeatability: candidateRepeatability,
-        cross_side: crossSide,
-        cross_side_blocked_reason: crossSide !== null
-            ? null
-            : !allDimensionsRequired
-                ? "Cross-side comparison is blocked until every returned dimension is required and repeatable."
-                : "Cross-side comparison is blocked because a required same-side dimension is unstable.",
-    });
-};

package/dist/application/ReconstructionCoverageWorkspaceStore.js

@@ -1,31 +0,0 @@
-import { InvestigationWorkspaceError } from "../domain/errors.js";
-import { parseReconstructionCoverageWorkspace, serializeReconstructionCoverageWorkspace, } from "../domain/reconstructionCoverage.js";
-import { err, ok } from "../domain/result.js";
-import { readRevisionedWorkspace, writeRevisionedWorkspace, } from "./InvestigationWorkspaceStore.js";
-const codec = {
-    parse: parseReconstructionCoverageWorkspace,
-    serialize: serializeReconstructionCoverageWorkspace,
-    validateNext: (current, next, expectedRevision) => {
-        if ((current?.revision ?? null) !== expectedRevision)
-            return err(new InvestigationWorkspaceError("update", "revision-conflict"));
-        if (current === null)
-            return next.revision === 1 && next.previous_revision_sha256 === null
-                ? ok(null)
-                : err(new InvestigationWorkspaceError("update", "revision-conflict"));
-        if (current.name !== next.name ||
-            current.workspace_id !== next.workspace_id)
-            return err(new InvestigationWorkspaceError("update", "name-conflict"));
-        return next.revision === current.revision + 1 &&
-            next.previous_revision_sha256 === current.revision_sha256
-            ? ok(null)
-            : err(new InvestigationWorkspaceError("update", "revision-conflict"));
-    },
-};
-/** Read a validated reconstruction coverage workspace revision. */
-export const readReconstructionCoverageWorkspace = (path, policy) => readRevisionedWorkspace(path, policy, codec);
-/** Atomically append one reconstruction coverage workspace CAS revision. */
-export const writeReconstructionCoverageWorkspace = (workspace, path, expectedRevision, policy) => writeRevisionedWorkspace(path, policy, {
-    document: workspace,
-    expectedRevision,
-    codec,
-});

package/dist/application/ReconstructionReadinessService.js

@@ -1,48 +0,0 @@
-import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
-import { createEvidence } from "../domain/evidence.js";
-import { jsonObjectSchema, jsonValueSchema } from "../domain/jsonValue.js";
-import { createReconstructionReadinessReport } from "../domain/reconstructionReadiness.js";
-import { reconstructionReadinessInputSchema, } from "../domain/reconstructionReadinessSchemas.js";
-import { err, ok } from "../domain/result.js";
-import { JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
-const OPERATION = "evaluate_reconstruction_readiness";
-/** Parse one portable readiness request for both CLI and MCP adapters. */
-export const resolveReconstructionReadinessRequest = (input) => {
-    const parsed = reconstructionReadinessInputSchema.safeParse(input);
-    return parsed.success
-        ? ok(parsed.data)
-        : err(new AnalysisInputError(OPERATION, { cause: parsed.error }));
-};
-/** Evaluate and wrap one deterministic readiness report in Evidence v2. */
-export const evaluateReconstructionReadinessValidated = (input) => {
-    try {
-        const report = createReconstructionReadinessReport(input);
-        return ok(createEvidence(undefined, JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER, {
-            predicateType: "rea.reconstruction-readiness-report/v1",
-            operation: OPERATION,
-            parameters: jsonObjectSchema.parse({
-                source_digest: report.source_digest,
-                expected_source_digest: input.replay.expected_source_digest,
-            }),
-            result: jsonValueSchema.parse(report),
-            rawResult: null,
-            confidence: "inferred",
-            authority: "analyst-inference",
-            environment: null,
-            limitations: report.status === "pass"
-                ? []
-                : [
-                    "Aggregate pass is withheld until every required conformance stage passes.",
-                ],
-            evidenceLinks: report.evidence_links,
-        }));
-    }
-    catch (cause) {
-        if (cause instanceof z.ZodError)
-            return err(new AnalysisInputError(OPERATION, { cause }));
-        return err(new AnalysisProtocolError("Reconstruction readiness evaluation failed", {
-            cause,
-        }));
-    }
-};

package/dist/cliInvestigationCommands.js

@@ -1,173 +0,0 @@
-import { Cli, z } from "incur";
-import { runCrossVersionInvestigation } from "./application/CrossVersionInvestigation.js";
-import { logCliCommand } from "./cliLogging.js";
-import { parseConfig } from "./config.js";
-import { projectAnalysisError } from "./domain/errors.js";
-import { loadConfiguredPermissionAuthority } from "./application/PermissionConfiguration.js";
-import { authorizeFileReadWithDeferredWrite, authorizeRootPermission, } from "./application/DeferredFileAuthorization.js";
-import { CLI_COMMANDS } from "./cliCommandNames.js";
-const investigationOptionsSchema = z.object({
-    yes: z
-        .boolean()
-        .default(false)
-        .describe("Approve persistent workspace writes"),
-    workspaceName: z
-        .string()
-        .trim()
-        .min(1)
-        .max(200)
-        .default("default")
-        .describe("Logical name recorded in the investigation workspace"),
-    expectedRevision: z
-        .number()
-        .int()
-        .min(1)
-        .optional()
-        .describe("Required current workspace revision for an atomic update"),
-    replayRunId: z
-        .string()
-        .regex(/^run_[a-f0-9]{64}$/u)
-        .optional()
-        .describe("Replay one verified complete workspace run without rescanning"),
-    maxEntries: z
-        .number()
-        .int()
-        .min(1)
-        .max(50_000)
-        .default(10_000)
-        .describe("Maximum artifact entries to inspect per version"),
-    maxTotalBytes: z
-        .number()
-        .int()
-        .min(1)
-        .max(Number.MAX_SAFE_INTEGER)
-        .default(1_073_741_824)
-        .describe("Maximum total uncompressed artifact content to inspect"),
-    maxEntryBytes: z
-        .number()
-        .int()
-        .min(1)
-        .max(Number.MAX_SAFE_INTEGER)
-        .default(268_435_456)
-        .describe("Maximum uncompressed content to inspect for one entry"),
-    pageSize: z
-        .number()
-        .int()
-        .min(1)
-        .max(500)
-        .default(500)
-        .describe("Maximum graph items loaded per investigation page"),
-    changeLimit: z
-        .number()
-        .int()
-        .min(1)
-        .max(500)
-        .default(500)
-        .describe("Maximum version changes to record"),
-    integrityPolicy: z
-        .enum(["fail", "record-and-continue"])
-        .default("fail")
-        .describe("Behavior when declared artifact integrity does not match"),
-    integrityContinueApproved: z
-        .boolean()
-        .default(false)
-        .describe("Approve continuing after recorded integrity mismatches"),
-    maxIntegrityMismatches: z
-        .number()
-        .int()
-        .min(1)
-        .max(100)
-        .default(10)
-        .describe("Maximum integrity mismatches to record before stopping"),
-});
-/** Register the persistent cross-version CLI workflow. */
-export const registerInvestigationCommands = (cli, logger) => {
-    cli.command(CLI_COMMANDS.investigateVersions, {
-        description: "Run or resume a persistent cross-version artifact investigation",
-        args: z.object({
-            leftPath: z.string().describe("Earlier artifact or directory path"),
-            rightPath: z.string().describe("Later artifact or directory path"),
-            workspacePath: z.string().describe("Persistent workspace JSON path"),
-        }),
-        options: investigationOptionsSchema,
-        alias: {
-            workspaceName: "workspace-name",
-            expectedRevision: "expected-revision",
-            replayRunId: "replay-run-id",
-            maxEntries: "max-entries",
-            maxTotalBytes: "max-total-bytes",
-            maxEntryBytes: "max-entry-bytes",
-            pageSize: "page-size",
-            changeLimit: "change-limit",
-            integrityPolicy: "integrity-policy",
-            integrityContinueApproved: "integrity-continue-approved",
-            maxIntegrityMismatches: "max-integrity-mismatches",
-            yes: "y",
-        },
-        run: ({ args, options }) => logCliCommand(logger, "investigate-versions", () => runInvestigation(args, options)),
-    });
-};
-const runInvestigation = async (args, options) => {
-    if (!options.yes)
-        return {
-            error: "ApprovalRequired",
-            message: "Persistent workspace writes require explicit --yes approval.",
-        };
-    const config = parseConfig(process.env);
-    if (!config.ok)
-        return cliError(config.error);
-    const authority = await loadConfiguredPermissionAuthority(config.value);
-    if (!authority.ok)
-        return cliError(authority.error);
-    const workspaceAuthorization = await authorizeFileReadWithDeferredWrite(authority.value, {
-        path: args.workspacePath,
-        readCapability: "investigation_workspace_read",
-        writeCapability: "investigation_workspace_write",
-        operation: "investigate_versions",
-    });
-    if (!workspaceAuthorization.ok)
-        return cliError(workspaceAuthorization.error);
-    const investigated = await runCrossVersionInvestigation({
-        approved: true,
-        workspace_path: args.workspacePath,
-        workspace_name: options.workspaceName,
-        ...(options.expectedRevision === undefined
-            ? {}
-            : { expected_workspace_revision: options.expectedRevision }),
-        ...(options.replayRunId === undefined
-            ? {}
-            : { replay_run_id: options.replayRunId }),
-        left_path: args.leftPath,
-        right_path: args.rightPath,
-        integrity_policy: options.integrityPolicy,
-        integrity_continue_approved: options.integrityContinueApproved,
-        max_integrity_mismatches: options.maxIntegrityMismatches,
-        options: {
-            max_entries: options.maxEntries,
-            max_total_bytes: options.maxTotalBytes,
-            max_entry_bytes: options.maxEntryBytes,
-            max_compression_ratio: 1_000,
-            max_depth: 20,
-            max_path_bytes: 4_096,
-            page_size: options.pageSize,
-            change_limit: options.changeLimit,
-        },
-    }, config.value.evidenceFilePolicy, {
-        inputRoots: config.value.investigationInputRoots,
-        integrityContinueEnabled: config.value.artifactIntegrityContinueEnabled,
-        authorizeInputRead: () => authorizeRootPermission(authority.value, {
-            capability: "investigation_input",
-            roots: [args.leftPath, args.rightPath],
-            access: "read",
-            operation: "investigate_versions",
-        }),
-        authorizeWorkspaceWrite: workspaceAuthorization.value.authorizeWrite,
-    });
-    return investigated.ok
-        ? investigated.value.evidence
-        : cliError(investigated.error);
-};
-const cliError = (error) => ({
-    error: "Analysis failed",
-    ...projectAnalysisError(error),
-});

package/dist/domain/boundedCartesianProjection.js

@@ -1,15 +0,0 @@
-/** Project a Cartesian product without materializing values beyond the output limit. */
-export const projectBoundedCartesian = (left, right, maximum, project) => {
-    const values = [];
-    for (const leftValue of left) {
-        for (const rightValue of right) {
-            if (values.length === maximum)
-                return {
-                    values,
-                    omitted: left.length * right.length - values.length,
-                };
-            values.push(project(leftValue, rightValue));
-        }
-    }
-    return { values, omitted: 0 };
-};