@nimbus-sh/core 0.1.0

package/src/substrate/lifo/node-compat/dns.ts

@@ -0,0 +1,214 @@
+/**
+ * Node.js `dns` module shim for Lifo.
+ *
+ * Real DNS resolution is not available in the browser. The callback-style API
+ * invokes callbacks with an ENOTFOUND error, while the promises API rejects.
+ * `lookup` is the most commonly used function so it gets special treatment:
+ * for "localhost" it resolves to 127.0.0.1, everything else errors.
+ */
+
+const NOTFOUND = 'ENOTFOUND';
+
+function makeError(hostname: string, syscall: string): Error & { code: string; hostname: string; syscall: string } {
+  const err = new Error(`getaddrinfo ${NOTFOUND} ${hostname}`) as Error & { code: string; hostname: string; syscall: string };
+  err.code = NOTFOUND;
+  err.hostname = hostname;
+  err.syscall = syscall;
+  return err;
+}
+
+type LookupCallback = (err: Error | null, address?: string, family?: number) => void;
+type LookupAllCallback = (err: Error | null, addresses?: Array<{ address: string; family: number }>) => void;
+
+function lookup(hostname: string, options: { all: true }, cb: LookupAllCallback): void;
+function lookup(hostname: string, options: { family?: number } | number, cb: LookupCallback): void;
+function lookup(hostname: string, cb: LookupCallback): void;
+function lookup(
+  hostname: string,
+  optionsOrCb?: { all?: boolean; family?: number } | number | LookupCallback | LookupAllCallback,
+  cb?: LookupCallback | LookupAllCallback,
+): void {
+  let callback: LookupCallback | LookupAllCallback;
+  let all = false;
+
+  if (typeof optionsOrCb === 'function') {
+    callback = optionsOrCb;
+  } else {
+    if (typeof optionsOrCb === 'object' && optionsOrCb?.all) all = true;
+    callback = cb!;
+  }
+
+  if (hostname === 'localhost' || hostname === '127.0.0.1') {
+    if (all) {
+      (callback as LookupAllCallback)(null, [{ address: '127.0.0.1', family: 4 }]);
+    } else {
+      (callback as LookupCallback)(null, '127.0.0.1', 4);
+    }
+    return;
+  }
+
+  callback(makeError(hostname, 'getaddrinfo'));
+}
+
+function resolve(hostname: string, cb: (err: Error | null, addresses?: string[]) => void): void;
+function resolve(hostname: string, rrtype: string, cb: (err: Error | null, addresses?: unknown[]) => void): void;
+function resolve(
+  hostname: string,
+  rrtypeOrCb: string | ((err: Error | null, addresses?: string[]) => void),
+  cb?: (err: Error | null, addresses?: unknown[]) => void,
+): void {
+  const callback = typeof rrtypeOrCb === 'function' ? rrtypeOrCb : cb!;
+  callback(makeError(hostname, 'queryA'));
+}
+
+function resolve4(hostname: string, cb: (err: Error | null, addresses?: string[]) => void): void {
+  cb(makeError(hostname, 'queryA'));
+}
+
+function resolve6(hostname: string, cb: (err: Error | null, addresses?: string[]) => void): void {
+  cb(makeError(hostname, 'queryAaaa'));
+}
+
+function resolveMx(hostname: string, cb: (err: Error | null, addresses?: Array<{ exchange: string; priority: number }>) => void): void {
+  cb(makeError(hostname, 'queryMx'));
+}
+
+function resolveTxt(hostname: string, cb: (err: Error | null, addresses?: string[][]) => void): void {
+  cb(makeError(hostname, 'queryTxt'));
+}
+
+function resolveSrv(hostname: string, cb: (err: Error | null, addresses?: Array<{ name: string; port: number; priority: number; weight: number }>) => void): void {
+  cb(makeError(hostname, 'querySrv'));
+}
+
+function resolveNs(hostname: string, cb: (err: Error | null, addresses?: string[]) => void): void {
+  cb(makeError(hostname, 'queryNs'));
+}
+
+function resolveCname(hostname: string, cb: (err: Error | null, addresses?: string[]) => void): void {
+  cb(makeError(hostname, 'queryCname'));
+}
+
+function reverse(ip: string, cb: (err: Error | null, hostnames?: string[]) => void): void {
+  cb(makeError(ip, 'getHostByAddr'));
+}
+
+function setServers(_servers: string[]): void {
+  // no-op
+}
+
+function getServers(): string[] {
+  return [];
+}
+
+// dns.promises API
+const promises = {
+  lookup: (hostname: string, options?: { all?: boolean; family?: number } | number): Promise<{ address: string; family: number } | Array<{ address: string; family: number }>> => {
+    return new Promise((resolve, reject) => {
+      if (hostname === 'localhost' || hostname === '127.0.0.1') {
+        const entry = { address: '127.0.0.1', family: 4 };
+        if (typeof options === 'object' && options?.all) {
+          resolve([entry]);
+        } else {
+          resolve(entry);
+        }
+        return;
+      }
+      reject(makeError(hostname, 'getaddrinfo'));
+    });
+  },
+  resolve: (hostname: string, _rrtype?: string): Promise<string[]> => {
+    return Promise.reject(makeError(hostname, 'queryA'));
+  },
+  resolve4: (hostname: string): Promise<string[]> => {
+    return Promise.reject(makeError(hostname, 'queryA'));
+  },
+  resolve6: (hostname: string): Promise<string[]> => {
+    return Promise.reject(makeError(hostname, 'queryAaaa'));
+  },
+  reverse: (ip: string): Promise<string[]> => {
+    return Promise.reject(makeError(ip, 'getHostByAddr'));
+  },
+  setServers: (_servers: string[]): void => { /* no-op */ },
+  getServers: (): string[] => [],
+};
+
+// Error code constants
+const ADDRGETNETWORKPARAMS = 'EADDRGETNETWORKPARAMS';
+const BADFAMILY = 'EBADFAMILY';
+const BADFLAGS = 'EBADFLAGS';
+const BADHINTS = 'EBADHINTS';
+const BADNAME = 'EBADNAME';
+const BADQUERY = 'EBADQUERY';
+const BADRESP = 'EBADRESP';
+const BADSTR = 'EBADSTR';
+const CANCELLED = 'ECANCELLED';
+const CONNREFUSED = 'ECONNREFUSED';
+const DESTRUCTION = 'EDESTRUCTION';
+const EOF = 'EEOF';
+const FILE = 'EFILE';
+const FORMERR = 'EFORMERR';
+const LOADIPHLPAPI = 'ELOADIPHLPAPI';
+const NODATA = 'ENODATA';
+const NOMEM = 'ENOMEM';
+const NONAME = 'ENONAME';
+const NOTINITIALIZED = 'ENOTINITIALIZED';
+const REFUSED = 'EREFUSED';
+const SERVFAIL = 'ESERVFAIL';
+const TIMEOUT = 'ETIMEOUT';
+
+export {
+  lookup,
+  resolve,
+  resolve4,
+  resolve6,
+  resolveMx,
+  resolveTxt,
+  resolveSrv,
+  resolveNs,
+  resolveCname,
+  reverse,
+  setServers,
+  getServers,
+  promises,
+  NOTFOUND,
+  ADDRGETNETWORKPARAMS,
+  BADFAMILY,
+  BADFLAGS,
+  BADHINTS,
+  BADNAME,
+  BADQUERY,
+  BADRESP,
+  BADSTR,
+  CANCELLED,
+  CONNREFUSED,
+  DESTRUCTION,
+  EOF,
+  FILE,
+  FORMERR,
+  LOADIPHLPAPI,
+  NODATA,
+  NOMEM,
+  NONAME,
+  NOTINITIALIZED,
+  REFUSED,
+  SERVFAIL,
+  TIMEOUT,
+};
+
+export default {
+  lookup,
+  resolve,
+  resolve4,
+  resolve6,
+  resolveMx,
+  resolveTxt,
+  resolveSrv,
+  resolveNs,
+  resolveCname,
+  reverse,
+  setServers,
+  getServers,
+  promises,
+  NOTFOUND,
+};

package/src/substrate/lifo/node-compat/esbuild.ts

@@ -0,0 +1,85 @@
+/**
+ * esbuild shim that uses esbuild-wasm loaded from CDN.
+ *
+ * When code inside Lifo does `require('esbuild')`, this shim is returned
+ * instead of the native esbuild package (which can't run in the browser).
+ *
+ * The WASM binary is lazy-loaded on first transform/build call.
+ */
+
+const ESBUILD_WASM_VERSION = '0.24.2';
+const ESBUILD_WASM_URL = `https://unpkg.com/esbuild-wasm@${ESBUILD_WASM_VERSION}/esbuild.wasm`;
+const ESBUILD_ESM_URL = `https://unpkg.com/esbuild-wasm@${ESBUILD_WASM_VERSION}/esm/browser.min.js`;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let esbuildModule: any = null;
+let initPromise: Promise<void> | null = null;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function ensureInitialized(): Promise<any> {
+  if (esbuildModule) return esbuildModule;
+
+  if (!initPromise) {
+    initPromise = (async () => {
+      // Use dynamic import from CDN
+      // This works in browsers natively
+      const mod = await import(/* @vite-ignore */ ESBUILD_ESM_URL);
+      await mod.initialize({
+        wasmURL: ESBUILD_WASM_URL,
+      });
+      esbuildModule = mod;
+    })();
+  }
+
+  await initPromise;
+  return esbuildModule;
+}
+
+export function createEsbuild(): Record<string, unknown> {
+  const mod: Record<string, unknown> = {
+    version: ESBUILD_WASM_VERSION,
+
+    initialize: async (_options?: unknown): Promise<void> => {
+      await ensureInitialized();
+    },
+
+    transform: async (code: string, options?: unknown): Promise<unknown> => {
+      const esb = await ensureInitialized();
+      return esb.transform(code, options);
+    },
+
+    transformSync: (_code: string, _options?: unknown): never => {
+      throw new Error('[lifo] esbuild.transformSync() is not available in browser. Use transform() instead.');
+    },
+
+    build: async (options?: unknown): Promise<unknown> => {
+      const esb = await ensureInitialized();
+      return esb.build(options);
+    },
+
+    buildSync: (_options?: unknown): never => {
+      throw new Error('[lifo] esbuild.buildSync() is not available in browser. Use build() instead.');
+    },
+
+    formatMessages: async (messages: unknown, options?: unknown): Promise<unknown> => {
+      const esb = await ensureInitialized();
+      return esb.formatMessages(messages, options);
+    },
+
+    analyzeMetafile: async (metafile: unknown, options?: unknown): Promise<unknown> => {
+      const esb = await ensureInitialized();
+      return esb.analyzeMetafile(metafile, options);
+    },
+
+    context: async (options?: unknown): Promise<unknown> => {
+      const esb = await ensureInitialized();
+      return esb.context(options);
+    },
+
+    stop: (): void => {
+      // No-op in browser
+    },
+  };
+
+  return mod;
+}

package/src/substrate/lifo/node-compat/events.ts

@@ -0,0 +1,94 @@
+export class EventEmitter {
+  private _events = new Map<string, Array<(...args: unknown[]) => void>>();
+  private _maxListeners = 10;
+
+  on(event: string, listener: (...args: unknown[]) => void): this {
+    let list = this._events.get(event);
+    if (!list) {
+      list = [];
+      this._events.set(event, list);
+    }
+    list.push(listener);
+    return this;
+  }
+
+  addListener(event: string, listener: (...args: unknown[]) => void): this {
+    return this.on(event, listener);
+  }
+
+  once(event: string, listener: (...args: unknown[]) => void): this {
+    const wrapped = (...args: unknown[]) => {
+      this.removeListener(event, wrapped);
+      listener.apply(this, args);
+    };
+    (wrapped as { _original?: (...args: unknown[]) => void })._original = listener;
+    return this.on(event, wrapped);
+  }
+
+  emit(event: string, ...args: unknown[]): boolean {
+    const list = this._events.get(event);
+    if (!list || list.length === 0) return false;
+    const copy = [...list];
+    for (const fn of copy) {
+      fn.apply(this, args);
+    }
+    return true;
+  }
+
+  removeListener(event: string, listener: (...args: unknown[]) => void): this {
+    const list = this._events.get(event);
+    if (!list) return this;
+    const idx = list.findIndex(
+      (fn) => fn === listener || (fn as { _original?: unknown })._original === listener,
+    );
+    if (idx !== -1) list.splice(idx, 1);
+    if (list.length === 0) this._events.delete(event);
+    return this;
+  }
+
+  off(event: string, listener: (...args: unknown[]) => void): this {
+    return this.removeListener(event, listener);
+  }
+
+  removeAllListeners(event?: string): this {
+    if (event !== undefined) {
+      this._events.delete(event);
+    } else {
+      this._events.clear();
+    }
+    return this;
+  }
+
+  listenerCount(event: string): number {
+    return this._events.get(event)?.length ?? 0;
+  }
+
+  listeners(event: string): Array<(...args: unknown[]) => void> {
+    return [...(this._events.get(event) ?? [])];
+  }
+
+  setMaxListeners(n: number): this {
+    this._maxListeners = n;
+    return this;
+  }
+
+  getMaxListeners(): number {
+    return this._maxListeners;
+  }
+
+  eventNames(): string[] {
+    return [...this._events.keys()];
+  }
+
+  prependListener(event: string, listener: (...args: unknown[]) => void): this {
+    let list = this._events.get(event);
+    if (!list) {
+      list = [];
+      this._events.set(event, list);
+    }
+    list.unshift(listener);
+    return this;
+  }
+}
+
+export default EventEmitter;