@econ-v1/app-sdk 7.6.64 → 7.6.66

package/dist/burger-build/aliases.d.ts

@@ -3,7 +3,7 @@
  * they become. Everything here is data; `classifySpecifier` is the only
  * decision function.
  */
-export declare const BURGER_MODULES: readonly ["burger:host", "burger:fs", "burger:fs/promises", "burger:path", "burger:os", "burger:worker_threads", "burger:crypto", "burger:buffer", "burger:sqlite", "burger:zlib", "burger:async_hooks", "burger:zod", "burger:test"];
+export declare const BURGER_MODULES: readonly ["burger:host", "burger:fs", "burger:fs/promises", "burger:path", "burger:os", "burger:worker_threads", "burger:crypto", "burger:buffer", "burger:sqlite", "burger:zlib", "burger:async_hooks", "burger:zod", "burger:net", "burger:tls", "burger:dns/promises", "burger:test"];
 export type BurgerModule = (typeof BURGER_MODULES)[number];
 /** C5/C6 "Aliased from" columns (plus `fs/promises`, the module form of `fs.promises`). */
 export declare const ALIASES: ReadonlyMap<string, BurgerModule>;
@@ -42,6 +42,12 @@ export declare const NODE_BUILTINS: ReadonlySet<string>;
  * `burger:zod` (node-app-burger ADR 015, >= 0.3.12) has no `node:`/`bun:`
  * alias: an app imports it by name (`import { install } from "burger:zod";
  * install(z);`) to compile its zod 3 schemas into plain check functions.
+ *
+ * SOCKET PACK (node-app-burger ADR 018, >= 0.3.15): `burger:net`, `burger:tls`
+ * and `burger:dns/promises` are a client subset, what node-app-api-store's
+ * timed HTTP client (ADR-120) uses: `net.connect`/`createConnection`, `isIP`,
+ * `Socket` (no `createServer`), `tls.connect` with certificate checks always
+ * on (`rejectUnauthorized: false` throws), and `lookup`.
  */
 export declare const BURGER_EXPORTS: Readonly<Record<BurgerModule, readonly string[]>>;
 /**

package/dist/burger-build/cli.js

@@ -35,6 +35,9 @@ var BURGER_MODULES = [
   "burger:zlib",
   "burger:async_hooks",
   "burger:zod",
+  "burger:net",
+  "burger:tls",
+  "burger:dns/promises",
   "burger:test"
 ];
 var ALIASES = new Map([
@@ -57,7 +60,13 @@ var ALIASES = new Map([
   ["zlib", "burger:zlib"],
   ["node:async_hooks", "burger:async_hooks"],
   ["async_hooks", "burger:async_hooks"],
-  ["bun:test", "burger:test"]
+  ["bun:test", "burger:test"],
+  ["node:net", "burger:net"],
+  ["net", "burger:net"],
+  ["node:tls", "burger:tls"],
+  ["tls", "burger:tls"],
+  ["node:dns/promises", "burger:dns/promises"],
+  ["dns/promises", "burger:dns/promises"]
 ]);
 var NODE_BUILTINS = new Set([
   "_http_agent",
@@ -218,6 +227,9 @@ var BURGER_EXPORTS = {
   ],
   "burger:async_hooks": ["AsyncLocalStorage"],
   "burger:zod": ["install", "compile"],
+  "burger:net": ["Socket", "connect", "createConnection", "isIP", "isIPv4", "isIPv6"],
+  "burger:tls": ["TLSSocket", "connect"],
+  "burger:dns/promises": ["lookup"],
   "burger:test": [
     "describe",
     "test",
@@ -243,7 +255,10 @@ var BURGER_DEFAULT_EXPORT = {
   "burger:sqlite": true,
   "burger:zlib": true,
   "burger:async_hooks": true,
-  "burger:zod": true
+  "burger:zod": true,
+  "burger:net": true,
+  "burger:tls": true,
+  "burger:dns/promises": true
 };
 var BURGER_MODULE_SET = new Set(BURGER_MODULES);
 function classifySpecifier(specifier) {

package/dist/burger-build/index.js

@@ -30,6 +30,9 @@ var BURGER_MODULES = [
   "burger:zlib",
   "burger:async_hooks",
   "burger:zod",
+  "burger:net",
+  "burger:tls",
+  "burger:dns/promises",
   "burger:test"
 ];
 var ALIASES = new Map([
@@ -52,7 +55,13 @@ var ALIASES = new Map([
   ["zlib", "burger:zlib"],
   ["node:async_hooks", "burger:async_hooks"],
   ["async_hooks", "burger:async_hooks"],
-  ["bun:test", "burger:test"]
+  ["bun:test", "burger:test"],
+  ["node:net", "burger:net"],
+  ["net", "burger:net"],
+  ["node:tls", "burger:tls"],
+  ["tls", "burger:tls"],
+  ["node:dns/promises", "burger:dns/promises"],
+  ["dns/promises", "burger:dns/promises"]
 ]);
 var NODE_BUILTINS = new Set([
   "_http_agent",
@@ -213,6 +222,9 @@ var BURGER_EXPORTS = {
   ],
   "burger:async_hooks": ["AsyncLocalStorage"],
   "burger:zod": ["install", "compile"],
+  "burger:net": ["Socket", "connect", "createConnection", "isIP", "isIPv4", "isIPv6"],
+  "burger:tls": ["TLSSocket", "connect"],
+  "burger:dns/promises": ["lookup"],
   "burger:test": [
     "describe",
     "test",
@@ -238,7 +250,10 @@ var BURGER_DEFAULT_EXPORT = {
   "burger:sqlite": true,
   "burger:zlib": true,
   "burger:async_hooks": true,
-  "burger:zod": true
+  "burger:zod": true,
+  "burger:net": true,
+  "burger:tls": true,
+  "burger:dns/promises": true
 };
 var BURGER_MODULE_SET = new Set(BURGER_MODULES);
 function classifySpecifier(specifier) {

package/dist/burger-types/aliases.d.ts

@@ -24,3 +24,10 @@ declare module "zlib" { export * from "burger:zlib"; export { default } from "bu
 declare module "node:async_hooks" { export * from "burger:async_hooks"; export { default } from "burger:async_hooks"; }
 declare module "async_hooks" { export * from "burger:async_hooks"; export { default } from "burger:async_hooks"; }
 declare module "bun:test" { export * from "burger:test"; }
+// Socket pack (node-app-burger ADR 018, >= 0.3.15): the client subset of net, tls and dns/promises.
+declare module "node:net" { export * from "burger:net"; export { default } from "burger:net"; }
+declare module "net" { export * from "burger:net"; export { default } from "burger:net"; }
+declare module "node:tls" { export * from "burger:tls"; export { default } from "burger:tls"; }
+declare module "tls" { export * from "burger:tls"; export { default } from "burger:tls"; }
+declare module "node:dns/promises" { export * from "burger:dns/promises"; export { default } from "burger:dns/promises"; }
+declare module "dns/promises" { export * from "burger:dns/promises"; export { default } from "burger:dns/promises"; }

package/dist/burger-types/modules.d.ts

@@ -511,6 +511,198 @@ declare module "burger:zod" {
   export default burgerZod;
 }
 
+/** Socket pack (node-app-burger ADR 018, >= 0.3.15): the client subset of `node:net` that
+ *  node-app-api-store's timed HTTP client (ADR-120) uses. No servers, no IPC paths, no
+ *  `allowHalfOpen`. At most 32 open sockets per app (one more fails with `EMFILE`). */
+declare module "burger:net" {
+  import type { Buffer, BufferEncoding } from "burger:buffer";
+
+  export interface SocketConnectOpts {
+    port: number | string;
+    host?: string;
+    noDelay?: boolean;
+  }
+
+  export interface SocketAddress {
+    address: string;
+    family: "IPv4" | "IPv6";
+    port: number;
+  }
+
+  export interface SocketEvents {
+    connect: [];
+    ready: [];
+    data: [data: Buffer];
+    end: [];
+    finish: [];
+    drain: [];
+    error: [error: Error];
+    close: [hadError: boolean];
+    lookup: [error: Error | null, address: string, family: number, host: string];
+  }
+
+  type Listener<Args extends unknown[]> = (...args: Args) => void;
+  /** Any listener: every function type is assignable to it. */
+  export type AnyListener = (...args: never[]) => void;
+
+  /** A TCP client socket: Node's net.Socket events and methods, the part a client uses. */
+  export class Socket {
+    constructor(options?: { noDelay?: boolean });
+    readonly connecting: boolean;
+    readonly destroyed: boolean;
+    readonly pending: boolean;
+    readonly readable: boolean;
+    readonly writable: boolean;
+    readonly readyState: "opening" | "open" | "readOnly" | "writeOnly" | "closed";
+    readonly remoteAddress: string | undefined;
+    readonly remotePort: number | undefined;
+    readonly remoteFamily: "IPv4" | "IPv6" | undefined;
+    readonly localAddress: string | undefined;
+    readonly localPort: number | undefined;
+    readonly localFamily: "IPv4" | "IPv6" | undefined;
+    readonly bytesRead: number;
+    readonly bytesWritten: number;
+    connect(options: SocketConnectOpts, connectListener?: () => void): this;
+    connect(port: number, host?: string, connectListener?: () => void): this;
+    /** `false` once 16 KiB wait to be sent; `drain` follows when they are gone. */
+    write(data: string | Uint8Array, callback?: (error: Error | null) => void): boolean;
+    write(data: string | Uint8Array, encoding?: BufferEncoding, callback?: (error: Error | null) => void): boolean;
+    end(callback?: () => void): this;
+    end(data: string | Uint8Array, callback?: () => void): this;
+    end(data: string | Uint8Array, encoding?: BufferEncoding, callback?: () => void): this;
+    destroy(error?: Error): this;
+    pause(): this;
+    resume(): this;
+    isPaused(): boolean;
+    setNoDelay(noDelay?: boolean): this;
+    ref(): this;
+    unref(): this;
+    address(): SocketAddress | Record<string, never>;
+    on<Name extends keyof SocketEvents>(event: Name, listener: Listener<SocketEvents[Name]>): this;
+    on(event: string | symbol, listener: AnyListener): this;
+    addListener<Name extends keyof SocketEvents>(event: Name, listener: Listener<SocketEvents[Name]>): this;
+    addListener(event: string | symbol, listener: AnyListener): this;
+    prependListener<Name extends keyof SocketEvents>(event: Name, listener: Listener<SocketEvents[Name]>): this;
+    prependListener(event: string | symbol, listener: AnyListener): this;
+    once<Name extends keyof SocketEvents>(event: Name, listener: Listener<SocketEvents[Name]>): this;
+    once(event: string | symbol, listener: AnyListener): this;
+    prependOnceListener<Name extends keyof SocketEvents>(event: Name, listener: Listener<SocketEvents[Name]>): this;
+    prependOnceListener(event: string | symbol, listener: AnyListener): this;
+    off(event: string | symbol, listener: AnyListener): this;
+    removeListener(event: string | symbol, listener: AnyListener): this;
+    removeAllListeners(event?: string | symbol): this;
+    emit(event: string | symbol, ...args: unknown[]): boolean;
+    listenerCount(event: string | symbol, listener?: AnyListener): number;
+    listeners(event: string | symbol): AnyListener[];
+    rawListeners(event: string | symbol): AnyListener[];
+    eventNames(): Array<string | symbol>;
+    setMaxListeners(n: number): this;
+    getMaxListeners(): number;
+  }
+
+  export function connect(options: SocketConnectOpts, connectListener?: () => void): Socket;
+  export function connect(port: number, host?: string, connectListener?: () => void): Socket;
+  export function createConnection(options: SocketConnectOpts, connectListener?: () => void): Socket;
+  export function createConnection(port: number, host?: string, connectListener?: () => void): Socket;
+  /** 4, 6, or 0 when `input` is no IP address (Node's patterns, zone ids included). */
+  export function isIP(input: string): number;
+  export function isIPv4(input: string): boolean;
+  export function isIPv6(input: string): boolean;
+
+  type SocketClass = Socket;
+  type SocketConnectOptsType = SocketConnectOpts;
+  const net: {
+    Socket: typeof Socket;
+    connect: typeof connect;
+    createConnection: typeof createConnection;
+    isIP: typeof isIP;
+    isIPv4: typeof isIPv4;
+    isIPv6: typeof isIPv6;
+  };
+  /** `net.Socket` as a type through the default import, as Node's typings allow. */
+  namespace net {
+    export type Socket = SocketClass;
+    export type SocketConnectOpts = SocketConnectOptsType;
+  }
+  export default net;
+}
+
+/** Socket pack (node-app-burger ADR 018, >= 0.3.15): `tls.connect` over rustls, Mozilla's roots
+ *  plus `NODE_EXTRA_CA_CERTS`, certificate and host checks always on. `rejectUnauthorized: false`
+ *  and the options that change the handshake (`key`, `cert`, `ciphers`, `minVersion`, ...) throw. */
+declare module "burger:tls" {
+  import type { Buffer } from "burger:buffer";
+  import { Socket, type AnyListener, type SocketEvents } from "burger:net";
+
+  export interface ConnectionOptions {
+    host?: string;
+    port?: number;
+    /** A connected or connecting `net.Socket` to run the handshake over. */
+    socket?: Socket;
+    /** The name the certificate is checked against and sent as SNI. */
+    servername?: string;
+    ALPNProtocols?: Array<string | Uint8Array> | Uint8Array;
+    /** PEM certificates that replace the bundled roots, as Node's `ca`. */
+    ca?: string | Buffer | Array<string | Buffer>;
+    noDelay?: boolean;
+    /** Only `true` (the default) is accepted. */
+    rejectUnauthorized?: true;
+  }
+
+  export interface TLSSocketEvents extends SocketEvents {
+    secureConnect: [];
+  }
+
+  type Listener<Args extends unknown[]> = (...args: Args) => void;
+
+  export class TLSSocket extends Socket {
+    readonly encrypted: true;
+    readonly authorized: boolean;
+    readonly authorizationError: Error | null;
+    /** The protocol the server chose by ALPN, or `false`. */
+    readonly alpnProtocol: string | false;
+    /** "TLSv1.3" or "TLSv1.2" once connected; `null` before. */
+    getProtocol(): string | null;
+    on<Name extends keyof TLSSocketEvents>(event: Name, listener: Listener<TLSSocketEvents[Name]>): this;
+    on(event: string | symbol, listener: AnyListener): this;
+    once<Name extends keyof TLSSocketEvents>(event: Name, listener: Listener<TLSSocketEvents[Name]>): this;
+    once(event: string | symbol, listener: AnyListener): this;
+  }
+
+  export function connect(options: ConnectionOptions, secureConnectListener?: () => void): TLSSocket;
+  export function connect(port: number, host?: string, options?: ConnectionOptions, secureConnectListener?: () => void): TLSSocket;
+  export function connect(port: number, options?: ConnectionOptions, secureConnectListener?: () => void): TLSSocket;
+
+  type TLSSocketClass = TLSSocket;
+  type ConnectionOptionsType = ConnectionOptions;
+  const tls: { TLSSocket: typeof TLSSocket; connect: typeof connect };
+  /** `tls.ConnectionOptions` and `tls.TLSSocket` as types through the default import. */
+  namespace tls {
+    export type TLSSocket = TLSSocketClass;
+    export type ConnectionOptions = ConnectionOptionsType;
+  }
+  export default tls;
+}
+
+/** Socket pack (node-app-burger ADR 018, >= 0.3.15): `lookup` from `node:dns/promises`,
+ *  `getaddrinfo` off the app thread and not cached. `node:dns` itself is not provided. */
+declare module "burger:dns/promises" {
+  export interface LookupAddress {
+    address: string;
+    family: number;
+  }
+
+  export interface LookupOptions {
+    family?: 0 | 4 | 6 | "IPv4" | "IPv6";
+    all?: boolean;
+  }
+
+  export function lookup(hostname: string, options: LookupOptions & { all: true }): Promise<LookupAddress[]>;
+  export function lookup(hostname: string, options?: LookupOptions | 0 | 4 | 6): Promise<LookupAddress>;
+  const dnsPromises: { lookup: typeof lookup };
+  export default dnsPromises;
+}
+
 declare module "burger:buffer" {
   export type BufferEncoding = "utf8" | "utf-8" | "hex" | "base64" | "base64url" | "latin1" | "binary" | "ascii";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@econ-v1/app-sdk",
-  "version": "7.6.64",
+  "version": "7.6.66",
   "description": "TypeScript SDK for building Node mini-app plugins (Bun runtime) on the Lightning-powered marketplace daemon",
   "license": "MIT OR Apache-2.0",
   "author": "Node contributors",