knodin 0.8.3 → 0.8.5

package/dist/src/agent-events.js

@@ -0,0 +1,128 @@
+import fs from "node:fs";
+import path from "node:path";
+import { countOutputTokens } from "./output-telemetry.js";
+import { appendSessionEvent, } from "./session-telemetry.js";
+export const SESSION_CONTEXT_BUDGET_LINE = "Budget: at most 600 tokens, 8 KiB, 12 items.";
+const KNOWN_OPERATIONS = new Set([
+    "context",
+    "explain",
+    "review",
+    "map",
+    "search",
+    "query",
+    "pack",
+    "compress",
+    "execute",
+    "prs",
+    "wiki",
+    "docs",
+    "remote",
+]);
+function knownOperation(value) {
+    return typeof value === "string" && KNOWN_OPERATIONS.has(value) ? value : undefined;
+}
+export function parseClaudeHookPayload(raw) {
+    if (Buffer.byteLength(raw) > 65_536)
+        throw new Error("knodin agent-event: hook input exceeds 65536 bytes");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        throw new Error("knodin agent-event: hook input must be a JSON object");
+    return parsed;
+}
+export function classifyTool(payload) {
+    const name = payload.tool_name ?? "";
+    if (name === "mcp__knodin__knodin") {
+        const operation = knownOperation(payload.tool_input?.operation);
+        return {
+            toolCategory: "knodin",
+            ...(operation ? { operation } : {}),
+        };
+    }
+    if (["Read", "Glob", "Grep"].includes(name))
+        return { toolCategory: "manual_traversal" };
+    if (["Edit", "Write", "NotebookEdit", "MultiEdit"].includes(name))
+        return { toolCategory: "edit" };
+    if (name === "Bash") {
+        const command = typeof payload.tool_input?.command === "string" ? payload.tool_input.command : "";
+        const knodin = command.match(/(?:^|[;&|]\s*)knodin\s+([a-z][a-z0-9-]*)/i);
+        if (knodin) {
+            const operation = knownOperation(knodin[1]?.toLowerCase());
+            return { toolCategory: "knodin", ...(operation ? { operation } : {}) };
+        }
+        if (/(?:^|[;&|]\s*)(?:rg|grep|find)\b/.test(command))
+            return { toolCategory: "manual_traversal" };
+    }
+    return { toolCategory: "other" };
+}
+function cachePath(repo) {
+    return path.join(repo, ".knodin", "session-context-cache.json");
+}
+export function readSessionContextCache(repo, key, now = Date.now()) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(cachePath(repo), "utf8"));
+        return parsed.key === key && typeof parsed.at === "number" && now - parsed.at <= 300_000
+            ? (parsed.text ?? null)
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeSessionContextCache(repo, key, text) {
+    const filePath = cachePath(repo);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(temporary, JSON.stringify({ schemaVersion: 1, key, at: Date.now(), text }), {
+        mode: 0o600,
+        flag: "wx",
+    });
+    fs.renameSync(temporary, filePath);
+}
+export function canUseSessionContextCache(status, freshness) {
+    return status === "healthy" && freshness === "fresh";
+}
+export function renderSessionContext(context, freshness) {
+    const list = (values, render) => (values ?? []).slice(0, 3).map(render).join(", ") || "none reported";
+    let text = [
+        "## knodin session context",
+        `Graph evidence: ${freshness}. Treat stale or unavailable evidence as incomplete.`,
+        SESSION_CONTEXT_BUDGET_LINE,
+        `Repository: ${context.stats?.files ?? "?"} files, ${context.stats?.symbols ?? "?"} symbols.`,
+        `Subsystems: ${list(context.communities, (value) => `${value.name} (${value.size})`)}`,
+        `Hubs: ${list(context.hubs, (value) => `${value.symbol} (${value.degree})`)}`,
+        `Flows: ${list(context.flows, (value) => value.symbol ?? "unnamed")}`,
+        `Suggested next operation: ${context.suggestedOperation ?? "context"} (heuristic only).`,
+        "Use exact source evidence and preserve ambiguity, freshness, omissions, and response budgets.",
+    ].join("\n");
+    while ((countOutputTokens(text) > 600 || Buffer.byteLength(text) > 8192) && text.includes("\n")) {
+        text = `${text.slice(0, text.lastIndexOf("\n"))}\nContext truncated to the configured session budget.`;
+    }
+    return text;
+}
+export function recordClaudeLifecycleEvent(repo, event, payload) {
+    const sessionId = payload.session_id;
+    if (!sessionId)
+        return false;
+    const names = {
+        "session-start": "session_start",
+        "session-end": "session_end",
+        "turn-start": "turn_start",
+        "turn-end": "turn_end",
+        "pre-tool": "tool_start",
+        "post-tool": "tool_success",
+        "tool-failure": "tool_failure",
+    };
+    const mapped = names[event];
+    if (!mapped)
+        return false;
+    const tool = event.includes("tool") ? classifyTool(payload) : undefined;
+    return appendSessionEvent(repo, { event: mapped, sessionId, ...tool });
+}
+export function sessionStartHookOutput(text) {
+    return {
+        hookSpecificOutput: {
+            hookEventName: "SessionStart",
+            additionalContext: text,
+        },
+    };
+}

package/dist/src/agent-hooks.js

@@ -0,0 +1,156 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const OWNED_COMMAND = "knodin agent-event";
+function settingsPath(homeDir = os.homedir()) {
+    return path.join(homeDir, ".claude", "settings.json");
+}
+function assertNotSymlink(filePath) {
+    for (const candidate of [path.dirname(filePath), filePath]) {
+        try {
+            if (fs.lstatSync(candidate).isSymbolicLink())
+                throw new Error(`knodin agent-hooks: refusing symlinked path ${candidate}`);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+}
+function readSettings(filePath) {
+    if (!fs.existsSync(filePath))
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+    catch (error) {
+        throw new Error(`knodin agent-hooks: invalid Claude settings JSON: ${error.message}`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        throw new Error("knodin agent-hooks: Claude settings must contain a JSON object");
+    return parsed;
+}
+function atomicWrite(filePath, content) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(temporary, content, { encoding: "utf8", mode: 0o600, flag: "wx" });
+    fs.renameSync(temporary, filePath);
+}
+function ownedEntry(value) {
+    return JSON.stringify(value).includes(OWNED_COMMAND);
+}
+function removeOwned(document) {
+    const hooks = document.hooks;
+    if (!hooks || typeof hooks !== "object" || Array.isArray(hooks))
+        return;
+    const hookObject = hooks;
+    for (const [event, value] of Object.entries(hookObject)) {
+        if (!Array.isArray(value))
+            continue;
+        const retained = value.filter((entry) => !ownedEntry(entry));
+        if (retained.length === 0)
+            delete hookObject[event];
+        else
+            hookObject[event] = retained;
+    }
+    if (Object.keys(hookObject).length === 0)
+        delete document.hooks;
+}
+function hook(command, event, matcher) {
+    return {
+        ...(matcher ? { matcher } : {}),
+        hooks: [
+            {
+                type: "command",
+                command: `${command} agent-event ${event}`,
+                timeout: 5,
+            },
+        ],
+    };
+}
+function managedHooks(command) {
+    const observed = "mcp__knodin__knodin|Bash|Read|Glob|Grep|Edit|Write|NotebookEdit";
+    return {
+        SessionStart: [hook(command, "session-start", "startup|resume|clear|compact")],
+        UserPromptSubmit: [hook(command, "turn-start")],
+        PreToolUse: [hook(command, "pre-tool", observed)],
+        PostToolUse: [hook(command, "post-tool", observed)],
+        PostToolUseFailure: [hook(command, "tool-failure", observed)],
+        Stop: [hook(command, "turn-end")],
+        SessionEnd: [hook(command, "session-end")],
+    };
+}
+function mergedSettings(existing, command) {
+    const document = structuredClone(existing);
+    removeOwned(document);
+    const hooks = document.hooks && typeof document.hooks === "object" && !Array.isArray(document.hooks)
+        ? document.hooks
+        : {};
+    for (const [event, entries] of Object.entries(managedHooks(command))) {
+        const current = Array.isArray(hooks[event]) ? hooks[event] : [];
+        hooks[event] = [...current, ...entries];
+    }
+    document.hooks = hooks;
+    return document;
+}
+export function inspectClaudeAgentHooks(options = {}) {
+    const filePath = settingsPath(options.homeDir);
+    assertNotSymlink(filePath);
+    const document = readSettings(filePath);
+    const serialized = JSON.stringify(document);
+    const count = serialized.split(OWNED_COMMAND).length - 1;
+    return {
+        schemaVersion: 1,
+        client: "claude",
+        settingsPath: filePath,
+        installed: count > 0,
+        managedEntries: count,
+    };
+}
+export function installClaudeAgentHooks(options = {}) {
+    const filePath = settingsPath(options.homeDir);
+    assertNotSymlink(filePath);
+    const before = readSettings(filePath);
+    const after = mergedSettings(before, options.command ?? "knodin");
+    const beforeText = `${JSON.stringify(before, null, 2)}\n`;
+    const afterText = `${JSON.stringify(after, null, 2)}\n`;
+    const changed = beforeText !== afterText;
+    if (changed && !options.dryRun) {
+        if (fs.existsSync(filePath)) {
+            const backup = `${filePath}.knodin-backup`;
+            if (!fs.existsSync(backup))
+                fs.copyFileSync(filePath, backup, fs.constants.COPYFILE_EXCL);
+        }
+        atomicWrite(filePath, afterText);
+    }
+    return {
+        schemaVersion: 1,
+        client: "claude",
+        settingsPath: filePath,
+        changed,
+        dryRun: options.dryRun === true,
+        managedEntries: Object.keys(managedHooks(options.command ?? "knodin")).length,
+    };
+}
+export function uninstallClaudeAgentHooks(options = {}) {
+    const filePath = settingsPath(options.homeDir);
+    assertNotSymlink(filePath);
+    if (!fs.existsSync(filePath))
+        return { removed: false, settingsPath: filePath };
+    const document = readSettings(filePath);
+    const hadOwned = ownedEntry(document);
+    removeOwned(document);
+    if (hadOwned) {
+        if (Object.keys(document).length === 0)
+            fs.unlinkSync(filePath);
+        else
+            atomicWrite(filePath, `${JSON.stringify(document, null, 2)}\n`);
+    }
+    return {
+        schemaVersion: 1,
+        client: "claude",
+        removed: hadOwned,
+        settingsPath: filePath,
+    };
+}

package/dist/src/cli-model.js

@@ -64,6 +64,28 @@ function addRemoteCommands(program, capture) {
     leaf(remote, "remove <identity>", "delete a mirror's clone, graph, and registry entry", capture);
     leaf(remote, "refresh <identity>", "fetch the mirror again and re-index it", capture);
 }
+function addSharedIndexCommands(program, capture) {
+    const shared = program.command("shared").description("manage verified shared-index snapshots");
+    leaf(shared, "status", "inspect shared-index configuration and provenance without network", capture).option("--probe", "explicitly probe S3 authentication and pointer access");
+    leaf(shared, "pull", "discover, verify, reconcile, audit, and promote a shared snapshot", capture)
+        .option("--jsonl", "stream lossless phase events as JSONL")
+        .option("--progress <mode>", "plain, jsonl, or none");
+    leaf(shared, "configure", "write reviewed repository trust configuration", capture)
+        .option("--disable", "disable automatic shared-index access without deleting graph or cache")
+        .option("--registration-id <id>", "publisher registration identifier")
+        .option("--region <region>", "AWS region")
+        .option("--bucket <bucket>", "S3 bucket")
+        .option("--host <host>", "canonical Git host")
+        .option("--owner <owner>", "repository owner")
+        .option("--name <name>", "repository name")
+        .addOption(option("--branch <pattern>", "exact branch or terminal slash-star pattern", "collect"))
+        .option("--key-id <id>", "reviewed signing key identifier")
+        .option("--public-key <path>", "PEM public-key file (credentials are never accepted)");
+    leaf(shared, "publisher-metadata", "stamp and emit the exact client-derived publisher compatibility metadata", capture);
+    leaf(shared, "publisher-bundle <branch>", "stream a graph and canonical manifest bundle", capture).requiredOption("--output <path>", "new or empty private output directory");
+    leaf(shared, "publisher-finalize <bundle>", "verify a detached signature and emit the canonical branch pointer", capture);
+    leaf(shared, "publisher-guard <pointer> <branch> <commit>", "refuse a backward or diverged branch-pointer update", capture);
+}
 function addRepositoryCommands(program, capture) {
     const repos = program.command("repos").description("manage a portfolio of repositories");
     for (const action of ["discover", "init", "status", "doctor"]) {
@@ -142,6 +164,9 @@ function addGraphCommands(program, capture) {
         .addOption(option("--min-complexity <count>", "minimum complexity", "integer"))
         .option("--kinds <values>", "comma-separated symbol kinds")
         .option("--path <prefix>", "repo-relative path prefix")
+        .option("--base <ref>", "compare file_metrics with the merge-base of this Git ref")
+        .option("--test-scope <scope>", "file_metrics scope: all, test, or production")
+        .option("--format <format>", "file_metrics machine output format; currently json")
         .option("--variable <name>", "flow-analysis variable")
         .option("--facets <values>", "comma-separated architecture facets")
         .addOption(option("--top <count>", "maximum ranked results", "integer"))
@@ -251,9 +276,18 @@ function createCliProgram(capture = () => { }) {
     leaf(program, "serve", "run the one-tool MCP gateway on stdio", capture);
     leaf(program, "version", "print the installed knodin version", capture);
     leaf(program, "hook-refresh <kind> [values...]", "internal Git lifecycle refresh", capture);
+    const agentHooks = program
+        .command("agent-hooks")
+        .description("manage optional user-global coding-agent lifecycle hooks");
+    for (const action of ["install", "status", "uninstall"])
+        leaf(agentHooks, action, `${action} optional coding-agent hooks`, capture)
+            .option("--client <client>", "coding-agent client; currently claude")
+            .option("--dry-run", "preview settings changes without writing");
+    leaf(program, "agent-event <event>", "internal coding-agent lifecycle event", capture);
     leaf(program, "refresh-artifacts [event]", "refresh external graph artifacts", capture);
     addRepositoryCommands(program, capture);
     addRemoteCommands(program, capture);
+    addSharedIndexCommands(program, capture);
     addGraphCommands(program, capture);
     addArtifactCommands(program, capture);
     const system = program.command("system").description("inspect declared multi-repository systems");
@@ -283,7 +317,14 @@ function createCliProgram(capture = () => { }) {
         .command("telemetry")
         .description("manage local opt-in ROI telemetry")
         .allowExcessArguments(false)
-        .addArgument(new Argument("<action>").choices(["status", "report", "export", "clear"]));
+        .addArgument(new Argument("<action>").choices([
+        "enable",
+        "disable",
+        "status",
+        "report",
+        "export",
+        "clear",
+    ]));
     telemetry
         .option("--input <path>", "telemetry input path")
         .option("--output <path>", "dashboard or evidence-bundle output path")

package/dist/src/engine/candidate-database.js

@@ -0,0 +1,167 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { resolveDbPath, resolveStateDir } from "./state-paths.js";
+const PROMOTION_SCHEMA_VERSION = 1;
+const CANDIDATES_DIRECTORY = "candidates";
+const PROMOTION_MARKER = "promotion.json";
+function inside(parent, child) {
+    const relative = path.relative(path.resolve(parent), path.resolve(child));
+    return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function assertPromotionRecord(repo, value) {
+    if (!value || typeof value !== "object")
+        throw new Error("invalid promotion recovery record");
+    const record = value;
+    const stateDir = resolveStateDir(repo);
+    const activePath = resolveDbPath(repo);
+    if (record.schemaVersion !== PROMOTION_SCHEMA_VERSION ||
+        !record.candidatePath ||
+        !record.backupPath ||
+        record.activePath !== activePath ||
+        !inside(stateDir, record.candidatePath) ||
+        !inside(stateDir, record.backupPath) ||
+        !record.phase ||
+        !["prepared", "backed-up", "promoted"].includes(record.phase)) {
+        throw new Error("invalid promotion recovery record");
+    }
+    return record;
+}
+function fsyncFile(target) {
+    const descriptor = fs.openSync(target, "r");
+    try {
+        fs.fsyncSync(descriptor);
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+}
+function fsyncDirectory(target) {
+    try {
+        const descriptor = fs.openSync(target, "r");
+        try {
+            fs.fsyncSync(descriptor);
+        }
+        finally {
+            fs.closeSync(descriptor);
+        }
+    }
+    catch (error) {
+        // Some platforms do not support directory fsync. File fsync and same-filesystem
+        // rename remain the strongest available ordering guarantee there.
+        if (process.platform !== "win32")
+            throw error;
+    }
+}
+function atomicRecord(target, record) {
+    const temporary = `${target}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    fs.writeFileSync(temporary, `${JSON.stringify(record)}\n`, { mode: 0o600 });
+    fsyncFile(temporary);
+    fs.renameSync(temporary, target);
+    fsyncDirectory(path.dirname(target));
+}
+export function candidateRoot(repo) {
+    return path.join(resolveStateDir(repo), CANDIDATES_DIRECTORY);
+}
+export function promotionMarkerPath(repo) {
+    return path.join(resolveStateDir(repo), PROMOTION_MARKER);
+}
+export function allocateCandidate(repo) {
+    const resolvedRepo = path.resolve(repo);
+    const root = candidateRoot(resolvedRepo);
+    fs.mkdirSync(root, { recursive: true, mode: 0o700 });
+    const directory = fs.mkdtempSync(path.join(root, "candidate-"));
+    fs.chmodSync(directory, 0o700);
+    return {
+        schemaVersion: 1,
+        id: path.basename(directory),
+        repo: resolvedRepo,
+        databasePath: path.join(directory, "db.sqlite"),
+        createdAt: new Date().toISOString(),
+    };
+}
+export function assertCandidate(repo, candidate) {
+    const resolvedRepo = path.resolve(repo);
+    if (candidate.schemaVersion !== 1 ||
+        candidate.repo !== resolvedRepo ||
+        !inside(candidateRoot(resolvedRepo), candidate.databasePath) ||
+        path.basename(candidate.databasePath) !== "db.sqlite") {
+        throw new Error("candidate does not belong to this repository");
+    }
+}
+/** Restore the previous active graph after a process stopped between promotion renames. */
+export function recoverInterruptedPromotion(repo) {
+    const marker = promotionMarkerPath(repo);
+    if (!fs.existsSync(marker))
+        return "none";
+    const record = assertPromotionRecord(repo, JSON.parse(fs.readFileSync(marker, "utf8")));
+    const activeExists = fs.existsSync(record.activePath);
+    const backupExists = fs.existsSync(record.backupPath);
+    let outcome;
+    if (!activeExists && backupExists) {
+        fs.renameSync(record.backupPath, record.activePath);
+        fsyncDirectory(path.dirname(record.activePath));
+        outcome = "recovered";
+    }
+    else if (activeExists) {
+        outcome = record.phase === "promoted" ? "completed" : "recovered";
+    }
+    else {
+        throw new Error("interrupted promotion has neither active nor backup database");
+    }
+    fs.rmSync(marker, { force: true });
+    fsyncDirectory(path.dirname(marker));
+    return outcome;
+}
+/** Same-filesystem, marker-backed promotion. Caller must close and audit both databases first. */
+export function promoteCandidateFile(repo, candidate) {
+    assertCandidate(repo, candidate);
+    const activePath = resolveDbPath(repo);
+    const stateDir = resolveStateDir(repo);
+    if (!fs.existsSync(candidate.databasePath))
+        throw new Error("candidate database is missing");
+    for (const suffix of ["-wal", "-shm"])
+        if (fs.existsSync(`${candidate.databasePath}${suffix}`))
+            throw new Error("candidate database has uncheckpointed sidecar files");
+    fs.mkdirSync(stateDir, { recursive: true, mode: 0o700 });
+    fsyncFile(candidate.databasePath);
+    const backupPath = path.join(stateDir, `db.sqlite.backup.${Date.now()}.${crypto.randomUUID().slice(0, 8)}`);
+    const marker = promotionMarkerPath(repo);
+    let record = {
+        schemaVersion: 1,
+        phase: "prepared",
+        candidatePath: candidate.databasePath,
+        activePath,
+        backupPath,
+    };
+    atomicRecord(marker, record);
+    try {
+        if (fs.existsSync(activePath))
+            fs.renameSync(activePath, backupPath);
+        record = { ...record, phase: "backed-up" };
+        atomicRecord(marker, record);
+        fs.renameSync(candidate.databasePath, activePath);
+        record = { ...record, phase: "promoted" };
+        atomicRecord(marker, record);
+        fsyncFile(activePath);
+        fsyncDirectory(stateDir);
+        fs.rmSync(marker, { force: true });
+        fsyncDirectory(stateDir);
+        return fs.existsSync(backupPath) ? backupPath : null;
+    }
+    catch (error) {
+        if (fs.existsSync(activePath) && fs.existsSync(backupPath)) {
+            fs.mkdirSync(path.dirname(candidate.databasePath), { recursive: true, mode: 0o700 });
+            fs.renameSync(activePath, candidate.databasePath);
+        }
+        if (!fs.existsSync(activePath) && fs.existsSync(backupPath))
+            fs.renameSync(backupPath, activePath);
+        fs.rmSync(marker, { force: true });
+        fsyncDirectory(stateDir);
+        throw error;
+    }
+}
+export function discardCandidateFiles(repo, candidate) {
+    assertCandidate(repo, candidate);
+    fs.rmSync(path.dirname(candidate.databasePath), { recursive: true, force: true });
+}

package/dist/src/engine/embeddings.js

@@ -15,7 +15,9 @@ let embedderPromise = null;
 let embedderOverride = null;
 const embedderProgressListeners = new Set();
 let embedderReady = false;
-const EMBEDDING_DIMENSIONS = 384;
+export const EMBEDDING_DIMENSIONS = 384;
+export const EMBEDDING_MODEL_ID = "Xenova/all-MiniLM-L6-v2";
+export const EMBEDDING_MODEL_REVISION = "751bff37182d3f1213fa05d7196b954e230abad9";
 const DEFAULT_MODEL_REMOTE_HOST = "https://huggingface.co/";
 /**
  * One machine-level model cache shared by every repository and every installed
@@ -113,7 +115,7 @@ export function getEmbedder(onProgress) {
         return Promise.resolve(embedderOverride);
     }
     if (onProgress && embedderReady)
-        onProgress({ status: "ready", name: "Xenova/all-MiniLM-L6-v2" });
+        onProgress({ status: "ready", name: EMBEDDING_MODEL_ID });
     else if (onProgress)
         embedderProgressListeners.add(onProgress);
     if (!embedderPromise) {
@@ -132,13 +134,14 @@ export function getEmbedder(onProgress) {
                         }
                     }
                 };
-                notify({ status: "loading", name: "Xenova/all-MiniLM-L6-v2" });
-                const pipe = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2", {
+                notify({ status: "loading", name: EMBEDDING_MODEL_ID });
+                const pipe = await pipeline("feature-extraction", EMBEDDING_MODEL_ID, {
+                    revision: EMBEDDING_MODEL_REVISION,
                     progress_callback: notify,
                 });
                 realEmbedderLoadCount++;
                 embedderReady = true;
-                notify({ status: "ready", name: "Xenova/all-MiniLM-L6-v2" });
+                notify({ status: "ready", name: EMBEDDING_MODEL_ID });
                 embedderProgressListeners.clear();
                 return pipe;
             }