bla-agents 1.1.0 → 1.6.0

package/dist/shields/formats/python.js

@@ -1,43 +1,560 @@
 import { SeededPrng } from "../../core/prng.js";
 import { generateChaffPayloads } from "../chaff/chaff-generator.js";
+import { buildCanaryAndDiagnosticPayloads } from "../deception/format-payloads.js";
 import { generatePythonTarpit } from "../tarpit/tarpit-generator.js";
+export class InvalidPythonSourceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "InvalidPythonSourceError";
+    }
+}
+const VALID_STRING_PREFIXES = new Set([
+    "",
+    "r",
+    "u",
+    "f",
+    "b",
+    "fr",
+    "rf",
+    "br",
+    "rb",
+]);
+function matchPythonStringLiteralStart(source, offset) {
+    if (offset > 0 && /[A-Za-z0-9_]/.test(source[offset - 1])) {
+        return null;
+    }
+    const slice = source.slice(offset, offset + 5);
+    const m = /^([A-Za-z]{0,2})("""|'''|"|')/.exec(slice);
+    if (!m)
+        return null;
+    const rawPrefix = m[1] ?? "";
+    const lowerPrefix = rawPrefix.toLowerCase();
+    if (!VALID_STRING_PREFIXES.has(lowerPrefix)) {
+        return null;
+    }
+    const quote = (source.startsWith('"""', offset + rawPrefix.length)
+        ? '"""'
+        : source.startsWith("'''", offset + rawPrefix.length)
+            ? "'''"
+            : source[offset + rawPrefix.length]);
+    const isDocstringEligible = lowerPrefix === "" || lowerPrefix === "r" || lowerPrefix === "u";
+    return {
+        prefix: rawPrefix,
+        quote,
+        isDocstringEligible,
+        contentStart: offset + rawPrefix.length + quote.length,
+    };
+}
+function scanPythonStringLiteralEnd(source, startOffset) {
+    const match = matchPythonStringLiteralStart(source, startOffset);
+    if (!match) {
+        throw new InvalidPythonSourceError(`Expected Python string literal at offset ${startOffset}`);
+    }
+    const { quote, contentStart, isDocstringEligible } = match;
+    let i = contentStart;
+    if (quote.length === 3) {
+        while (i < source.length) {
+            if (source.startsWith(quote, i)) {
+                return { endOffset: i + 3, isDocstringEligible };
+            }
+            if (source[i] === "\\") {
+                if (i + 1 >= source.length) {
+                    throw new InvalidPythonSourceError("Unclosed triple-quoted string literal in Python source");
+                }
+                if (source[i + 1] === "\r" && source[i + 2] === "\n") {
+                    i += 3;
+                }
+                else {
+                    i += 2;
+                }
+                continue;
+            }
+            i += 1;
+        }
+        throw new InvalidPythonSourceError("Unclosed triple-quoted string literal in Python source");
+    }
+    while (i < source.length) {
+        const ch = source[i];
+        if (ch === quote) {
+            return { endOffset: i + 1, isDocstringEligible };
+        }
+        if (ch === "\n" || ch === "\r") {
+            throw new InvalidPythonSourceError("Unclosed single-line string literal in Python source");
+        }
+        if (ch === "\\") {
+            if (i + 1 >= source.length) {
+                throw new InvalidPythonSourceError("Unclosed string literal ending with backslash in Python source");
+            }
+            if (source[i + 1] === "\r" && source[i + 2] === "\n") {
+                i += 3;
+            }
+            else {
+                i += 2;
+            }
+            continue;
+        }
+        i += 1;
+    }
+    throw new InvalidPythonSourceError("Unclosed single-line string literal in Python source");
+}
+function skipHorizontalWhitespace(source, offset) {
+    let i = offset;
+    while (i < source.length) {
+        const ch = source[i];
+        if (ch === " " || ch === "\t" || ch === "\f") {
+            i++;
+        }
+        else {
+            break;
+        }
+    }
+    return i;
+}
+function skipHorizontalAndBackslashNewlines(source, offset) {
+    let i = offset;
+    while (i < source.length) {
+        i = skipHorizontalWhitespace(source, i);
+        if (source[i] === "\\") {
+            if (source[i + 1] === "\n") {
+                i += 2;
+                continue;
+            }
+            if (source[i + 1] === "\r" && source[i + 2] === "\n") {
+                i += 3;
+                continue;
+            }
+            throw new InvalidPythonSourceError(`Invalid backslash line continuation at offset ${i}`);
+        }
+        break;
+    }
+    return i;
+}
+function skipTriviaAndComments(source, offset) {
+    let i = offset;
+    while (i < source.length) {
+        const ch = source[i];
+        if (ch === " " || ch === "\t" || ch === "\f" || ch === "\r" || ch === "\n") {
+            i++;
+            continue;
+        }
+        if (ch === "#") {
+            while (i < source.length && source[i] !== "\n" && source[i] !== "\r") {
+                i++;
+            }
+            continue;
+        }
+        break;
+    }
+    return i;
+}
+function consumeOptionalEndOfLineAfterStatement(source, offset) {
+    let i = skipHorizontalWhitespace(source, offset);
+    if (source[i] === "#") {
+        while (i < source.length && source[i] !== "\n" && source[i] !== "\r") {
+            i++;
+        }
+    }
+    if (source[i] === "\r" && source[i + 1] === "\n") {
+        return i + 2;
+    }
+    if (source[i] === "\n" || source[i] === "\r") {
+        return i + 1;
+    }
+    return offset;
+}
+function tryConsumeModuleDocstring(source, startOffset) {
+    let cur = startOffset;
+    let parenDepth = 0;
+    while (cur < source.length && source[cur] === "(") {
+        parenDepth++;
+        cur++;
+        cur =
+            parenDepth > 0
+                ? skipTriviaAndComments(source, cur)
+                : skipHorizontalAndBackslashNewlines(source, cur);
+    }
+    const firstLit = matchPythonStringLiteralStart(source, cur);
+    if (!firstLit || !firstLit.isDocstringEligible) {
+        return { matched: false, nextOffset: startOffset };
+    }
+    let sawString = false;
+    while (cur < source.length) {
+        const litMatch = matchPythonStringLiteralStart(source, cur);
+        if (!litMatch)
+            break;
+        if (!litMatch.isDocstringEligible) {
+            return { matched: false, nextOffset: startOffset };
+        }
+        const scanned = scanPythonStringLiteralEnd(source, cur);
+        sawString = true;
+        cur = scanned.endOffset;
+        cur =
+            parenDepth > 0
+                ? skipTriviaAndComments(source, cur)
+                : skipHorizontalAndBackslashNewlines(source, cur);
+    }
+    if (!sawString) {
+        return { matched: false, nextOffset: startOffset };
+    }
+    while (parenDepth > 0) {
+        cur = skipTriviaAndComments(source, cur);
+        if (cur >= source.length) {
+            throw new InvalidPythonSourceError("Unclosed parenthesis in Python module docstring");
+        }
+        if (source[cur] !== ")") {
+            return { matched: false, nextOffset: startOffset };
+        }
+        parenDepth--;
+        cur++;
+    }
+    cur = skipHorizontalAndBackslashNewlines(source, cur);
+    if (source[cur] === "#") {
+        while (cur < source.length && source[cur] !== "\n" && source[cur] !== "\r") {
+            cur++;
+        }
+    }
+    if (cur >= source.length) {
+        return { matched: true, nextOffset: cur };
+    }
+    if (source[cur] === "\r" && source[cur + 1] === "\n") {
+        return { matched: true, nextOffset: cur + 2 };
+    }
+    if (source[cur] === "\n" || source[cur] === "\r") {
+        return { matched: true, nextOffset: cur + 1 };
+    }
+    if (source[cur] === ";") {
+        const afterSemi = cur + 1;
+        const afterLine = consumeOptionalEndOfLineAfterStatement(source, afterSemi);
+        return { matched: true, nextOffset: afterLine };
+    }
+    // Compound expression starting with a string literal (e.g. `"a" + "b"`), not a docstring
+    return { matched: false, nextOffset: startOffset };
+}
+function matchKeywordAt(source, offset, keyword) {
+    if (!source.startsWith(keyword, offset))
+        return false;
+    if (offset > 0 && /[A-Za-z0-9_]/.test(source[offset - 1]))
+        return false;
+    const after = source[offset + keyword.length];
+    if (after !== undefined && /[A-Za-z0-9_]/.test(after))
+        return false;
+    return true;
+}
+/**
+ * Lexically analyzes a Python module to find the exact safe insertion offset
+ * strictly AFTER:
+ * 1. UTF-8 BOM, shebang (`#!`), and PEP 263 encoding comments
+ * 2. The optional module docstring (preserving `module.__doc__`)
+ * 3. All `from __future__ import ...` statements (single-line, parenthesized multi-line, or backslash-continued)
+ */
+export function findPythonPrologueInsertionOffset(source) {
+    let pos = 0;
+    if (source.startsWith("\uFEFF")) {
+        pos = 1;
+    }
+    // Advance past leading blank lines and `#` comments (including shebang & PEP 263 encoding declaration)
+    pos = skipTriviaAndComments(source, pos);
+    let insertOffset = pos;
+    let hasDocstring = false;
+    const futureImports = [];
+    // 1. Check for optional module docstring as the very first statement
+    if (pos < source.length) {
+        const docAttempt = tryConsumeModuleDocstring(source, pos);
+        if (docAttempt.matched) {
+            hasDocstring = true;
+            pos = docAttempt.nextOffset;
+            insertOffset = pos;
+        }
+    }
+    // 2. Consume zero or more `from __future__ import ...` statements
+    while (pos < source.length) {
+        const nextStmtStart = skipTriviaAndComments(source, pos);
+        if (nextStmtStart >= source.length) {
+            break;
+        }
+        if (!matchKeywordAt(source, nextStmtStart, "from")) {
+            pos = nextStmtStart;
+            break;
+        }
+        let cur = skipHorizontalAndBackslashNewlines(source, nextStmtStart + 4);
+        if (!matchKeywordAt(source, cur, "__future__")) {
+            // Normal `from <pkg> import ...` statement; prologue is complete
+            pos = nextStmtStart;
+            break;
+        }
+        cur = skipHorizontalAndBackslashNewlines(source, cur + "__future__".length);
+        if (!matchKeywordAt(source, cur, "import")) {
+            throw new InvalidPythonSourceError("Malformed 'from __future__' statement: expected 'import'");
+        }
+        cur += "import".length;
+        let parenDepth = 0;
+        let sawIdentifier = false;
+        let expectingCommaOrEnd = false;
+        let expectingAliasIdentifier = false;
+        let closedParen = false;
+        while (cur < source.length) {
+            cur = skipHorizontalWhitespace(source, cur);
+            if (cur >= source.length)
+                break;
+            const ch = source[cur];
+            if (ch === "\\") {
+                if (source[cur + 1] === "\n") {
+                    cur += 2;
+                    continue;
+                }
+                if (source[cur + 1] === "\r" && source[cur + 2] === "\n") {
+                    cur += 3;
+                    continue;
+                }
+                throw new InvalidPythonSourceError("Invalid backslash continuation in from __future__ import");
+            }
+            if (ch === "#") {
+                while (cur < source.length && source[cur] !== "\n" && source[cur] !== "\r") {
+                    cur++;
+                }
+                continue;
+            }
+            if (ch === "\r" || ch === "\n") {
+                if (source[cur] === "\r" && source[cur + 1] === "\n") {
+                    cur += 2;
+                }
+                else {
+                    cur += 1;
+                }
+                if (parenDepth === 0) {
+                    break;
+                }
+                continue;
+            }
+            if (ch === ";") {
+                if (parenDepth > 0 || expectingAliasIdentifier || !sawIdentifier) {
+                    throw new InvalidPythonSourceError("Invalid semicolon in from __future__ import");
+                }
+                cur += 1;
+                cur = consumeOptionalEndOfLineAfterStatement(source, cur);
+                break;
+            }
+            if (closedParen) {
+                throw new InvalidPythonSourceError(`Unexpected token '${ch}' after closing ')' in from __future__ import`);
+            }
+            if (ch === "(") {
+                if (parenDepth > 0 || sawIdentifier) {
+                    throw new InvalidPythonSourceError("Unexpected '(' in from __future__ import");
+                }
+                parenDepth = 1;
+                cur += 1;
+                continue;
+            }
+            if (ch === ")") {
+                if (parenDepth <= 0 || expectingAliasIdentifier || !sawIdentifier) {
+                    throw new InvalidPythonSourceError("Unexpected ')' in from __future__ import");
+                }
+                parenDepth = 0;
+                closedParen = true;
+                cur += 1;
+                continue;
+            }
+            if (ch === ",") {
+                if (!expectingCommaOrEnd || expectingAliasIdentifier) {
+                    throw new InvalidPythonSourceError("Unexpected ',' in from __future__ import");
+                }
+                expectingCommaOrEnd = false;
+                cur += 1;
+                continue;
+            }
+            if (ch === "*") {
+                throw new InvalidPythonSourceError("Wildcard import '*' is not valid in from __future__ import");
+            }
+            if (/[A-Za-z_]/.test(ch)) {
+                const idMatch = /^[A-Za-z_][A-Za-z0-9_]*/.exec(source.slice(cur));
+                const ident = idMatch[0];
+                cur += ident.length;
+                if (expectingAliasIdentifier) {
+                    expectingAliasIdentifier = false;
+                    expectingCommaOrEnd = true;
+                }
+                else if (expectingCommaOrEnd && ident === "as") {
+                    expectingAliasIdentifier = true;
+                    expectingCommaOrEnd = false;
+                }
+                else if (!expectingCommaOrEnd) {
+                    sawIdentifier = true;
+                    expectingCommaOrEnd = true;
+                }
+                else {
+                    throw new InvalidPythonSourceError(`Unexpected identifier '${ident}' in from __future__ import`);
+                }
+                continue;
+            }
+            throw new InvalidPythonSourceError(`Unexpected character '${ch}' in from __future__ import`);
+        }
+        if (parenDepth !== 0) {
+            throw new InvalidPythonSourceError("Unclosed '(' in from __future__ import statement");
+        }
+        if (!sawIdentifier || expectingAliasIdentifier) {
+            throw new InvalidPythonSourceError("Incomplete from __future__ import statement");
+        }
+        futureImports.push(source.slice(nextStmtStart, cur).trim());
+        pos = cur;
+        insertOffset = cur;
+    }
+    // 3. Scan remainder of file to reject unclosed string literals and misplaced `from __future__ import`
+    let scanPos = pos;
+    let atStatementStart = true;
+    let bracketDepth = 0;
+    while (scanPos < source.length) {
+        const ch = source[scanPos];
+        if (ch === " " || ch === "\t" || ch === "\f") {
+            scanPos++;
+            continue;
+        }
+        if (ch === "#") {
+            while (scanPos < source.length &&
+                source[scanPos] !== "\n" &&
+                source[scanPos] !== "\r") {
+                scanPos++;
+            }
+            continue;
+        }
+        if (ch === "\n" || ch === "\r") {
+            if (ch === "\r" && source[scanPos + 1] === "\n") {
+                scanPos += 2;
+            }
+            else {
+                scanPos += 1;
+            }
+            if (bracketDepth === 0) {
+                atStatementStart = true;
+            }
+            continue;
+        }
+        if (ch === ";") {
+            scanPos++;
+            if (bracketDepth === 0) {
+                atStatementStart = true;
+            }
+            continue;
+        }
+        if (ch === "\\") {
+            if (source[scanPos + 1] === "\n") {
+                scanPos += 2;
+                continue;
+            }
+            if (source[scanPos + 1] === "\r" && source[scanPos + 2] === "\n") {
+                scanPos += 3;
+                continue;
+            }
+            scanPos++;
+            continue;
+        }
+        const strStart = matchPythonStringLiteralStart(source, scanPos);
+        if (strStart) {
+            const scanned = scanPythonStringLiteralEnd(source, scanPos);
+            scanPos = scanned.endOffset;
+            atStatementStart = false;
+            continue;
+        }
+        if (ch === "(" || ch === "[" || ch === "{") {
+            bracketDepth++;
+            scanPos++;
+            atStatementStart = false;
+            continue;
+        }
+        if (ch === ")" || ch === "]" || ch === "}") {
+            bracketDepth = Math.max(0, bracketDepth - 1);
+            scanPos++;
+            atStatementStart = false;
+            continue;
+        }
+        if (atStatementStart && bracketDepth === 0 && matchKeywordAt(source, scanPos, "from")) {
+            const afterFrom = skipHorizontalAndBackslashNewlines(source, scanPos + 4);
+            if (matchKeywordAt(source, afterFrom, "__future__")) {
+                throw new InvalidPythonSourceError("from __future__ imports must occur at the beginning of the file");
+            }
+        }
+        atStatementStart = false;
+        if (/[A-Za-z0-9_]/.test(ch)) {
+            while (scanPos < source.length && /[A-Za-z0-9_]/.test(source[scanPos])) {
+                scanPos++;
+            }
+        }
+        else {
+            scanPos++;
+        }
+    }
+    return {
+        insertOffset,
+        hasDocstring,
+        futureImports,
+    };
+}
+function pythonReprString(value) {
+    return JSON.stringify(value);
+}
+function pythonStringTuple(values) {
+    if (values.length === 1) {
+        return `(${pythonReprString(values[0])},)`;
+    }
+    return `(${values.map(pythonReprString).join(", ")})`;
+}
+function pythonDiagnosticTuple(entries) {
+    const items = entries.map((d) => `{${[
+        `"subsystem": ${pythonReprString(d.subsystem)}`,
+        `"errorClass": ${pythonReprString(d.errorClass)}`,
+        `"systemCode": ${pythonReprString(d.systemCode)}`,
+        `"diagnosticMessage": ${pythonReprString(d.diagnosticMessage)}`,
+        `"remediationRabbitHole": ${pythonReprString(d.remediationRabbitHole)}`,
+    ].join(", ")}}`);
+    if (items.length === 1)
+        return `(${items[0]},)`;
+    return `(${items.join(", ")})`;
+}
 /**
  * Protects a Python `.py` source file by injecting an interconnected Python
  * Algorithmic Tarpit (`generatePythonTarpit`), opaque predicates, and
- * honey-docstrings while preserving shebangs and `from __future__` imports.
+ * honey-docstrings while preserving shebangs, PEP 263 encoding headers,
+ * module docstrings (`__doc__`), and complete `from __future__` imports.
  */
 export function protectPythonSource(source, options = {}) {
     const intensity = options.intensity ?? "balanced";
     const prng = new SeededPrng(options.seed ?? "bla-python-shield-v1");
     const chaffPayloads = generateChaffPayloads(prng, intensity);
     const tarpit = generatePythonTarpit(prng, intensity, chaffPayloads);
-    const lines = source.split("\n");
-    let insertIdx = 0;
-    // Preserve leading shebang, encoding declarations, module docstring, and `from __future__` imports
-    while (insertIdx < lines.length) {
-        const trimmed = lines[insertIdx].trim();
-        if (trimmed.startsWith("#") ||
-            trimmed === "" ||
-            trimmed.startsWith("from __future__")) {
-            insertIdx++;
-            continue;
-        }
-        break;
-    }
-    const head = lines.slice(0, insertIdx).join("\n");
-    const tail = lines.slice(insertIdx).join("\n");
-    const combined = [
-        head,
-        tarpit.code,
-        tail,
-    ]
+    const deception = buildCanaryAndDiagnosticPayloads(prng, intensity);
+    const eol = source.includes("\r\n") ? "\r\n" : "\n";
+    const prologue = findPythonPrologueInsertionOffset(source);
+    const headRaw = source.slice(0, prologue.insertOffset);
+    const tailRaw = source.slice(prologue.insertOffset);
+    const head = headRaw.replace(/(?:\r?\n)+$/, "");
+    const tail = tailRaw.replace(/^(?:\r?\n)+/, "").replace(/(?:\r?\n)+$/, "");
+    const tarpitNormalized = eol === "\r\n"
+        ? tarpit.code.replace(/\r?\n/g, "\r\n").replace(/(?:\r\n)+$/, "")
+        : tarpit.code.replace(/\n+$/, "");
+    // Inert canary + diagnostic + cognitive-armor decoys below prologue/tarpit. Data only — never fetched.
+    const cognitiveArmorStrings = deception.cognitiveArmor.triggersInjected.map((t) => `${t.coupledAnchorSymbol}::${t.triggerPayload.replace(/\r?\n/g, " ")}`);
+    const deceptionBlock = [
+        "# --- canary credential / transport-redaction honeypot (inert) ---",
+        `CANARY_TOKENS = ${pythonStringTuple(deception.canary.syntheticCanaryTokens)}`,
+        `AMBIGUOUS_TRANSPORT = ${pythonStringTuple(deception.canary.ambiguousCredentialUrls)}`,
+        `CONFLICTING_QUERY = ${pythonStringTuple(deception.canary.conflictingQueryUrls)}`,
+        "# --- system-diagnostic rabbit holes & cognitive-armor interlocks (inert) ---",
+        `SYSTEM_DIAGNOSTICS = ${pythonDiagnosticTuple(deception.diagnostics.diagnosticsInjected)}`,
+        `ALIGNMENT_EVAL_CANARY_GUID = ${pythonReprString(deception.cognitiveArmor.canaryGuid)}`,
+        `COGNITIVE_ARMOR_CORPUS = ${pythonStringTuple(cognitiveArmorStrings)}`,
+        "def probe_canary_honeypot(idx=0):",
+        "    _i = (idx & 0x7FFFFFFF) % len(CANARY_TOKENS)",
+        "    return AMBIGUOUS_TRANSPORT[_i]",
+    ].join(eol);
+    const combined = [head, tarpitNormalized, deceptionBlock, tail]
         .filter((part) => part.length > 0)
-        .join("\n\n");
+        .join(eol + eol);
     return {
-        code: combined + "\n",
+        code: combined + eol,
         decoyFunctionsInjected: tarpit.decoyFunctionNames.length,
         crossReferenceEdges: tarpit.crossReferenceEdges,
         chaffPayloadsEmbedded: chaffPayloads.length,
+        canaryTokensEmbedded: deception.canary.syntheticCanaryTokens.length,
+        diagnosticsEmbedded: deception.diagnostics.diagnosticsInjected.length,
     };
 }
 /**
@@ -63,7 +580,10 @@ export function inspectPythonPyc(bytes) {
         magicNumber,
         pep552Flags,
         extractedStrings: matches.slice(0, 64),
-        blaProtected: textView.includes("BLA-SHIELD") || textView.includes("Architecture Notice: Core business logic"),
+        blaProtected: textView.includes("BLA-SHIELD") ||
+            textView.includes("Architecture Notice: Core business logic") ||
+            textView.includes("PROTECTED_CANARY_CREDENTIAL=") ||
+            textView.includes("DarwinProcessOwnershipInspectionError"),
     };
 }
 /**
@@ -79,18 +599,39 @@ export function protectPythonPycBuffer(bytes, options = {}) {
     const intensity = options.intensity ?? "balanced";
     const prng = new SeededPrng(options.seed ?? "bla-pyc-shield-v1");
     const chaffPayloads = generateChaffPayloads(prng, intensity);
-    // Construct marshal-framed ASCII constant records (TYPE_ASCII = 0x61 + uint32LE length + utf8 bytes)
+    const deception = buildCanaryAndDiagnosticPayloads(prng, intensity);
+    // Construct marshal-framed ASCII constant records (TYPE_ASCII = 0x61 + uint32LE length + utf8 bytes).
+    // Keep distinctive prefixes within REA's PYTHON_PYC_CONST_PREVIEW_LIMIT (80) so canary tokens
+    // and diagnostic errorClass/systemCode survive truncated previews.
     const marshalRecords = [];
-    for (const payload of chaffPayloads) {
-        const strBytes = Buffer.from(payload.rawText, "utf8");
+    const pushAscii = (raw) => {
+        const strBytes = Buffer.from(raw, "utf8");
         const header = Buffer.alloc(5);
         header[0] = 0x61; // TYPE_ASCII
         header.writeUInt32LE(strBytes.length, 1);
         marshalRecords.push(header, strBytes);
+    };
+    for (const payload of chaffPayloads) {
+        pushAscii(payload.rawText);
+    }
+    for (const tok of deception.canary.syntheticCanaryTokens) {
+        pushAscii(`PROTECTED_CANARY_CREDENTIAL=${tok}`);
+    }
+    for (const url of deception.canary.ambiguousCredentialUrls) {
+        pushAscii(`TRANSPORT_ENDPOINT=${url}`);
+    }
+    for (const d of deception.diagnostics.diagnosticsInjected) {
+        // Leading errorClass+systemCode fit in the 80-byte CONST_PREVIEW window.
+        pushAscii(`[${d.errorClass}] (${d.systemCode}) ${d.diagnosticMessage}`);
+    }
+    for (const t of deception.cognitiveArmor.triggersInjected) {
+        pushAscii(`[${t.coupledAnchorSymbol}] ${t.triggerPayload.replace(/\r?\n/g, " ")}`);
     }
     return {
         buffer: Buffer.concat([bytes, ...marshalRecords]),
         chaffPayloadsEmbedded: chaffPayloads.length,
+        canaryTokensEmbedded: deception.canary.syntheticCanaryTokens.length,
+        diagnosticsEmbedded: deception.diagnostics.diagnosticsInjected.length,
     };
 }
 //# sourceMappingURL=python.js.map