@cosmonic-labs/openapi2mcp 0.10.1 → 0.10.2

package/node_modules/@bytecodealliance/preview2-shim/lib/synckit/index.js

@@ -0,0 +1,127 @@
+// Based on: https://github.com/un-ts/synckit
+/*
+MIT License
+
+Copyright (c) 2021 UnTS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+import path from "node:path";
+import {
+  MessageChannel,
+  Worker,
+  receiveMessageOnPort,
+  workerData,
+  parentPort,
+} from "node:worker_threads";
+
+const DEFAULT_WORKER_BUFFER_SIZE = 1024;
+
+function extractProperties(object) {
+  if (object && typeof object === "object") {
+    const properties = {};
+    for (const key in object) {
+      properties[key] = object[key];
+    }
+    return properties;
+  }
+}
+
+const CALL_TIMEOUT = undefined;
+
+export function createSyncFn(workerPath, debug, callbackHandler) {
+  if (!path.isAbsolute(workerPath)) {
+    throw new Error("`workerPath` must be absolute");
+  }
+  const { port1: mainPort, port2: workerPort } = new MessageChannel();
+  const worker = new Worker(workerPath, {
+    workerData: { workerPort, debug },
+    transferList: [workerPort],
+    execArgv: [],
+  });
+  worker.on("message", ({ type, id, payload }) => {
+    if (!type) {
+      throw new Error("Internal error: Expected a type of a worker callback");
+    }
+    callbackHandler(type, id, payload);
+  });
+  let nextID = 0;
+  const syncFn = (...args) => {
+    const cid = nextID++;
+    const sharedBuffer = new SharedArrayBuffer(DEFAULT_WORKER_BUFFER_SIZE);
+    const sharedBufferView = new Int32Array(sharedBuffer);
+    const msg = { sharedBuffer, cid, args };
+    worker.postMessage(msg);
+    const status = Atomics.wait(sharedBufferView, 0, 0, CALL_TIMEOUT);
+    if (!["ok", "not-equal"].includes(status)) {
+      throw new Error("Internal error: Atomics.wait() failed: " + status);
+    }
+    const { cid: cid2, result, error, properties } = receiveMessageOnPort(mainPort).message;
+    if (cid !== cid2) {
+      throw new Error(`Internal error: Expected id ${cid} but got id ${cid2}`);
+    }
+    if (error) {
+      if (error instanceof Error) {
+        throw Object.assign(error, properties);
+      }
+      throw error;
+    }
+    return result;
+  };
+  if (worker.unref) {
+    worker.unref();
+  }
+  return syncFn;
+}
+
+export function runAsWorker(fn) {
+  if (!workerData) {
+    return;
+  }
+  const { workerPort, debug } = workerData;
+  try {
+    parentPort.on("message", ({ sharedBuffer, cid, args }) => {
+      (async () => {
+        const sharedBufferView = new Int32Array(sharedBuffer);
+        let msg;
+        try {
+          msg = { cid, result: await fn(...args) };
+        } catch (error) {
+          msg = { cid, error, properties: extractProperties(error) };
+        }
+        workerPort.postMessage(msg);
+        Atomics.add(sharedBufferView, 0, 1);
+        Atomics.notify(sharedBufferView, 0);
+      })();
+    });
+  } catch (error) {
+    parentPort.on("message", ({ sharedBuffer, cid }) => {
+      const sharedBufferView = new Int32Array(sharedBuffer);
+      workerPort.postMessage({
+        cid,
+        error,
+        properties: extractProperties(error),
+      });
+      Atomics.add(sharedBufferView, 0, 1);
+      Atomics.notify(sharedBufferView, 0);
+    });
+  }
+  return debug;
+}

package/node_modules/@bytecodealliance/preview2-shim/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@bytecodealliance/preview2-shim",
+  "version": "0.18.0",
+  "description": "WASI Preview2 shim for JS environments",
+  "homepage": "https://github.com/bytecodealliance/jco#readme",
+  "bugs": {
+    "url": "https://github.com/bytecodealliance/jco/issues"
+  },
+  "license": "(Apache-2.0 WITH LLVM-exception)",
+  "author": "Guy Bedford, Eduardo Rodrigues<16357187+eduardomourar@users.noreply.github.com>",
+  "contributors": [
+    {
+      "name": "Guy Bedford"
+    },
+    {
+      "name": "Eduardo Rodrigues",
+      "email": "16357187+eduardomourar@users.noreply.github.com"
+    },
+    {
+      "name": "Victor Adossi",
+      "email": "vadossi@cosmonic.com"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bytecodealliance/jco.git"
+  },
+  "files": [
+    "types",
+    "lib"
+  ],
+  "type": "module",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "node": "./lib/nodejs/index.js",
+      "default": "./lib/browser/index.js"
+    },
+    "./*": {
+      "types": "./types/*.d.ts",
+      "node": "./lib/nodejs/*.js",
+      "default": "./lib/browser/*.js"
+    },
+    "./instantiation": {
+      "types": "./types/instantiation.d.ts",
+      "node": "./lib/common/instantiation.js",
+      "default": "./lib/common/instantiation.js"
+    }
+  },
+  "devDependencies": {
+    "@bytecodealliance/componentize-js": "0.21.0",
+    "@bytecodealliance/jco": "1.15.2",
+    "mime": "^4.0.7",
+    "puppeteer": "^24.43.1"
+  },
+  "scripts": {
+    "types:check": "tsc --noEmit",
+    "fmt": "oxfmt",
+    "fmt:check": "oxfmt --check",
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "test": "vitest run -c test/vitest.ts"
+  }
+}

package/node_modules/@bytecodealliance/preview2-shim/types/cli.d.ts

@@ -0,0 +1,11 @@
+export type * as environment from './interfaces/wasi-cli-environment.d.ts';
+export type * as exit from './interfaces/wasi-cli-exit.d.ts';
+export type * as run from './interfaces/wasi-cli-run.d.ts';
+export type * as stderr from './interfaces/wasi-cli-stderr.d.ts';
+export type * as stdin from './interfaces/wasi-cli-stdin.d.ts';
+export type * as stdout from './interfaces/wasi-cli-stdout.d.ts';
+export type * as terminalInput from './interfaces/wasi-cli-terminal-input.d.ts';
+export type * as terminalOutput from './interfaces/wasi-cli-terminal-output.d.ts';
+export type * as terminalStderr from './interfaces/wasi-cli-terminal-stderr.d.ts';
+export type * as terminalStdin from './interfaces/wasi-cli-terminal-stdin.d.ts';
+export type * as terminalStdout from './interfaces/wasi-cli-terminal-stdout.d.ts';

package/node_modules/@bytecodealliance/preview2-shim/types/clocks.d.ts

@@ -0,0 +1,2 @@
+export type * as monotonicClock from './interfaces/wasi-clocks-monotonic-clock.d.ts';
+export type * as wallClock from './interfaces/wasi-clocks-wall-clock.d.ts';

package/node_modules/@bytecodealliance/preview2-shim/types/filesystem.d.ts

@@ -0,0 +1,29 @@
+export type * as preopens from './interfaces/wasi-filesystem-preopens.d.ts';
+export type * as types from './interfaces/wasi-filesystem-types.d.ts';
+
+import type { Descriptor } from './interfaces/wasi-filesystem-types.d.ts';
+
+/**
+ * Replace all preopens with the given set.
+ * @param preopens - Map of virtual paths to host paths
+ */
+export function _setPreopens(preopens: Record<string, string>): void;
+
+/**
+ * Add a single preopen mapping.
+ * @param virtualPath - The virtual path visible to the guest
+ * @param hostPreopen - The host filesystem path
+ */
+export function _addPreopen(virtualPath: string, hostPreopen: string): void;
+
+/**
+ * Clear all preopens, giving the guest no filesystem access.
+ * Call this immediately after import to disable default full filesystem access.
+ */
+export function _clearPreopens(): void;
+
+/**
+ * Get current preopens configuration.
+ * @returns Array of [descriptor, virtualPath] pairs
+ */
+export function _getPreopens(): Array<[Descriptor, string]>;

package/node_modules/@bytecodealliance/preview2-shim/types/http.d.ts

@@ -0,0 +1,3 @@
+export type * as incomingHandler from './interfaces/wasi-http-incoming-handler.d.ts';
+export type * as outgoingHandler from './interfaces/wasi-http-outgoing-handler.d.ts';
+export type * as types from './interfaces/wasi-http-types.d.ts';

package/node_modules/@bytecodealliance/preview2-shim/types/index.d.ts

@@ -0,0 +1,6 @@
+export type * as cli from "./cli.d.ts";
+export type * as clocks from './clocks.d.ts';
+export type * as filesystem from './filesystem.d.ts';
+export type * as http from "./http.d.ts";
+export type * as random from "./random.d.ts";
+export type * as sockets from "./sockets.d.ts";

package/node_modules/@bytecodealliance/preview2-shim/types/instantiation.d.ts

@@ -0,0 +1,199 @@
+/**
+ * Type alias that represents the kind of imports that the average
+ * transpiled Jco component will require.
+ *
+ * For example, `wasi:http/types` and `wasi:http/outgoing-handler` are present due to
+ * the ability for a component to call `fetch()` at any point in time.
+ *
+ * While the feature can be disabled when building with `jco componentize` or `componentize-js`,
+ * by default it is enabled, and as such included here (practically, the implementations can be no-ops).
+ */
+type _WASIImportObject = {
+    'wasi:cli/environment': typeof import('./interfaces/wasi-cli-environment.d.ts');
+    'wasi:cli/exit': typeof import('./interfaces/wasi-cli-exit.d.ts');
+    'wasi:cli/stderr': typeof import('./interfaces/wasi-cli-stderr.d.ts');
+    'wasi:cli/stdin': typeof import('./interfaces/wasi-cli-stdin.d.ts');
+    'wasi:cli/stdout': typeof import('./interfaces/wasi-cli-stdout.d.ts');
+    'wasi:cli/terminal-input': typeof import('./interfaces/wasi-cli-terminal-input.d.ts');
+    'wasi:cli/terminal-output': typeof import('./interfaces/wasi-cli-terminal-output.d.ts');
+    'wasi:cli/terminal-stderr': typeof import('./interfaces/wasi-cli-terminal-stderr.d.ts');
+    'wasi:cli/terminal-stdin': typeof import('./interfaces/wasi-cli-terminal-stdin.d.ts');
+    'wasi:cli/terminal-stdout': typeof import('./interfaces/wasi-cli-terminal-stdout.d.ts');
+
+    'wasi:sockets/instance-network': typeof import('./interfaces/wasi-sockets-instance-network.d.ts');
+    'wasi:sockets/ip-name-lookup': typeof import('./interfaces/wasi-sockets-ip-name-lookup.d.ts');
+    'wasi:sockets/network': typeof import('./interfaces/wasi-sockets-network.d.ts');
+    'wasi:sockets/tcp': typeof import('./interfaces/wasi-sockets-tcp.d.ts');
+    'wasi:sockets/tcp-create-socket': typeof import('./interfaces/wasi-sockets-tcp-create-socket.d.ts');
+    'wasi:sockets/udp': typeof import('./interfaces/wasi-sockets-udp.d.ts');
+    'wasi:sockets/udp-create-socket': typeof import('./interfaces/wasi-sockets-udp-create-socket.d.ts');
+
+    'wasi:filesystem/preopens': typeof import('./interfaces/wasi-filesystem-preopens.d.ts');
+    'wasi:filesystem/types': typeof import('./interfaces/wasi-filesystem-types.d.ts');
+
+    'wasi:io/error': typeof import('./interfaces/wasi-io-error.d.ts');
+    'wasi:io/poll': typeof import('./interfaces/wasi-io-poll.d.ts');
+    'wasi:io/streams': typeof import('./interfaces/wasi-io-streams.d.ts');
+
+    'wasi:random/random': typeof import('./interfaces/wasi-random-random.d.ts');
+    'wasi:random/insecure': typeof import('./interfaces/wasi-random-insecure.d.ts');
+    'wasi:random/insecure-seed': typeof import('./interfaces/wasi-random-insecure-seed.d.ts');
+
+    'wasi:clocks/monotonic-clock': typeof import('./interfaces/wasi-clocks-monotonic-clock.d.ts');
+    'wasi:clocks/wall-clock': typeof import('./interfaces/wasi-clocks-wall-clock.d.ts');
+
+    'wasi:http/types': typeof import('./interfaces/wasi-http-types.d.ts');
+    'wasi:http/outgoing-handler': typeof import('./interfaces/wasi-http-outgoing-handler.d.ts');
+};
+
+type WASIImportObject = VersionedWASIImportObject<''>;
+
+type VersionedWASIImportObject<V extends string> = {
+    [K in keyof _WASIImportObject as AppendVersion<K, V>]: _WASIImportObject[K];
+};
+
+/** Used to append versions to generated WASI import objects */
+type AppendVersion<
+    Key extends string | number | symbol,
+    Version extends string,
+> = Version extends `${infer V}`
+    ? Key extends `${infer K}`
+        ? Key extends ''
+            ? `${K}`
+            : `${K}@${V}`
+        : never
+    : never;
+
+/**
+ * Sandbox configuration options for WASIShim
+ */
+interface SandboxConfig {
+    /** Filesystem preopens mapping (virtual path -> host path) */
+    preopens?: Record<string, string>;
+    /** Environment variables visible to the guest */
+    env?: Record<string, string>;
+    /** Command-line arguments */
+    args?: string[];
+    /** Whether to enable network access (sockets, HTTP). Default: true */
+    enableNetwork?: boolean;
+}
+
+/**
+ * Configuration options for WASIShim
+ */
+interface WASIShimConfig {
+    /** Custom CLI shim */
+    cli?: object;
+    /** Custom filesystem shim */
+    filesystem?: object;
+    /** Custom I/O shim */
+    io?: object;
+    /** Custom random shim */
+    random?: object;
+    /** Custom clocks shim */
+    clocks?: object;
+    /** Custom sockets shim */
+    sockets?: object;
+    /** Custom HTTP shim */
+    http?: object;
+    /** Sandbox configuration for restricting guest capabilities */
+    sandbox?: SandboxConfig;
+}
+
+/**
+ * (EXPERIMENTAL) A class that holds WASI shims and can be used to configure
+ * an instantiation of a WebAssembly component transpiled with jco
+ * (i.e. via `jco transpile`).
+ *
+ * Normally, transpiled components contain mapping for WASI interfaces
+ * and/or imports that import the relevant packages (ex. `@bytecodealliance/preview2-shim/clocks`)
+ * from the right sources.
+ *
+ * This function makes use of the `WASIShim` object to provide an object that can be easily
+ * fed to the `instantiate` function produced by a transpiled component:
+ *
+ * ```js
+ * import { WASIShim } from "@bytecodealliance/preview2-shim/instantiation"
+ * // ...
+ * import { instantiate } from "path/to/transpiled/component.js"
+ * // ...
+ * const component = await instantiate(null, new WASIShim().getImportObject())
+ * ```
+ *
+ * You can also replace imports that you'd like to override with custom implementations,
+ * by using the `WASIShim` object directly:
+ *
+ * ```js
+ * import { random } from "@bytecodealliance/preview2-shim"
+ * import { WASIShim } from "@bytecodealliance/preview2-shim/instantiation"
+ * // ...
+ * import { instantiate } from "path/to/transpiled/component.js"
+ * // ...
+ * const customWASIShim = new WASIShim({
+ *     random: {
+ *         // For these two interfaces we re-use the default provided shim
+ *         random: random.random,
+ *         insecure-seed: random.insecureSeed,
+ *         // For insecure, we can supply our own custom implementation
+ *         insecure: {
+ *             ...
+ *         }
+ *     }
+ * });
+ *
+ * const component = await instantiate(null, customWASIShim.getImportObject())
+ * ```
+ *
+ * For sandboxing, you can configure preopens, environment variables, and other
+ * capabilities via the `sandbox` option:
+ *
+ * ```js
+ * import { WASIShim } from "@bytecodealliance/preview2-shim/instantiation"
+ *
+ * // Fully sandboxed - no filesystem, network, or env access
+ * const sandboxedShim = new WASIShim({
+ *     sandbox: {
+ *         preopens: {},           // No filesystem access
+ *         env: {},                // No environment variables
+ *         args: ['program'],      // Custom arguments
+ *         enableNetwork: false,   // Disable network
+ *     }
+ * });
+ *
+ * // Limited filesystem access
+ * const limitedShim = new WASIShim({
+ *     sandbox: {
+ *         preopens: {
+ *             '/data': '/tmp/guest-data',  // Guest sees /data, maps to /tmp/guest-data
+ *             '/config': '/etc/app'        // Guest sees /config, maps to /etc/app
+ *         }
+ *     }
+ * });
+ * ```
+ *
+ * Note that this object is similar but not identical to the Node `WASI` object --
+ * it is solely concerned with shimming of preview2 when dealing with a WebAssembly
+ * component transpiled by Jco. While this object *does* work with Node (and the browser)
+ * semantics are not the same as Node's `WASI` object.
+ *
+ * @class WASIShim
+ */
+export class WASIShim {
+    constructor(config?: WASIShimConfig);
+
+    /**
+     * Generate an import object for the shim that can be used with
+     * functions like `instantiate` that are exposed from a transpiled
+     * WebAssembly component.
+     *
+     * @param {options} [opt]
+     * @returns {object}
+     */
+    getImportObject<V extends string = ''>(
+        opts?: GetImportObjectArgs
+    ): VersionedWASIImportObject<V>;
+}
+
+interface GetImportObjectArgs {
+    asVersion?: string;
+}

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-cli-environment.d.ts

@@ -0,0 +1,21 @@
+/** @module Interface wasi:cli/environment@0.2.3 **/
+/**
+ * Get the POSIX-style environment variables.
+ * 
+ * Each environment variable is provided as a pair of string variable names
+ * and string value.
+ * 
+ * Morally, these are a value import, but until value imports are available
+ * in the component model, this import function should return the same
+ * values each time it is called.
+ */
+export function getEnvironment(): Array<[string, string]>;
+/**
+ * Get the POSIX-style arguments to the program.
+ */
+export function getArguments(): Array<string>;
+/**
+ * Return a path that programs should use as their initial current working
+ * directory, interpreting `.` as shorthand for this.
+ */
+export function initialCwd(): string | undefined;

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-cli-exit.d.ts

@@ -0,0 +1,6 @@
+/** @module Interface wasi:cli/exit@0.2.3 **/
+/**
+ * Exit the current instance and any linked instances.
+ */
+export function exit(status: Result<void, void>): void;
+export type Result<T, E> = { tag: 'ok', val: T } | { tag: 'err', val: E };

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-cli-run.d.ts

@@ -0,0 +1,5 @@
+/** @module Interface wasi:cli/run@0.2.3 **/
+/**
+ * Run the program.
+ */
+export function run(): void;

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-cli-stderr.d.ts

@@ -0,0 +1,3 @@
+/** @module Interface wasi:cli/stderr@0.2.3 **/
+export function getStderr(): OutputStream;
+export type OutputStream = import('./wasi-io-streams.js').OutputStream;

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-cli-stdin.d.ts

@@ -0,0 +1,3 @@
+/** @module Interface wasi:cli/stdin@0.2.3 **/
+export function getStdin(): InputStream;
+export type InputStream = import('./wasi-io-streams.js').InputStream;

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-cli-stdout.d.ts

@@ -0,0 +1,3 @@
+/** @module Interface wasi:cli/stdout@0.2.3 **/
+export function getStdout(): OutputStream;
+export type OutputStream = import('./wasi-io-streams.js').OutputStream;

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-cli-terminal-input.d.ts

@@ -0,0 +1,8 @@
+/** @module Interface wasi:cli/terminal-input@0.2.3 **/
+
+export class TerminalInput {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+}

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-cli-terminal-output.d.ts

@@ -0,0 +1,8 @@
+/** @module Interface wasi:cli/terminal-output@0.2.3 **/
+
+export class TerminalOutput {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+}

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-cli-terminal-stderr.d.ts

@@ -0,0 +1,7 @@
+/** @module Interface wasi:cli/terminal-stderr@0.2.3 **/
+/**
+ * If stderr is connected to a terminal, return a `terminal-output` handle
+ * allowing further interaction with it.
+ */
+export function getTerminalStderr(): TerminalOutput | undefined;
+export type TerminalOutput = import('./wasi-cli-terminal-output.js').TerminalOutput;

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-cli-terminal-stdin.d.ts

@@ -0,0 +1,7 @@
+/** @module Interface wasi:cli/terminal-stdin@0.2.3 **/
+/**
+ * If stdin is connected to a terminal, return a `terminal-input` handle
+ * allowing further interaction with it.
+ */
+export function getTerminalStdin(): TerminalInput | undefined;
+export type TerminalInput = import('./wasi-cli-terminal-input.js').TerminalInput;

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-cli-terminal-stdout.d.ts

@@ -0,0 +1,7 @@
+/** @module Interface wasi:cli/terminal-stdout@0.2.3 **/
+/**
+ * If stdout is connected to a terminal, return a `terminal-output` handle
+ * allowing further interaction with it.
+ */
+export function getTerminalStdout(): TerminalOutput | undefined;
+export type TerminalOutput = import('./wasi-cli-terminal-output.js').TerminalOutput;

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-clocks-monotonic-clock.d.ts

@@ -0,0 +1,34 @@
+/** @module Interface wasi:clocks/monotonic-clock@0.2.3 **/
+/**
+ * Read the current value of the clock.
+ * 
+ * The clock is monotonic, therefore calling this function repeatedly will
+ * produce a sequence of non-decreasing values.
+ */
+export function now(): Instant;
+/**
+ * Query the resolution of the clock. Returns the duration of time
+ * corresponding to a clock tick.
+ */
+export function resolution(): Duration;
+/**
+ * Create a `pollable` which will resolve once the specified instant
+ * has occurred.
+ */
+export function subscribeInstant(when: Instant): Pollable;
+/**
+ * Create a `pollable` that will resolve after the specified duration has
+ * elapsed from the time this function is invoked.
+ */
+export function subscribeDuration(when: Duration): Pollable;
+export type Pollable = import('./wasi-io-poll.js').Pollable;
+/**
+ * An instant in time, in nanoseconds. An instant is relative to an
+ * unspecified initial value, and can only be compared to instances from
+ * the same monotonic-clock.
+ */
+export type Instant = bigint;
+/**
+ * A duration of time, in nanoseconds.
+ */
+export type Duration = bigint;

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-clocks-wall-clock.d.ts

@@ -0,0 +1,30 @@
+/** @module Interface wasi:clocks/wall-clock@0.2.3 **/
+/**
+ * Read the current value of the clock.
+ * 
+ * This clock is not monotonic, therefore calling this function repeatedly
+ * will not necessarily produce a sequence of non-decreasing values.
+ * 
+ * The returned timestamps represent the number of seconds since
+ * 1970-01-01T00:00:00Z, also known as [POSIX's Seconds Since the Epoch],
+ * also known as [Unix Time].
+ * 
+ * The nanoseconds field of the output is always less than 1000000000.
+ * 
+ * [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16
+ * [Unix Time]: https://en.wikipedia.org/wiki/Unix_time
+ */
+export function now(): Datetime;
+/**
+ * Query the resolution of the clock.
+ * 
+ * The nanoseconds field of the output is always less than 1000000000.
+ */
+export function resolution(): Datetime;
+/**
+ * A time and date in seconds plus nanoseconds.
+ */
+export interface Datetime {
+  seconds: bigint,
+  nanoseconds: number,
+}

package/node_modules/@bytecodealliance/preview2-shim/types/interfaces/wasi-filesystem-preopens.d.ts

@@ -0,0 +1,6 @@
+/** @module Interface wasi:filesystem/preopens@0.2.3 **/
+/**
+ * Return the set of preopened directories, and their paths.
+ */
+export function getDirectories(): Array<[Descriptor, string]>;
+export type Descriptor = import('./wasi-filesystem-types.js').Descriptor;