@matter/nodejs 0.11.0-alpha.0-20241005-e3e4e4a7a

package/dist/cjs/environment/NodeJsActionTracer.js

@@ -0,0 +1,80 @@
+"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 NodeJsActionTracer_exports = {};
+__export(NodeJsActionTracer_exports, {
+  NodeJsActionTracer: () => NodeJsActionTracer
+});
+module.exports = __toCommonJS(NodeJsActionTracer_exports);
+var import_general = require("#general");
+var import_node = require("#node");
+var import_promises = require("fs/promises");
+var import_path = require("path");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class NodeJsActionTracer extends import_node.ActionTracer {
+  #path;
+  #output;
+  #write;
+  constructor(path) {
+    super();
+    this.#path = path;
+  }
+  static configure(env) {
+    env.vars.use(() => {
+      if (env.has(import_node.ActionTracer)) {
+        env.delete(env.get(import_node.ActionTracer).constructor);
+      }
+      if (!env.vars.boolean("trace.enable")) {
+        return;
+      }
+      const path = (0, import_path.resolve)(env.vars.get("path.root", "."), env.vars.get("trace.path", "trace.jsonl"));
+      const tracer = new NodeJsActionTracer(path);
+      env.set(import_node.ActionTracer, tracer);
+      env.runtime.add(tracer);
+    });
+  }
+  [Symbol.asyncDispose]() {
+    import_general.MaybePromise.then(this.#write, () => this.#output?.close());
+  }
+  record(action) {
+    const raw = {
+      ...action,
+      path: action.path?.toString(false),
+      mutations: action.mutations ? action.mutations.map((m) => ({ ...m, path: m.path.toString(false) })) : void 0
+    };
+    this.#write = import_general.MaybePromise.then(this.#write, () => this.#record(raw));
+  }
+  async #record(action) {
+    if (this.#output === void 0) {
+      this.#output = await (0, import_promises.open)(this.#path, "w");
+    }
+    await this.#output.write(JSON.stringify(action, replacer));
+    await this.#output.write("\n");
+  }
+}
+function replacer(_key, value) {
+  if (typeof value === "bigint" || ArrayBuffer.isView(value)) {
+    return (0, import_general.serialize)(value);
+  }
+  return value;
+}
+//# sourceMappingURL=NodeJsActionTracer.js.map

package/dist/cjs/environment/NodeJsActionTracer.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/environment/NodeJsActionTracer.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,qBAAqD;AACrD,kBAA6B;AAC7B,sBAAiC;AACjC,kBAAwB;AATxB;AAAA;AAAA;AAAA;AAAA;AAWO,MAAM,2BAA2B,yBAAa;AAAA,EACjD;AAAA,EACA;AAAA,EACA;AAAA,EAEA,YAAY,MAAc;AACtB,UAAM;AAEN,SAAK,QAAQ;AAAA,EACjB;AAAA,EAEA,OAAO,UAAU,KAAkB;AAC/B,QAAI,KAAK,IAAI,MAAM;AACf,UAAI,IAAI,IAAI,wBAAY,GAAG;AACvB,YAAI,OAAO,IAAI,IAAI,wBAAY,EAAE,WAAqC;AAAA,MAC1E;AAEA,UAAI,CAAC,IAAI,KAAK,QAAQ,cAAc,GAAG;AACnC;AAAA,MACJ;AAEA,YAAM,WAAO,qBAAQ,IAAI,KAAK,IAAI,aAAa,GAAG,GAAG,IAAI,KAAK,IAAI,cAAc,aAAa,CAAC;AAE9F,YAAM,SAAS,IAAI,mBAAmB,IAAI;AAC1C,UAAI,IAAI,0BAAc,MAAM;AAC5B,UAAI,QAAQ,IAAI,MAAM;AAAA,IAC1B,CAAC;AAAA,EACL;AAAA,EAEA,CAAC,OAAO,YAAY,IAAI;AACpB,gCAAa,KAAK,KAAK,QAAQ,MAAM,KAAK,SAAS,MAAM,CAAC;AAAA,EAC9D;AAAA,EAES,OAAO,QAA6B;AACzC,UAAM,MAAM;AAAA,MACR,GAAG;AAAA,MACH,MAAM,OAAO,MAAM,SAAS,KAAK;AAAA,MACjC,WAAW,OAAO,YACZ,OAAO,UAAU,IAAI,QAAM,EAAE,GAAG,GAAG,MAAM,EAAE,KAAK,SAAS,KAAK,EAAE,EAAE,IAClE;AAAA,IACV;AACA,SAAK,SAAS,4BAAa,KAAK,KAAK,QAAQ,MAAM,KAAK,QAAQ,GAAG,CAAC;AAAA,EACxE;AAAA,EAEA,MAAM,QAAQ,QAAgB;AAC1B,QAAI,KAAK,YAAY,QAAW;AAC5B,WAAK,UAAU,UAAM,sBAAK,KAAK,OAAO,GAAG;AAAA,IAC7C;AACA,UAAM,KAAK,QAAQ,MAAM,KAAK,UAAU,QAAQ,QAAQ,CAAC;AACzD,UAAM,KAAK,QAAQ,MAAM,IAAI;AAAA,EACjC;AACJ;AAEA,SAAS,SAAS,MAAc,OAAY;AACxC,MAAI,OAAO,UAAU,YAAY,YAAY,OAAO,KAAK,GAAG;AACxD,eAAO,0BAAU,KAAK;AAAA,EAC1B;AACA,SAAO;AACX;",
+  "names": []
+}

package/dist/cjs/environment/NodeJsEnvironment.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Environment, VariableService } from "#general";
+/**
+ * This is the default environment implementation for Node.js:
+ *
+ *   - Sets variables using rudimentary command line, environment and configuration file parsers.
+ *
+ *   - Processes UNIX-style signals and sets process exit codes via {@link ProcessManager}
+ *
+ *   - Creates a default storage pool using the loaded configuration.
+ *
+ * You can modify this behavior:
+ *
+ *   - Via configuration
+ *
+ *   - By modifying {@link Environment.default}
+ *
+ *   - By providing an {@link Environment} to your components other than {@link Environment.default}
+ *
+ * The settings are applied in this order (the higher numbers overwrite lower numbers):
+ * 1. Some internal Defaults (mainly Loglevel and such)
+ * 2. Config file
+ * 3. Environment variables (MATTER_*)
+ * 4. Command line parameters
+ *
+ * The following variables are defined by this class additionally to {@link Environment}:
+ * * `environment` - Name of the environment, Default "default"
+ * * `path.root` - Path considered as root for any files to store, Fallback: ".", Default: APPDATA/.matter (Windows), HOME/.matter else (or .matter-<envname>)
+ * * `path.config` - Path to config file, Default: "config.json"
+ * * `trace.path` - Path of the trace file to write, Default: "trace.jsonl" relative to path.root
+ * * `trace.enable` - Enable writing a trace file
+ * * `storage.path` - Where to store storage files, Default: "path.root"
+ * * `storage.clear` - Clear storage on start? Default: false
+ * * `runtime.signals` - By default register SIGINT and SIGUSR2 (diag) handlers, set to false if not wanted
+ * * `runtime.exitcode` - By default we set the process.exitcode to 0 (ok) or 1 (crash); set to false to disable
+ * * `runtime.unhandlederrors` - By default we log unhandled errors to matter.js log; set to false to disable
+ */
+export declare function NodeJsEnvironment(): Environment;
+export declare function loadConfigFile(vars: VariableService): any;
+export declare function getDefaults(vars: VariableService): {
+    environment: "default";
+    path: {
+        root: string;
+        config: string;
+    };
+    runtime: {
+        signals: boolean;
+        exitcode: boolean;
+    };
+};
+//# sourceMappingURL=NodeJsEnvironment.d.ts.map

package/dist/cjs/environment/NodeJsEnvironment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeJsEnvironment.d.ts","sourceRoot":"","sources":["../../../src/environment/NodeJsEnvironment.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACH,WAAW,EAMX,eAAe,EAClB,MAAM,UAAU,CAAC;AAQlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,iBAAiB,gBAkBhC;AAyCD,wBAAgB,cAAc,CAAC,IAAI,EAAE,eAAe,OAsBnD;AAiBD,wBAAgB,WAAW,CAAC,IAAI,EAAE,eAAe;;;;;;;;;;EAgBhD"}

package/dist/cjs/environment/NodeJsEnvironment.js

@@ -0,0 +1,121 @@
+"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 NodeJsEnvironment_exports = {};
+__export(NodeJsEnvironment_exports, {
+  NodeJsEnvironment: () => NodeJsEnvironment,
+  getDefaults: () => getDefaults,
+  loadConfigFile: () => loadConfigFile
+});
+module.exports = __toCommonJS(NodeJsEnvironment_exports);
+var import_general = require("#general");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_NodeJsNetwork = require("../net/NodeJsNetwork.js");
+var import_StorageBackendDisk = require("../storage/StorageBackendDisk.js");
+var import_NodeJsActionTracer = require("./NodeJsActionTracer.js");
+var import_ProcessManager = require("./ProcessManager.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function NodeJsEnvironment() {
+  const env = new import_general.Environment("default");
+  loadVariables(env);
+  configureRuntime(env);
+  configureStorage(env);
+  configureNetwork(env);
+  if (!env.vars.has("logger.format") && import_general.Logger.format === import_general.LogFormat.PLAIN && process.stdin?.isTTY) {
+    env.vars.set("logger.format", import_general.LogFormat.ANSI);
+  }
+  import_NodeJsActionTracer.NodeJsActionTracer.configure(env);
+  return env;
+}
+function loadVariables(env) {
+  const vars = env.vars;
+  vars.addConfigStyle(getDefaults(vars));
+  vars.addUnixEnvStyle(process.env);
+  vars.addArgvStyle(process.argv);
+  vars.addConfigStyle(loadConfigFile(vars));
+  vars.addUnixEnvStyle(process.env);
+  vars.addArgvStyle(process.argv);
+}
+function configureRuntime(env) {
+  const processManager = new import_ProcessManager.ProcessManager(env);
+  env.set(import_ProcessManager.ProcessManager, processManager);
+}
+function configureStorage(env) {
+  const service = env.get(import_general.StorageService);
+  env.vars.use(() => {
+    const location = env.vars.get("storage.path", env.vars.get("path.root", "."));
+    service.location = location;
+  });
+  service.factory = (namespace) => new import_StorageBackendDisk.StorageBackendDisk((0, import_path.resolve)(service.location ?? ".", namespace), env.vars.get("storage.clear", false));
+}
+function configureNetwork(env) {
+  env.set(import_general.Network, new import_NodeJsNetwork.NodeJsNetwork());
+}
+function loadConfigFile(vars) {
+  const path = vars.get("path.config", "config.json");
+  if (!(0, import_fs.existsSync)(path)) {
+    return {};
+  }
+  let configJson;
+  try {
+    configJson = (0, import_fs.readFileSync)(path).toString();
+  } catch (e) {
+    throw new import_general.ImplementationError(`Error reading configuration file ${path}: ${e.message}`);
+  }
+  let configVars;
+  try {
+    configVars = JSON.parse(configJson);
+  } catch (e) {
+    throw new import_general.ImplementationError(`Error parsing configuration file ${path}: ${e.message}`);
+  }
+  return configVars;
+}
+function getDefaultRoot(envName) {
+  let matterDir;
+  if (process.platform === "win32") {
+    matterDir = (0, import_path.resolve)(process.env.APPDATA ?? ".", "matter");
+  } else {
+    matterDir = (0, import_path.resolve)(process.env.HOME ?? ".", ".matter");
+  }
+  if (envName !== "default") {
+    matterDir = `${matterDir}-${envName}`;
+  }
+  return matterDir;
+}
+function getDefaults(vars) {
+  const envName = vars.get("environment", "default");
+  const rootPath = vars.get("path.root", getDefaultRoot(envName));
+  const configPath = (0, import_path.resolve)(rootPath, vars.get("path.config", "config.json"));
+  return {
+    environment: envName,
+    path: {
+      root: rootPath,
+      config: configPath
+    },
+    runtime: {
+      signals: true,
+      exitcode: true
+    }
+  };
+}
+//# sourceMappingURL=NodeJsEnvironment.js.map

package/dist/cjs/environment/NodeJsEnvironment.js.map

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

package/dist/cjs/environment/ProcessManager.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Destructable, Environment, RuntimeService } from "#general";
+/**
+ * ProcessManager watches Node.js signals SIGINT and SIGUSR2 to terminate the Matter.js runtime and trigger Matter.js
+ * diagnostics respectively.  It sets the process exit code to 0 if the runtime completes without error and to 1 if the
+ * runtime crashes.
+ *
+ * If enabled, SIGINT will perform a soft interrupt of the runtime once.  ProcessManager will not process subsequent
+ * interrupts so they will result in forced exit if no other handler exists.
+ *
+ * {@link NodeJsEnvironment} installs a ProcessManager into the default Matter.js {@link Environment}.
+ *
+ * You can modify behavior by:
+ *
+ *   - Passing an {@link Environment} other than {@link Environment.default} to your components
+ *
+ *   - Disabling signal and exit code support with {@link VariableService} variables "runtime.signals" and
+ *     "runtime.exitcode" respectively
+ *
+ *   - Destroying ProcessManager in the default environment using {@link ProcessManager.close}
+ *
+ *   - Subclassing ProcessManager, overriding specific functionality, and installing with {@link Environment.set}
+ */
+export declare class ProcessManager implements Destructable {
+    #private;
+    protected env: Environment;
+    protected runtime: RuntimeService;
+    constructor(env: Environment);
+    close(): void;
+    [Symbol.dispose](): void;
+    protected get hasSignalSupport(): true;
+    protected get hasExitCodeSupport(): true;
+    protected get hasUnhandledErrorSupport(): true;
+    protected startListener: () => void;
+    protected stopListener: () => void;
+    protected crashListener: () => void;
+    protected interruptHandler: (signal: string) => void;
+    protected exitHandler: () => void;
+    protected diagnosticHandler: () => void;
+}
+//# sourceMappingURL=ProcessManager.d.ts.map

package/dist/cjs/environment/ProcessManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProcessManager.d.ts","sourceRoot":"","sources":["../../../src/environment/ProcessManager.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,YAAY,EAAE,WAAW,EAAU,cAAc,EAAmB,MAAM,UAAU,CAAC;AAK9F;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,cAAe,YAAW,YAAY;;IAInC,SAAS,CAAC,GAAG,EAAE,WAAW;IAHtC,SAAS,CAAC,OAAO,EAAE,cAAc,CAAC;gBAGZ,GAAG,EAAE,WAAW;IActC,KAAK;IAOL,CAAC,MAAM,CAAC,OAAO,CAAC;IAIhB,SAAS,KAAK,gBAAgB,SAE7B;IAED,SAAS,KAAK,kBAAkB,SAE/B;IAED,SAAS,KAAK,wBAAwB,SAErC;IAED,SAAS,CAAC,aAAa,aAcrB;IAEF,SAAS,CAAC,YAAY,aAMpB;IAEF,SAAS,CAAC,aAAa,aAIrB;IAEF,SAAS,CAAC,gBAAgB,WAAY,MAAM,UAG1C;IAEF,SAAS,CAAC,WAAW,aAInB;IAEF,SAAS,CAAC,iBAAiB,aAEzB;CAWL"}

package/dist/cjs/environment/ProcessManager.js

@@ -0,0 +1,112 @@
+"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 ProcessManager_exports = {};
+__export(ProcessManager_exports, {
+  ProcessManager: () => ProcessManager
+});
+module.exports = __toCommonJS(ProcessManager_exports);
+var import_general = require("#general");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = import_general.Logger.get("ProcessManager");
+class ProcessManager {
+  constructor(env) {
+    this.env = env;
+    this.runtime = env.get(import_general.RuntimeService);
+    this.runtime.started.on(this.startListener);
+    this.runtime.stopped.on(this.stopListener);
+    this.runtime.crashed.on(this.crashListener);
+    if (this.hasUnhandledErrorSupport) {
+      process.addListener("uncaughtExceptionMonitor", (event) => {
+        import_general.Logger.reportUnhandledError(event);
+      });
+    }
+  }
+  runtime;
+  #signalHandlersInstalled = false;
+  close() {
+    this.runtime.started.off(this.startListener);
+    this.runtime.stopped.off(this.stopListener);
+    this.runtime.crashed.off(this.crashListener);
+    this.#ignoreSignals();
+  }
+  [Symbol.dispose]() {
+    this.close();
+  }
+  get hasSignalSupport() {
+    return this.env.vars.get("runtime.signals", true);
+  }
+  get hasExitCodeSupport() {
+    return this.env.vars.get("runtime.exitcode", true);
+  }
+  get hasUnhandledErrorSupport() {
+    return this.env.vars.get("runtime.unhandlederrors", true);
+  }
+  startListener = () => {
+    this.env.vars.use(() => {
+      if (this.hasSignalSupport) {
+        if (this.#signalHandlersInstalled) {
+          return;
+        }
+        process.on("SIGINT", this.interruptHandler);
+        process.on("SIGTERM", this.interruptHandler);
+        process.on("SIGUSR2", this.diagnosticHandler);
+        process.on("exit", this.exitHandler);
+      } else {
+        this.#ignoreSignals();
+      }
+    });
+  };
+  stopListener = () => {
+    this.#ignoreSignals();
+    if (this.hasExitCodeSupport && process.exitCode === void 0) {
+      process.exitCode = 0;
+    }
+  };
+  crashListener = () => {
+    if (this.hasExitCodeSupport) {
+      process.exitCode = 1;
+    }
+  };
+  interruptHandler = (signal) => {
+    process.off(signal, this.interruptHandler);
+    this.runtime.cancel();
+  };
+  exitHandler = () => {
+    if (process.exitCode === 13) {
+      logger.error("Internal error: Premature process exit because ongoing work has stalled");
+    }
+  };
+  diagnosticHandler = () => {
+    this.env.diagnose();
+  };
+  #ignoreSignals() {
+    if (this.#signalHandlersInstalled) {
+      process.off("SIGINT", this.interruptHandler);
+      process.off("SIGTERM", this.interruptHandler);
+      process.off("SIGUSR2", this.diagnosticHandler);
+      process.off("exit", this.exitHandler);
+      this.#signalHandlersInstalled = false;
+    }
+  }
+}
+//# sourceMappingURL=ProcessManager.js.map

package/dist/cjs/environment/ProcessManager.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/environment/ProcessManager.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,qBAAmF;AANnF;AAAA;AAAA;AAAA;AAAA;AASA,MAAM,SAAS,sBAAO,IAAI,gBAAgB;AAuBnC,MAAM,eAAuC;AAAA,EAIhD,YAAsB,KAAkB;AAAlB;AAClB,SAAK,UAAU,IAAI,IAAI,6BAAc;AAErC,SAAK,QAAQ,QAAQ,GAAG,KAAK,aAAa;AAC1C,SAAK,QAAQ,QAAQ,GAAG,KAAK,YAAY;AACzC,SAAK,QAAQ,QAAQ,GAAG,KAAK,aAAa;AAE1C,QAAI,KAAK,0BAA0B;AAC/B,cAAQ,YAAY,4BAA4B,WAAS;AACrD,8BAAO,qBAAqB,KAAK;AAAA,MACrC,CAAC;AAAA,IACL;AAAA,EACJ;AAAA,EAfU;AAAA,EACV,2BAA2B;AAAA,EAgB3B,QAAQ;AACJ,SAAK,QAAQ,QAAQ,IAAI,KAAK,aAAa;AAC3C,SAAK,QAAQ,QAAQ,IAAI,KAAK,YAAY;AAC1C,SAAK,QAAQ,QAAQ,IAAI,KAAK,aAAa;AAC3C,SAAK,eAAe;AAAA,EACxB;AAAA,EAEA,CAAC,OAAO,OAAO,IAAI;AACf,SAAK,MAAM;AAAA,EACf;AAAA,EAEA,IAAc,mBAAmB;AAC7B,WAAO,KAAK,IAAI,KAAK,IAAI,mBAAmB,IAAI;AAAA,EACpD;AAAA,EAEA,IAAc,qBAAqB;AAC/B,WAAO,KAAK,IAAI,KAAK,IAAI,oBAAoB,IAAI;AAAA,EACrD;AAAA,EAEA,IAAc,2BAA2B;AACrC,WAAO,KAAK,IAAI,KAAK,IAAI,2BAA2B,IAAI;AAAA,EAC5D;AAAA,EAEU,gBAAgB,MAAM;AAC5B,SAAK,IAAI,KAAK,IAAI,MAAM;AACpB,UAAI,KAAK,kBAAkB;AACvB,YAAI,KAAK,0BAA0B;AAC/B;AAAA,QACJ;AACA,gBAAQ,GAAG,UAAU,KAAK,gBAAgB;AAC1C,gBAAQ,GAAG,WAAW,KAAK,gBAAgB;AAC3C,gBAAQ,GAAG,WAAW,KAAK,iBAAiB;AAC5C,gBAAQ,GAAG,QAAQ,KAAK,WAAW;AAAA,MACvC,OAAO;AACH,aAAK,eAAe;AAAA,MACxB;AAAA,IACJ,CAAC;AAAA,EACL;AAAA,EAEU,eAAe,MAAM;AAC3B,SAAK,eAAe;AAEpB,QAAI,KAAK,sBAAsB,QAAQ,aAAa,QAAW;AAC3D,cAAQ,WAAW;AAAA,IACvB;AAAA,EACJ;AAAA,EAEU,gBAAgB,MAAM;AAC5B,QAAI,KAAK,oBAAoB;AACzB,cAAQ,WAAW;AAAA,IACvB;AAAA,EACJ;AAAA,EAEU,mBAAmB,CAAC,WAAmB;AAC7C,YAAQ,IAAI,QAAQ,KAAK,gBAAgB;AACzC,SAAK,QAAQ,OAAO;AAAA,EACxB;AAAA,EAEU,cAAc,MAAM;AAC1B,QAAI,QAAQ,aAAa,IAAI;AACzB,aAAO,MAAM,yEAAyE;AAAA,IAC1F;AAAA,EACJ;AAAA,EAEU,oBAAoB,MAAM;AAChC,SAAK,IAAI,SAAS;AAAA,EACtB;AAAA,EAEA,iBAAiB;AACb,QAAI,KAAK,0BAA0B;AAC/B,cAAQ,IAAI,UAAU,KAAK,gBAAgB;AAC3C,cAAQ,IAAI,WAAW,KAAK,gBAAgB;AAC5C,cAAQ,IAAI,WAAW,KAAK,iBAAiB;AAC7C,cAAQ,IAAI,QAAQ,KAAK,WAAW;AACpC,WAAK,2BAA2B;AAAA,IACpC;AAAA,EACJ;AACJ;",
+  "names": []
+}

package/dist/cjs/environment/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import "./register.js";
+export * from "./NodeJsActionTracer.js";
+export * from "./NodeJsEnvironment.js";
+export * from "./ProcessManager.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/environment/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/environment/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,eAAe,CAAC;AACvB,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC"}

package/dist/cjs/environment/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var environment_exports = {};
+module.exports = __toCommonJS(environment_exports);
+var import_register = require("./register.js");
+__reExport(environment_exports, require("./NodeJsActionTracer.js"), module.exports);
+__reExport(environment_exports, require("./NodeJsEnvironment.js"), module.exports);
+__reExport(environment_exports, require("./ProcessManager.js"), module.exports);
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+//# sourceMappingURL=index.js.map

package/dist/cjs/environment/index.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/environment/index.ts"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAMA,sBAAO;AACP,gCAAc,oCAPd;AAQA,gCAAc,mCARd;AASA,gCAAc,gCATd;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}

package/dist/cjs/environment/register.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};
+//# sourceMappingURL=register.d.ts.map

package/dist/cjs/environment/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../src/environment/register.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/cjs/environment/register.js

@@ -0,0 +1,10 @@
+"use strict";
+var import_general = require("#general");
+var import_NodeJsEnvironment = require("./NodeJsEnvironment.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import_general.Environment.default = (0, import_NodeJsEnvironment.NodeJsEnvironment)();
+//# sourceMappingURL=register.js.map

package/dist/cjs/environment/register.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/environment/register.ts"],
+  "mappings": ";AAMA,qBAA4B;AAC5B,+BAAkC;AAPlC;AAAA;AAAA;AAAA;AAAA;AASA,2BAAY,cAAU,4CAAkB;",
+  "names": []
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./behavior/index.js";
+export * from "./crypto/index.js";
+export * from "./environment/index.js";
+export * from "./log/index.js";
+export * from "./net/index.js";
+export * from "./storage/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC"}

package/dist/cjs/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./behavior/index.js"), module.exports);
+__reExport(src_exports, require("./crypto/index.js"), module.exports);
+__reExport(src_exports, require("./environment/index.js"), module.exports);
+__reExport(src_exports, require("./log/index.js"), module.exports);
+__reExport(src_exports, require("./net/index.js"), module.exports);
+__reExport(src_exports, require("./storage/index.js"), module.exports);
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAMA,wBAAc,gCANd;AAOA,wBAAc,8BAPd;AAQA,wBAAc,mCARd;AASA,wBAAc,2BATd;AAUA,wBAAc,2BAVd;AAWA,wBAAc,+BAXd;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}

package/dist/cjs/log/FileLogger.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { LogLevel } from "#general";
+/**
+ * Creates a file based logger to append to the given path.
+ * The file is opened on start and closed when the process shuts down.
+ * Errors are logged to the console.
+ */
+export declare function createFileLogger(path: string): Promise<(_level: LogLevel, formattedLog: string) => void>;
+//# sourceMappingURL=FileLogger.d.ts.map

package/dist/cjs/log/FileLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileLogger.d.ts","sourceRoot":"","sources":["../../../src/log/FileLogger.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGpC;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,oBAQ/B,QAAQ,gBAAgB,MAAM,WAOjD"}

package/dist/cjs/log/FileLogger.js

@@ -0,0 +1,46 @@
+"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 FileLogger_exports = {};
+__export(FileLogger_exports, {
+  createFileLogger: () => createFileLogger
+});
+module.exports = __toCommonJS(FileLogger_exports);
+var import_promises = require("fs/promises");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+async function createFileLogger(path) {
+  const fileHandle = await (0, import_promises.open)(path, "a");
+  const writer = fileHandle.createWriteStream();
+  process.on(
+    "beforeExit",
+    () => void fileHandle.close().catch((err) => err && console.error(`Failed to close log file: ${err}`))
+  );
+  return (_level, formattedLog) => {
+    try {
+      writer.write(`${formattedLog}
+`);
+    } catch (error) {
+      console.error(`Failed to write to log file: ${error}`);
+    }
+  };
+}
+//# sourceMappingURL=FileLogger.js.map