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

package/dist/cjs/chip/cert/cert-test.js

@@ -0,0 +1,250 @@
+"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 cert_test_exports = {};
+__export(cert_test_exports, {
+  CertTest: () => CertTest,
+  createRegisteredCertTest: () => createRegisteredCertTest,
+  registerCertTestFactory: () => registerCertTestFactory
+});
+module.exports = __toCommonJS(cert_test_exports);
+var import_test = require("../../device/test.js");
+var import_expression = require("../pics/expression.js");
+var import_file = require("../pics/file.js");
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const inertRecorder = {
+  beginStep() {
+  },
+  check() {
+  },
+  endStep() {
+    return [];
+  },
+  async flush() {
+    return "";
+  }
+};
+class CertTest extends import_test.BaseTest {
+  #definition;
+  constructor(definition, descriptor, container) {
+    super(descriptor, container);
+    this.#definition = definition;
+  }
+  get definition() {
+    return this.#definition;
+  }
+  async initializeSubject(_subject) {
+  }
+  async invoke(subject, step, _args, _uncommissioned) {
+    const cx = this.contextFor(subject);
+    const { recorder, devices } = cx;
+    const picsFile = resolvePicsFile(subject);
+    const deviceExitWatch = watchDeviceExits(devices, recorder);
+    const flavor = currentFlavor(devices);
+    const tc = this.#definition.tc;
+    let aborted = false;
+    let failure;
+    let failed = false;
+    try {
+      for (const stepDef of this.#definition.steps) {
+        if (aborted) {
+          announceStepEnd(cx, tc, stepDef, "aborted", recorder.endStep(stepDef, "aborted"));
+          continue;
+        }
+        try {
+          if (stepDef.flavors && flavor !== void 0 && !stepDef.flavors.includes(flavor)) {
+            announceStepEnd(
+              cx,
+              tc,
+              stepDef,
+              "skipped",
+              recorder.endStep(stepDef, "skipped", `unsupported on device flavor "${flavor}"`)
+            );
+            continue;
+          }
+          if (!stepPicsMet(stepDef, picsFile)) {
+            announceStepEnd(
+              cx,
+              tc,
+              stepDef,
+              "skipped",
+              recorder.endStep(stepDef, "skipped", `PICS "${stepDef.pics}" not met`)
+            );
+            continue;
+          }
+          step(`Test Step ${stepDef.number}: ${stepDef.text}`);
+          announceStepStart(cx, tc, stepDef);
+          recorder.beginStep(stepDef);
+          await raceAgainstDeviceExit(stepDef.run(cx), deviceExitWatch.exit, tc, stepDef.number);
+        } catch (e) {
+          announceStepEnd(cx, tc, stepDef, "fail", recorder.endStep(stepDef, "fail"));
+          aborted = true;
+          failed = true;
+          failure = e;
+          continue;
+        }
+        announceStepEnd(cx, tc, stepDef, "pass", recorder.endStep(stepDef, "pass"));
+      }
+    } finally {
+      try {
+        await this.beforeFlush(cx);
+      } catch (e) {
+        console.warn("Cert test beforeFlush hook failed:", e);
+      }
+      try {
+        await recorder.flush();
+      } catch (e) {
+        if (failed) {
+          console.warn("Cert test evidence flush failed after a step failure:", e);
+        } else {
+          failed = true;
+          failure = e;
+        }
+      }
+      deviceExitWatch.disarm();
+    }
+    if (failed) {
+      throw failure;
+    }
+    const exited = deviceExitWatch.observed;
+    if (exited !== void 0) {
+      throw new Error(
+        `A cert-test device exited unexpectedly (code ${exited.code}, signal ${exited.signal}) during the run`
+      );
+    }
+  }
+  /**
+   * Build the step context for a run.  Overridable so controller/device wiring can be layered on in
+   * later tasks without changing {@link invoke}'s public contract.
+   */
+  contextFor(_subject) {
+    return {
+      controllers: {},
+      devices: {},
+      recorder: inertRecorder
+    };
+  }
+  /**
+   * Runs immediately before {@link StepRecorder.flush}, after every step has settled. Overridable
+   * so wiring that built its own concrete recorder (see `WiredCertTest` in `cert-dsl.ts`) can attach
+   * final device/controller logs — `contextFor`'s generic `StepRecorder` type doesn't expose that,
+   * only the concrete recorder implementation does.
+   */
+  async beforeFlush(_cx) {
+  }
+}
+function resolvePicsFile(subject) {
+  try {
+    return subject.pics ?? void 0;
+  } catch (e) {
+    if (e instanceof import_file.PicsUnavailableError) {
+      return void 0;
+    }
+    throw e;
+  }
+}
+function currentFlavor(devices) {
+  return Object.values(devices)[0]?.flavor;
+}
+function stepPicsMet(stepDef, picsFile) {
+  if (stepDef.pics === void 0 || !picsFile) {
+    return true;
+  }
+  return new import_expression.PicsExpression(stepDef.pics).evaluate(picsFile);
+}
+const STEP_BANNER_RULE = "-".repeat(70);
+function announceStep(cx, lines) {
+  for (const line of lines) {
+    for (const device of Object.values(cx.devices)) {
+      device.log.annotate(line);
+    }
+    for (const controller of Object.values(cx.controllers)) {
+      controller.log.annotate(line);
+    }
+  }
+}
+function announceStepStart(cx, tc, stepDef) {
+  announceStep(cx, [STEP_BANNER_RULE, `${tc} \u2014 Test Step ${stepDef.number}: ${stepDef.text}`, STEP_BANNER_RULE]);
+}
+function formatCheckLine(check) {
+  if (check.type === "device-log") {
+    return `pattern=${check.pattern ?? "(none)"} matched=${check.matched ?? "(none)"}`;
+  }
+  return check.detail ?? "(no detail)";
+}
+function announceStepEnd(cx, tc, stepDef, verdict, checks) {
+  const checkLines = checks.map(
+    (check, index) => checks.length > 1 ? `${index}: ${formatCheckLine(check)}` : formatCheckLine(check)
+  );
+  announceStep(cx, [
+    STEP_BANNER_RULE,
+    `${tc} \u2014 Test Step ${stepDef.number}: ${verdict.toUpperCase()}`,
+    ...checkLines,
+    STEP_BANNER_RULE
+  ]);
+}
+function watchDeviceExits(devices, recorder) {
+  let observed;
+  let onExit = (info) => recorder.deviceExited?.(info);
+  const exit = Promise.race(Object.values(devices).map((device) => device.exit));
+  void exit.then((info) => {
+    if (onExit === void 0) {
+      return;
+    }
+    observed = info;
+    try {
+      onExit(info);
+    } catch (e) {
+      console.warn("Cert test deviceExited hook failed:", e);
+    }
+  });
+  return {
+    exit,
+    get observed() {
+      return observed;
+    },
+    disarm() {
+      onExit = void 0;
+    }
+  };
+}
+async function raceAgainstDeviceExit(stepRun, deviceExit, tc, step) {
+  const outcome = await Promise.race([stepRun.then(() => "ran"), deviceExit.then(() => "exited")]);
+  if (outcome === "exited") {
+    void stepRun.catch((e) => {
+      console.warn(`Cert test ${tc} step ${step}: orphaned step run settled after the device exit:`, e);
+    });
+    throw new Error("A cert-test device exited unexpectedly while a step was running");
+  }
+}
+const certTestFactories = /* @__PURE__ */ new WeakMap();
+function registerCertTestFactory(descriptor, factory) {
+  certTestFactories.set(descriptor, factory);
+}
+function createRegisteredCertTest(descriptor) {
+  const factory = certTestFactories.get(descriptor);
+  if (!factory) {
+    throw new Error(`No cert test registered for descriptor "${descriptor.name}"`);
+  }
+  return factory();
+}
+//# sourceMappingURL=cert-test.js.map

package/dist/cjs/chip/cert/cert-test.js.map

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

package/dist/cjs/chip/cert/chip-app-subject.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @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 { HARNESS_DBUS_CONTAINER } from "../config.js";
+import { type PicsFile } from "../pics/file.js";
+import type { CertDevice, CertDeviceFactory, DeviceExitInfo, DeviceFlavor } from "./cert-context.js";
+import { LogFollower } from "./log-follower.js";
+export { HARNESS_DBUS_CONTAINER };
+/**
+ * Resolve the directory `chip-local` subjects spawn `chip-<app>-app` binaries from. When
+ * `MATTER_CHIP_BINS_SOURCE=cert-bins`, this extracts (if not already cached — see
+ * {@link prepareChipBins}) the official `connectedhomeip/chip-cert-bins` image and returns its own
+ * directory, ignoring `MATTER_CERT_APP_DIR` entirely; otherwise it requires `MATTER_CERT_APP_DIR` as
+ * before (a directory the user built/populated themselves). `cert-dsl.ts`'s
+ * `chipLocalMarkerRevision()` calls this too, so a cert-bins-sourced run's evidence `chipRef` comes
+ * from the same directory without separate wiring.
+ */
+export declare function resolveChipLocalAppDir(): Promise<string>;
+export declare function chipImageBase(): string;
+/**
+ * The subset of `Docker.compose()`'s return value that {@link ChipDockerDevice} needs, extracted so
+ * tests can substitute a fake without a running Docker daemon.
+ */
+export interface CompositionHandle {
+    add(config: Partial<Container.Configuration> & {
+        name: string;
+        recreate?: boolean;
+    }): Promise<Container>;
+    close(): Promise<void>;
+}
+/**
+ * The subset of {@link Docker} (plus volume setup) that {@link ChipDockerDevice} needs, extracted so
+ * tests can substitute a fake without a running Docker daemon.
+ */
+export interface DockerHandle {
+    ensureVolume(name: string): Promise<void>;
+    compose(name: string, config?: Partial<Container.Configuration>): CompositionHandle;
+    containerStatus(name: string): Promise<{
+        isRunning: boolean;
+    } | undefined>;
+}
+/**
+ * A chip-app device run in Docker.  Runs the app-specific `ghcr.io/matter-js/chip-<app>` image (its
+ * own `ENTRYPOINT` already runs the right binary) as a single container, reusing the CHIP harness's
+ * dbus/mdns sidecars (`chip/state.ts`'s `configureContainer`) instead of starting a duplicate pair —
+ * see {@link HARNESS_DBUS_CONTAINER}.
+ */
+export declare class ChipDockerDevice implements CertDevice {
+    #private;
+    readonly flavor: DeviceFlavor;
+    readonly id: string;
+    readonly app: string;
+    readonly commissioning: Subject.CommissioningParameters;
+    readonly log: LogFollower;
+    constructor(app: string, domain: string, options?: Subject.Options, docker?: DockerHandle);
+    get pics(): PicsFile;
+    get exit(): Promise<DeviceExitInfo>;
+    initialize(): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    close(): Promise<void>;
+    snapshot(): Promise<{}>;
+    restore(): Promise<void>;
+    backchannel(): Promise<void>;
+}
+/**
+ * Spawns `${MATTER_CERT_APP_DIR}/chip-<app>-app` as a local child process for cert tests.
+ */
+export declare function ChipLocalSubject(app: string): CertDeviceFactory;
+/**
+ * Runs a chip-<app> device in a Docker container. Requires the CHIP harness's dbus/mdns sidecars
+ * (started by `certTest()` via `State.initialize()`) to already be running — see
+ * {@link HARNESS_DBUS_CONTAINER}.
+ */
+export declare function ChipDockerSubject(app: string): CertDeviceFactory;
+//# sourceMappingURL=chip-app-subject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chip-app-subject.d.ts","sourceRoot":"","sources":["../../../../src/chip/cert/chip-app-subject.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAQ3D,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAwB,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACrG,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAKhD,OAAO,EAAE,sBAAsB,EAAE,CAAC;AA0ClC;;;;;;;;GAQG;AACH,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,MAAM,CAAC,CAsB9D;AAwID,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAMD;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAC9B,GAAG,CACC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,aAAa,CAAC,GAAG;QACvC,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,CAAC,EAAE,OAAO,CAAC;KACtB,GACF,OAAO,CAAC,SAAS,CAAC,CAAC;IACtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IACzB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,aAAa,CAAC,GAAG,iBAAiB,CAAC;IACpF,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,CAAC,CAAC;CAC9E;AAiBD;;;;;GAKG;AACH,qBAAa,gBAAiB,YAAW,UAAU;;IAC/C,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAiB;IAC9C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC,uBAAuB,CAAC;IACxD,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;IAU1B,YAAY,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,GAAE,YAAiC,EAO5G;IAED,IAAI,IAAI,IAAI,QAAQ,CAEnB;IAED,IAAI,IAAI,IAAI,OAAO,CAAC,cAAc,CAAC,CAElC;IAEK,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAG;IAE9B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CA6D3B;IAgBK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAgB1B;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAQ3B;IAEK,QAAQ,IAAI,OAAO,CAAC,EAAE,CAAC,CAE5B;IAEK,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAE7B;IAEK,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAEjC;CACJ;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAE/D;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAEhE"}

package/dist/cjs/chip/cert/chip-app-subject.js

@@ -0,0 +1,337 @@
+"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 chip_app_subject_exports = {};
+__export(chip_app_subject_exports, {
+  ChipDockerDevice: () => ChipDockerDevice,
+  ChipDockerSubject: () => ChipDockerSubject,
+  ChipLocalSubject: () => ChipLocalSubject,
+  HARNESS_DBUS_CONTAINER: () => import_config.HARNESS_DBUS_CONTAINER,
+  chipImageBase: () => chipImageBase,
+  resolveChipLocalAppDir: () => resolveChipLocalAppDir
+});
+module.exports = __toCommonJS(chip_app_subject_exports);
+var import_node_child_process = require("node:child_process");
+var import_promises = require("node:fs/promises");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var import_node_process = require("node:process");
+var import_docker = require("../../docker/docker.js");
+var import_errors = require("../../docker/errors.js");
+var import_terminal = require("../../docker/terminal.js");
+var import_volume = require("../../docker/volume.js");
+var import_async = require("../../util/async.js");
+var import_text = require("../../util/text.js");
+var import_chip_bins = require("../chip-bins.js");
+var import_config = require("../config.js");
+var import_file = require("../pics/file.js");
+var import_log_follower = require("./log-follower.js");
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const DEFAULT_DISCRIMINATOR = 3840;
+const DEFAULT_PASSCODE = 20202021;
+const STOP_TIMEOUT_MS = 5e3;
+const TRACE_ARGS = ["--trace_log", "1", "--trace_decode", "1"];
+function defaultCommissioning() {
+  return {
+    kind: "on-network",
+    passcode: DEFAULT_PASSCODE,
+    discriminator: DEFAULT_DISCRIMINATOR,
+    // A real onboarding QR code needs the spec's base38 payload encoder, which lives in
+    // matter.js and is out of reach here per the packages/testing dependency invariant.
+    // ControllerAdapter.CommissioningTarget treats qrPairingCode as optional and commissions
+    // via discriminator/passcode instead.
+    qrPairingCode: ""
+  };
+}
+function throwUnsupported(flavor, capability) {
+  throw new Error(`${flavor} subjects do not support ${capability}; commission fresh per test instead`);
+}
+function createExitDeferred() {
+  let resolve;
+  const promise = new Promise((r) => {
+    resolve = r;
+  });
+  return { promise, resolve };
+}
+async function resolveChipLocalAppDir() {
+  if ((0, import_chip_bins.resolveChipBinsSource)() === "cert-bins") {
+    if (import_node_process.platform !== "linux") {
+      throw new Error(
+        `MATTER_CHIP_BINS_SOURCE=cert-bins selects Linux/${import_chip_bins.CERT_BINS_PLATFORM} binaries that chip-local spawns directly on the host; this host is "${import_node_process.platform}", which cannot run them. Use a Linux host or CI runner for chip-local with cert-bins, or unset MATTER_CHIP_BINS_SOURCE and point MATTER_CERT_APP_DIR at binaries built for this platform.`
+      );
+    }
+    return (await (0, import_chip_bins.prepareChipBins)()).dir;
+  }
+  const dir = import_node_process.env.MATTER_CERT_APP_DIR;
+  if (!dir) {
+    throw new Error("MATTER_CERT_APP_DIR is not set; ChipLocalSubject needs it to find chip-<app>-app binaries");
+  }
+  return dir;
+}
+class ChipLocalDevice {
+  flavor = "chip-local";
+  id;
+  app;
+  commissioning;
+  log;
+  #appArgs;
+  #hub = new import_async.LineQueue();
+  #storageDir;
+  #child;
+  #exit = createExitDeferred();
+  #pumps = new Array();
+  constructor(app, domain, options) {
+    this.app = app;
+    this.id = domain;
+    this.commissioning = defaultCommissioning();
+    this.log = new import_log_follower.LogFollower(this.#hub.follow(), domain);
+    this.#appArgs = options?.appArgs ?? [];
+  }
+  get pics() {
+    throw new import_file.PicsUnavailableError("No active PICS file for this device");
+  }
+  get exit() {
+    return this.#exit.promise;
+  }
+  async initialize() {
+    await resolveChipLocalAppDir();
+    this.#storageDir ??= await (0, import_promises.mkdtemp)((0, import_node_path.join)((0, import_node_os.tmpdir)(), "matter-cert-local-"));
+  }
+  async start() {
+    if (this.#child) {
+      return;
+    }
+    const dir = await resolveChipLocalAppDir();
+    this.#storageDir ??= await (0, import_promises.mkdtemp)((0, import_node_path.join)((0, import_node_os.tmpdir)(), "matter-cert-local-"));
+    const binPath = (0, import_node_path.join)(dir, `chip-${this.app}-app`);
+    const kvsPath = (0, import_node_path.join)(this.#storageDir, "chip_kvs");
+    const args = [
+      "--discriminator",
+      String(this.commissioning.discriminator),
+      "--passcode",
+      String(this.commissioning.passcode),
+      "--KVS",
+      kvsPath,
+      ...TRACE_ARGS,
+      ...this.#appArgs
+    ];
+    const child = (0, import_node_child_process.spawn)(binPath, args, { stdio: ["ignore", "pipe", "pipe"] });
+    const { stdout, stderr } = child;
+    if (!stdout || !stderr) {
+      throw new Error("Spawned process has no stdout/stderr streams");
+    }
+    this.#child = child;
+    this.#exit = createExitDeferred();
+    this.#pumps = [this.#hub.pump((0, import_text.asyncLinesOf)(stdout)), this.#hub.pump((0, import_text.asyncLinesOf)(stderr))];
+    child.once("exit", (code, signal) => {
+      this.#exit.resolve({ code, signal });
+    });
+    child.once("error", (error) => {
+      this.#exit.resolve({ code: null, signal: null });
+      console.warn(`Error running ${binPath}:`, error);
+    });
+  }
+  async stop() {
+    const child = this.#child;
+    if (!child) {
+      return;
+    }
+    child.kill("SIGTERM");
+    const timer = (0, import_async.delay)(STOP_TIMEOUT_MS);
+    try {
+      const outcome = await Promise.race([this.#exit.promise.then(() => "exited"), timer.promise]);
+      if (outcome === "timeout") {
+        child.kill("SIGKILL");
+        await this.#exit.promise;
+      }
+    } finally {
+      timer.cancel();
+      this.#child = void 0;
+    }
+  }
+  async close() {
+    await this.stop();
+    const results = await Promise.allSettled(this.#pumps);
+    for (const result of results) {
+      if (result.status === "rejected") {
+        console.warn("Error reading device output:", result.reason);
+      }
+    }
+    this.#hub.close();
+    if (this.#storageDir) {
+      await (0, import_promises.rm)(this.#storageDir, { recursive: true, force: true });
+      this.#storageDir = void 0;
+    }
+  }
+  async snapshot() {
+    throwUnsupported(this.flavor, "snapshot/restore");
+  }
+  async restore() {
+    throwUnsupported(this.flavor, "snapshot/restore");
+  }
+  async backchannel() {
+    throwUnsupported(this.flavor, "backchannel simulation");
+  }
+}
+function chipImageBase() {
+  return import_node_process.env.MATTER_CERT_CHIP_IMAGE_BASE || "ghcr.io/matter-js/chip";
+}
+function mdnsVolumeName() {
+  return import_node_process.env.MATTER_MDNS_VOLUME || "matter.js-mdns";
+}
+function realDockerHandle() {
+  const docker = new import_docker.Docker();
+  return {
+    async ensureVolume(name) {
+      await (0, import_volume.Volume)(docker, name).open();
+    },
+    compose(name, config) {
+      return docker.compose(name, config);
+    },
+    containerStatus(name) {
+      return docker.containerStatus(name);
+    }
+  };
+}
+class ChipDockerDevice {
+  flavor = "chip-docker";
+  id;
+  app;
+  commissioning;
+  log;
+  #appArgs;
+  #hub = new import_async.LineQueue();
+  #docker;
+  #composition;
+  #container;
+  #exit = createExitDeferred();
+  #pump;
+  constructor(app, domain, options, docker = realDockerHandle()) {
+    this.app = app;
+    this.id = domain;
+    this.commissioning = defaultCommissioning();
+    this.log = new import_log_follower.LogFollower(this.#hub.follow(), domain);
+    this.#appArgs = options?.appArgs ?? [];
+    this.#docker = docker;
+  }
+  get pics() {
+    throw new import_file.PicsUnavailableError("No active PICS file for this device");
+  }
+  get exit() {
+    return this.#exit.promise;
+  }
+  async initialize() {
+  }
+  async start() {
+    if (this.#container) {
+      return;
+    }
+    const dbusStatus = await this.#docker.containerStatus(import_config.HARNESS_DBUS_CONTAINER);
+    if (!dbusStatus?.isRunning) {
+      throw new Error(
+        `Cannot start chip-docker cert subject "${this.id}": harness dbus container "${import_config.HARNESS_DBUS_CONTAINER}" is not running. chip-docker subjects reuse the CHIP harness's dbus/mdns sidecars (chip/state.ts's configureContainer) instead of starting their own; start the harness (e.g. via certTest(), which installs State.initialize() as a beforeRun hook) before starting this subject.`
+      );
+    }
+    const platform = import_node_process.env.MATTER_CHIP_PLATFORM || "linux/amd64";
+    const appImage = `${chipImageBase()}-${this.app}:latest`;
+    const volumeName = mdnsVolumeName();
+    await this.#docker.ensureVolume(volumeName);
+    const composition = this.#docker.compose(`cert-${this.app}-${this.id}`, {
+      platform,
+      binds: { [volumeName]: "/run/dbus" },
+      network: "host",
+      autoRemove: true
+    });
+    const args = [
+      "--discriminator",
+      String(this.commissioning.discriminator),
+      "--passcode",
+      String(this.commissioning.passcode),
+      ...TRACE_ARGS,
+      ...this.#appArgs
+    ];
+    const container = await composition.add({
+      name: "app",
+      image: appImage,
+      recreate: true,
+      binds: { [volumeName]: "/run/dbus" },
+      command: args
+    });
+    this.#composition = composition;
+    this.#container = container;
+    this.#exit = createExitDeferred();
+    void this.#trackExit(container);
+    const terminal = await container.attach(import_terminal.Terminal.Line);
+    this.#pump = this.#hub.pump(terminal);
+  }
+  async #trackExit(container) {
+    try {
+      await container.wait();
+      this.#exit.resolve({ code: 0, signal: null });
+    } catch (e) {
+      if (e instanceof import_errors.NonZeroExitError) {
+        this.#exit.resolve({ code: e.code, signal: null });
+      } else {
+        console.warn(`Error waiting for cert device container ${this.id}:`, e);
+        this.#exit.resolve({ code: null, signal: null });
+      }
+    }
+  }
+  async stop() {
+    const container = this.#container;
+    if (!container) {
+      return;
+    }
+    try {
+      await container.kill();
+    } catch {
+    }
+    await this.#exit.promise;
+    await this.#composition?.close();
+    this.#composition = void 0;
+    this.#container = void 0;
+  }
+  async close() {
+    await this.stop();
+    if (this.#pump) {
+      await this.#pump.catch((e) => console.warn("Error reading device output:", e));
+      this.#pump = void 0;
+    }
+    this.#hub.close();
+  }
+  async snapshot() {
+    throwUnsupported(this.flavor, "snapshot/restore");
+  }
+  async restore() {
+    throwUnsupported(this.flavor, "snapshot/restore");
+  }
+  async backchannel() {
+    throwUnsupported(this.flavor, "backchannel simulation");
+  }
+}
+function ChipLocalSubject(app) {
+  return (domain, options) => new ChipLocalDevice(app, domain, options);
+}
+function ChipDockerSubject(app) {
+  return (domain, options) => new ChipDockerDevice(app, domain, options);
+}
+//# sourceMappingURL=chip-app-subject.js.map