@matter/testing 0.17.9 → 0.18.0-alpha.0-20260812-4d7f2790e

package/dist/cjs/chip/cert/log-follower.js

@@ -0,0 +1,209 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var log_follower_exports = {};
+__export(log_follower_exports, {
+  CertLogClosedError: () => CertLogClosedError,
+  CertLogTimeoutError: () => CertLogTimeoutError,
+  LogFollower: () => LogFollower
+});
+module.exports = __toCommonJS(log_follower_exports);
+var import_async = require("../../util/async.js");
+var import_text = require("../../util/text.js");
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const DEFAULT_TIMEOUT_MS = 3e4;
+class CertLogTimeoutError extends Error {
+  constructor(pattern, from, tail) {
+    super(
+      `Timed out waiting for ${pattern} (from index ${from}); last lines: ` + tail.slice(-20).map((line) => line.text).join("\n")
+    );
+    this.pattern = pattern;
+    this.from = from;
+    this.tail = tail;
+  }
+  pattern;
+  from;
+  tail;
+}
+class CertLogClosedError extends Error {
+  constructor(name) {
+    super(`Log follower "${name}" closed before a pending expect() matched`);
+  }
+}
+function patternFor(patterns, flavor) {
+  if (flavor.startsWith("chip")) {
+    return patterns.chip;
+  }
+  if (flavor === "matterjs") {
+    return patterns.matterjs;
+  }
+  return void 0;
+}
+function matchableCopy(pattern) {
+  return new RegExp(pattern.source, pattern.flags.replace(/[gy]/g, ""));
+}
+class LogFollower {
+  name;
+  #lines = new Array();
+  #lastMark = 0;
+  #closed = false;
+  #closeError;
+  #waiters = new Array();
+  #resolveCloseSignal;
+  #closeSignal;
+  #pump;
+  constructor(source, name) {
+    this.name = name;
+    this.#closeSignal = new Promise((resolve) => {
+      this.#resolveCloseSignal = resolve;
+    });
+    this.#pump = this.#consume(source);
+  }
+  /**
+   * Appends a synthetic line (e.g. a step-boundary banner) to the buffer at the current position,
+   * indexed like a real line but flagged so {@link expect} skips it. Lets a caller mark the
+   * chronologically right position in the evidence `.log` output without that marker ever
+   * satisfying a step's own pattern.
+   */
+  annotate(text) {
+    this.#lines.push({ index: this.#lines.length, at: /* @__PURE__ */ new Date(), text, synthetic: true });
+    this.#wake();
+  }
+  /**
+   * Sets the default cursor a subsequent {@link expect} call scans from when it doesn't specify
+   * `from` itself. Typically called once at the start of a step.
+   */
+  mark() {
+    this.#lastMark = this.#lines.length;
+    return this.#lastMark;
+  }
+  /**
+   * Every line seen so far, in arrival order. A fresh copy on each access — callers cannot
+   * mutate the follower's own buffer through it.
+   */
+  get lines() {
+    return [...this.#lines];
+  }
+  /**
+   * Waits for a line at or after the cursor (`options.from`, default: the last {@link mark})
+   * matching the pattern for `options.flavor`. Resolves `unverified` immediately if `patterns`
+   * has no entry for that flavor. Throws {@link CertLogTimeoutError} if the deadline passes
+   * first, or {@link CertLogClosedError} (or the source's own error) if the follower closes
+   * first.
+   */
+  async expect(patterns, options) {
+    const original = patternFor(patterns, options.flavor);
+    if (!original) {
+      return { verdict: "unverified", reason: "no-pattern-for-flavor" };
+    }
+    const pattern = matchableCopy(original);
+    const from = options.from ?? this.#lastMark;
+    const timeout = (0, import_async.delay)(options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    try {
+      for (; ; ) {
+        const matched = this.#firstMatchFrom(pattern, from);
+        if (matched) {
+          return { verdict: "pass", matched, pattern: String(original) };
+        }
+        if (this.#closeError) {
+          throw this.#closeError;
+        }
+        if (this.#closed) {
+          throw new CertLogClosedError(this.name);
+        }
+        const outcome = await Promise.race([this.#waitForWake(), timeout.promise]);
+        if (outcome === "timeout") {
+          throw new CertLogTimeoutError(String(original), from, this.#lines.slice(from));
+        }
+      }
+    } finally {
+      timeout.cancel();
+    }
+  }
+  follow() {
+    return this.#replay();
+  }
+  async close() {
+    this.#resolveCloseSignal();
+    await this.#pump;
+  }
+  #firstMatchFrom(pattern, from) {
+    for (let i = from; i < this.#lines.length; i++) {
+      if (this.#lines[i].synthetic) {
+        continue;
+      }
+      if (pattern.test(this.#lines[i].text)) {
+        return this.#lines[i];
+      }
+    }
+    return void 0;
+  }
+  #waitForWake() {
+    return new Promise((resolve) => this.#waiters.push(() => resolve("activity")));
+  }
+  #wake() {
+    const waiters = this.#waiters;
+    this.#waiters = new Array();
+    for (const waiter of waiters) {
+      waiter();
+    }
+  }
+  async *#replay() {
+    let index = 0;
+    for (; ; ) {
+      while (index < this.#lines.length) {
+        yield this.#lines[index++].text;
+      }
+      if (this.#closed) {
+        return;
+      }
+      await new Promise((resolve) => this.#waiters.push(resolve));
+    }
+  }
+  // #closeSignal is a single reused promise, so close() ends the loop immediately without
+  // forcing the source's iterator closed (which could hang on a source parked mid-await).
+  // Never rethrows: failures land on #closeError for expect() to surface, so #pump always
+  // resolves and close() has nothing to catch.
+  async #consume(source) {
+    const iterator = source[Symbol.asyncIterator]();
+    try {
+      for (; ; ) {
+        const outcome = await Promise.race([
+          iterator.next().then((result) => ({ closed: false, result })),
+          this.#closeSignal.then(() => ({ closed: true }))
+        ]);
+        if (outcome.closed || outcome.result.done) {
+          return;
+        }
+        this.#lines.push({ index: this.#lines.length, at: /* @__PURE__ */ new Date(), text: (0, import_text.deansify)(outcome.result.value) });
+        this.#wake();
+      }
+    } catch (e) {
+      this.#closeError = e instanceof Error ? e : new Error(String(e));
+      console.warn(`Log follower "${this.name}" lost its source:`, this.#closeError);
+    } finally {
+      this.#closed = true;
+      this.#wake();
+    }
+  }
+}
+//# sourceMappingURL=log-follower.js.map

package/dist/cjs/chip/cert/log-follower.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/chip/cert/log-follower.ts"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/chip/cert/matterjs-subject-registry.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { CertDeviceFactory } from "./cert-context.js";
+/**
+ * Registers a {@link CertDeviceFactory} for the "matterjs" {@link DeviceFlavor}, keyed by
+ * chip-test-header app name.
+ *
+ * Kept separate from {@link Chip.subjectFor}'s app registry: that one is for the existing py/yaml
+ * harness's plain `Subject.Factory`s, which don't carry {@link CertDevice}'s extra fields
+ * (`log`/`flavor`/`exit`). Registering the same app name in both places is fine — they're
+ * independent maps — but a cert factory needs the matter.js `Logger` sink that only
+ * `support/chip-testing` (not this package) is allowed to depend on, so it registers here instead.
+ */
+export declare function registerMatterJsCertSubject(app: string, factory: CertDeviceFactory): void;
+/**
+ * Looks up a factory registered via {@link registerMatterJsCertSubject}.
+ */
+export declare function matterJsCertSubjectFor(app: string): CertDeviceFactory | undefined;
+//# sourceMappingURL=matterjs-subject-registry.d.ts.map

package/dist/cjs/chip/cert/matterjs-subject-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matterjs-subject-registry.d.ts","sourceRoot":"","sources":["../../../../src/chip/cert/matterjs-subject-registry.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAI3D;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAKzF;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAEjF"}

package/dist/cjs/chip/cert/matterjs-subject-registry.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var matterjs_subject_registry_exports = {};
+__export(matterjs_subject_registry_exports, {
+  matterJsCertSubjectFor: () => matterJsCertSubjectFor,
+  registerMatterJsCertSubject: () => registerMatterJsCertSubject
+});
+module.exports = __toCommonJS(matterjs_subject_registry_exports);
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const subjects = /* @__PURE__ */ new Map();
+function registerMatterJsCertSubject(app, factory) {
+  if (subjects.has(app)) {
+    throw new Error(`A matterjs cert subject is already registered for app "${app}"`);
+  }
+  subjects.set(app, factory);
+}
+function matterJsCertSubjectFor(app) {
+  return subjects.get(app);
+}
+//# sourceMappingURL=matterjs-subject-registry.js.map

package/dist/cjs/chip/cert/matterjs-subject-registry.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/chip/cert/matterjs-subject-registry.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,MAAM,WAAW,oBAAI,IAA+B;AAY7C,SAAS,4BAA4B,KAAa,SAAkC;AACvF,MAAI,SAAS,IAAI,GAAG,GAAG;AACnB,UAAM,IAAI,MAAM,0DAA0D,GAAG,GAAG;AAAA,EACpF;AACA,WAAS,IAAI,KAAK,OAAO;AAC7B;AAKO,SAAS,uBAAuB,KAA4C;AAC/E,SAAO,SAAS,IAAI,GAAG;AAC3B;",
+  "names": []
+}

package/dist/cjs/chip/cert/prompt-driven-python-test.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Subject } from "../../device/subject.js";
+import type { Container } from "../../docker/container.js";
+import type { TestFileDescriptor } from "../../test-descriptor.js";
+import { PythonTest } from "../python-test.js";
+import type { CertStepContext } from "./cert-context.js";
+/**
+ * Reacts to one line of a python-wrapped CHIP test script's own stdout. `pattern` identifies a prompt
+ * line — see `MatterBaseTest.wait_for_user_input` in `connectedhomeip`'s
+ * `matter/testing/matter_testing.py`, which logs the prompt then blocks on a bare `input()` read — and
+ * `action` reacts to it (e.g. drives a {@link CertStepContext} controller through a commissioning
+ * attempt) and returns the text {@link PromptDrivenPythonTest} writes to the script's stdin to unblock
+ * it.
+ */
+export interface PromptHandler {
+    pattern: RegExp;
+    action: (cx: CertStepContext, promptText: string) => Promise<string>;
+}
+/**
+ * Runs a CHIP python test script that drives its own multi-party scenario and prompts for out-of-band
+ * action instead of letting the harness commission/act on its behalf — see `TC_SC_3_5.py`'s
+ * `wait_for_user_input` calls, one per CASE-handshake attempt it wants a real commissioner to make.
+ *
+ * Reuses {@link PythonTest}'s command construction ({@link createCommand}, so the same argument/PICS
+ * rules apply) but keeps the container exec's stdin open and answers matching prompt lines through
+ * `handlers` instead of running fully unattended. Commissioning happens interactively, driven by
+ * `handlers` reacting to prompts, so there is no subject to pre-pair — {@link initializeSubject} is a
+ * no-op.
+ */
+export declare class PromptDrivenPythonTest extends PythonTest {
+    #private;
+    constructor(descriptor: TestFileDescriptor, container: Container, handlers: PromptHandler[], cx: CertStepContext);
+    initializeSubject(_subject: Subject): Promise<void>;
+    invoke(subject: Subject, step: (title: string) => void, args: string[], uncommissioned: boolean): Promise<void>;
+}
+//# sourceMappingURL=prompt-driven-python-test.d.ts.map

package/dist/cjs/chip/cert/prompt-driven-python-test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-driven-python-test.d.ts","sourceRoot":"","sources":["../../../../src/chip/cert/prompt-driven-python-test.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAE3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAGnE,OAAO,EAAiB,UAAU,EAAU,MAAM,mBAAmB,CAAC;AACtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,CAAC,EAAE,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CACxE;AAED;;;;;;;;;;GAUG;AACH,qBAAa,sBAAuB,SAAQ,UAAU;;IAIlD,YAAY,UAAU,EAAE,kBAAkB,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,EAAE,EAAE,EAAE,EAAE,eAAe,EAI/G;IAEc,iBAAiB,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAG;IAEtD,MAAM,CACjB,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,EAC7B,IAAI,EAAE,MAAM,EAAE,EACd,cAAc,EAAE,OAAO,GACxB,OAAO,CAAC,IAAI,CAAC,CA8Cf;CACJ"}

package/dist/cjs/chip/cert/prompt-driven-python-test.js

@@ -0,0 +1,77 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var prompt_driven_python_test_exports = {};
+__export(prompt_driven_python_test_exports, {
+  PromptDrivenPythonTest: () => PromptDrivenPythonTest
+});
+module.exports = __toCommonJS(prompt_driven_python_test_exports);
+var import_terminal = require("../../docker/terminal.js");
+var import_chip_test_common = require("../chip-test-common.js");
+var import_container_command_pipe = require("../container-command-pipe.js");
+var import_python_test = require("../python-test.js");
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class PromptDrivenPythonTest extends import_python_test.PythonTest {
+  #handlers;
+  #cx;
+  constructor(descriptor, container, handlers, cx) {
+    super(descriptor, container);
+    this.#handlers = handlers;
+    this.#cx = cx;
+  }
+  async initializeSubject(_subject) {
+  }
+  async invoke(subject, step, args, uncommissioned) {
+    await this.container.exec(["bash", "-c", `test -p ${import_container_command_pipe.FIFO_PATH} || mkfifo ${import_container_command_pipe.FIFO_PATH}`]);
+    const terminal = await this.container.exec(
+      await (0, import_python_test.createCommand)(this.descriptor, this.container, subject, args, uncommissioned),
+      import_terminal.Terminal.Line,
+      { cwd: "/tmp", stdin: true }
+    );
+    let passed = false;
+    try {
+      for await (let line of terminal) {
+        line = (0, import_chip_test_common.parseStep)(line, step);
+        const handler = this.#handlers.find((h) => h.pattern.test(line));
+        if (handler) {
+          const answer = await handler.action(this.#cx, line);
+          await terminal.write(answer);
+        }
+        if (line.indexOf("Final result: PASS") !== -1) {
+          passed = true;
+        } else if (line.match(/\[Test\]\s+\S+\s+PASS$/)) {
+          passed = true;
+        }
+        MockLogger.injectExternalMessage("CHIP", (0, import_python_test.spiffy)(line));
+      }
+    } catch (e) {
+      await terminal.close().catch((closeError) => {
+        console.warn("Error closing prompt-driven python test terminal:", closeError);
+      });
+      throw e;
+    }
+    if (!passed) {
+      throw new Error("Python test exited without error but did not indicate successful test");
+    }
+  }
+}
+//# sourceMappingURL=prompt-driven-python-test.js.map

package/dist/cjs/chip/cert/prompt-driven-python-test.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/chip/cert/prompt-driven-python-test.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,sBAAyB;AAEzB,8BAA0B;AAC1B,oCAA0B;AAC1B,yBAAkD;AAZlD;AAAA;AAAA;AAAA;AAAA;AAuCO,MAAM,+BAA+B,8BAAW;AAAA,EACnD;AAAA,EACA;AAAA,EAEA,YAAY,YAAgC,WAAsB,UAA2B,IAAqB;AAC9G,UAAM,YAAY,SAAS;AAC3B,SAAK,YAAY;AACjB,SAAK,MAAM;AAAA,EACf;AAAA,EAEA,MAAe,kBAAkB,UAAkC;AAAA,EAAC;AAAA,EAEpE,MAAe,OACX,SACA,MACA,MACA,gBACa;AAIb,UAAM,KAAK,UAAU,KAAK,CAAC,QAAQ,MAAM,WAAW,uCAAS,cAAc,uCAAS,EAAE,CAAC;AAEvF,UAAM,WAAW,MAAM,KAAK,UAAU;AAAA,MAClC,UAAM,kCAAc,KAAK,YAAY,KAAK,WAAW,SAAS,MAAM,cAAc;AAAA,MAClF,yBAAS;AAAA,MACT,EAAE,KAAK,QAAQ,OAAO,KAAK;AAAA,IAC/B;AAEA,QAAI,SAAS;AACb,QAAI;AACA,qBAAe,QAAQ,UAAU;AAC7B,mBAAO,mCAAU,MAAM,IAAI;AAE3B,cAAM,UAAU,KAAK,UAAU,KAAK,OAAK,EAAE,QAAQ,KAAK,IAAI,CAAC;AAC7D,YAAI,SAAS;AACT,gBAAM,SAAS,MAAM,QAAQ,OAAO,KAAK,KAAK,IAAI;AAClD,gBAAM,SAAS,MAAM,MAAM;AAAA,QAC/B;AAEA,YAAI,KAAK,QAAQ,oBAAoB,MAAM,IAAI;AAE3C,mBAAS;AAAA,QACb,WAAW,KAAK,MAAM,wBAAwB,GAAG;AAE7C,mBAAS;AAAA,QACb;AAEA,mBAAW,sBAAsB,YAAQ,2BAAO,IAAI,CAAC;AAAA,MACzD;AAAA,IACJ,SAAS,GAAG;AAIR,YAAM,SAAS,MAAM,EAAE,MAAM,gBAAc;AACvC,gBAAQ,KAAK,qDAAqD,UAAU;AAAA,MAChF,CAAC;AACD,YAAM;AAAA,IACV;AAEA,QAAI,CAAC,QAAQ;AACT,YAAM,IAAI,MAAM,uEAAuE;AAAA,IAC3F;AAAA,EACJ;AACJ;",
+  "names": []
+}

package/dist/cjs/chip/chip-bins.d.ts

@@ -0,0 +1,132 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Which build of CHIP example-app/chip-tool binaries a test run uses.
+ *
+ * `"matterjs"` is matter.js's own image/build (`ghcr.io/matter-js/chip*`, or a directory the user
+ * built themselves). `"cert-bins"` selects project-chip's official `connectedhomeip/chip-cert-bins`
+ * image — the same binaries the official Matter Test Harness certifies against.
+ */
+export type ChipBinsSource = "matterjs" | "cert-bins";
+/** Docker Hub repository publishing the official CHIP certification binaries. */
+export declare const CERT_BINS_IMAGE = "connectedhomeip/chip-cert-bins";
+/**
+ * Maintainer-vetted default tag: the connectedhomeip commit SHA `chip-cert-bins` publishes for
+ * Matter 1.6.1, verified pullable and `linux/arm64`-inventoried at the time this integration was
+ * built. Override with `MATTER_CHIP_BINS_TAG`.
+ */
+export declare const DEFAULT_CERT_BINS_TAG = "df8bd0308caa0680e2a78cda724a959e5b385205";
+/**
+ * `chip-cert-bins` publishes `linux/arm64` only, at every tag on Docker Hub (no `amd64` manifest
+ * has ever existed) — the official Test Harness targets Raspberry Pi hardware. Extraction always
+ * requests this platform regardless of host architecture; on non-arm64 hosts Docker runs it under
+ * emulation (QEMU), which is fine here since extraction only ever runs `cp`, never the app binaries
+ * themselves.
+ */
+export declare const CERT_BINS_PLATFORM = "linux/arm64";
+/**
+ * Whether a container platform string (as used for `Container.Configuration.platform`, e.g.
+ * `"linux/amd64"`) can run `chip-cert-bins` binaries bind-mounted into it. Verified directly: a
+ * platform mismatch doesn't fail at pull/extract time, only later at `exec` — `chip/state.ts`'s
+ * `configureContainer()` calls this up front so a mismatch fails fast with a clear error instead.
+ */
+export declare function chipBinsPlatformSupported(platform: string): boolean;
+/**
+ * Resolve which binary source a test run uses, from `MATTER_CHIP_BINS_SOURCE`. Unset (or empty)
+ * means unchanged default behavior: matter.js's own build.
+ */
+export declare function resolveChipBinsSource(): ChipBinsSource;
+/** The tag requested via `MATTER_CHIP_BINS_TAG`, before resolving a possible `"latest"`. */
+export declare function requestedChipBinsTag(): string;
+/** Base host directory under which `chip-cert-bins` binaries are extracted, one subdirectory per tag. */
+export declare function chipBinsDir(): string;
+/**
+ * Directory a given tag's binaries extract into and are cached under, one level below
+ * {@link chipBinsDir}. Scoping by tag means two runs against different tags can never clobber each
+ * other's `rm -rf`/`cp -a`/stamp-write, even sharing one `MATTER_CHIP_BINS_DIR` — each tag gets its own
+ * subtree, created fresh on first use.
+ *
+ * This does not make same-tag concurrency safe: two runs racing to extract the *same* tag into the
+ * same base directory at once can still interleave their `rm -rf`/`cp -a`/stamp-write (no cross-process
+ * lock exists). Point concurrent runs at different `MATTER_CHIP_BINS_DIR` values if they might extract
+ * the same tag at the same time — see the README's "Choosing a CHIP binary source" section.
+ */
+export declare function chipBinsExtractionDir(tag: string, baseDir?: string): string;
+/** Injectable so `"latest"` resolution is unit-testable without a network call. */
+export type LatestTagResolver = () => Promise<string>;
+interface DockerHubTag {
+    name: string;
+    tag_last_pushed: string;
+}
+/**
+ * Narrows Docker Hub's tags-list response to the shape this integration depends on
+ * (`{ results?: [{ name, tag_last_pushed }, ...] }`), so a shape drift on their end throws a clear,
+ * named error here instead of a `TypeError` from deep inside the later `.sort()`/`.name` access.
+ */
+export declare function parseDockerHubTagsResponse(body: unknown): DockerHubTag[];
+/**
+ * Resolve a requested tag to a concrete one. Anything other than the literal string `"latest"`
+ * passes through unchanged (a pinned SHA, or a maintainer-curated default) — reproducible, no
+ * network access. `"latest"` is a live lookup, gated behind this explicit opt-in rather than made
+ * the default so ordinary runs stay reproducible without depending on network access.
+ */
+export declare function resolveChipBinsTag(requested: string, fetchLatest?: LatestTagResolver): Promise<string>;
+/** The subset of {@link Docker} extraction needs, narrowed so tests can substitute a fake. */
+export interface ChipBinsDockerHandle {
+    pull(imageRef: string, platform: string): Promise<void>;
+    extractApps(imageRef: string, platform: string, targetDir: string): Promise<void>;
+}
+export interface EnsureChipBinsResult {
+    tag: string;
+    dir: string;
+    /** False when the target directory already held this exact tag's binaries; extraction was skipped. */
+    extracted: boolean;
+}
+/**
+ * Thrown when `targetDir` is not writable by the host after a `chip-cert-bins` extraction
+ * otherwise succeeded — the extraction container's UID mapping left files the host user cannot
+ * write, most often on rootless Docker/Podman (see the message for what to do about it).
+ */
+export declare class ChipBinsPermissionError extends Error {
+}
+/**
+ * Thrown when an existing chip-cert-bins extraction directory is owned by a different host user —
+ * on a multi-user host that user could have pre-created it and planted binaries this harness later
+ * spawns.
+ */
+export declare class ChipBinsOwnershipError extends Error {
+}
+/**
+ * Refuse to trust an existing extraction directory this host user does not own, before any stamp
+ * read or extraction relies on its contents. Skipped when `process.getuid` is unavailable
+ * (Windows has no POSIX ownership) or when `MATTER_CHIP_BINS_DIR` was set explicitly — that
+ * directory is the caller's own responsibility.
+ */
+export declare function assertChipBinsDirOwnership(dir: string): Promise<void>;
+/**
+ * Ensure `targetDir` holds `chip-<app>-app`/`chip-tool` binaries extracted from
+ * `connectedhomeip/chip-cert-bins:<tag>`. Lazy and cached: if `targetDir`'s stamp file already
+ * records `tag`, this is a no-op. A stamp mismatch (different tag, or no stamp at all — including a
+ * prior extraction that crashed before writing one) triggers a fresh pull + extract, so a partial
+ * failure self-heals on the next call rather than wedging the cache.
+ */
+export declare function ensureChipBins(tag: string, targetDir: string, docker?: ChipBinsDockerHandle): Promise<EnsureChipBinsResult>;
+/**
+ * Resolve the configured tag and ensure it's extracted, memoized process-wide so the classic
+ * yaml/python harness (`chip/state.ts`) and cert-test `chip-local` subjects
+ * (`chip/cert/chip-app-subject.ts`) — both of which may call this once per process — share a single
+ * pull/extract rather than racing each other. `docker` is injectable for tests only; production
+ * callers always take the default.
+ *
+ * A failed attempt clears the memo so the next call retries instead of being stuck replaying the
+ * same rejection for the rest of the process — matching `ensureChipBins()`'s own self-healing
+ * behavior on a failed extraction.
+ */
+export declare function prepareChipBins(docker?: ChipBinsDockerHandle): Promise<EnsureChipBinsResult>;
+/** Test-only: clears the process-wide memoization so each test starts from a clean slate. */
+export declare function resetChipBinsPrepareCacheForTesting(): void;
+export {};
+//# sourceMappingURL=chip-bins.d.ts.map

package/dist/cjs/chip/chip-bins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chip-bins.d.ts","sourceRoot":"","sources":["../../../src/chip/chip-bins.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG,WAAW,CAAC;AAEtD,iFAAiF;AACjF,eAAO,MAAM,eAAe,mCAAmC,CAAC;AAEhE;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,6CAA6C,CAAC;AAEhF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,gBAAgB,CAAC;AAEhD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEnE;AAaD;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,cAAc,CAYtD;AAED,4FAA4F;AAC5F,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C;AAYD,yGAAyG;AACzG,wBAAgB,WAAW,IAAI,MAAM,CAEpC;AAcD;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,MAAsB,GAAG,MAAM,CAG1F;AAED,mFAAmF;AACnF,MAAM,MAAM,iBAAiB,GAAG,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;AAEtD,UAAU,YAAY;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,MAAM,CAAC;CAC3B;AAYD;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,OAAO,GAAG,YAAY,EAAE,CAqBxE;AAqBD;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACpC,SAAS,EAAE,MAAM,EACjB,WAAW,GAAE,iBAA0C,GACxD,OAAO,CAAC,MAAM,CAAC,CAKjB;AAED,8FAA8F;AAC9F,MAAM,WAAW,oBAAoB;IACjC,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACrF;AAqCD,MAAM,WAAW,oBAAoB;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,sGAAsG;IACtG,SAAS,EAAE,OAAO,CAAC;CACtB;AAcD;;;;GAIG;AACH,qBAAa,uBAAwB,SAAQ,KAAK;CAAG;AAqBrD;;;;GAIG;AACH,qBAAa,sBAAuB,SAAQ,KAAK;CAAG;AAEpD;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAyB3E;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAChC,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,oBAAiD,GAC1D,OAAO,CAAC,oBAAoB,CAAC,CAmB/B;AAID;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC3B,MAAM,GAAE,oBAAiD,GAC1D,OAAO,CAAC,oBAAoB,CAAC,CAc/B;AAED,6FAA6F;AAC7F,wBAAgB,mCAAmC,IAAI,IAAI,CAE1D"}