checkly 9.5.0 → 10.0.0-rc.1

package/dist/services/content-hash.js

@@ -0,0 +1,22 @@
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { pipeline } from 'node:stream/promises';
+/**
+ * Lowercase hex SHA-256 of a file's contents.
+ *
+ * The deploy payload carries one of these per uploaded artifact — every
+ * Playwright visual snapshot and the code bundle archive — so Checkly can tell
+ * an unchanged upload from a new one by content rather than by storage key,
+ * which changes on every upload. A hash is also computable before anything is
+ * uploaded, which is what lets `checkly deploy` ask what a deploy would change
+ * without uploading first.
+ *
+ * Streamed rather than read into a buffer: a bundle archive or a full-page
+ * screenshot can be tens of megabytes, and several are hashed per deploy.
+ */
+export async function sha256OfFile(filePath) {
+    const hash = createHash('sha256');
+    await pipeline(createReadStream(filePath), hash);
+    return hash.digest('hex');
+}
+//# sourceMappingURL=content-hash.js.map

package/dist/services/content-hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-hash.js","sourceRoot":"","sources":["../../src/services/content-hash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAE/C;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAAE,QAAgB;IAClD,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAA;IACjC,MAAM,QAAQ,CAAC,gBAAgB,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAA;IAChD,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;AAC3B,CAAC"}

package/dist/services/deploy-diff/diff-lines.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A line-oriented diff, used to show what a deploy would change about a
+ * resource: the construct as Checkly currently has it against the construct
+ * the local code would produce.
+ *
+ * Deliberately implemented here rather than taken from a package. The output
+ * is read by people in a terminal, the inputs are a few dozen lines of
+ * generated code, and a diff library would be a new dependency of a CLI that
+ * ships to users for the sake of one screen of code.
+ */
+export interface DiffLinesOptions {
+    /** Lines of context around each change. Defaults to 3. */
+    context?: number;
+    /** Lines per side above which no diff is produced. Defaults to 1500. */
+    maxLines?: number;
+}
+/** One line of a diff: a hunk boundary (with no text of its own), or a line of either side. */
+export interface DiffLine {
+    kind: 'context' | 'add' | 'remove' | 'hunk';
+    text: string;
+}
+/**
+ * The diff of two texts as typed lines, without colour — the caller decides
+ * how to present them.
+ *
+ * Hunk grouping follows `git diff` and GNU `diff -u`, which is the shape a
+ * reader recognises. When two sides can be aligned in more than one minimal
+ * way, which edit script you get is a matter of heuristics, and this one's is
+ * not git's: the result is always a valid, minimal diff of the same two texts,
+ * but it may group its hunks differently from the diff the same input would
+ * get from git.
+ *
+ * @returns An empty array when the two sides are identical (or differ only by
+ * a trailing newline), `undefined` when they are too large to compare (see
+ * {@link DEFAULT_MAX_LINES} and {@link MAX_CELLS}), and otherwise one `hunk`
+ * line per changed region followed by that region's lines.
+ */
+export declare function diffLines(before: string, after: string, options?: DiffLinesOptions): DiffLine[] | undefined;

package/dist/services/deploy-diff/diff-lines.js

@@ -0,0 +1,191 @@
+/**
+ * A line-oriented diff, used to show what a deploy would change about a
+ * resource: the construct as Checkly currently has it against the construct
+ * the local code would produce.
+ *
+ * Deliberately implemented here rather than taken from a package. The output
+ * is read by people in a terminal, the inputs are a few dozen lines of
+ * generated code, and a diff library would be a new dependency of a CLI that
+ * ships to users for the sake of one screen of code.
+ */
+/** Lines of leading and trailing context kept around each changed run. */
+const DEFAULT_CONTEXT = 3;
+/**
+ * Largest number of lines either side may have before the diff is declined.
+ * The comparison is a quadratic dynamic program over the lines that actually
+ * differ, so a pathological input (two unrelated thousand-line scripts) would
+ * cost a multiple of a million cells for output nobody would read. Callers
+ * have a coarser listing to fall back to.
+ */
+const DEFAULT_MAX_LINES = 1500;
+/**
+ * Cells the dynamic program may allocate, whatever `maxLines` says. The line
+ * guard above is about output nobody would read; this one is about the
+ * allocation itself, which is the product of the two sides and so grows far
+ * faster — without it, a caller raising `maxLines` gets a `RangeError` from
+ * the typed array instead of the `undefined` this function promises for an
+ * input it declines. Four million cells is 16 MB, and comfortably above what
+ * the default line guard can reach.
+ */
+const MAX_CELLS = 4_000_000;
+/**
+ * Splits text into lines, treating a trailing newline as a line terminator
+ * rather than as an empty last line, so `'a\n'` and `'a'` both have one line
+ * and neither reports a phantom change against the other.
+ */
+function toLines(text) {
+    if (text === '') {
+        return [];
+    }
+    const lines = text.split('\n');
+    if (lines[lines.length - 1] === '') {
+        lines.pop();
+    }
+    return lines;
+}
+/**
+ * The edit script turning `before` into `after`, one entry per line of either
+ * side, via the longest common subsequence of the two.
+ *
+ * Identical head and tail lines are matched off before the dynamic program
+ * runs — they are the bulk of any real comparison — and put back as context
+ * afterwards, so the line numbering downstream needs no adjustment.
+ *
+ * @returns `undefined` when what is left after that trim would need more than
+ * {@link MAX_CELLS} cells to compare.
+ */
+function editScript(before, after) {
+    let head = 0;
+    while (head < before.length && head < after.length && before[head] === after[head]) {
+        head += 1;
+    }
+    let tail = 0;
+    while (tail < before.length - head
+        && tail < after.length - head
+        && before[before.length - 1 - tail] === after[after.length - 1 - tail]) {
+        tail += 1;
+    }
+    const a = before.slice(head, before.length - tail);
+    const b = after.slice(head, after.length - tail);
+    const n = a.length;
+    const m = b.length;
+    if ((n + 1) * (m + 1) > MAX_CELLS) {
+        return undefined;
+    }
+    const width = m + 1;
+    // lengths[i][j] is the LCS length of a[i..] and b[j..], filled from the end
+    // so the walk below can go forwards and keep the two sides in step.
+    const lengths = new Int32Array((n + 1) * width);
+    for (let i = n - 1; i >= 0; i -= 1) {
+        for (let j = m - 1; j >= 0; j -= 1) {
+            lengths[i * width + j] = a[i] === b[j]
+                ? lengths[(i + 1) * width + j + 1] + 1
+                : Math.max(lengths[(i + 1) * width + j], lengths[i * width + j + 1]);
+        }
+    }
+    const edits = [];
+    for (const line of before.slice(0, head)) {
+        edits.push({ kind: 'context', line });
+    }
+    let i = 0;
+    let j = 0;
+    while (i < n && j < m) {
+        if (a[i] === b[j]) {
+            edits.push({ kind: 'context', line: a[i] });
+            i += 1;
+            j += 1;
+        }
+        else if (lengths[(i + 1) * width + j] >= lengths[i * width + j + 1]) {
+            // Dropping a[i] keeps at least as much of the common subsequence as
+            // dropping b[j] would; ties go to the deletion so a replaced line reads
+            // as `-old` then `+new`.
+            edits.push({ kind: 'remove', line: a[i] });
+            i += 1;
+        }
+        else {
+            edits.push({ kind: 'add', line: b[j] });
+            j += 1;
+        }
+    }
+    while (i < n) {
+        edits.push({ kind: 'remove', line: a[i] });
+        i += 1;
+    }
+    while (j < m) {
+        edits.push({ kind: 'add', line: b[j] });
+        j += 1;
+    }
+    for (const line of before.slice(before.length - tail)) {
+        edits.push({ kind: 'context', line });
+    }
+    return edits;
+}
+/**
+ * Groups the edit script into hunks: every changed line with `context` lines
+ * either side, and two changed runs separated by no more than twice that
+ * merged into one, which is what keeps a diff of scattered small edits from
+ * repeating the same lines under two headers.
+ */
+function toHunks(edits, context) {
+    const ranges = [];
+    edits.forEach((edit, index) => {
+        if (edit.kind === 'context') {
+            return;
+        }
+        const from = Math.max(0, index - context);
+        const to = Math.min(edits.length - 1, index + context);
+        const last = ranges[ranges.length - 1];
+        if (last !== undefined && from <= last[1] + 1) {
+            last[1] = Math.max(last[1], to);
+        }
+        else {
+            ranges.push([from, to]);
+        }
+    });
+    return ranges.map(([from, to]) => ({ edits: edits.slice(from, to + 1) }));
+}
+/**
+ * The diff of two texts as typed lines, without colour — the caller decides
+ * how to present them.
+ *
+ * Hunk grouping follows `git diff` and GNU `diff -u`, which is the shape a
+ * reader recognises. When two sides can be aligned in more than one minimal
+ * way, which edit script you get is a matter of heuristics, and this one's is
+ * not git's: the result is always a valid, minimal diff of the same two texts,
+ * but it may group its hunks differently from the diff the same input would
+ * get from git.
+ *
+ * @returns An empty array when the two sides are identical (or differ only by
+ * a trailing newline), `undefined` when they are too large to compare (see
+ * {@link DEFAULT_MAX_LINES} and {@link MAX_CELLS}), and otherwise one `hunk`
+ * line per changed region followed by that region's lines.
+ */
+export function diffLines(before, after, options = {}) {
+    const { context = DEFAULT_CONTEXT, maxLines = DEFAULT_MAX_LINES, } = options;
+    if (before === after) {
+        return [];
+    }
+    const beforeLines = toLines(before);
+    const afterLines = toLines(after);
+    if (beforeLines.length > maxLines || afterLines.length > maxLines) {
+        return undefined;
+    }
+    const edits = editScript(beforeLines, afterLines);
+    if (edits === undefined) {
+        return undefined;
+    }
+    const hunks = toHunks(edits, context);
+    if (hunks.length === 0) {
+        // The texts differ only by the trailing newline that `toLines` dropped.
+        return [];
+    }
+    const lines = [];
+    for (const hunk of hunks) {
+        lines.push({ kind: 'hunk', text: '' });
+        for (const edit of hunk.edits) {
+            lines.push({ kind: edit.kind, text: edit.line });
+        }
+    }
+    return lines;
+}
+//# sourceMappingURL=diff-lines.js.map

package/dist/services/deploy-diff/diff-lines.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-lines.js","sourceRoot":"","sources":["../../../src/services/deploy-diff/diff-lines.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,0EAA0E;AAC1E,MAAM,eAAe,GAAG,CAAC,CAAA;AAEzB;;;;;;GAMG;AACH,MAAM,iBAAiB,GAAG,IAAI,CAAA;AAE9B;;;;;;;;GAQG;AACH,MAAM,SAAS,GAAG,SAAS,CAAA;AAe3B;;;;GAIG;AACH,SAAS,OAAO,CAAE,IAAY;IAC5B,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QAChB,OAAO,EAAE,CAAA;IACX,CAAC;IACD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;IAC9B,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC;QACnC,KAAK,CAAC,GAAG,EAAE,CAAA;IACb,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,UAAU,CAAE,MAAgB,EAAE,KAAe;IACpD,IAAI,IAAI,GAAG,CAAC,CAAA;IACZ,OAAO,IAAI,GAAG,MAAM,CAAC,MAAM,IAAI,IAAI,GAAG,KAAK,CAAC,MAAM,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QACnF,IAAI,IAAI,CAAC,CAAA;IACX,CAAC;IACD,IAAI,IAAI,GAAG,CAAC,CAAA;IACZ,OACE,IAAI,GAAG,MAAM,CAAC,MAAM,GAAG,IAAI;WACxB,IAAI,GAAG,KAAK,CAAC,MAAM,GAAG,IAAI;WAC1B,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC,EACtE,CAAC;QACD,IAAI,IAAI,CAAC,CAAA;IACX,CAAC;IAED,MAAM,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IAClD,MAAM,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IAEhD,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAA;IAClB,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAA;IAClB,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,SAAS,EAAE,CAAC;QAClC,OAAO,SAAS,CAAA;IAClB,CAAC;IACD,MAAM,KAAK,GAAG,CAAC,GAAG,CAAC,CAAA;IACnB,4EAA4E;IAC5E,oEAAoE;IACpE,MAAM,OAAO,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,CAAA;IAC/C,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QACnC,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;YACnC,OAAO,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBACpC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC;gBACtC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;QACxE,CAAC;IACH,CAAC;IAED,MAAM,KAAK,GAAW,EAAE,CAAA;IACxB,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC;QACzC,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAA;IACvC,CAAC;IAED,IAAI,CAAC,GAAG,CAAC,CAAA;IACT,IAAI,CAAC,GAAG,CAAC,CAAA;IACT,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;QACtB,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAClB,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;YAC3C,CAAC,IAAI,CAAC,CAAA;YACN,CAAC,IAAI,CAAC,CAAA;QACR,CAAC;aAAM,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;YACtE,oEAAoE;YACpE,wEAAwE;YACxE,yBAAyB;YACzB,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;YAC1C,CAAC,IAAI,CAAC,CAAA;QACR,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;YACvC,CAAC,IAAI,CAAC,CAAA;QACR,CAAC;IACH,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACb,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;QAC1C,CAAC,IAAI,CAAC,CAAA;IACR,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACb,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;QACvC,CAAC,IAAI,CAAC,CAAA;IACR,CAAC;IAED,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;QACtD,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAA;IACvC,CAAC;IAED,OAAO,KAAK,CAAA;AACd,CAAC;AAMD;;;;;GAKG;AACH,SAAS,OAAO,CAAE,KAAa,EAAE,OAAe;IAC9C,MAAM,MAAM,GAA4B,EAAE,CAAA;IAC1C,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;QAC5B,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC5B,OAAM;QACR,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,CAAA;QACzC,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,CAAA;QACtD,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;QACtC,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;YAC9C,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;QACjC,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAA;QACzB,CAAC;IACH,CAAC,CAAC,CAAA;IACF,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;AAC3E,CAAC;AAQD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,SAAS,CACvB,MAAc,EACd,KAAa,EACb,UAA4B,EAAE;IAE9B,MAAM,EACJ,OAAO,GAAG,eAAe,EACzB,QAAQ,GAAG,iBAAiB,GAC7B,GAAG,OAAO,CAAA;IAEX,IAAI,MAAM,KAAK,KAAK,EAAE,CAAC;QACrB,OAAO,EAAE,CAAA;IACX,CAAC;IAED,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACnC,MAAM,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,CAAA;IACjC,IAAI,WAAW,CAAC,MAAM,GAAG,QAAQ,IAAI,UAAU,CAAC,MAAM,GAAG,QAAQ,EAAE,CAAC;QAClE,OAAO,SAAS,CAAA;IAClB,CAAC;IAED,MAAM,KAAK,GAAG,UAAU,CAAC,WAAW,EAAE,UAAU,CAAC,CAAA;IACjD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,SAAS,CAAA;IAClB,CAAC;IAED,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;IACrC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,wEAAwE;QACxE,OAAO,EAAE,CAAA;IACX,CAAC;IAED,MAAM,KAAK,GAAe,EAAE,CAAA;IAC5B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAA;QACtC,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YAC9B,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAA;QAClD,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC"}

package/dist/services/deploy-diff/import-shape.d.ts

@@ -0,0 +1,171 @@
+import type { Resource, ResourceType } from '../../constructs/construct-codegen.js';
+import { type Context } from '../../constructs/internal/codegen/index.js';
+import type { Project } from '../../constructs/project.js';
+import type { DiffChange, DiffEntry, DiffMaskedMarker, DiffRedaction, ResourceSync } from '../../rest/projects.js';
+import type { Program } from '../../sourcegen/index.js';
+/**
+ * Shapes the local side of a deploy preview like an import resource — the
+ * payload `checkly import` receives per resource and the construct codegens
+ * read — so it can be rendered by the same codegen as the deployed side and
+ * the two diffed as text.
+ *
+ * The deployed side needs no shaping: a preview's `before` (`detail: 'full'`)
+ * IS the import format, straight from the API. The local side is the payload
+ * this CLI synthesized for the deploy, which differs from the import format in
+ * exactly the ways `toImportResource` bridges: it has no `id`; it references
+ * other resources by logical id (`{ ref }`) where the import format carries
+ * physical ids; its relations are separate subscription and assignment
+ * resources, which the codegen folds onto the parent by registering them; it
+ * keeps a check's intent constraints in the author's order where the stored
+ * form groups them; and it carries a few keys only a deploy reads.
+ *
+ * Nothing here canonicalizes nulls, defaults or ordering beyond that. The
+ * local payload is well-formed by construction, and the deployed side comes
+ * from the same function the import plan uses, which the codegen was written
+ * for. A payload that cannot be shaped throws `UnshapeableError`; the
+ * renderer catches it and lists the changes instead.
+ */
+/** Physical ids keyed by `${type}:${logicalId}`. */
+export type PhysicalIds = ReadonlyMap<string, string | number>;
+export declare function idKey(type: string, logicalId: string): string;
+/**
+ * The segments of an RFC 6901 pointer, unescaped; the root pointer has none.
+ *
+ * @throws UnshapeableError for a string that is not a pointer, rather than
+ * matching it against nothing.
+ */
+export declare function pointerSegments(pointer: string): string[];
+/** A payload this module cannot turn into an import resource; the message says why. */
+export declare class UnshapeableError extends Error {
+}
+/**
+ * Every resource's physical id, for the rendering: the preview's entries
+ * carry the id of everything that exists (including a resource the code only
+ * references, whose `fromId` construct sends it), and a resource being created
+ * gets a synthetic one so the codegen has something to key its registrations
+ * on. Every local resource has an entry afterwards; this is the one place an
+ * id is minted.
+ */
+export declare function physicalIdsFromPlan(diff: readonly DiffEntry[], local: readonly ResourceSync[]): PhysicalIds;
+/**
+ * Keys of a deployed row that neither side renders: a setup or teardown
+ * snippet reference. The codegen resolves one through snippet files an
+ * import registers and a preview has not, a deploy clears it either way, and
+ * it is a bookkeeping column the plan never reports — so left in `before`,
+ * `fillUnchangedFromBefore` would copy it onto the local side.
+ */
+export declare const UNRENDERED_KEYS: readonly ["setupSnippetId", "tearDownSnippetId"];
+/**
+ * Fills into the shaped local payload every property the deployed row holds
+ * that the payload leaves out and the plan does not report as changed. Those
+ * are the defaults the deploy's validation fills into an absent property
+ * (`activated: true`, a check type's response-time limits, an empty header
+ * list), which the row then always carries and the codegen prints: the plan
+ * compared the validated payload against the row, so a property absent here
+ * and unreported there is one the deploy leaves as it is. Taking it from
+ * `before` makes the two renderings agree on it without this CLI keeping a
+ * copy of any default — and cannot hide a change, since a value copied to
+ * both sides prints alike on both.
+ *
+ * A key is left alone when a reported change path is it, lies under it, or
+ * lies above it; an explicit `null` is a value, not an absence; and only
+ * object keys are filled, never the elements of a list.
+ */
+export declare function fillUnchangedFromBefore(local: Record<string, unknown>, before: Record<string, unknown>, changes: readonly DiffChange[]): void;
+/**
+ * The local payload of one resource, as an import resource: `id` set, every
+ * reference a physical id, deploy-only keys dropped, the intent's constraints
+ * grouped as stored. No canonicalization of nulls, defaults or
+ * ordering: the payload has none, and the defaults the deploy would fill
+ * are taken from the deployed row by `fillUnchangedFromBefore`.
+ *
+ * @throws UnshapeableError for a payload the codegen could not render.
+ */
+export declare function toImportResource(type: ResourceType, logicalId: string, payload: unknown, ids: PhysicalIds): Resource;
+/**
+ * The relation rows a parent's `before` carries — every live subscription
+ * and assignment, the way the import format spells them — as the resources
+ * whose `prepare()` registers them on the codegen context.
+ */
+export declare function relationResourcesFromBefore(type: string, before: Record<string, unknown>): Resource[];
+export interface AfterRelationsInput {
+    ids: PhysicalIds;
+    /** Every resource of the local deploy payload. */
+    local: readonly ResourceSync[];
+    /** The parent's own preview entry: its type, logical id and `before`. */
+    entry: DiffEntry;
+    /** The whole preview, for the relation entries folded into this parent. */
+    diff: readonly DiffEntry[];
+    pruneRelations: boolean;
+}
+/**
+ * The relation resources the local side renders with: the project's own
+ * subscription and assignment constructs for this parent, plus every deployed
+ * relation the deploy will leave in place. A deployed row is left out when the
+ * code removed it (a DELETE or DETACH relation entry folded into this parent
+ * names its row id), when `--prune-relations` will delete it (a pruned entry
+ * names it too), or when a local construct already stands for the same target.
+ * What remains is unmanaged: the deploy keeps it, so both sides show it.
+ *
+ * @throws UnshapeableError when one of the parent's own relations cannot be shaped.
+ */
+export declare function relationResourcesForAfter(input: AfterRelationsInput): Resource[];
+/** What a redacted value renders as, on both sides: never an empty string, which could pass for a value. */
+export declare const MASK = "********";
+/**
+ * A payload with the API's redaction rules applied — the type's whole table,
+ * whatever the deployed row held — so a credential is masked on both sides
+ * (the deployed side arrives blanked and is masked the same way, since a
+ * blank could pass for a value) and never a phantom change, nor printed. A
+ * rule that matches nothing is simply ignored. No table at all is refused:
+ * an API that reports a `before` without one predates the rules, and the one
+ * direction this module must never take is printing a credential.
+ *
+ * @throws UnshapeableError when the API reported no rule table.
+ */
+export declare function blankRedacted<T>(payload: T, redactions: readonly DiffRedaction[] | undefined): T;
+export declare function isMaskedMarker(value: unknown): value is DiffMaskedMarker;
+/** Whether a reported value holds a marker anywhere inside it. */
+export declare const carriesMarker: (value: unknown) => boolean;
+/** The value at `segments` inside `root`, or undefined where the path does not resolve. */
+export declare function nodeAt(root: unknown, segments: readonly string[]): unknown;
+/**
+ * Write `text` over the masked value of every element the report marks
+ * `changed`, in the payload's list at `path`. A reported element is matched
+ * to the payload's by `key` when that key is unique in both, else by index
+ * when the key at that index is the same and the lists are equal in length,
+ * else not at all — the deployed row's list can be ordered differently from
+ * the report, so an index alone is never trusted, and a name is never
+ * wrong. A scalar marker names its own path. Returns whether any mark was
+ * placed.
+ */
+export declare function markChanged(payload: unknown, path: string, reported: unknown, text: string): boolean;
+/** The types another construct refers to by variable. */
+export declare const REFERENCEABLE_TYPES: (keyof import("../../constructs/project.js").Resources)[];
+/**
+ * Re-register the construct a codegen has just prepared under the name it
+ * has in the user's code (`names`, keyed by `idKey`), or else its logical
+ * id, in the construct file the codegen chose. A codegen names the variable
+ * it exports after the resource's content (an alert channel after its
+ * address, a group after its name), so a change to that content would show
+ * as a renamed variable beside the change itself; the code's name and the
+ * logical id are the same on both sides. The codegen's own name is given up
+ * first, so the new one can be the same (a group declared as `websiteGroup`
+ * and named "Website Group") without a counter to tell the two apart. A type
+ * whose codegen registers no variable is left alone.
+ */
+export declare function registerUnderCodeName(context: Context, resource: Resource, names?: ReadonlyMap<string, string>): void;
+/**
+ * Register every referenceable construct of the local project on a fresh
+ * context, under its physical id, so a rendered reference comes out as a
+ * variable rather than as `fromId(...)`: the one the construct has in the
+ * user's code (`names`, keyed by `idKey`), or else one derived from its name. Both
+ * sides of a comparison register the same set in the same order, which is
+ * what makes their identifiers agree. The constructs the code names go
+ * first, so a name derived for another construct that happens to be the
+ * same is the one that gets a counter. One support file for all of them, so
+ * the context's per-file identifier namespace tells two constructs with the
+ * same name apart (`group`, `group2`); a support file, not a construct file,
+ * because `renderConstruct` counts the construct files a render adds.
+ */
+export declare function registerProject(context: Context, program: Program, project: Project, ids: PhysicalIds, names?: ReadonlyMap<string, string>): void;