@ad-sdk/bgd 0.0.1

package/sss/strategy.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright © 2026 Alerta Dino. All rights reserved.
+ *
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ *
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+import type { BufferLike } from "../types";
+import { MemoryBuffer } from "../allocators";
+export declare const SALT_LEN = 76;
+export declare function deriveKey(imk: BufferLike, rkl?: number): Promise<readonly [MemoryBuffer, MemoryBuffer, MemoryBuffer]>;

package/sss/strategy.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SALT_LEN = void 0;
+exports.deriveKey = deriveKey;
+var _nodeCrypto = require("node:crypto");
+var _util = require("../util");
+var _allocators = require("../allocators");
+/**
+ * Copyright © 2026 Alerta Dino. All rights reserved.
+ * 
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ * 
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+
+// Input (plain text)       ->  f(n, k)    ->  [n slices of cipher text]
+// Input (cipher_slice[n])  ->  f(n >= k)  ->  [plain text]
+
+// WHERE:
+
+// `f()`  is the secret redactor/unwrapper function
+// `n`    is the number of input/output slices
+// `k`    is the minimun required slices to recover original payload
+
+const SALT_LEN = exports.SALT_LEN = 0x4C;
+async function deriveKey(imk, rkl = 32 // eslint-disable-line comma-dangle
+) {
+  const data = (0, _util.toBuffer)(imk);
+  try {
+    return await Promise.all([new Promise((resolve, reject) => {
+      (0, _nodeCrypto.randomBytes)(SALT_LEN, (err, buf) => {
+        if (!err) {
+          const out = _allocators.MemoryBuffer.alloc(buf.length);
+          for (let i = 0; i < buf.length; ++i) {
+            out.setByte(i, buf[i]);
+          }
+          buf.fill(0);
+          buf = null;
+          resolve(out);
+        } else {
+          reject(err);
+        }
+      });
+    }), new Promise((resolve, reject) => {
+      (0, _nodeCrypto.hkdf)("sha512", data.valueOf(), Buffer.alloc(0), "::DBGD_K_SSS.HEAD::", rkl, (err, ab) => {
+        if (!err) {
+          resolve((0, _util.toBuffer)(ab));
+        } else {
+          reject(err);
+        }
+      } // eslint-disable-line comma-dangle
+      );
+    }), new Promise((resolve, reject) => {
+      (0, _nodeCrypto.hkdf)("sha512", data.valueOf(), Buffer.alloc(0), "::DBGD_K_SSS.PAYLOAD::", rkl, (err, ab) => {
+        if (!err) {
+          resolve((0, _util.toBuffer)(ab));
+        } else {
+          reject(err);
+        }
+      } // eslint-disable-line comma-dangle
+      );
+    })]);
+  } finally {
+    data.dispose();
+  }
+}

package/structured/heap.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright © 2026 Alerta Dino. All rights reserved.
+ *
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ *
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+export type Comparator<T> = (a: T, b: T) => number;
+export type IsEqual<T> = (s: T, o: T) => boolean;
+export declare abstract class Heap<T> {
+    abstract readonly comparator: Comparator<T>;
+    abstract readonly capacity: number;
+    abstract push(item: T): void;
+    static getChildrenIndexOf(index: number): readonly [number, number];
+    static getParentIndexOf(index: number): number;
+    static getSiblingIndexOf(index: number): number;
+    static minComparator<N>(a: N, b: N): number;
+    static maxComparator<N>(a: N, b: N): number;
+}

package/structured/heap.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Heap = void 0;
+/**
+ * Copyright © 2026 Alerta Dino. All rights reserved.
+ * 
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ * 
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+
+// import { assertType } from "../util";
+
+class Heap {
+  // ABSTRACT INSTANCE METHODS
+
+  // STATIC METHODS 
+
+  static getChildrenIndexOf(index) {
+    return [index * 2 + 1, index * 2 + 2];
+  }
+  static getParentIndexOf(index) {
+    return index > 0 ? index - 1 >> 1 : -1;
+  }
+  static getSiblingIndexOf(index) {
+    if (index <= 0) return -1;
+    return index + (index % 2 ? 1 : -1);
+  }
+  static minComparator(a, b) {
+    if (a > b) return 1;
+    if (a < b) return -1;
+    return 0;
+  }
+  static maxComparator(a, b) {
+    if (b > a) return 1;
+    if (b < a) return -1;
+    return 0;
+  }
+}
+exports.Heap = Heap;

package/types.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright © 2026 Alerta Dino. All rights reserved.
+ *
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ *
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+/** Represents a struct (object with string keys) */
+export type Dict<T> = {
+    [key: string]: T;
+};
+export type BufferLike = Buffer | string | ArrayBuffer | Uint8Array | Uint16Array | Uint32Array | SharedArrayBuffer | ArrayBufferView | DataView | readonly number[];
+export type GenericFunction = (...args: any[]) => unknown;
+export type MaybePromise<T> = T | Promise<T>;

package/util/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./runtime";
+export * from "./validator";

package/util/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _runtime = require("./runtime");
+Object.keys(_runtime).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _runtime[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _runtime[key];
+    }
+  });
+});
+var _validator = require("./validator");
+Object.keys(_validator).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _validator[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _validator[key];
+    }
+  });
+});

package/util/runtime.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright © 2026 Alerta Dino. All rights reserved.
+ *
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ *
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+import type { BufferLike } from "../types";
+import { MemoryBuffer } from "../allocators";
+export declare function toInt(n: number): number;
+export declare function toBuffer(chunk: BufferLike): MemoryBuffer;

package/util/runtime.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toBuffer = toBuffer;
+exports.toInt = toInt;
+var _errors = require("../errors");
+var _allocators = require("../allocators");
+/**
+ * Copyright © 2026 Alerta Dino. All rights reserved.
+ * 
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ * 
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+
+function toInt(n) {
+  return ~~n;
+}
+function toBuffer(chunk) {
+  let target = Buffer.isBuffer(chunk) ? chunk : null;
+  if (typeof chunk === "string") {
+    target = Buffer.from(chunk);
+  }
+  if (chunk instanceof ArrayBuffer) {
+    target = Buffer.from(chunk);
+  }
+  if (chunk instanceof Uint8Array) {
+    target = Buffer.from(chunk);
+  }
+  if (chunk instanceof Uint16Array) {
+    target = Buffer.from(chunk);
+  }
+  if (chunk instanceof Uint32Array) {
+    target = Buffer.from(chunk);
+  }
+  if (chunk instanceof Int8Array) {
+    target = Buffer.from(chunk);
+  }
+  if (chunk instanceof Int16Array) {
+    target = Buffer.from(chunk);
+  }
+  if (chunk instanceof Int32Array) {
+    target = Buffer.from(chunk);
+  }
+  if (chunk instanceof Float32Array) {
+    target = Buffer.from(chunk);
+  }
+  if (chunk instanceof Float64Array) {
+    target = Buffer.from(chunk);
+  }
+  if (chunk instanceof SharedArrayBuffer) {
+    target = Buffer.from(chunk);
+  }
+  if (chunk instanceof DataView) {
+    target = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+  }
+  if (ArrayBuffer.isView(chunk)) {
+    target = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+  }
+  if (Array.isArray(chunk) && chunk.every(x => typeof x === "number")) {
+    target = Buffer.from(chunk);
+  }
+  if (!target || !Buffer.isBuffer(target)) {
+    throw new _errors.BGDException(`[@@toBuffer] Failed to cast 'typeof ${typeof chunk}' to binary data`, "ER_INVALID_ARGUMENT");
+  }
+  const out = _allocators.MemoryBuffer.alloc(target.length);
+  for (let i = 0; i < target.length; ++i) {
+    out.setByte(i, target[i]);
+  }
+  target.fill(0);
+  target = null;
+  return out;
+}

package/util/validator.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright © 2026 Alerta Dino. All rights reserved.
+ *
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ *
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+import type { GenericFunction } from "../types";
+type Tn = "uint8" | "uint16" | "uint32" | "func";
+interface Tmap {
+    uint8: number;
+    uint16: number;
+    uint32: number;
+    func: GenericFunction;
+}
+export declare function assertType(typename: Tn, val: unknown, message?: string): asserts val is Tmap[Tn];
+export declare function assert(c: unknown, message?: string): asserts c;
+export {};

package/util/validator.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assert = assert;
+exports.assertType = assertType;
+var _const = require("../const");
+var _errors = require("../errors");
+/**
+ * Copyright © 2026 Alerta Dino. All rights reserved.
+ * 
+ * This code was released under the BSD 3-Clause License.
+ * See the "LICENSE" file under project root.
+ * 
+ * @author (PUBLIC_ID) 1D-C2-9B-98-D6-C3-D6-AB
+ * @signphrase It was created on Earth by humans, although
+ *             I can't define what a "human" is.
+ */
+
+function assertType(typename, val, message) {
+  let isValid = false;
+  switch (typename) {
+    case "uint8":
+      {
+        isValid = typeof val === "number" && !Number.isNaN(val) && Number.isFinite(val) && Number.isInteger(val) && val >= _const.UINT8_RANGE[0] && val <= _const.UINT8_RANGE[1];
+      }
+      break;
+    case "uint16":
+      {
+        isValid = typeof val === "number" && !Number.isNaN(val) && Number.isFinite(val) && Number.isInteger(val) && val >= _const.UINT16_RANGE[0] && val <= _const.UINT16_RANGE[1];
+      }
+      break;
+    case "uint32":
+      {
+        isValid = typeof val === "number" && !Number.isNaN(val) && Number.isFinite(val) && Number.isInteger(val) && val >= _const.UINT32_RANGE[0] && val <= _const.UINT32_RANGE[1];
+      }
+      break;
+    case "func":
+      {
+        isValid = typeof val === "function";
+      }
+      break;
+  }
+  if (!isValid) {
+    throw new _errors.BGDException(message?.trim() || `[@@assertType] Assertation failed for 'typeof ${typename}'`, "ER_ASSERTATION_FAILED" // eslint-disable-line comma-dangle
+    );
+  }
+}
+function assert(c, message) {
+  let isValid = false;
+  switch (typeof c) {
+    case "string":
+      {
+        isValid = c.trim().length > 0;
+      }
+      break;
+    case "boolean":
+      {
+        isValid = c;
+      }
+      break;
+    case "number":
+      {
+        isValid = !isNaN(c);
+      }
+      break;
+    default:
+      isValid = !!c;
+  }
+  if (!isValid) {
+    throw new _errors.BGDException(message?.trim() || `[@@assert] Assertation failed for 'typeof ${typeof c}'`, "ER_ASSERTATION_FAILED" // eslint-disable-line comma-dangle
+    );
+  }
+}