@gjsify/utils 0.0.4 → 0.1.0

package/README.md

@@ -0,0 +1,26 @@
+# @gjsify/utils
+
+Shared utility functions for gjsify packages including error polyfills, structured clone, and GNOME library helpers.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/utils
+# or
+yarn add @gjsify/utils
+```
+
+## Usage
+
+```typescript
+import { ensureMainLoop } from '@gjsify/utils';
+
+// Start GLib MainLoop if not already running (no-op on Node.js)
+ensureMainLoop();
+```
+
+## License
+
+MIT

package/lib/esm/base64.js

@@ -0,0 +1,72 @@
+const B64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const B64_LOOKUP = new Uint8Array(256);
+for (let i = 0; i < B64_CHARS.length; i++) B64_LOOKUP[B64_CHARS.charCodeAt(i)] = i;
+function atobPolyfill(str) {
+  if (typeof globalThis.atob === "function") return globalThis.atob(str);
+  const cleaned = str.replace(/[=\s]/g, "");
+  let result = "";
+  let bits = 0;
+  let collected = 0;
+  for (let i = 0; i < cleaned.length; i++) {
+    bits = bits << 6 | B64_LOOKUP[cleaned.charCodeAt(i)];
+    collected += 6;
+    if (collected >= 8) {
+      collected -= 8;
+      result += String.fromCharCode(bits >> collected & 255);
+    }
+  }
+  return result;
+}
+function btoaPolyfill(str) {
+  if (typeof globalThis.btoa === "function") return globalThis.btoa(str);
+  let result = "";
+  let i = 0;
+  for (; i + 2 < str.length; i += 3) {
+    const n = str.charCodeAt(i) << 16 | str.charCodeAt(i + 1) << 8 | str.charCodeAt(i + 2);
+    result += B64_CHARS[n >> 18 & 63] + B64_CHARS[n >> 12 & 63] + B64_CHARS[n >> 6 & 63] + B64_CHARS[n & 63];
+  }
+  if (i + 1 === str.length) {
+    const n = str.charCodeAt(i) << 16;
+    result += B64_CHARS[n >> 18 & 63] + B64_CHARS[n >> 12 & 63] + "==";
+  } else if (i + 2 === str.length) {
+    const n = str.charCodeAt(i) << 16 | str.charCodeAt(i + 1) << 8;
+    result += B64_CHARS[n >> 18 & 63] + B64_CHARS[n >> 12 & 63] + B64_CHARS[n >> 6 & 63] + "=";
+  }
+  return result;
+}
+function base64Decode(str) {
+  const cleaned = str.replace(/[=\s]/g, "");
+  const bytes = new Uint8Array(cleaned.length * 3 >> 2);
+  let bits = 0;
+  let collected = 0;
+  let pos = 0;
+  for (let i = 0; i < cleaned.length; i++) {
+    bits = bits << 6 | B64_LOOKUP[cleaned.charCodeAt(i)];
+    collected += 6;
+    if (collected >= 8) {
+      collected -= 8;
+      bytes[pos++] = bits >> collected & 255;
+    }
+  }
+  return bytes.subarray(0, pos);
+}
+function base64Encode(bytes) {
+  let result = "";
+  const len = bytes.length;
+  for (let i = 0; i < len; i += 3) {
+    const b0 = bytes[i];
+    const b1 = i + 1 < len ? bytes[i + 1] : 0;
+    const b2 = i + 2 < len ? bytes[i + 2] : 0;
+    result += B64_CHARS[b0 >> 2];
+    result += B64_CHARS[(b0 & 3) << 4 | b1 >> 4];
+    result += i + 1 < len ? B64_CHARS[(b1 & 15) << 2 | b2 >> 6] : "=";
+    result += i + 2 < len ? B64_CHARS[b2 & 63] : "=";
+  }
+  return result;
+}
+export {
+  atobPolyfill,
+  base64Decode,
+  base64Encode,
+  btoaPolyfill
+};

package/lib/esm/byte-array.js

@@ -0,0 +1,6 @@
+function gbytesToUint8Array(bytes) {
+  return imports.byteArray.fromGBytes(bytes);
+}
+export {
+  gbytesToUint8Array
+};

package/lib/esm/cli.js

@@ -2,8 +2,7 @@ import GLib from "@girs/glib-2.0";
 const byteArray = imports.byteArray;
 const cli = (commandLine) => {
   const [res, out, err, status] = GLib.spawn_command_line_sync(commandLine);
-  if (err.byteLength)
-    throw new Error(byteArray.toString(err));
+  if (err.byteLength) throw new Error(byteArray.toString(err));
   return byteArray.toString(out);
 };
 export {

package/lib/esm/defer.js

@@ -0,0 +1,6 @@
+function deferEmit(emitter, event, ...args) {
+  setTimeout(() => emitter.emit(event, ...args), 0);
+}
+export {
+  deferEmit
+};

package/lib/esm/encoding.js

@@ -0,0 +1,35 @@
+const VALID_ENCODINGS = ["utf8", "ascii", "latin1", "binary", "base64", "base64url", "hex", "ucs2", "utf16le"];
+function normalizeEncoding(enc) {
+  if (!enc || enc === "utf8" || enc === "utf-8") return "utf8";
+  const lower = ("" + enc).toLowerCase().replace(/-/g, "");
+  switch (lower) {
+    case "utf8":
+      return "utf8";
+    case "ascii":
+      return "ascii";
+    case "latin1":
+    case "binary":
+      return "latin1";
+    case "base64":
+      return "base64";
+    case "base64url":
+      return "base64url";
+    case "hex":
+      return "hex";
+    case "ucs2":
+    case "utf16le":
+      return "utf16le";
+    default:
+      return "utf8";
+  }
+}
+function checkEncoding(encoding) {
+  const lower = ("" + encoding).toLowerCase().replace(/-/g, "");
+  if (!VALID_ENCODINGS.includes(lower)) {
+    throw new TypeError(`Unknown encoding: ${encoding}`);
+  }
+}
+export {
+  checkEncoding,
+  normalizeEncoding
+};

package/lib/esm/fs.js

@@ -1,7 +1,8 @@
 import Gio from "@girs/gio-2.0";
+import GioUnix from "@girs/giounix-2.0";
 const existsFD = (fd) => {
   try {
-    let stream = Gio.UnixInputStream.new(fd, false);
+    let stream = GioUnix.InputStream.new(fd, false);
     stream.close(null);
     return true;
   } catch (error) {

package/lib/esm/gio-errors.js

@@ -0,0 +1,98 @@
+const GIO_ERROR_TO_NODE = {
+  0: "EIO",
+  // FAILED
+  1: "ENOENT",
+  // NOT_FOUND
+  2: "EEXIST",
+  // EXISTS
+  3: "EISDIR",
+  // IS_DIRECTORY
+  4: "ENOTDIR",
+  // NOT_DIRECTORY
+  5: "ENOTEMPTY",
+  // NOT_EMPTY
+  6: "ENOENT",
+  // NOT_REGULAR_FILE
+  7: "ENFILE",
+  // TOO_MANY_OPEN_FILES
+  9: "EACCES",
+  // NOT_MOUNTABLE_FILE
+  10: "ENFILE",
+  // FILENAME_TOO_LONG
+  11: "EINVAL",
+  // INVALID_FILENAME
+  12: "ELOOP",
+  // TOO_MANY_LINKS
+  13: "ENOSPC",
+  // NO_SPACE
+  14: "EACCES",
+  // PERMISSION_DENIED
+  17: "ELOOP",
+  // TOO_MANY_LINKS (duplicate guard)
+  19: "ENOSPC",
+  // NO_SPACE (duplicate guard)
+  20: "ENOTSUP",
+  // NOT_SUPPORTED
+  22: "EMFILE",
+  // TOO_MANY_OPEN_FILES
+  24: "EROFS",
+  // READ_ONLY
+  25: "ECANCELED",
+  // CANCELLED
+  26: "EBUSY",
+  // BUSY
+  27: "ETIMEDOUT",
+  // TIMED_OUT
+  28: "EHOSTUNREACH",
+  // HOST_NOT_FOUND (was WOULD_BLOCK)
+  30: "EHOSTUNREACH",
+  // HOST_NOT_FOUND
+  31: "ENETUNREACH",
+  // NETWORK_UNREACHABLE
+  32: "ECONNREFUSED",
+  // CONNECTION_REFUSED (legacy value)
+  33: "EADDRINUSE",
+  // ADDRESS_IN_USE
+  34: "ECONNRESET",
+  // CONNECTION_CLOSED (mapped to reset)
+  36: "EPIPE",
+  // BROKEN_PIPE
+  38: "ENETUNREACH",
+  // NETWORK_UNREACHABLE (actual GJS value)
+  39: "ECONNREFUSED",
+  // CONNECTION_REFUSED (actual GJS value)
+  40: "ECONNREFUSED",
+  // PROXY_FAILED
+  41: "EACCES",
+  // PROXY_AUTH_FAILED
+  44: "ECONNRESET",
+  // CONNECTION_CLOSED (actual GJS value)
+  46: "EMSGSIZE"
+  // MESSAGE_TOO_LARGE
+};
+function createNodeError(err, syscall, details) {
+  const errObj = err;
+  const code = GIO_ERROR_TO_NODE[errObj?.code ?? -1] || "EIO";
+  let msg = `${code}: ${errObj?.message || "unknown error"}, ${syscall}`;
+  if (details?.path) msg += ` '${details.path}'`;
+  if (details?.dest) msg += ` -> '${details.dest}'`;
+  if (details?.address) msg += ` ${details.address}`;
+  if (details?.port != null) msg += `:${details.port}`;
+  const error = new Error(msg);
+  error.code = code;
+  error.syscall = syscall;
+  error.errno = -(errObj?.code || 0);
+  if (details?.path) error.path = details.path;
+  if (details?.address) error.address = details.address;
+  if (details?.port != null) error.port = details.port;
+  return error;
+}
+function isNotFoundError(err) {
+  const errObj = err;
+  return errObj?.code === 1 || errObj?.code === "ENOENT";
+}
+export {
+  GIO_ERROR_TO_NODE,
+  createNodeError,
+  isNotFoundError
+};

package/lib/esm/gio.js

@@ -0,0 +1,39 @@
+import GLib from "@girs/glib-2.0";
+const byteArray = imports.byteArray;
+function gioAsync(obj, asyncMethod, finishMethod, ...args) {
+  return new Promise((resolve, reject) => {
+    obj[asyncMethod](...args, (_self, asyncRes) => {
+      try {
+        resolve(obj[finishMethod](asyncRes));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}
+async function readBytesAsync(inputStream, count = 4096, ioPriority = GLib.PRIORITY_DEFAULT, cancellable = null) {
+  return new Promise((resolve, reject) => {
+    inputStream.read_bytes_async(count, ioPriority, cancellable, (_self, asyncRes) => {
+      try {
+        const res = inputStream.read_bytes_finish(asyncRes);
+        if (res.get_size() === 0) {
+          return resolve(null);
+        }
+        return resolve(byteArray.fromGBytes(res));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}
+async function* inputStreamAsyncIterator(inputStream, count = 4096, ioPriority = GLib.PRIORITY_DEFAULT, cancellable = null) {
+  let chunk;
+  while ((chunk = await readBytesAsync(inputStream, count, ioPriority, cancellable)) !== null) {
+    yield chunk;
+  }
+}
+export {
+  gioAsync,
+  inputStreamAsyncIterator,
+  readBytesAsync
+};

package/lib/esm/globals.js

@@ -0,0 +1,8 @@
+function registerGlobal(name, value) {
+  if (typeof globalThis[name] === "undefined") {
+    globalThis[name] = value;
+  }
+}
+export {
+  registerGlobal
+};

package/lib/esm/index.js

@@ -1,14 +1,16 @@
-export * from "./types/index.js";
-export * from "./cancel-handler.js";
+export * from "./base64.js";
+export * from "./byte-array.js";
 export * from "./cli.js";
+export * from "./defer.js";
+export * from "./encoding.js";
+export * from "./globals.js";
 export * from "./error.js";
 export * from "./file.js";
 export * from "./fs.js";
-export * from "./log.js";
+export * from "./gio.js";
+export * from "./gio-errors.js";
 export * from "./message.js";
-export * from "./os.js";
+export * from "./next-tick.js";
 export * from "./path.js";
-export * from "./process.js";
-export * from "./system.js";
-export * from "./tty.js";
-export * from "./version.js";
+export * from "./structured-clone.js";
+export * from "./main-loop.js";

package/lib/esm/main-loop.js

@@ -0,0 +1,28 @@
+let _started = false;
+let _loop = null;
+function ensureMainLoop() {
+  const gjsImports = globalThis.imports;
+  if (!gjsImports) return void 0;
+  if (_started) return _loop;
+  const GLibModule = gjsImports.gi.GLib;
+  _loop = new GLibModule.MainLoop(null, false);
+  _started = true;
+  if (GLibModule.main_depth() === 0) {
+    try {
+      _loop.runAsync();
+    } catch {
+    }
+  }
+  return _loop;
+}
+function quitMainLoop() {
+  if (_loop) {
+    _loop.quit();
+    _started = false;
+    _loop = null;
+  }
+}
+export {
+  ensureMainLoop,
+  quitMainLoop
+};

package/lib/esm/next-tick.js

@@ -0,0 +1,6 @@
+const nextTick = typeof globalThis.process?.nextTick === "function" ? globalThis.process.nextTick : typeof globalThis.queueMicrotask === "function" ? (fn, ...args) => queueMicrotask(() => fn(...args)) : (fn, ...args) => {
+  Promise.resolve().then(() => fn(...args));
+};
+export {
+  nextTick
+};

package/lib/esm/structured-clone.js

@@ -0,0 +1,169 @@
+const { toString } = Object.prototype;
+function classOf(value) {
+  return toString.call(value).slice(8, -1);
+}
+function throwDataCloneError(message) {
+  const DOMExceptionCtor = globalThis.DOMException;
+  if (typeof DOMExceptionCtor === "function") {
+    throw new DOMExceptionCtor(message, "DataCloneError");
+  }
+  const error = new Error(message);
+  error.name = "DataCloneError";
+  throw error;
+}
+const ERROR_CONSTRUCTORS = {
+  Error,
+  EvalError,
+  RangeError,
+  ReferenceError,
+  SyntaxError,
+  TypeError,
+  URIError
+};
+const TYPED_ARRAY_TAGS = /* @__PURE__ */ new Set([
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Uint16Array",
+  "Int32Array",
+  "Uint32Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array"
+]);
+function internalClone(value, seen) {
+  if (value === null || value === void 0) return value;
+  const type = typeof value;
+  if (type === "boolean" || type === "number" || type === "string" || type === "bigint") {
+    return value;
+  }
+  if (type === "symbol") {
+    throwDataCloneError("Symbol cannot be cloned");
+  }
+  if (type === "function") {
+    throwDataCloneError("Function cannot be cloned");
+  }
+  const obj = value;
+  if (seen.has(obj)) return seen.get(obj);
+  const tag = classOf(obj);
+  if (tag === "Date") {
+    return new Date(obj.getTime());
+  }
+  if (tag === "RegExp") {
+    return new RegExp(obj.source, obj.flags);
+  }
+  if (tag === "Boolean") return Object(obj.valueOf());
+  if (tag === "Number") return Object(obj.valueOf());
+  if (tag === "String") return Object(obj.valueOf());
+  if (tag === "BigInt") return Object(BigInt.prototype.valueOf.call(obj));
+  if (obj instanceof Error) {
+    const src = obj;
+    const ctorName = src.constructor?.name;
+    const Ctor = ctorName && ERROR_CONSTRUCTORS[ctorName] || ERROR_CONSTRUCTORS[src.name] || Error;
+    const cloned = new Ctor(src.message);
+    cloned.name = src.name;
+    if ("cause" in src) {
+      Object.defineProperty(cloned, "cause", {
+        value: internalClone(src.cause, seen),
+        writable: true,
+        enumerable: false,
+        configurable: true
+      });
+    }
+    return cloned;
+  }
+  if (tag === "DOMException") {
+    const DOMExceptionCtor = globalThis.DOMException;
+    if (typeof DOMExceptionCtor === "function") {
+      const src = obj;
+      return new DOMExceptionCtor(src.message, src.name);
+    }
+  }
+  if (tag === "ArrayBuffer") {
+    const src = obj;
+    const cloned = src.slice(0);
+    seen.set(obj, cloned);
+    return cloned;
+  }
+  if (tag === "SharedArrayBuffer") {
+    return obj;
+  }
+  if (tag === "DataView") {
+    const src = obj;
+    const bufferClone = internalClone(src.buffer, seen);
+    const cloned = new DataView(bufferClone, src.byteOffset, src.byteLength);
+    seen.set(obj, cloned);
+    return cloned;
+  }
+  if (TYPED_ARRAY_TAGS.has(tag)) {
+    const src = obj;
+    const bufferClone = internalClone(src.buffer, seen);
+    const Ctor = src.constructor;
+    const cloned = new Ctor(bufferClone, src.byteOffset, src.length);
+    seen.set(obj, cloned);
+    return cloned;
+  }
+  if (tag === "Map") {
+    const cloned = /* @__PURE__ */ new Map();
+    seen.set(obj, cloned);
+    for (const [k, v] of obj) {
+      cloned.set(internalClone(k, seen), internalClone(v, seen));
+    }
+    return cloned;
+  }
+  if (tag === "Set") {
+    const cloned = /* @__PURE__ */ new Set();
+    seen.set(obj, cloned);
+    for (const v of obj) {
+      cloned.add(internalClone(v, seen));
+    }
+    return cloned;
+  }
+  {
+    const g = globalThis;
+    const BlobCtor = g.Blob;
+    const FileCtor = g.File;
+    if (typeof FileCtor === "function" && obj instanceof FileCtor) {
+      const src = obj;
+      return new FileCtor([obj], src.name, { type: src.type, lastModified: src.lastModified });
+    }
+    if (typeof BlobCtor === "function" && obj instanceof BlobCtor) {
+      const src = obj;
+      return new BlobCtor([obj], { type: src.type });
+    }
+  }
+  if (obj instanceof WeakMap) throwDataCloneError("WeakMap cannot be cloned");
+  if (obj instanceof WeakSet) throwDataCloneError("WeakSet cannot be cloned");
+  if (obj instanceof WeakRef) throwDataCloneError("WeakRef cannot be cloned");
+  if (typeof globalThis.Promise === "function" && obj instanceof Promise) {
+    throwDataCloneError("Promise cannot be cloned");
+  }
+  if (tag === "Array") {
+    const src = obj;
+    const cloned = [];
+    seen.set(obj, cloned);
+    for (let i = 0; i < src.length; i++) {
+      if (i in src) {
+        cloned[i] = internalClone(src[i], seen);
+      }
+    }
+    return cloned;
+  }
+  if (tag === "Object" || typeof obj === "object") {
+    const cloned = {};
+    seen.set(obj, cloned);
+    for (const key of Object.keys(obj)) {
+      cloned[key] = internalClone(obj[key], seen);
+    }
+    return cloned;
+  }
+  throwDataCloneError(`${tag} cannot be cloned`);
+}
+function structuredClone(value, _options) {
+  return internalClone(value, /* @__PURE__ */ new Map());
+}
+export {
+  structuredClone
+};

package/lib/types/base64.d.ts

@@ -0,0 +1,8 @@
+/** Decode a base64 string to a binary string. Uses native atob when available. */
+export declare function atobPolyfill(str: string): string;
+/** Encode a binary string to base64. Uses native btoa when available. */
+export declare function btoaPolyfill(str: string): string;
+/** Decode a base64 string directly to Uint8Array (avoids lossy atob string round-trip). */
+export declare function base64Decode(str: string): Uint8Array;
+/** Encode a Uint8Array to base64 string. */
+export declare function base64Encode(bytes: Uint8Array): string;

package/lib/types/byte-array.d.ts

@@ -0,0 +1,7 @@
+import type GLib from '@girs/glib-2.0';
+/**
+ * Convert GLib.Bytes to Uint8Array using GJS's byteArray module.
+ * This wraps the GJS-specific `imports.byteArray.fromGBytes()` API
+ * with proper typing to eliminate `as any` casts throughout the codebase.
+ */
+export declare function gbytesToUint8Array(bytes: GLib.Bytes): Uint8Array;

package/lib/types/defer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Defer an event emission to the next macrotask, matching Node.js behavior
+ * for server 'listening', 'close', and 'error' events.
+ */
+export declare function deferEmit(emitter: {
+    emit(event: string | symbol, ...args: unknown[]): boolean;
+}, event: string, ...args: unknown[]): void;

package/lib/types/encoding.d.ts

@@ -0,0 +1,11 @@
+/** Canonical encoding names (matches BufferEncoding from @types/node). */
+export type Encoding = 'utf8' | 'ascii' | 'latin1' | 'base64' | 'base64url' | 'hex' | 'utf16le' | 'binary' | 'ucs2' | 'ucs-2' | 'utf-8';
+/**
+ * Normalize an encoding string to a canonical encoding value.
+ * Returns 'utf8' as default for undefined/null/empty input.
+ */
+export declare function normalizeEncoding(enc?: string): Encoding;
+/**
+ * Check that an encoding string is valid. Throws TypeError if not.
+ */
+export declare function checkEncoding(encoding: string): void;

package/lib/types/gio-errors.d.ts

@@ -0,0 +1,28 @@
+/** Map from Gio.IOErrorEnum numeric values to Node.js error code strings. */
+export declare const GIO_ERROR_TO_NODE: Record<number, string>;
+export interface NodeErrorDetails {
+    path?: string;
+    dest?: string;
+    address?: string;
+    port?: number;
+    hostname?: string;
+}
+/** Node.js-style ErrnoException (defined locally to avoid @types/node dependency). */
+export interface ErrnoException extends Error {
+    errno?: number;
+    code?: string;
+    path?: string;
+    syscall?: string;
+    address?: string;
+    port?: number;
+    hostname?: string;
+}
+/**
+ * Create a Node.js-style ErrnoException from a Gio error.
+ * Works for fs, net, dns, child-process, and other modules.
+ */
+export declare function createNodeError(err: unknown, syscall: string, details?: NodeErrorDetails): ErrnoException;
+/**
+ * Check if a Gio error is a "not found" error.
+ */
+export declare function isNotFoundError(err: unknown): boolean;

package/lib/types/gio.d.ts

@@ -0,0 +1,17 @@
+import Gio from '@girs/gio-2.0';
+/**
+ * Generic promise wrapper for Gio async/finish method pairs.
+ *
+ * Example:
+ *   const stream = await gioAsync<Gio.InputStream>(session, 'send_async', 'send_finish', msg, priority, null);
+ */
+export declare function gioAsync<T>(obj: any, asyncMethod: string, finishMethod: string, ...args: any[]): Promise<T>;
+/**
+ * Promise wrapper around `Gio.InputStream.read_bytes_async` / `read_bytes_finish`.
+ * Returns a `Uint8Array` or `null` if the end of the stream is reached.
+ */
+export declare function readBytesAsync(inputStream: Gio.InputStream, count?: number, ioPriority?: number, cancellable?: Gio.Cancellable | null): Promise<Uint8Array | null>;
+/**
+ * Async generator that yields `Uint8Array` chunks from a `Gio.InputStream`.
+ */
+export declare function inputStreamAsyncIterator(inputStream: Gio.InputStream, count?: number, ioPriority?: number, cancellable?: Gio.Cancellable | null): AsyncGenerator<Uint8Array>;

package/lib/types/globals.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Register a value as a global property if it doesn't already exist.
+ * This is a no-op in environments where the global is already defined (e.g. Node.js).
+ */
+export declare function registerGlobal(name: string, value: unknown): void;

package/lib/types/index.d.ts

@@ -1,14 +1,16 @@
-export * from './types/index.js';
-export * from './cancel-handler.js';
+export * from './base64.js';
+export * from './byte-array.js';
 export * from './cli.js';
+export * from './defer.js';
+export * from './encoding.js';
+export * from './globals.js';
 export * from './error.js';
 export * from './file.js';
 export * from './fs.js';
-export * from './log.js';
+export * from './gio.js';
+export * from './gio-errors.js';
 export * from './message.js';
-export * from './os.js';
+export * from './next-tick.js';
 export * from './path.js';
-export * from './process.js';
-export * from './system.js';
-export * from './tty.js';
-export * from './version.js';
+export * from './structured-clone.js';
+export * from './main-loop.js';