@econ-v1/app-sdk 7.6.62 → 7.6.63

package/dist/burger-build/cli.js

@@ -197,7 +197,14 @@ var BURGER_EXPORTS = {
     "timingSafeEqual",
     "createCipheriv",
     "createDecipheriv",
-    "scryptSync"
+    "scryptSync",
+    "KeyObject",
+    "generateKeyPairSync",
+    "generateKeyPair",
+    "createPublicKey",
+    "createPrivateKey",
+    "diffieHellman",
+    "hkdfSync"
   ],
   "burger:buffer": ["Buffer"],
   "burger:sqlite": ["Database"],

package/dist/burger-build/index.js

@@ -192,7 +192,14 @@ var BURGER_EXPORTS = {
     "timingSafeEqual",
     "createCipheriv",
     "createDecipheriv",
-    "scryptSync"
+    "scryptSync",
+    "KeyObject",
+    "generateKeyPairSync",
+    "generateKeyPair",
+    "createPublicKey",
+    "createPrivateKey",
+    "diffieHellman",
+    "hkdfSync"
   ],
   "burger:buffer": ["Buffer"],
   "burger:sqlite": ["Database"],

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

@@ -1,6 +1,6 @@
-// Globals present in every Burger runtime in Phase 1 (Contract C5).
-// Pair with `"lib": ["ES2023"]` and no DOM lib: fetch, URL, streams, etc. are
-// deliberately absent until Phase 2.
+// Globals present in every Burger runtime (Contract C5 and the packs since).
+// Pair with `"lib": ["ES2023"]` and no DOM lib: WebSocket, EventTarget, Blob,
+// etc. are deliberately absent.
 
 interface BurgerConsole {
   log(...data: unknown[]): void;
@@ -20,11 +20,19 @@ declare function queueMicrotask(callback: () => void): void;
 declare function setImmediate(handler: (...args: any[]) => void, ...args: any[]): number;
 declare function clearImmediate(id: number | undefined): void;
 
+/** QuickJS's built-in DOMException: `name` defaults to "Error", `code` is the legacy number of the name (20 for AbortError). */
+declare class DOMException extends Error {
+  constructor(message?: string, name?: string);
+  readonly code: number;
+}
+
 /**
  * Agent runtime pack (node-app-burger ADR 003, >= 0.3.3): the WHATWG pair
  * without the DOM. Listeners receive a plain `{ type: "abort", target,
  * currentTarget }`; there is no EventTarget or Event class. The default
- * reason is an Error named AbortError; a timeout's is named TimeoutError.
+ * reason is a DOMException named AbortError (code 20); a timeout's is named
+ * TimeoutError (code 23). Releases before 0.3.10 (fetch pack, ADR 011) used an
+ * Error with the same name.
  */
 interface BurgerAbortEvent {
   readonly type: "abort";
@@ -58,7 +66,12 @@ declare class TextEncoder {
 declare class TextDecoder {
   constructor(label?: "utf-8" | "utf8", options?: { fatal?: boolean; ignoreBOM?: boolean });
   readonly encoding: "utf-8";
-  decode(input?: Uint8Array | ArrayBuffer): string;
+  /**
+   * `{ stream: true }` (text and bytes pack, node-app-burger ADR 007, >= 0.3.6): a UTF-8
+   * sequence the chunk cuts off is held and joined with the next call; a call without `stream`
+   * flushes it. Older Burger ignores `stream`.
+   */
+  decode(input?: ArrayBuffer | ArrayBufferView, options?: { stream?: boolean }): string;
 }
 
 declare var performance: { now(): number };
@@ -74,6 +87,107 @@ type Buffer = import("burger:buffer").Buffer;
 
 declare function structuredClone<T>(value: T): T;
 
+/**
+ * Fetch pack (node-app-burger ADR 011, >= 0.3.10): `fetch`, `Response`,
+ * `Headers` and `ReadableStream`, with
+ * Node's and Bun's semantics over HTTP/1.1 and HTTP/2 (ALPN), TLS with
+ * Mozilla's roots plus `NODE_EXTRA_CA_CERTS`, gzip/deflate/br decoding and up
+ * to 20 redirects. Errors are `TypeError`s carrying Bun's `code`
+ * (`ECONNREFUSED`, `ENOTFOUND`, `CERT_HAS_EXPIRED`, ...); an abort rejects
+ * with the signal's reason, and an abort or `cancel()` during the body closes
+ * an HTTP/1.1 socket (never pooled) or resets an HTTP/2 stream. No `Request`,
+ * `FormData`, `Blob`, `clone()`, `tee`/`pipeTo` or BYOB readers.
+ */
+type HeadersInit = Headers | Iterable<readonly [string, string]> | Record<string, string>;
+type BodyInit = string | ArrayBuffer | ArrayBufferView | URLSearchParams | ReadableStream<Uint8Array>;
+declare class Headers {
+  constructor(init?: HeadersInit);
+  append(name: string, value: string): void;
+  delete(name: string): void;
+  get(name: string): string | null;
+  getSetCookie(): string[];
+  has(name: string): boolean;
+  set(name: string, value: string): void;
+  forEach(callback: (value: string, name: string, headers: Headers) => void, thisArg?: unknown): void;
+  entries(): IterableIterator<[string, string]>;
+  keys(): IterableIterator<string>;
+  values(): IterableIterator<string>;
+  [Symbol.iterator](): IterableIterator<[string, string]>;
+}
+type ReadableStreamReadResult<R> = { done: false; value: R } | { done: true; value: undefined };
+interface ReadableStreamDefaultController<R = unknown> {
+  readonly desiredSize: number | null;
+  enqueue(chunk: R): void;
+  close(): void;
+  error(reason?: unknown): void;
+}
+interface UnderlyingDefaultSource<R = unknown> {
+  start?(controller: ReadableStreamDefaultController<R>): void | PromiseLike<void>;
+  pull?(controller: ReadableStreamDefaultController<R>): void | PromiseLike<void>;
+  cancel?(reason?: unknown): void | PromiseLike<void>;
+}
+interface QueuingStrategy<R = unknown> {
+  highWaterMark?: number;
+  size?(chunk: R): number;
+}
+declare class ReadableStreamDefaultReader<R = unknown> {
+  constructor(stream: ReadableStream<R>);
+  readonly closed: Promise<void>;
+  read(): Promise<ReadableStreamReadResult<R>>;
+  cancel(reason?: unknown): Promise<void>;
+  releaseLock(): void;
+}
+declare class ReadableStream<R = unknown> {
+  constructor(underlyingSource?: UnderlyingDefaultSource<R>, strategy?: QueuingStrategy<R>);
+  readonly locked: boolean;
+  cancel(reason?: unknown): Promise<void>;
+  getReader(): ReadableStreamDefaultReader<R>;
+  values(options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
+  [Symbol.asyncIterator](options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
+  /**
+   * Burger only (ADR 011): the body as batches of complete lines, without
+   * their `\n` (and a `\r` before it), one batch per read. For a fetch body
+   * the bytes are split and decoded natively off the app thread, so a UTF-8
+   * character cut across reads is never broken. Feature-detect it
+   * (`typeof body.readLines === "function"`) in code that also runs on Bun.
+   */
+  readLines(): AsyncIterableIterator<string[]>;
+}
+interface ResponseInit {
+  status?: number;
+  statusText?: string;
+  headers?: HeadersInit;
+}
+declare class Response {
+  constructor(body?: BodyInit | null, init?: ResponseInit);
+  readonly type: "basic" | "default" | "error";
+  readonly url: string;
+  readonly redirected: boolean;
+  readonly status: number;
+  readonly ok: boolean;
+  readonly statusText: string;
+  readonly headers: Headers;
+  readonly body: ReadableStream<Uint8Array> | null;
+  readonly bodyUsed: boolean;
+  text(): Promise<string>;
+  /** `any` as in bun-types and lib.dom, so code that type-checks against Bun compiles here unchanged. */
+  json(): Promise<any>;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  bytes(): Promise<Uint8Array>;
+  static json(data: unknown, init?: ResponseInit): Response;
+  static error(): Response;
+  static redirect(url: string, status?: 301 | 302 | 303 | 307 | 308): Response;
+}
+interface RequestInit {
+  method?: string;
+  headers?: HeadersInit;
+  body?: BodyInit | null;
+  redirect?: "follow" | "error" | "manual";
+  signal?: AbortSignal | null;
+}
+/** `input` is a URL string, or an object with `href` (a URL) or `url`. */
+declare function fetch(input: string | { readonly href: string } | { readonly url: string }, init?: RequestInit): Promise<Response>;
+
 interface BurgerProcessMemoryUsage {
   heapUsed: number;
   heapTotal: number;
@@ -145,3 +259,48 @@ declare var onmessage: ((event: BurgerWorkerMessageEvent) => void) | null;
 declare function addEventListener(type: "message", listener: (event: BurgerWorkerMessageEvent) => void): void;
 declare function removeEventListener(type: "message", listener: (event: BurgerWorkerMessageEvent) => void): void;
 declare var self: typeof globalThis;
+
+/**
+ * URL pack (node-app-burger ADR 010, >= 0.3.9): the WHATWG
+ * `URL` and `URLSearchParams` with Node's behaviour, parsed by Ada (the
+ * parser Node uses). A parse failure throws a TypeError with
+ * `code: "ERR_INVALID_URL"`. No `URL.createObjectURL`/`revokeObjectURL`
+ * (Burger has no Blob) and no `node:url` module.
+ */
+declare class URL {
+  constructor(url: string | { toString(): string }, base?: string | URL);
+  static canParse(url: string | { toString(): string }, base?: string | URL): boolean;
+  static parse(url: string | { toString(): string }, base?: string | URL): URL | null;
+  href: string;
+  readonly origin: string;
+  protocol: string;
+  username: string;
+  password: string;
+  host: string;
+  hostname: string;
+  port: string;
+  pathname: string;
+  search: string;
+  readonly searchParams: URLSearchParams;
+  hash: string;
+  toString(): string;
+  toJSON(): string;
+}
+
+declare class URLSearchParams {
+  constructor(init?: string | URLSearchParams | Iterable<readonly [string, string] | readonly string[]> | Record<string, string>);
+  readonly size: number;
+  append(name: string, value: string): void;
+  delete(name: string, value?: string): void;
+  get(name: string): string | null;
+  getAll(name: string): string[];
+  has(name: string, value?: string): boolean;
+  set(name: string, value: string): void;
+  sort(): void;
+  forEach<This = undefined>(callback: (this: This, value: string, name: string, params: URLSearchParams) => void, thisArg?: This): void;
+  keys(): IterableIterator<string>;
+  values(): IterableIterator<string>;
+  entries(): IterableIterator<[string, string]>;
+  [Symbol.iterator](): IterableIterator<[string, string]>;
+  toString(): string;
+}

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

@@ -360,6 +360,66 @@ declare module "burger:crypto" {
   }
   export function scryptSync(password: BinaryLike, salt: BinaryLike, keylen: number, options?: ScryptOptions): Buffer;
 
+  /**
+   * X25519 keys, diffieHellman and hkdfSync (node-app-burger ADR 012, the
+   * release after 0.3.10), for node-app-api-store's sealed sessions. Keys are
+   * X25519 only: other key types throw. Key bytes stay native until exported.
+   */
+  export type KeyFormat = "pem" | "der" | "jwk";
+  export interface X25519Jwk {
+    kty: "OKP";
+    crv: "X25519";
+    x: string;
+    d?: string;
+  }
+  export interface PublicKeyExportOptions<F extends KeyFormat = KeyFormat> {
+    format: F;
+    type?: "spki";
+  }
+  export interface PrivateKeyExportOptions<F extends KeyFormat = KeyFormat> {
+    format: F;
+    type?: "pkcs8";
+  }
+  export class KeyObject {
+    private constructor();
+    readonly type: "public" | "private";
+    readonly asymmetricKeyType: "x25519";
+    readonly asymmetricKeyDetails: {};
+    equals(otherKeyObject: KeyObject): boolean;
+    export(options: { format: "pem"; type: "spki" | "pkcs8" }): string;
+    export(options: { format: "der"; type: "spki" | "pkcs8" }): Buffer;
+    export(options: { format: "jwk" }): X25519Jwk;
+  }
+  export interface KeyInput {
+    key: string | ArrayBuffer | ArrayBufferView;
+    format?: "pem" | "der";
+    type?: "spki" | "pkcs8";
+    encoding?: string;
+    passphrase?: string | Uint8Array;
+  }
+  export interface JwkKeyInput {
+    key: X25519Jwk;
+    format: "jwk";
+  }
+  export function createPublicKey(key: string | ArrayBuffer | ArrayBufferView | KeyObject | KeyInput | JwkKeyInput | { key: KeyObject }): KeyObject;
+  export function createPrivateKey(key: string | ArrayBuffer | ArrayBufferView | KeyInput | JwkKeyInput): KeyObject;
+  export function diffieHellman(options: { privateKey: KeyObject; publicKey: KeyObject }): Buffer;
+  export function hkdfSync(digest: HashAlgorithm, ikm: BinaryLike, salt: BinaryLike, info: BinaryLike, keylen: number): ArrayBuffer;
+
+  export interface KeyPairKeyObjectResult {
+    publicKey: KeyObject;
+    privateKey: KeyObject;
+  }
+  export interface KeyPairEncodings {
+    publicKeyEncoding?: { type: "spki"; format: "pem" | "der" } | { format: "jwk" };
+    privateKeyEncoding?: { type: "pkcs8"; format: "pem" | "der" } | { format: "jwk" };
+  }
+  type Encoded<E> = E extends { format: "pem" } ? string : E extends { format: "der" } ? Buffer : E extends { format: "jwk" } ? X25519Jwk : KeyObject;
+  export function generateKeyPairSync(type: "x25519"): KeyPairKeyObjectResult;
+  export function generateKeyPairSync<O extends KeyPairEncodings>(type: "x25519", options: O): { publicKey: Encoded<O["publicKeyEncoding"]>; privateKey: Encoded<O["privateKeyEncoding"]> };
+  export function generateKeyPair(type: "x25519", callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void): void;
+  export function generateKeyPair<O extends KeyPairEncodings>(type: "x25519", options: O, callback: (err: Error | null, publicKey: Encoded<O["publicKeyEncoding"]>, privateKey: Encoded<O["privateKeyEncoding"]>) => void): void;
+
   const crypto: {
     randomUUID: typeof randomUUID;
     randomBytes: typeof randomBytes;
@@ -369,6 +429,13 @@ declare module "burger:crypto" {
     createCipheriv: typeof createCipheriv;
     createDecipheriv: typeof createDecipheriv;
     scryptSync: typeof scryptSync;
+    KeyObject: typeof KeyObject;
+    generateKeyPairSync: typeof generateKeyPairSync;
+    generateKeyPair: typeof generateKeyPair;
+    createPublicKey: typeof createPublicKey;
+    createPrivateKey: typeof createPrivateKey;
+    diffieHellman: typeof diffieHellman;
+    hkdfSync: typeof hkdfSync;
   };
   export default crypto;
 }
@@ -442,6 +509,70 @@ declare module "burger:buffer" {
     compare(target: Uint8Array): -1 | 0 | 1;
     subarray(start?: number, end?: number): Buffer;
     slice(start?: number, end?: number): Buffer;
+    /**
+     * Text and bytes pack (node-app-burger ADR 007, >= 0.3.6), Node 26 semantics: a number
+     * searches for its low 8 bits, a string for its bytes in `encoding`, a view for its bytes.
+     * `end` (exclusive) is optional; a string in its place is the encoding.
+     */
+    indexOf(value: number | string | Uint8Array, byteOffset?: number | BufferEncoding, end?: number | BufferEncoding, encoding?: BufferEncoding): number;
+    lastIndexOf(value: number | string | Uint8Array, byteOffset?: number | BufferEncoding, end?: number | BufferEncoding, encoding?: BufferEncoding): number;
+    includes(value: number | string | Uint8Array, byteOffset?: number | BufferEncoding, end?: number | BufferEncoding, encoding?: BufferEncoding): boolean;
+    /** Text and bytes pack (ADR 007, >= 0.3.6): Node's integer reads; `Uint` aliases are the same functions. */
+    readUInt8(offset?: number): number;
+    readUint8(offset?: number): number;
+    readUInt16LE(offset?: number): number;
+    readUint16LE(offset?: number): number;
+    readUInt16BE(offset?: number): number;
+    readUint16BE(offset?: number): number;
+    readUInt32LE(offset?: number): number;
+    readUint32LE(offset?: number): number;
+    readUInt32BE(offset?: number): number;
+    readUint32BE(offset?: number): number;
+    readUIntLE(offset: number, byteLength: number): number;
+    readUintLE(offset: number, byteLength: number): number;
+    readUIntBE(offset: number, byteLength: number): number;
+    readUintBE(offset: number, byteLength: number): number;
+    readInt8(offset?: number): number;
+    readInt16LE(offset?: number): number;
+    readInt16BE(offset?: number): number;
+    readInt32LE(offset?: number): number;
+    readInt32BE(offset?: number): number;
+    readIntLE(offset: number, byteLength: number): number;
+    readIntBE(offset: number, byteLength: number): number;
+    readBigUInt64LE(offset?: number): bigint;
+    readBigUint64LE(offset?: number): bigint;
+    readBigUInt64BE(offset?: number): bigint;
+    readBigUint64BE(offset?: number): bigint;
+    readBigInt64LE(offset?: number): bigint;
+    readBigInt64BE(offset?: number): bigint;
+    /** Text and bytes pack (ADR 007, >= 0.3.6): Node's integer writes; each returns the offset after the value. */
+    writeUInt8(value: number, offset?: number): number;
+    writeUint8(value: number, offset?: number): number;
+    writeUInt16LE(value: number, offset?: number): number;
+    writeUint16LE(value: number, offset?: number): number;
+    writeUInt16BE(value: number, offset?: number): number;
+    writeUint16BE(value: number, offset?: number): number;
+    writeUInt32LE(value: number, offset?: number): number;
+    writeUint32LE(value: number, offset?: number): number;
+    writeUInt32BE(value: number, offset?: number): number;
+    writeUint32BE(value: number, offset?: number): number;
+    writeUIntLE(value: number, offset: number, byteLength: number): number;
+    writeUintLE(value: number, offset: number, byteLength: number): number;
+    writeUIntBE(value: number, offset: number, byteLength: number): number;
+    writeUintBE(value: number, offset: number, byteLength: number): number;
+    writeInt8(value: number, offset?: number): number;
+    writeInt16LE(value: number, offset?: number): number;
+    writeInt16BE(value: number, offset?: number): number;
+    writeInt32LE(value: number, offset?: number): number;
+    writeInt32BE(value: number, offset?: number): number;
+    writeIntLE(value: number, offset: number, byteLength: number): number;
+    writeIntBE(value: number, offset: number, byteLength: number): number;
+    writeBigUInt64LE(value: bigint, offset?: number): number;
+    writeBigUint64LE(value: bigint, offset?: number): number;
+    writeBigUInt64BE(value: bigint, offset?: number): number;
+    writeBigUint64BE(value: bigint, offset?: number): number;
+    writeBigInt64LE(value: bigint, offset?: number): number;
+    writeBigInt64BE(value: bigint, offset?: number): number;
   }
 
   export interface BufferConstructor {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@econ-v1/app-sdk",
-  "version": "7.6.62",
+  "version": "7.6.63",
   "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",