@c9up/eon 0.1.0

package/src/schema/EonSchema.ts

@@ -0,0 +1,396 @@
+/**
+ * `EonSchema` — the fluent DDL surface a migration's `up()`/`down()` drives.
+ *
+ * Mirrors atlas `Schema` (`schema/Schema.ts`) in shape: each method compiles its
+ * spec through the Rust `compileStatementNative` seam and appends the resulting
+ * SQL to an internal buffer the runner flushes. The TS side NEVER string-builds
+ * SQL — every identifier, literal, and option value is quoted/validated in Rust
+ * (the injection seam stays in one place, memory `feedback_security_first`).
+ *
+ * The `StableBuilder` is intentionally THINNER than atlas `TableBuilder`:
+ * TDengine columns have no `DEFAULT`, no per-column `PRIMARY KEY` choice (the
+ * first `TIMESTAMP` is always the key), no `UNIQUE`, no foreign keys, no SQL
+ * secondary indexes — so `defaultTo`/`primary`/`unique`/`references`/`increments`
+ * have NO analogue and are deliberately absent (D — the reconciliation note).
+ */
+
+import { compileStatementNative } from "../query/native.js";
+import type {
+	AlterChange,
+	AlterDatabaseSpec,
+	AlterStableSpec,
+	CreateStableSpec,
+	CreateTableSpec,
+	EonAlterDatabaseOptions,
+	EonColumnSpec,
+	EonDatabaseOptions,
+} from "./CreateStableSpec.js";
+
+/** Build one column/tag spec — the ONE place logical type args become an `EonColumnSpec`. */
+function columnSpec(
+	name: string,
+	kind: string,
+	length: number | null = null,
+	precision: number | null = null,
+	scale: number | null = null,
+): EonColumnSpec {
+	return { name, kind, length, precision, scale };
+}
+
+/** The type portion of an `EonColumnSpec` (everything but the name). */
+type EonType = Omit<EonColumnSpec, "name">;
+
+/** Build the type portion — the ONE place logical type args become an `EonType`. */
+function makeType(
+	kind: string,
+	length: number | null = null,
+	precision: number | null = null,
+	scale: number | null = null,
+): EonType {
+	return { kind, length, precision, scale };
+}
+
+/**
+ * The thin column/tag surface shared by every builder: only column-type methods
+ * (+ length/precision/scale). No `defaultTo`/`primary`/`unique` — TDengine has
+ * no analogue. Each method appends a column via `#add` and returns whatever that
+ * hook returns (a tag-handle for stables, `void` for basic tables).
+ */
+abstract class ColumnMethods<R> {
+	protected abstract add(spec: EonColumnSpec): R;
+
+	timestamp(name: string): R {
+		return this.add(columnSpec(name, "timestamp"));
+	}
+	int(name: string): R {
+		return this.add(columnSpec(name, "int"));
+	}
+	bigInteger(name: string): R {
+		return this.add(columnSpec(name, "bigInt"));
+	}
+	float(name: string): R {
+		return this.add(columnSpec(name, "float"));
+	}
+	double(name: string): R {
+		return this.add(columnSpec(name, "double"));
+	}
+	bool(name: string): R {
+		return this.add(columnSpec(name, "bool"));
+	}
+	varchar(name: string, length: number): R {
+		return this.add(columnSpec(name, "varchar", length));
+	}
+	nchar(name: string, length: number): R {
+		return this.add(columnSpec(name, "nchar", length));
+	}
+	binary(name: string, length: number): R {
+		return this.add(columnSpec(name, "varbinary", length));
+	}
+	decimal(name: string, precision: number, scale?: number): R {
+		return this.add(
+			columnSpec(name, "decimal", null, precision, scale ?? null),
+		);
+	}
+	json(name: string): R {
+		return this.add(columnSpec(name, "json"));
+	}
+}
+
+/**
+ * The no-name type surface for an `ALTER STABLE` add/modify change: the column
+ * name is already fixed (by `addColumn(name)` etc.), so these methods take ONLY
+ * the type arguments and finalize the change.
+ */
+abstract class TypeMethods<R> {
+	protected abstract emit(type: EonType): R;
+
+	timestamp(): R {
+		return this.emit(makeType("timestamp"));
+	}
+	int(): R {
+		return this.emit(makeType("int"));
+	}
+	bigInteger(): R {
+		return this.emit(makeType("bigInt"));
+	}
+	float(): R {
+		return this.emit(makeType("float"));
+	}
+	double(): R {
+		return this.emit(makeType("double"));
+	}
+	bool(): R {
+		return this.emit(makeType("bool"));
+	}
+	varchar(length: number): R {
+		return this.emit(makeType("varchar", length));
+	}
+	nchar(length: number): R {
+		return this.emit(makeType("nchar", length));
+	}
+	binary(length: number): R {
+		return this.emit(makeType("varbinary", length));
+	}
+	decimal(precision: number, scale?: number): R {
+		return this.emit(makeType("decimal", null, precision, scale ?? null));
+	}
+	json(): R {
+		return this.emit(makeType("json"));
+	}
+}
+
+/** A handle returned by a `StableBuilder` column method — `.tag()` re-homes it as a tag. */
+export interface StableColumnHandle {
+	/** Mark the just-declared column as a `TAG` instead of a metric column. */
+	tag(): void;
+}
+
+/** Fluent builder for `CREATE STABLE` columns + tags (ts-first is enforced in Rust). */
+export class StableBuilder extends ColumnMethods<StableColumnHandle> {
+	readonly #columns: EonColumnSpec[] = [];
+	readonly #tags: EonColumnSpec[] = [];
+
+	protected add(spec: EonColumnSpec): StableColumnHandle {
+		this.#columns.push(spec);
+		return {
+			tag: () => {
+				// Idempotent: a second `.tag()` on the same handle finds the spec
+				// already re-homed (i < 0) and must NOT push a duplicate tag.
+				const i = this.#columns.indexOf(spec);
+				if (i >= 0) {
+					this.#columns.splice(i, 1);
+					this.#tags.push(spec);
+				}
+			},
+		};
+	}
+
+	/** @internal */
+	columns(): EonColumnSpec[] {
+		return this.#columns;
+	}
+	/** @internal */
+	tags(): EonColumnSpec[] {
+		return this.#tags;
+	}
+}
+
+/** Fluent builder for a basic (non-super) table — same columns, no tags. */
+export class BasicTableBuilder extends ColumnMethods<void> {
+	readonly #columns: EonColumnSpec[] = [];
+
+	protected add(spec: EonColumnSpec): void {
+		this.#columns.push(spec);
+	}
+
+	/** @internal */
+	columns(): EonColumnSpec[] {
+		return this.#columns;
+	}
+}
+
+/** Sets the type on a pending `ALTER STABLE` add/modify change, then records it. */
+export interface AlterTypeSetter extends TypeMethods<void> {}
+class AlterTypeSetterImpl extends TypeMethods<void> {
+	readonly #record: (type: EonType) => void;
+	constructor(record: (type: EonType) => void) {
+		super();
+		this.#record = record;
+	}
+	protected emit(type: EonType): void {
+		this.#record(type);
+	}
+}
+
+/** Fluent builder for `ALTER STABLE` — one method per TDengine change op. */
+export class AlterStableBuilder {
+	readonly #changes: AlterChange[] = [];
+
+	addColumn(name: string): AlterTypeSetter {
+		return new AlterTypeSetterImpl((type) =>
+			this.#changes.push({ op: "addColumn", name, type }),
+		);
+	}
+	modifyColumn(name: string): AlterTypeSetter {
+		return new AlterTypeSetterImpl((type) =>
+			this.#changes.push({ op: "modifyColumn", name, type }),
+		);
+	}
+	dropColumn(name: string): this {
+		this.#changes.push({ op: "dropColumn", name });
+		return this;
+	}
+	addTag(name: string): AlterTypeSetter {
+		return new AlterTypeSetterImpl((type) =>
+			this.#changes.push({ op: "addTag", name, type }),
+		);
+	}
+	modifyTag(name: string): AlterTypeSetter {
+		return new AlterTypeSetterImpl((type) =>
+			this.#changes.push({ op: "modifyTag", name, type }),
+		);
+	}
+	dropTag(name: string): this {
+		this.#changes.push({ op: "dropTag", name });
+		return this;
+	}
+	renameTag(from: string, to: string): this {
+		this.#changes.push({ op: "renameTag", from, to });
+		return this;
+	}
+
+	/** @internal */
+	changes(): AlterChange[] {
+		return this.#changes;
+	}
+}
+
+/** Map an `alterDatabase` option key to its Rust-side option name. */
+const ALTER_DB_OPTION_NAMES: Record<keyof EonAlterDatabaseOptions, string> = {
+	keep: "keep",
+	buffer: "buffer",
+	walLevel: "wal_level",
+	cachemodel: "cachemodel",
+	replica: "replica",
+	minrows: "minrows",
+};
+
+export class EonSchema {
+	#statements: string[] = [];
+
+	#push(spec: object): void {
+		const { statements } = compileStatementNative(spec, "tdengine");
+		this.#statements.push(...statements);
+	}
+
+	/**
+	 * `CREATE STABLE`. Defaults to `IF NOT EXISTS` (idempotent DDL — the mitigation
+	 * for TDengine's non-transactional migrations, AC6). Pass `keep` for retention.
+	 */
+	createStable(
+		name: string,
+		callback: (table: StableBuilder) => void,
+		options: { ifNotExists?: boolean; keep?: string } = {},
+	): this {
+		const builder = new StableBuilder();
+		callback(builder);
+		const spec: CreateStableSpec = {
+			kind: "createStable",
+			name,
+			columns: builder.columns(),
+			tags: builder.tags(),
+			ifNotExists: options.ifNotExists ?? true,
+			...(options.keep !== undefined ? { keep: options.keep } : {}),
+		};
+		this.#push(spec);
+		return this;
+	}
+
+	/** `ALTER STABLE` → one statement per change. */
+	alterStable(
+		name: string,
+		callback: (table: AlterStableBuilder) => void,
+	): this {
+		const builder = new AlterStableBuilder();
+		callback(builder);
+		const spec: AlterStableSpec = {
+			kind: "alterStable",
+			name,
+			changes: builder.changes(),
+		};
+		this.#push(spec);
+		return this;
+	}
+
+	/** `DROP STABLE IF EXISTS`. */
+	dropStable(name: string): this {
+		this.#push({ kind: "dropStable", name, ifExists: true });
+		return this;
+	}
+
+	/** `CREATE DATABASE IF NOT EXISTS` with optional retention/storage options. */
+	createDatabase(name: string, options: EonDatabaseOptions = {}): this {
+		this.#push({
+			kind: "createDatabase",
+			name,
+			ifNotExists: true,
+			...options,
+		});
+		return this;
+	}
+
+	/**
+	 * `ALTER DATABASE` — exactly ONE option per call (TDengine restriction).
+	 * Throws if zero or more than one option key is provided.
+	 */
+	alterDatabase(name: string, options: EonAlterDatabaseOptions): this {
+		const keys: (keyof EonAlterDatabaseOptions)[] = [
+			"keep",
+			"buffer",
+			"walLevel",
+			"cachemodel",
+			"replica",
+			"minrows",
+		];
+		const set = keys.filter((k) => options[k] !== undefined);
+		const key = set[0];
+		if (set.length !== 1 || key === undefined) {
+			throw new Error(
+				`[E_EON_ALTER_DB_ONE_OPTION] alterDatabase('${name}', …) requires exactly one option, got ${set.length}`,
+			);
+		}
+		const value = options[key];
+		if (value === undefined) {
+			throw new Error(
+				`[E_EON_ALTER_DB_ONE_OPTION] alterDatabase('${name}', …) option '${key}' has no value`,
+			);
+		}
+		const spec: AlterDatabaseSpec = {
+			kind: "alterDatabase",
+			name,
+			option: ALTER_DB_OPTION_NAMES[key],
+			value,
+		};
+		this.#push(spec);
+		return this;
+	}
+
+	/** `CREATE TABLE IF NOT EXISTS` — a basic (non-super) table, no tags. */
+	createTable(
+		name: string,
+		callback: (table: BasicTableBuilder) => void,
+	): this {
+		const builder = new BasicTableBuilder();
+		callback(builder);
+		const spec: CreateTableSpec = {
+			kind: "createTable",
+			name,
+			columns: builder.columns(),
+			ifNotExists: true,
+		};
+		this.#push(spec);
+		return this;
+	}
+
+	/** `DROP TABLE IF EXISTS`. */
+	dropTable(name: string): this {
+		this.#push({ kind: "dropTable", name, ifExists: true });
+		return this;
+	}
+
+	/** Queue a raw SQL statement verbatim (an escape hatch for options not modelled above). */
+	raw(sql: string): this {
+		this.#statements.push(sql);
+		return this;
+	}
+
+	/** Clear the buffer (called before each `up()`/`down()` run). */
+	reset(): void {
+		this.#statements = [];
+	}
+
+	/** The compiled SQL statements queued so far. */
+	toSQL(): string[] {
+		return [...this.#statements];
+	}
+}

package/src/schema/Migration.ts

@@ -0,0 +1,66 @@
+/**
+ * `Migration` — extend this to author a versioned eon (TDengine) migration.
+ *
+ * Mirrors atlas `Migration` (`schema/Migration.ts`): `up()`/`down()` drive a
+ * fluent `EonSchema`, and `getUpSQL()`/`getDownSQL()` replay the callback to
+ * collect the compiled SQL. Single-dialect (TDengine) so — unlike atlas — the
+ * constructor takes NO dialect argument, and there is no `now()`/`defaultTo`
+ * helper (TDengine columns have no `DEFAULT`).
+ *
+ * TDengine caveat (AC6): DDL is non-transactional and some operations are
+ * irreversible (a `MODIFY` length-extension cannot be un-extended, a dropped
+ * column's data is gone) — `down()` is best-effort. Prefer idempotent DDL
+ * (`IF (NOT) EXISTS`, the `EonSchema` default) so a partially-applied migration
+ * re-runs cleanly.
+ *
+ *     import { Migration } from "@c9up/eon";
+ *
+ *     export default class CreateMeters extends Migration {
+ *       up() {
+ *         this.schema.createDatabase("metrics", { keep: "90d", duration: "10d" });
+ *         this.schema.createStable("meters", (t) => {
+ *           t.timestamp("ts");
+ *           t.float("current");
+ *           t.int("groupid").tag();
+ *         });
+ *       }
+ *       down() {
+ *         this.schema.dropStable("meters");
+ *       }
+ *     }
+ */
+
+import { EonSchema } from "./EonSchema.js";
+
+export abstract class Migration {
+	readonly schema: EonSchema;
+
+	constructor() {
+		this.schema = new EonSchema();
+	}
+
+	/** Apply the migration. */
+	abstract up(): Promise<void> | void;
+
+	/** Reverse the migration (best-effort on TDengine — see class docs). */
+	abstract down(): Promise<void> | void;
+
+	/** Queue a raw SQL statement verbatim (escape hatch for un-modelled DDL). */
+	raw(sql: string): void {
+		this.schema.raw(sql);
+	}
+
+	/** Compile the SQL statements this migration's `up()` produces. */
+	async getUpSQL(): Promise<string[]> {
+		this.schema.reset();
+		await this.up();
+		return this.schema.toSQL();
+	}
+
+	/** Compile the SQL statements this migration's `down()` produces. */
+	async getDownSQL(): Promise<string[]> {
+		this.schema.reset();
+		await this.down();
+		return this.schema.toSQL();
+	}
+}

package/src/schema/compile.ts

@@ -0,0 +1,109 @@
+/**
+ * Assemble a `CreateStableSpec` from a decorated super-table class.
+ *
+ * Reads schema through the metadata getters ONLY (never `key in instance` — the
+ * `declare` pitfall, memory `project_atlas_declare_hydration`), places the
+ * timestamp column first (TDengine's PK rule), and normalises each logical type
+ * string to the compiler kind via `TYPE_KIND_MAP`. Mirror of atlas
+ * `TableBuilder.toStatements` spec-build.
+ */
+
+import {
+	type EonColumnMetadata,
+	type EonTagMetadata,
+	getColumnMetadata,
+	getSuperTableMetadata,
+	getTagMetadata,
+	getTimestampColumn,
+} from "../decorators/superTable.js";
+import {
+	type CreateStableSpec,
+	type EonColumnSpec,
+	TYPE_KIND_MAP,
+} from "./CreateStableSpec.js";
+
+/** A decorated super-table class. Every constructor carries `.name` (`Function.name`). */
+export type SuperTableClass = (abstract new (
+	...args: never[]
+) => object) & {
+	readonly name: string;
+};
+
+/** Resolve the super-table name for a class, or throw if it is undecorated. */
+export function requireSuperTableName(EntityClass: SuperTableClass): string {
+	const meta = getSuperTableMetadata(EntityClass);
+	if (!meta) {
+		const label =
+			EntityClass.name.length > 0 ? EntityClass.name : "the given class";
+		throw new Error(
+			`[E_EON_NOT_A_SUPERTABLE] ${label} is not decorated with @SuperTable`,
+		);
+	}
+	return meta.name;
+}
+
+/**
+ * The stable's physical column order: timestamp first (TDengine's PK rule), then
+ * declaration order. The STMT columnar bind is POSITIONAL (the connector's
+ * prepare template omits the value-column list), so its bind order MUST match the
+ * order the STABLE was created with. Both `compileCreateStableSpec` (the DDL) and
+ * `SuperTableRepository`'s ingest plan derive their order from THIS one function
+ * so the two can never silently drift apart and write values into wrong columns.
+ */
+export function orderTimestampFirst<T extends { propertyKey: string }>(
+	columns: readonly T[],
+	tsColumn: T,
+	tsProperty: string,
+): T[] {
+	return [tsColumn, ...columns.filter((c) => c.propertyKey !== tsProperty)];
+}
+
+function toColumnSpec(meta: EonColumnMetadata | EonTagMetadata): EonColumnSpec {
+	const logical = (meta.type ?? "").toLowerCase();
+	const kind = TYPE_KIND_MAP[logical];
+	if (!kind) {
+		throw new Error(
+			`[E_EON_TYPE] column/tag '${meta.propertyKey}' has an unknown or missing type '${meta.type ?? ""}'`,
+		);
+	}
+	return {
+		name: meta.propertyKey,
+		kind,
+		length: meta.length ?? null,
+		precision: meta.precision ?? null,
+		scale: meta.scale ?? null,
+	};
+}
+
+/**
+ * Build the `createStable` spec (ts column first). `ifNotExists` defaults to
+ * `false`; `syncSuperTable` overrides it to `true`.
+ */
+export function compileCreateStableSpec(
+	EntityClass: SuperTableClass,
+): CreateStableSpec {
+	const name = requireSuperTableName(EntityClass);
+	const tsProperty = getTimestampColumn(EntityClass);
+	if (!tsProperty) {
+		throw new Error(
+			`[E_EON_NO_TIMESTAMP] super-table '${name}' has no @Timestamp column`,
+		);
+	}
+
+	const columns = getColumnMetadata(EntityClass);
+	const tsColumn = columns.find((c) => c.propertyKey === tsProperty);
+	if (!tsColumn) {
+		throw new Error(
+			`[E_EON_NO_TIMESTAMP] super-table '${name}' @Timestamp column '${tsProperty}' is not registered`,
+		);
+	}
+	const orderedColumns = orderTimestampFirst(columns, tsColumn, tsProperty);
+
+	return {
+		kind: "createStable",
+		name,
+		columns: orderedColumns.map(toColumnSpec),
+		tags: getTagMetadata(EntityClass).map(toColumnSpec),
+		ifNotExists: false,
+	};
+}

package/src/schema/sync.ts

@@ -0,0 +1,142 @@
+/**
+ * Schema facade — drive TDengine DDL from decorator metadata through a live
+ * `EonConnection`. Agnostic leaf: takes the connection structurally, never
+ * imports `@c9up/ream`.
+ *
+ * Every statement is compiled in Rust (`compileStatementNative`) and run through
+ * the literal-only `EonConnection.exec` (58.2 D3). Child-table creation renders
+ * its tag values as inlined SQL literals (`literal: true`, D4) so `exec` can run
+ * it directly; the `?`-bound STMT form lands with ingest in 58.4.
+ */
+
+import type { EonConnection } from "../connection/EonConnection.js";
+import { compileStatementNative } from "../query/native.js";
+import type {
+	CreateChildTableSpec,
+	DropStableSpec,
+} from "./CreateStableSpec.js";
+import {
+	compileCreateStableSpec,
+	requireSuperTableName,
+	type SuperTableClass,
+} from "./compile.js";
+
+/** Compile a spec and run each resulting statement through the connection. */
+async function execSpec(conn: EonConnection, spec: object): Promise<void> {
+	const { statements } = compileStatementNative(spec, "tdengine");
+	for (const sql of statements) {
+		await conn.exec(sql);
+	}
+}
+
+/** Create the super-table for a decorated class (`CREATE STABLE IF NOT EXISTS`). */
+export function syncSuperTable(
+	conn: EonConnection,
+	EntityClass: SuperTableClass,
+): Promise<void> {
+	const spec = { ...compileCreateStableSpec(EntityClass), ifNotExists: true };
+	return execSpec(conn, spec);
+}
+
+/** Options for {@link createChildTable}: identify the stable by name or class. */
+export interface CreateChildTableOptions {
+	stable?: string;
+	EntityClass?: SuperTableClass;
+	name: string;
+	tags: unknown[];
+	ifNotExists?: boolean;
+}
+
+/**
+ * Create an explicit child table bound to its super-table's tag values
+ * (`CREATE TABLE name USING stable TAGS (...)`). Tag values are inlined as typed
+ * SQL literals (D4).
+ */
+export function createChildTable(
+	conn: EonConnection,
+	options: CreateChildTableOptions,
+): Promise<void> {
+	const using = resolveStableName(options);
+	const spec: CreateChildTableSpec = {
+		kind: "createChildTable",
+		name: options.name,
+		using,
+		tags: options.tags,
+		ifNotExists: options.ifNotExists ?? true,
+		literal: true,
+	};
+	return execSpec(conn, spec);
+}
+
+/** Drop the super-table for a decorated class (`DROP STABLE IF EXISTS`). */
+export function dropSuperTable(
+	conn: EonConnection,
+	EntityClass: SuperTableClass,
+): Promise<void> {
+	const spec: DropStableSpec = {
+		kind: "dropStable",
+		name: requireSuperTableName(EntityClass),
+		ifExists: true,
+	};
+	return execSpec(conn, spec);
+}
+
+/**
+ * A deterministic child-table name for a stable + tag-set, so the same tags
+ * always map to the same child (idempotent create, stable routing for 58.4
+ * ingest). Dependency-free FNV-1a — no `crypto`, no npm dep (D6). Pass an
+ * explicit `name` to {@link createChildTable} to override.
+ */
+export function childTableName(
+	stableOrEntity: string | SuperTableClass,
+	tagValues: unknown[],
+): string {
+	const stable =
+		typeof stableOrEntity === "string"
+			? stableOrEntity
+			: requireSuperTableName(stableOrEntity);
+	const key = [stable, ...tagValues.map(stringifyTagValue)].join("\u0000");
+	return `t_${fnv1a(key)}`;
+}
+
+function resolveStableName(options: CreateChildTableOptions): string {
+	if (typeof options.stable === "string" && options.stable.length > 0) {
+		return options.stable;
+	}
+	if (options.EntityClass) {
+		return requireSuperTableName(options.EntityClass);
+	}
+	throw new Error(
+		"[E_EON_CHILD_STABLE] createChildTable requires either `stable` (name) or `EntityClass`",
+	);
+}
+
+/**
+ * A tag value's stable string form for the child-name key. `JSON.stringify`
+ * throws on a `bigint` (`TypeError: Do not know how to serialize a BigInt`),
+ * which would surface as an opaque crash for any BIGINT `@Tag`; render bigints
+ * explicitly so every tag type maps to a deterministic, typed-out string.
+ */
+export function stringifyTagValue(value: unknown): string {
+	if (typeof value === "bigint") return `${value}n`;
+	return JSON.stringify(value) ?? "null";
+}
+
+/**
+ * 64-bit FNV-1a over UTF-16 code units → zero-padded 16-char hex. 64 bits keeps
+ * the child-name collision probability negligible even at millions of distinct
+ * tag-sets; a 32-bit space collides ~50% by only ~77k children (realistic
+ * per-device TSDB cardinality), which would silently write one device's rows
+ * under another's tags. `groupByChild` additionally asserts no two distinct
+ * tag-sets ever share a name.
+ */
+function fnv1a(input: string): string {
+	const MASK = (1n << 64n) - 1n;
+	const PRIME = 0x00000100000001b3n;
+	let hash = 0xcbf29ce484222325n;
+	for (let i = 0; i < input.length; i++) {
+		hash = (hash ^ BigInt(input.charCodeAt(i))) & MASK;
+		hash = (hash * PRIME) & MASK;
+	}
+	return hash.toString(16).padStart(16, "0");
+}