cloving 1.1.0 → 1.3.0

package/dist/src/host/step-bridge-host.js

@@ -1,11 +1,19 @@
 import { createHash } from "node:crypto";
 import { setTimeout as delay } from "node:timers/promises";
 import { getStepMetadata, getWorkflowMetadata } from "workflow";
-import { gateKey } from "../authority/gates.js";
+import { openBridgeGate, waitForBridgeDecision, } from "./gate-bridge.js";
+import { runWait } from "./run-wait.js";
+import { reconciledDecision } from "./decision-resume.js";
+import { taggedRuns } from "./world-runs.js";
 import { stepBridgeKey, } from "../step-bridge.js";
 export function sdkStepCall() {
-    const { stepId, attempt } = getStepMetadata();
-    return { worldRunId: getWorkflowMetadata().workflowRunId, stepId, attempt };
+    const { stepId, attempt, stepStartedAt } = getStepMetadata();
+    return {
+        worldRunId: getWorkflowMetadata().workflowRunId,
+        stepId,
+        attempt,
+        startedAt: stepStartedAt.getTime(),
+    };
 }
 export const bridgeTiming = {
     lookupTries: 250,
@@ -129,71 +137,65 @@ async function effect(hold, request) {
         return answer;
     return await settled(hold, answer.operationId);
 }
-function verdict(hold, receipt) {
-    if (receipt === undefined || receipt.kind === "failed")
-        return hold.timing.retryMilliseconds;
-    if (committed.includes(receipt.kind))
-        return "committed";
-    if (receipt.reason === "service-busy")
-        return hold.timing.retryMilliseconds;
-    if (receipt.reason === "stale-revision")
-        return hold.timing.pollMilliseconds;
-    return { kind: "refused", reason: receipt.reason ?? receipt.kind };
-}
-async function gateCommand(hold, send) {
-    for (;;) {
-        await paused(hold, 0);
-        const result = verdict(hold, await send().catch(() => undefined));
-        if (result === "committed")
-            return undefined;
-        if (typeof result !== "number")
-            return result;
-        await paused(hold, result);
-    }
-}
-async function opening(hold, subject) {
-    const { runId, transport, request } = subject;
-    const { gateId, kind, prompt } = request;
-    const state = await hold.ports.state();
-    const run = state.runs[runId];
-    if (run === undefined)
-        return { kind: "rejected", reason: "unknown-run" };
-    if (Object.hasOwn(state.gates, gateKey(runId, gateId)))
-        return { kind: "duplicate" };
-    return await hold.ports.openGate({
-        runId,
-        commandId: `${transport}:open:${gateId}`,
-        expectedRevision: run.revision,
-        gateId,
-        kind,
-        prompt,
-        subject: `sha256:${createHash("sha256").update(prompt).digest("hex")}`,
-    });
-}
-async function gate(hold, request) {
+async function gateSubject(hold, request) {
     const call = hold.ports.call();
     const world = await located(hold, call.worldRunId);
     if (world === undefined)
-        return { kind: "unavailable", reason: "unknown-world-run" };
+        return undefined;
     await inWork(hold, world.runId);
-    const subject = {
+    return {
+        request,
         runId: world.runId,
         transport: transportOf(call),
-        request,
     };
-    const refusal = (await gateCommand(hold, () => opening(hold, subject))) ??
-        (await gateCommand(hold, () => hold.ports.registerWait({
-            runId: subject.runId,
-            commandId: `${subject.transport}:wait:${request.gateId}`,
-            gateId: request.gateId,
-        })));
-    return refusal ?? { kind: "opened", decisionId: request.gateId };
+}
+async function gate(hold, request) {
+    const subject = await gateSubject(hold, request);
+    if (subject === undefined)
+        return { kind: "unavailable", reason: "unknown-world-run" };
+    return await openBridgeGate(hold.ports, subject);
 }
 export function stepBridge(ports) {
     const hold = { ports, timing: ports.timing ?? bridgeTiming };
     return {
         effect: (request) => effect(hold, request),
         gate: (request) => gate(hold, request),
+        waitForDecision: async (request) => {
+            const subject = await gateSubject(hold, request);
+            if (subject === undefined)
+                throw new Error("unknown-world-run");
+            return await waitForBridgeDecision({
+                ...ports,
+                decisionReceived: ports.decisionReceived ??
+                    (async (runId, gateId) => (await reconciledDecision({ runs: taggedRuns, document: ports.document }, { runId, gateId })).kind === "accepted"),
+            }, subject);
+        },
+        waitForRun: async (request) => {
+            const call = ports.call();
+            const world = await located(hold, call.worldRunId);
+            if (world === undefined ||
+                ports.runWait === undefined ||
+                call.startedAt === undefined)
+                throw new Error("cloving-host-unavailable");
+            await inWork(hold, world.runId);
+            return await runWait(ports.runWait, {
+                caller: { ...world, stepId: call.stepId, startedAt: call.startedAt },
+                request,
+            });
+        },
+        handoff: (request) => effect(hold, {
+            scope: {
+                phase: "handoff",
+                operation: "handoff",
+                round: 1,
+                key: createHash("sha256").update(ports.call().stepId).digest("hex"),
+            },
+            capability: "handoff",
+            method: "run",
+            target: request.workflowId,
+            payload: JSON.stringify(request.input),
+            units: 1,
+        }),
     };
 }
 export function registerStepBridge(bridge) {

package/dist/src/host/world-reconciliation.d.ts

@@ -3,6 +3,7 @@ import type { AuthorityState } from "../authority/transitions.ts";
 export type ReconciledState = Pick<AuthorityState, "runs" | "intents" | "details" | "gates" | "commands">;
 export interface WorkflowOutcome {
     readonly kind: string;
+    readonly promotionId?: string;
     readonly reason?: string;
     readonly issueUpdate?: "failed";
     readonly ticketStatus?: "complete" | "partial";

package/dist/src/host/world-reconciliation.js

@@ -14,6 +14,9 @@ async function withOutcome(ports, observed) {
         : {
             ...world,
             outcome: read.outcome.kind,
+            ...(read.outcome.promotionId === undefined
+                ? {}
+                : { promotionId: read.outcome.promotionId }),
             ...(read.outcome.issueUpdate === "failed"
                 ? { issueUpdate: read.outcome.issueUpdate }
                 : {}),

package/dist/src/host/world-runs.js

@@ -1,4 +1,5 @@
 import { isTicketStatus } from "../ticket-status.js";
+import { isPromotionId } from "../workflow-contracts.js";
 import { getRun } from "workflow/api";
 import { getWorld } from "workflow/runtime";
 export const runTag = "cloving.run";
@@ -47,8 +48,12 @@ export async function workflowOutcome(receipt) {
     const reason = Reflect.get(Object(value), "reason");
     const issueUpdate = Reflect.get(Object(value), "issueUpdate");
     const ticketStatus = Reflect.get(Object(value), "ticketStatus");
+    const promotionId = Reflect.get(Object(value), "promotionId");
     return {
         kind,
+        ...(kind === "handoff_requested" && isPromotionId(promotionId)
+            ? { promotionId }
+            : {}),
         ...(typeof reason === "string" ? { reason } : {}),
         ...(issueUpdate === "failed" ? { issueUpdate } : {}),
         ...(isTicketStatus(ticketStatus) ? { ticketStatus } : {}),

package/dist/src/issue-identity.d.ts

@@ -0,0 +1,6 @@
+export interface IssueIdentity {
+    readonly owner: string;
+    readonly repository: string;
+    readonly number: number;
+}
+export declare function issueIdentity(ticket: unknown): IssueIdentity | null;

package/dist/src/issue-identity.js

@@ -0,0 +1,23 @@
+export function issueIdentity(ticket) {
+    if (typeof ticket !== "string")
+        return null;
+    const markers = ticket
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith("GitHub issue:"));
+    if (markers.length !== 1)
+        return null;
+    const match = /^GitHub issue: ([a-zA-Z0-9][a-zA-Z0-9-]*)\/([a-zA-Z0-9_.-]+)#([1-9][0-9]*)(?: \((?:open|closed)\))?\s*$/.exec(markers[0] ?? "");
+    const [, owner, repository, digits] = match ?? [];
+    const number = Number(digits);
+    if (owner === undefined ||
+        repository === undefined ||
+        [".", ".."].includes(repository) ||
+        !Number.isSafeInteger(number) ||
+        number <= 0)
+        return null;
+    return {
+        owner: owner.toLowerCase(),
+        repository: repository.toLowerCase(),
+        number,
+    };
+}

package/dist/src/merge-request.d.ts

@@ -0,0 +1,19 @@
+export interface PullRequest {
+    readonly number: number;
+    readonly url: string;
+    readonly commit: string;
+    readonly target: string;
+}
+export type MergeCheckName = "beforeMerge";
+export interface MergeRequest {
+    readonly pull: PullRequest;
+    readonly check: MergeCheckName | null;
+    readonly round?: number;
+}
+export type MergeReason = "check-failed" | "merge-conflict" | "ci-failed" | "ci-pending" | "check-not-configured" | "not-approved";
+export interface MergeResult {
+    readonly merged: boolean;
+    readonly reason: MergeReason | null;
+    readonly output: string;
+}
+export declare function mergeRequest(value: unknown): Required<MergeRequest>;

package/dist/src/merge-request.js

@@ -0,0 +1,32 @@
+import { record } from "./protocol.js";
+import { commitId } from "./review-subject.js";
+export function mergeRequest(value) {
+    const request = record(value);
+    const pull = pullRequest(request?.["pull"]);
+    const check = request?.["check"];
+    if (request === undefined ||
+        pull === undefined ||
+        !Object.hasOwn(request, "check") ||
+        (check !== null && check !== "beforeMerge"))
+        throw new Error("invalid-merge-request");
+    return { pull, check, round: mergeRound(request["round"] ?? 1) };
+}
+function mergeRound(value) {
+    if (!positiveInteger(value))
+        throw new Error("invalid-merge-request");
+    return value;
+}
+function pullRequest(value) {
+    const pull = record(value);
+    const { number, url, commit, target } = pull ?? {};
+    if (!positiveInteger(number) ||
+        typeof url !== "string" ||
+        !commitId(commit) ||
+        typeof target !== "string" ||
+        target.trim() === "")
+        return undefined;
+    return { number, url, commit, target };
+}
+function positiveInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}

package/dist/src/phone/canonical-json.d.ts

@@ -0,0 +1 @@
+export declare function canonicalJson(value: unknown): string;

package/dist/src/phone/canonical-json.js

@@ -0,0 +1,16 @@
+export function canonicalJson(value) {
+    if (value === null || typeof value === "boolean" || typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "number" && !Number.isSafeInteger(value))
+        throw new Error("canonical-json-number: Only safe integers are allowed.");
+    if (typeof value === "number")
+        return String(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (typeof value !== "object")
+        throw new Error("canonical-json-value: The value is not JSON.");
+    const fields = Object.keys(value)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${canonicalJson(Reflect.get(value, key))}`);
+    return `{${fields.join(",")}}`;
+}

package/dist/src/phone/phone-link.d.ts

@@ -0,0 +1,7 @@
+export interface PhoneLink {
+    readonly daemonId: string;
+    readonly origin: string;
+    readonly token: string;
+    readonly registeredAt: string;
+}
+export declare function parsePhoneLink(text: string | undefined): PhoneLink | undefined;

package/dist/src/phone/phone-link.js

@@ -0,0 +1,21 @@
+export function parsePhoneLink(text) {
+    if (text === undefined)
+        return undefined;
+    const value = JSON.parse(text);
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const filled = (name) => {
+        const field = Reflect.get(value, name);
+        return typeof field === "string" && field !== "" ? field : undefined;
+    };
+    const daemonId = filled("daemonId");
+    const origin = filled("origin");
+    const token = filled("token");
+    const registeredAt = filled("registeredAt");
+    if (daemonId === undefined ||
+        origin === undefined ||
+        token === undefined ||
+        registeredAt === undefined)
+        return undefined;
+    return { daemonId, origin, token, registeredAt };
+}

package/dist/src/phone/qr-data.d.ts

@@ -0,0 +1,8 @@
+export declare function qrVersion(byteCount: number): number;
+export declare function qrDataCodewords(bytes: Uint8Array, version: number): number[];
+export declare function qrCorrection(data: readonly number[], degree: number): number[];
+export interface QrCodewords {
+    readonly version: number;
+    readonly codewords: readonly number[];
+}
+export declare function qrCodewords(text: string): QrCodewords;

package/dist/src/phone/qr-data.js

@@ -0,0 +1,133 @@
+const layouts = [
+    { correctionCodewords: 10, groups: [{ count: 1, dataCodewords: 16 }] },
+    { correctionCodewords: 16, groups: [{ count: 1, dataCodewords: 28 }] },
+    { correctionCodewords: 26, groups: [{ count: 1, dataCodewords: 44 }] },
+    { correctionCodewords: 18, groups: [{ count: 2, dataCodewords: 32 }] },
+    { correctionCodewords: 24, groups: [{ count: 2, dataCodewords: 43 }] },
+    { correctionCodewords: 16, groups: [{ count: 4, dataCodewords: 27 }] },
+    { correctionCodewords: 18, groups: [{ count: 4, dataCodewords: 31 }] },
+    {
+        correctionCodewords: 22,
+        groups: [
+            { count: 2, dataCodewords: 38 },
+            { count: 2, dataCodewords: 39 },
+        ],
+    },
+    {
+        correctionCodewords: 22,
+        groups: [
+            { count: 3, dataCodewords: 36 },
+            { count: 2, dataCodewords: 37 },
+        ],
+    },
+    {
+        correctionCodewords: 26,
+        groups: [
+            { count: 4, dataCodewords: 43 },
+            { count: 1, dataCodewords: 44 },
+        ],
+    },
+];
+function multiply(left, right) {
+    let product = 0;
+    for (let bit = 7; bit >= 0; bit -= 1) {
+        product = (product << 1) ^ ((product >>> 7) * 0x11d);
+        product ^= ((right >>> bit) & 1) * left;
+    }
+    return product;
+}
+function layoutOf(version) {
+    const layout = layouts[version - 1];
+    if (layout === undefined)
+        throw new Error("qr-version-unsupported");
+    return layout;
+}
+function dataCapacity(version) {
+    return layoutOf(version).groups.reduce((total, group) => total + group.count * group.dataCodewords, 0);
+}
+function countBits(version) {
+    return version < 10 ? 8 : 16;
+}
+export function qrVersion(byteCount) {
+    const version = layouts.findIndex((_, index) => 4 + countBits(index + 1) + 8 * byteCount <= 8 * dataCapacity(index + 1));
+    if (version < 0)
+        throw new Error("qr-text-too-long");
+    return version + 1;
+}
+function bitStream(bytes, version) {
+    const bits = [];
+    const append = (value, length) => {
+        for (let shift = length - 1; shift >= 0; shift -= 1)
+            bits.push((value >>> shift) & 1);
+    };
+    append(0b0100, 4);
+    append(bytes.length, countBits(version));
+    for (const byte of bytes)
+        append(byte, 8);
+    append(0, Math.min(4, 8 * dataCapacity(version) - bits.length));
+    append(0, (8 - (bits.length % 8)) % 8);
+    return bits;
+}
+export function qrDataCodewords(bytes, version) {
+    const bits = bitStream(bytes, version);
+    const codewords = [];
+    for (let start = 0; start < bits.length; start += 8)
+        codewords.push(bits.slice(start, start + 8).reduce((byte, bit) => (byte << 1) | bit, 0));
+    for (let index = 0; codewords.length < dataCapacity(version); index += 1)
+        codewords.push(index % 2 === 0 ? 0xec : 0x11);
+    return codewords;
+}
+function divisor(degree) {
+    let coefficients = [...Array.from({ length: degree - 1 }, () => 0), 1];
+    let root = 1;
+    for (let step = 0; step < degree; step += 1) {
+        const previous = coefficients;
+        coefficients = previous.map((value, index) => multiply(value, root) ^ (previous[index + 1] ?? 0));
+        root = multiply(root, 0x02);
+    }
+    return coefficients;
+}
+export function qrCorrection(data, degree) {
+    const coefficients = divisor(degree);
+    let remainder = Array.from({ length: degree }, () => 0);
+    for (const codeword of data) {
+        const [first, ...rest] = remainder;
+        const factor = codeword ^ Number(first);
+        remainder = [...rest, 0].map((value, index) => value ^ multiply(Number(coefficients[index]), factor));
+    }
+    return remainder;
+}
+function blocks(data, version) {
+    const result = [];
+    let start = 0;
+    for (const group of layoutOf(version).groups)
+        for (let block = 0; block < group.count; block += 1) {
+            result.push(data.slice(start, start + group.dataCodewords));
+            start += group.dataCodewords;
+        }
+    return result;
+}
+function interleaved(columns) {
+    const longest = Math.max(...columns.map((column) => column.length));
+    const result = [];
+    for (let index = 0; index < longest; index += 1)
+        for (const column of columns) {
+            const value = column[index];
+            if (value !== undefined)
+                result.push(value);
+        }
+    return result;
+}
+export function qrCodewords(text) {
+    const bytes = new TextEncoder().encode(text);
+    const version = qrVersion(bytes.length);
+    const dataBlocks = blocks(qrDataCodewords(bytes, version), version);
+    const degree = layoutOf(version).correctionCodewords;
+    return {
+        version,
+        codewords: [
+            ...interleaved(dataBlocks),
+            ...interleaved(dataBlocks.map((block) => qrCorrection(block, degree))),
+        ],
+    };
+}

package/dist/src/phone/qr-matrix.d.ts

@@ -0,0 +1,6 @@
+export interface QrSymbol {
+    readonly version: number;
+    readonly mask: number;
+    readonly modules: readonly (readonly boolean[])[];
+}
+export declare function qrMatrix(text: string): QrSymbol;

package/dist/src/phone/qr-matrix.js

@@ -0,0 +1,175 @@
+import { qrCodewords } from "./qr-data.js";
+import { qrPenalty } from "./qr-penalty.js";
+const alignmentCenters = [
+    [],
+    [6, 18],
+    [6, 22],
+    [6, 26],
+    [6, 30],
+    [6, 34],
+    [6, 22, 38],
+    [6, 24, 42],
+    [6, 26, 46],
+    [6, 28, 50],
+];
+const masks = [
+    (row, column) => (row + column) % 2 === 0,
+    (row) => row % 2 === 0,
+    (_, column) => column % 3 === 0,
+    (row, column) => (row + column) % 3 === 0,
+    (row, column) => (Math.floor(row / 2) + Math.floor(column / 3)) % 2 === 0,
+    (row, column) => ((row * column) % 2) + ((row * column) % 3) === 0,
+    (row, column) => (((row * column) % 2) + ((row * column) % 3)) % 2 === 0,
+    (row, column) => (((row + column) % 2) + ((row * column) % 3)) % 2 === 0,
+];
+function grid(size) {
+    return Array.from({ length: size }, () => Array.from({ length: size }, () => false));
+}
+function mark(canvas, place) {
+    const [row, column, dark] = place;
+    const modules = canvas.modules[row];
+    const reserved = canvas.reserved[row];
+    if (modules === undefined || reserved === undefined)
+        return;
+    if (column < 0 || column >= canvas.size)
+        return;
+    modules[column] = dark;
+    reserved[column] = true;
+}
+function finder(canvas, corner) {
+    const [top, left] = corner;
+    for (let row = -1; row <= 7; row += 1)
+        for (let column = -1; column <= 7; column += 1) {
+            const distance = Math.max(Math.abs(row - 3), Math.abs(column - 3));
+            mark(canvas, [top + row, left + column, distance !== 2 && distance < 4]);
+        }
+}
+function alignment(canvas, center) {
+    const [top, left] = center;
+    for (let row = -2; row <= 2; row += 1)
+        for (let column = -2; column <= 2; column += 1)
+            mark(canvas, [
+                top + row,
+                left + column,
+                Math.max(Math.abs(row), Math.abs(column)) !== 1,
+            ]);
+}
+function functionPatterns(canvas, version) {
+    const last = canvas.size - 7;
+    for (let index = 8; index < canvas.size - 8; index += 1) {
+        mark(canvas, [6, index, index % 2 === 0]);
+        mark(canvas, [index, 6, index % 2 === 0]);
+    }
+    finder(canvas, [0, 0]);
+    finder(canvas, [0, last]);
+    finder(canvas, [last, 0]);
+    const centers = alignmentCenters[version - 1] ?? [];
+    const final = centers.length - 1;
+    centers.forEach((row, rowIndex) => {
+        centers.forEach((column, columnIndex) => {
+            const corner = (rowIndex === 0 && (columnIndex === 0 || columnIndex === final)) ||
+                (rowIndex === final && columnIndex === 0);
+            if (!corner)
+                alignment(canvas, [row, column]);
+        });
+    });
+}
+function formatPlaces(size) {
+    const first = [
+        ...[0, 1, 2, 3, 4, 5, 7, 8].map((row) => [row, 8]),
+        ...[7, 5, 4, 3, 2, 1, 0].map((column) => [8, column]),
+    ];
+    const second = [
+        ...[0, 1, 2, 3, 4, 5, 6, 7].map((index) => [
+            8,
+            size - 1 - index,
+        ]),
+        ...[6, 5, 4, 3, 2, 1, 0].map((index) => [
+            size - 1 - index,
+            8,
+        ]),
+    ];
+    return [...first, ...second];
+}
+function formatBits(mask) {
+    let remainder = mask;
+    for (let step = 0; step < 10; step += 1)
+        remainder = (remainder << 1) ^ ((remainder >>> 9) * 0x537);
+    return ((mask << 10) | remainder) ^ 0x5412;
+}
+function versionBits(version) {
+    let remainder = version;
+    for (let step = 0; step < 12; step += 1)
+        remainder = (remainder << 1) ^ ((remainder >>> 11) * 0x1f25);
+    return (version << 12) | remainder;
+}
+function formatInformation(canvas, mask) {
+    const format = formatBits(mask);
+    formatPlaces(canvas.size).forEach(([row, column], index) => {
+        mark(canvas, [row, column, ((format >>> (index % 15)) & 1) === 1]);
+    });
+    mark(canvas, [canvas.size - 8, 8, true]);
+}
+function versionInformation(canvas, version) {
+    if (version < 7)
+        return;
+    const bits = versionBits(version);
+    for (let index = 0; index < 18; index += 1) {
+        const near = Math.floor(index / 3);
+        const far = canvas.size - 11 + (index % 3);
+        const dark = ((bits >>> index) & 1) === 1;
+        mark(canvas, [near, far, dark]);
+        mark(canvas, [far, near, dark]);
+    }
+}
+function columnPairs(size) {
+    const columns = [];
+    for (let right = size - 1; right >= 1; right -= 2) {
+        if (right === 6)
+            right = 5;
+        columns.push(right);
+    }
+    return columns;
+}
+function dataPlaces(canvas) {
+    return columnPairs(canvas.size).flatMap((right) => {
+        const upward = ((right + 1) & 2) === 0;
+        return Array.from({ length: canvas.size }, (_, step) => upward ? canvas.size - 1 - step : step)
+            .flatMap((row) => [right, right - 1].map((column) => [row, column]))
+            .filter(([row, column]) => canvas.reserved[row]?.[column] !== true);
+    });
+}
+function placeData(canvas, codewords) {
+    dataPlaces(canvas).forEach(([row, column], index) => {
+        const codeword = codewords[Math.floor(index / 8)] ?? 0;
+        const modules = canvas.modules[row];
+        if (modules !== undefined)
+            modules[column] = ((codeword >>> (7 - (index % 8))) & 1) === 1;
+    });
+}
+function masked(canvas, mask) {
+    const condition = masks[mask] ?? (() => false);
+    return canvas.modules.map((row, rowIndex) => Array.from({ length: row.length }, (_, column) => {
+        const dark = row[column] === true;
+        return canvas.reserved[rowIndex]?.[column] === true
+            ? dark
+            : dark !== condition(rowIndex, column);
+    }));
+}
+function maskedCanvas(canvas, mask) {
+    const candidate = { ...canvas, modules: masked(canvas, mask) };
+    formatInformation(candidate, mask);
+    return candidate;
+}
+export function qrMatrix(text) {
+    const { version, codewords } = qrCodewords(text);
+    const size = 17 + 4 * version;
+    const canvas = { size, modules: grid(size), reserved: grid(size) };
+    functionPatterns(canvas, version);
+    formatInformation(canvas, 0);
+    versionInformation(canvas, version);
+    placeData(canvas, codewords);
+    const penalties = masks.map((_, mask) => qrPenalty(maskedCanvas(canvas, mask).modules));
+    const mask = penalties.indexOf(Math.min(...penalties));
+    return { version, mask, modules: maskedCanvas(canvas, mask).modules };
+}

package/dist/src/phone/qr-penalty.d.ts

@@ -0,0 +1,3 @@
+type Line = readonly boolean[];
+export declare function qrPenalty(modules: readonly Line[]): number;
+export {};