@econ-v1/app-sdk 7.4.9 → 7.5.0

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

@@ -37,6 +37,8 @@ declare module "burger:host" {
 }
 
 declare module "burger:fs" {
+  import type { Buffer } from "burger:buffer";
+
   export type PathLike = string;
   export type Utf8Encoding = "utf8" | "utf-8";
 
@@ -74,7 +76,8 @@ declare module "burger:fs" {
   }
 
   export function existsSync(path: PathLike): boolean;
-  export function readFileSync(path: PathLike): Uint8Array;
+  /** Binary contents as a `Buffer` viewing the bytes read (Node shape). */
+  export function readFileSync(path: PathLike): Buffer;
   export function readFileSync(path: PathLike, encoding: Utf8Encoding | { encoding: Utf8Encoding }): string;
   export function writeFileSync(path: PathLike, data: string | Uint8Array): void;
   export function appendFileSync(path: PathLike, data: string | Uint8Array): void;
@@ -124,7 +127,7 @@ declare module "burger:fs" {
 
   export interface FsPromises {
     exists(path: PathLike): Promise<boolean>;
-    readFile(path: PathLike): Promise<Uint8Array>;
+    readFile(path: PathLike): Promise<Buffer>;
     readFile(path: PathLike, encoding: Utf8Encoding | { encoding: Utf8Encoding }): Promise<string>;
     writeFile(path: PathLike, data: string | Uint8Array): Promise<void>;
     appendFile(path: PathLike, data: string | Uint8Array): Promise<void>;
@@ -300,8 +303,10 @@ declare module "burger:buffer" {
 
   /** C5 subset of Node's Buffer. Instances are `Uint8Array`s. */
   export interface Buffer extends Uint8Array<ArrayBuffer> {
-    toString(encoding?: BufferEncoding): string;
+    toString(encoding?: BufferEncoding, start?: number, end?: number): string;
     equals(other: Uint8Array): boolean;
+    /** Same as `Buffer.compare(this, target)`. */
+    compare(target: Uint8Array): -1 | 0 | 1;
     subarray(start?: number, end?: number): Buffer;
     slice(start?: number, end?: number): Buffer;
   }
@@ -309,11 +314,22 @@ declare module "burger:buffer" {
   export interface BufferConstructor {
     readonly prototype: Buffer;
     from(value: string, encoding?: BufferEncoding): Buffer;
-    from(value: Uint8Array | ArrayBuffer | readonly number[]): Buffer;
+    /**
+     * A view of `arrayBuffer` (no copy), from `byteOffset` for `length` bytes (default: to its end).
+     * A `SharedArrayBuffer` needs the node-app-burger release carrying that fix (newer than 0.3.1);
+     * Burger 0.3.1 throws a TypeError on one.
+     */
+    from(arrayBuffer: ArrayBufferLike, byteOffset?: number, length?: number): Buffer;
+    /** A copy of the bytes. */
+    from(value: ArrayBufferView | readonly number[]): Buffer;
     alloc(size: number): Buffer;
     concat(list: readonly Uint8Array[]): Buffer;
     isBuffer(value: unknown): value is Buffer;
-    byteLength(value: string): number;
+    /** UTF-8 (or `encoding`) length of a string; `byteLength` of a view or ArrayBuffer. */
+    byteLength(value: string, encoding?: BufferEncoding): number;
+    byteLength(value: ArrayBufferView | ArrayBuffer): number;
+    /** Bytewise (unsigned) order, a shorter prefix first; usable as a `sort` comparator. */
+    compare(a: Uint8Array, b: Uint8Array): -1 | 0 | 1;
   }
 
   export const Buffer: BufferConstructor;
@@ -324,23 +340,28 @@ declare module "burger:buffer" {
 declare module "burger:sqlite" {
   export type SQLValue = null | number | bigint | string | Uint8Array;
   export type SQLBinding = SQLValue | boolean | undefined;
+  /**
+   * Bindings for one execution, as the runtime reads them: several values bind
+   * positionally; a single array binds its items positionally; a single plain
+   * object binds by name (a single Uint8Array is one blob value).
+   */
   export type SQLParams =
     | SQLBinding[]
-    | [SQLBinding[]]
-    | [Record<string, SQLBinding>];
+    | [SQLBinding | SQLBinding[] | Record<string, SQLBinding>];
 
   export interface Changes {
     changes: number;
     lastInsertRowid: number | bigint;
   }
 
-  export interface Statement<Row = unknown> {
-    all(...params: SQLParams): Row[];
-    get(...params: SQLParams): Row | null;
-    run(...params: SQLParams): Changes;
-    values(...params: SQLParams): SQLValue[][];
+  /** `Params` narrows what each execution accepts, as in `bun:sqlite` (`query<Row, [string]>`). */
+  export interface Statement<Row = unknown, Params extends SQLParams = SQLParams> {
+    all(...params: Params): Row[];
+    get(...params: Params): Row | null;
+    run(...params: Params): Changes;
+    values(...params: Params): SQLValue[][];
     /** data-app pack: rows one at a time; the deadline bounds the whole iteration. */
-    iterate(...params: SQLParams): IterableIterator<Row>;
+    iterate(...params: Params): IterableIterator<Row>;
     [Symbol.iterator](): IterableIterator<Row>;
     /** data-app pack. */
     readonly columnNames: string[];
@@ -366,8 +387,8 @@ declare module "burger:sqlite" {
     constructor(filename?: string, options?: DatabaseOptions);
     /** data-app pack: the default statement deadline in ms (`undefined`: none). */
     deadlineMs: number | null | undefined;
-    query<Row = unknown>(sql: string): Statement<Row>;
-    prepare<Row = unknown>(sql: string): Statement<Row>;
+    query<Row = unknown, Params extends SQLParams = SQLParams>(sql: string): Statement<Row, Params>;
+    prepare<Row = unknown, Params extends SQLParams = SQLParams>(sql: string): Statement<Row, Params>;
     exec(sql: string, ...params: SQLParams): Changes;
     run(sql: string, ...params: SQLParams): Changes;
     transaction<Args extends unknown[], Result>(fn: (...args: Args) => Result): (...args: Args) => Result;

package/package.json

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