@bytecodealliance/preview2-shim 0.17.1 → 0.17.3

package/types/interfaces/wasi-clocks-monotonic-clock.d.ts

@@ -1,29 +1,27 @@
-export namespace WasiClocksMonotonicClock {
-  /**
-   * 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;
-}
-import type { Pollable } from './wasi-io-poll.js';
-export { Pollable };
+/** @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

package/types/interfaces/wasi-clocks-wall-clock.d.ts

@@ -1,27 +1,26 @@
-export namespace WasiClocksWallClock {
-  /**
-   * 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;
-}
+/** @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.
  */

package/types/interfaces/wasi-filesystem-preopens.d.ts

@@ -1,8 +1,6 @@
-export namespace WasiFilesystemPreopens {
-  /**
-   * Return the set of preopened directories, and their path.
-   */
-  export function getDirectories(): Array<[Descriptor, string]>;
-}
-import type { Descriptor } from './wasi-filesystem-types.js';
-export { Descriptor };
+/** @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;

package/types/interfaces/wasi-filesystem-types.d.ts

@@ -1,28 +1,21 @@
-export namespace WasiFilesystemTypes {
-  export { Descriptor };
-  export { DirectoryEntryStream };
-  /**
-   * Attempts to extract a filesystem-related `error-code` from the stream
-   * `error` provided.
-   * 
-   * Stream operations which return `stream-error::last-operation-failed`
-   * have a payload with more information about the operation that failed.
-   * This payload can be passed through to this function to see if there's
-   * filesystem-related information about the error to return.
-   * 
-   * Note that this function is fallible because not all stream-related
-   * errors are filesystem-related errors.
-   */
-  export function filesystemErrorCode(err: Error): ErrorCode | undefined;
-}
-import type { InputStream } from './wasi-io-streams.js';
-export { InputStream };
-import type { OutputStream } from './wasi-io-streams.js';
-export { OutputStream };
-import type { Error } from './wasi-io-streams.js';
-export { Error };
-import type { Datetime } from './wasi-clocks-wall-clock.js';
-export { Datetime };
+/** @module Interface wasi:filesystem/types@0.2.3 **/
+/**
+ * Attempts to extract a filesystem-related `error-code` from the stream
+ * `error` provided.
+ * 
+ * Stream operations which return `stream-error::last-operation-failed`
+ * have a payload with more information about the operation that failed.
+ * This payload can be passed through to this function to see if there's
+ * filesystem-related information about the error to return.
+ * 
+ * Note that this function is fallible because not all stream-related
+ * errors are filesystem-related errors.
+ */
+export function filesystemErrorCode(err: Error): ErrorCode | undefined;
+export type InputStream = import('./wasi-io-streams.js').InputStream;
+export type OutputStream = import('./wasi-io-streams.js').OutputStream;
+export type Error = import('./wasi-io-streams.js').Error;
+export type Datetime = import('./wasi-clocks-wall-clock.js').Datetime;
 /**
  * File size or length of a region within a file.
  */
@@ -395,6 +388,10 @@ export interface MetadataHashValue {
 }
 
 export class Descriptor {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Return a stream for reading from a file, if available.
   * 
@@ -421,7 +418,7 @@ export class Descriptor {
   * May fail with an error-code describing why the file cannot be appended.
   * 
   * Note: This allows using `write-stream`, which is similar to `write` with
-  * `O_APPEND` in in POSIX.
+  * `O_APPEND` in POSIX.
   */
   appendViaStream(): OutputStream;
   /**
@@ -639,14 +636,14 @@ export class Descriptor {
   * replaced. It may also include a secret value chosen by the
   * implementation and not otherwise exposed.
   * 
-  * Implementations are encourated to provide the following properties:
+  * Implementations are encouraged to provide the following properties:
   * 
-  * - If the file is not modified or replaced, the computed hash value should
-  * usually not change.
-  * - If the object is modified or replaced, the computed hash value should
-  * usually change.
-  * - The inputs to the hash should not be easily computable from the
-  * computed hash.
+  *  - If the file is not modified or replaced, the computed hash value should
+  *    usually not change.
+  *  - If the object is modified or replaced, the computed hash value should
+  *    usually change.
+  *  - The inputs to the hash should not be easily computable from the
+  *    computed hash.
   * 
   * However, none of these is required.
   */
@@ -661,6 +658,10 @@ export class Descriptor {
 }
 
 export class DirectoryEntryStream {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Read a single directory entry from a `directory-entry-stream`.
   */

package/types/interfaces/wasi-http-incoming-handler.d.ts

@@ -1,19 +1,16 @@
-export namespace WasiHttpIncomingHandler {
-  /**
-   * This function is invoked with an incoming HTTP Request, and a resource
-   * `response-outparam` which provides the capability to reply with an HTTP
-   * Response. The response is sent by calling the `response-outparam.set`
-   * method, which allows execution to continue after the response has been
-   * sent. This enables both streaming to the response body, and performing other
-   * work.
-   * 
-   * The implementor of this function must write a response to the
-   * `response-outparam` before returning, or else the caller will respond
-   * with an error on its behalf.
-   */
-  export function handle(request: IncomingRequest, responseOut: ResponseOutparam): void;
-}
-import type { IncomingRequest } from './wasi-http-types.js';
-export { IncomingRequest };
-import type { ResponseOutparam } from './wasi-http-types.js';
-export { ResponseOutparam };
+/** @module Interface wasi:http/incoming-handler@0.2.3 **/
+/**
+ * This function is invoked with an incoming HTTP Request, and a resource
+ * `response-outparam` which provides the capability to reply with an HTTP
+ * Response. The response is sent by calling the `response-outparam.set`
+ * method, which allows execution to continue after the response has been
+ * sent. This enables both streaming to the response body, and performing other
+ * work.
+ * 
+ * The implementor of this function must write a response to the
+ * `response-outparam` before returning, or else the caller will respond
+ * with an error on its behalf.
+ */
+export function handle(request: IncomingRequest, responseOut: ResponseOutparam): void;
+export type IncomingRequest = import('./wasi-http-types.js').IncomingRequest;
+export type ResponseOutparam = import('./wasi-http-types.js').ResponseOutparam;

package/types/interfaces/wasi-http-outgoing-handler.d.ts

@@ -1,23 +1,18 @@
-export namespace WasiHttpOutgoingHandler {
-  /**
-   * This function is invoked with an outgoing HTTP Request, and it returns
-   * a resource `future-incoming-response` which represents an HTTP Response
-   * which may arrive in the future.
-   * 
-   * The `options` argument accepts optional parameters for the HTTP
-   * protocol's transport layer.
-   * 
-   * This function may return an error if the `outgoing-request` is invalid
-   * or not allowed to be made. Otherwise, protocol errors are reported
-   * through the `future-incoming-response`.
-   */
-  export function handle(request: OutgoingRequest, options: RequestOptions | undefined): FutureIncomingResponse;
-}
-import type { OutgoingRequest } from './wasi-http-types.js';
-export { OutgoingRequest };
-import type { RequestOptions } from './wasi-http-types.js';
-export { RequestOptions };
-import type { FutureIncomingResponse } from './wasi-http-types.js';
-export { FutureIncomingResponse };
-import type { ErrorCode } from './wasi-http-types.js';
-export { ErrorCode };
+/** @module Interface wasi:http/outgoing-handler@0.2.3 **/
+/**
+ * This function is invoked with an outgoing HTTP Request, and it returns
+ * a resource `future-incoming-response` which represents an HTTP Response
+ * which may arrive in the future.
+ * 
+ * The `options` argument accepts optional parameters for the HTTP
+ * protocol's transport layer.
+ * 
+ * This function may return an error if the `outgoing-request` is invalid
+ * or not allowed to be made. Otherwise, protocol errors are reported
+ * through the `future-incoming-response`.
+ */
+export function handle(request: OutgoingRequest, options: RequestOptions | undefined): FutureIncomingResponse;
+export type OutgoingRequest = import('./wasi-http-types.js').OutgoingRequest;
+export type RequestOptions = import('./wasi-http-types.js').RequestOptions;
+export type FutureIncomingResponse = import('./wasi-http-types.js').FutureIncomingResponse;
+export type ErrorCode = import('./wasi-http-types.js').ErrorCode;

package/types/interfaces/wasi-http-types.d.ts

@@ -1,40 +1,23 @@
-export namespace WasiHttpTypes {
-  /**
-   * Attempts to extract a http-related `error` from the wasi:io `error`
-   * provided.
-   * 
-   * Stream operations which return
-   * `wasi:io/stream/stream-error::last-operation-failed` have a payload of
-   * type `wasi:io/error/error` with more information about the operation
-   * that failed. This payload can be passed through to this function to see
-   * if there's http-related information about the error to return.
-   * 
-   * Note that this function is fallible because not all io-errors are
-   * http-related errors.
-   */
-  export function httpErrorCode(err: IoError): ErrorCode | undefined;
-  export { Fields };
-  export { IncomingRequest };
-  export { OutgoingRequest };
-  export { RequestOptions };
-  export { ResponseOutparam };
-  export { IncomingResponse };
-  export { IncomingBody };
-  export { FutureTrailers };
-  export { OutgoingResponse };
-  export { OutgoingBody };
-  export { FutureIncomingResponse };
-}
-import type { Duration } from './wasi-clocks-monotonic-clock.js';
-export { Duration };
-import type { InputStream } from './wasi-io-streams.js';
-export { InputStream };
-import type { OutputStream } from './wasi-io-streams.js';
-export { OutputStream };
-import type { Error as IoError } from './wasi-io-error.js';
-export { IoError };
-import type { Pollable } from './wasi-io-poll.js';
-export { Pollable };
+/** @module Interface wasi:http/types@0.2.3 **/
+/**
+ * Attempts to extract a http-related `error` from the wasi:io `error`
+ * provided.
+ * 
+ * Stream operations which return
+ * `wasi:io/stream/stream-error::last-operation-failed` have a payload of
+ * type `wasi:io/error/error` with more information about the operation
+ * that failed. This payload can be passed through to this function to see
+ * if there's http-related information about the error to return.
+ * 
+ * Note that this function is fallible because not all io-errors are
+ * http-related errors.
+ */
+export function httpErrorCode(err: IoError): ErrorCode | undefined;
+export type Duration = import('./wasi-clocks-monotonic-clock.js').Duration;
+export type InputStream = import('./wasi-io-streams.js').InputStream;
+export type OutputStream = import('./wasi-io-streams.js').OutputStream;
+export type IoError = import('./wasi-io-error.js').Error;
+export type Pollable = import('./wasi-io-poll.js').Pollable;
 /**
  * This type corresponds to HTTP standard Methods.
  */
@@ -107,7 +90,7 @@ export interface FieldSizePayload {
 }
 /**
  * These cases are inspired by the IANA HTTP Proxy Error Types:
- * https://www.iana.org/assignments/http-proxy-status/http-proxy-status.xhtml#table-http-proxy-error-types
+ *   <https://www.iana.org/assignments/http-proxy-status/http-proxy-status.xhtml#table-http-proxy-error-types>
  */
 export type ErrorCode = ErrorCodeDnsTimeout | ErrorCodeDnsError | ErrorCodeDestinationNotFound | ErrorCodeDestinationUnavailable | ErrorCodeDestinationIpProhibited | ErrorCodeDestinationIpUnroutable | ErrorCodeConnectionRefused | ErrorCodeConnectionTerminated | ErrorCodeConnectionTimeout | ErrorCodeConnectionReadTimeout | ErrorCodeConnectionWriteTimeout | ErrorCodeConnectionLimitReached | ErrorCodeTlsProtocolError | ErrorCodeTlsCertificateError | ErrorCodeTlsAlertReceived | ErrorCodeHttpRequestDenied | ErrorCodeHttpRequestLengthRequired | ErrorCodeHttpRequestBodySize | ErrorCodeHttpRequestMethodInvalid | ErrorCodeHttpRequestUriInvalid | ErrorCodeHttpRequestUriTooLong | ErrorCodeHttpRequestHeaderSectionSize | ErrorCodeHttpRequestHeaderSize | ErrorCodeHttpRequestTrailerSectionSize | ErrorCodeHttpRequestTrailerSize | ErrorCodeHttpResponseIncomplete | ErrorCodeHttpResponseHeaderSectionSize | ErrorCodeHttpResponseHeaderSize | ErrorCodeHttpResponseBodySize | ErrorCodeHttpResponseTrailerSectionSize | ErrorCodeHttpResponseTrailerSize | ErrorCodeHttpResponseTransferCoding | ErrorCodeHttpResponseContentCoding | ErrorCodeHttpResponseTimeout | ErrorCodeHttpUpgradeFailed | ErrorCodeHttpProtocolError | ErrorCodeLoopDetected | ErrorCodeConfigurationError | ErrorCodeInternalError;
 export interface ErrorCodeDnsTimeout {
@@ -400,6 +383,10 @@ export class Fields {
 }
 
 export class FutureIncomingResponse {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Returns a pollable which becomes ready when either the Response has
   * been received, or an error has occurred. When this pollable is ready,
@@ -426,6 +413,10 @@ export class FutureIncomingResponse {
 }
 
 export class FutureTrailers {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Returns a pollable which becomes ready when either the trailers have
   * been received, or an error has occurred. When this pollable is ready,
@@ -457,6 +448,10 @@ export class FutureTrailers {
 }
 
 export class IncomingBody {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Returns the contents of the body, as a stream of bytes.
   * 
@@ -483,6 +478,10 @@ export class IncomingBody {
 }
 
 export class IncomingRequest {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Returns the method of the incoming request.
   */
@@ -518,6 +517,10 @@ export class IncomingRequest {
 }
 
 export class IncomingResponse {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Returns the status code from the incoming response.
   */
@@ -540,6 +543,10 @@ export class IncomingResponse {
 }
 
 export class OutgoingBody {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Returns a stream for writing the body contents.
   * 
@@ -722,6 +729,10 @@ export class RequestOptions {
 }
 
 export class ResponseOutparam {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Set the value of the `response-outparam` to either send a response,
   * or indicate an error.

package/types/interfaces/wasi-io-error.d.ts

@@ -1,8 +1,10 @@
-export namespace WasiIoError {
-  export { Error };
-}
+/** @module Interface wasi:io/error@0.2.3 **/
 
 export class Error {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Returns a string that is suitable to assist humans in debugging
   * this error.

package/types/interfaces/wasi-io-poll.d.ts

@@ -1,30 +1,32 @@
-export namespace WasiIoPoll {
-  export { Pollable };
-  /**
-   * Poll for completion on a set of pollables.
-   * 
-   * This function takes a list of pollables, which identify I/O sources of
-   * interest, and waits until one or more of the events is ready for I/O.
-   * 
-   * The result `list<u32>` contains one or more indices of handles in the
-   * argument list that is ready for I/O.
-   * 
-   * This function traps if either:
-   * - the list is empty, or:
-   * - the list contains more elements than can be indexed with a `u32` value.
-   * 
-   * A timeout can be implemented by adding a pollable from the
-   * wasi-clocks API to the list.
-   * 
-   * This function does not return a `result`; polling in itself does not
-   * do any I/O so it doesn't fail. If any of the I/O sources identified by
-   * the pollables has an error, it is indicated by marking the source as
-   * being ready for I/O.
-   */
-  export function poll(in_: Array<Pollable>): Uint32Array;
-}
+/** @module Interface wasi:io/poll@0.2.3 **/
+/**
+ * Poll for completion on a set of pollables.
+ * 
+ * This function takes a list of pollables, which identify I/O sources of
+ * interest, and waits until one or more of the events is ready for I/O.
+ * 
+ * The result `list<u32>` contains one or more indices of handles in the
+ * argument list that is ready for I/O.
+ * 
+ * This function traps if either:
+ * - the list is empty, or:
+ * - the list contains more elements than can be indexed with a `u32` value.
+ * 
+ * A timeout can be implemented by adding a pollable from the
+ * wasi-clocks API to the list.
+ * 
+ * This function does not return a `result`; polling in itself does not
+ * do any I/O so it doesn't fail. If any of the I/O sources identified by
+ * the pollables has an error, it is indicated by marking the source as
+ * being ready for I/O.
+ */
+export function poll(in_: Array<Pollable>): Uint32Array;
 
 export class Pollable {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Return the readiness of a pollable. This function never blocks.
   * 

package/types/interfaces/wasi-io-streams.d.ts

@@ -1,11 +1,6 @@
-export namespace WasiIoStreams {
-  export { InputStream };
-  export { OutputStream };
-}
-import type { Error } from './wasi-io-error.js';
-export { Error };
-import type { Pollable } from './wasi-io-poll.js';
-export { Pollable };
+/** @module Interface wasi:io/streams@0.2.3 **/
+export type Error = import('./wasi-io-error.js').Error;
+export type Pollable = import('./wasi-io-poll.js').Pollable;
 /**
  * An error for input-stream and output-stream operations.
  */
@@ -32,6 +27,10 @@ export interface StreamErrorClosed {
 }
 
 export class InputStream {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Perform a non-blocking read from the stream.
   * 
@@ -90,6 +89,10 @@ export class InputStream {
 }
 
 export class OutputStream {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
   /**
   * Check readiness for writing. This function never blocks.
   * 
@@ -129,13 +132,13 @@ export class OutputStream {
   * ```text
   * let pollable = this.subscribe();
   * while !contents.is_empty() {
-    * // Wait for the stream to become writable
-    * pollable.block();
-    * let Ok(n) = this.check-write(); // eliding error handling
-    * let len = min(n, contents.len());
-    * let (chunk, rest) = contents.split_at(len);
-    * this.write(chunk  );            // eliding error handling
-    * contents = rest;
+    *     // Wait for the stream to become writable
+    *     pollable.block();
+    *     let Ok(n) = this.check-write(); // eliding error handling
+    *     let len = min(n, contents.len());
+    *     let (chunk, rest) = contents.split_at(len);
+    *     this.write(chunk  );            // eliding error handling
+    *     contents = rest;
     * }
     * this.flush();
     * // Wait for completion of `flush`
@@ -197,12 +200,12 @@ export class OutputStream {
     * ```text
     * let pollable = this.subscribe();
     * while num_zeroes != 0 {
-      * // Wait for the stream to become writable
-      * pollable.block();
-      * let Ok(n) = this.check-write(); // eliding error handling
-      * let len = min(n, num_zeroes);
-      * this.write-zeroes(len);         // eliding error handling
-      * num_zeroes -= len;
+      *     // Wait for the stream to become writable
+      *     pollable.block();
+      *     let Ok(n) = this.check-write(); // eliding error handling
+      *     let len = min(n, num_zeroes);
+      *     this.write-zeroes(len);         // eliding error handling
+      *     num_zeroes -= len;
       * }
       * this.flush();
       * // Wait for completion of `flush`

package/types/interfaces/wasi-random-insecure-seed.d.ts

@@ -1,22 +1,21 @@
-export namespace WasiRandomInsecureSeed {
-  /**
-   * Return a 128-bit value that may contain a pseudo-random value.
-   * 
-   * The returned value is not required to be computed from a CSPRNG, and may
-   * even be entirely deterministic. Host implementations are encouraged to
-   * provide pseudo-random values to any program exposed to
-   * attacker-controlled content, to enable DoS protection built into many
-   * languages' hash-map implementations.
-   * 
-   * This function is intended to only be called once, by a source language
-   * to initialize Denial Of Service (DoS) protection in its hash-map
-   * implementation.
-   * 
-   * # Expected future evolution
-   * 
-   * This will likely be changed to a value import, to prevent it from being
-   * called multiple times and potentially used for purposes other than DoS
-   * protection.
-   */
-  export function insecureSeed(): [bigint, bigint];
-}
+/** @module Interface wasi:random/insecure-seed@0.2.3 **/
+/**
+ * Return a 128-bit value that may contain a pseudo-random value.
+ * 
+ * The returned value is not required to be computed from a CSPRNG, and may
+ * even be entirely deterministic. Host implementations are encouraged to
+ * provide pseudo-random values to any program exposed to
+ * attacker-controlled content, to enable DoS protection built into many
+ * languages' hash-map implementations.
+ * 
+ * This function is intended to only be called once, by a source language
+ * to initialize Denial Of Service (DoS) protection in its hash-map
+ * implementation.
+ * 
+ * # Expected future evolution
+ * 
+ * This will likely be changed to a value import, to prevent it from being
+ * called multiple times and potentially used for purposes other than DoS
+ * protection.
+ */
+export function insecureSeed(): [bigint, bigint];