@blue-quickjs/abi-manifest 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 @blue-labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# abi-manifest
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build abi-manifest` to build the library.
+
+## Running unit tests
+
+Run `nx test abi-manifest` to execute the unit tests via [Vitest](https://vitest.dev/).

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './lib/abi-manifest.js';
+export * from './lib/host-v1-manifest.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './lib/abi-manifest.js';
+export * from './lib/host-v1-manifest.js';

package/dist/lib/abi-manifest.d.ts

@@ -0,0 +1,64 @@
+export type AbiEffect = 'READ' | 'EMIT' | 'MUTATE';
+export interface AbiSchemaString {
+    type: 'string';
+}
+export interface AbiSchemaDv {
+    type: 'dv';
+}
+export interface AbiSchemaNull {
+    type: 'null';
+}
+export type AbiSchema = AbiSchemaString | AbiSchemaDv | AbiSchemaNull;
+export interface AbiGasParameters {
+    schedule_id: string;
+    base: number;
+    k_arg_bytes: number;
+    k_ret_bytes: number;
+    k_units: number;
+}
+export interface AbiLimits {
+    max_request_bytes: number;
+    max_response_bytes: number;
+    max_units: number;
+    arg_utf8_max?: number[];
+}
+export interface AbiErrorCode {
+    code: string;
+    tag: string;
+}
+export interface AbiFunction {
+    fn_id: number;
+    js_path: string[];
+    effect: AbiEffect;
+    arity: number;
+    arg_schema: AbiSchema[];
+    return_schema: AbiSchema;
+    gas: AbiGasParameters;
+    limits: AbiLimits;
+    error_codes: AbiErrorCode[];
+}
+export interface AbiManifest {
+    abi_id: string;
+    abi_version: number;
+    functions: AbiFunction[];
+}
+export type CanonicalAbiFunction = AbiFunction;
+export type CanonicalAbiManifest = AbiManifest & {
+    functions: CanonicalAbiFunction[];
+};
+export type AbiManifestErrorCode = 'INVALID_TYPE' | 'MISSING_FIELD' | 'UNKNOWN_FIELD' | 'INVALID_VALUE' | 'OUT_OF_RANGE' | 'UNSORTED' | 'DUPLICATE' | 'PATH_CONFLICT';
+export declare class AbiManifestError extends Error {
+    readonly code: AbiManifestErrorCode;
+    readonly path?: string | undefined;
+    constructor(code: AbiManifestErrorCode, message: string, path?: string | undefined);
+}
+export interface AbiManifestBytes {
+    bytes: Uint8Array;
+    hash: string;
+    manifest: CanonicalAbiManifest;
+}
+export declare function validateAbiManifest(manifest: AbiManifest): CanonicalAbiManifest;
+export declare function encodeAbiManifest(manifest: AbiManifest): Uint8Array;
+export declare function hashAbiManifest(manifest: AbiManifest): AbiManifestBytes;
+export declare function hashAbiManifestBytes(bytes: ArrayBufferView | ArrayBuffer | Uint8Array): string;
+//# sourceMappingURL=abi-manifest.d.ts.map

package/dist/lib/abi-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abi-manifest.d.ts","sourceRoot":"","sources":["../../src/lib/abi-manifest.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEnD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,QAAQ,CAAC;CAChB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,IAAI,CAAC;CACZ;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,SAAS,GAAG,eAAe,GAAG,WAAW,GAAG,aAAa,CAAC;AAEtE,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,SAAS;IACxB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,SAAS,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,aAAa,EAAE,SAAS,CAAC;IACzB,GAAG,EAAE,gBAAgB,CAAC;IACtB,MAAM,EAAE,SAAS,CAAC;IAClB,WAAW,EAAE,YAAY,EAAE,CAAC;CAC7B;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,WAAW,EAAE,CAAC;CAC1B;AAED,MAAM,MAAM,oBAAoB,GAAG,WAAW,CAAC;AAC/C,MAAM,MAAM,oBAAoB,GAAG,WAAW,GAAG;IAC/C,SAAS,EAAE,oBAAoB,EAAE,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAC5B,cAAc,GACd,eAAe,GACf,eAAe,GACf,eAAe,GACf,cAAc,GACd,UAAU,GACV,WAAW,GACX,eAAe,CAAC;AAEpB,qBAAa,gBAAiB,SAAQ,KAAK;aAEvB,IAAI,EAAE,oBAAoB;aAE1B,IAAI,CAAC,EAAE,MAAM;gBAFb,IAAI,EAAE,oBAAoB,EAC1C,OAAO,EAAE,MAAM,EACC,IAAI,CAAC,EAAE,MAAM,YAAA;CAKhC;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,UAAU,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,oBAAoB,CAAC;CAChC;AAED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,WAAW,GACpB,oBAAoB,CAMtB;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,WAAW,GAAG,UAAU,CAGnE;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,WAAW,GAAG,gBAAgB,CAQvE;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,eAAe,GAAG,WAAW,GAAG,UAAU,GAChD,MAAM,CAQR"}

package/dist/lib/abi-manifest.js

@@ -0,0 +1,316 @@
+import { DV_LIMIT_DEFAULTS, encodeDv } from '@blue-quickjs/dv';
+import { sha256 } from '@noble/hashes/sha2';
+import { bytesToHex } from '@noble/hashes/utils';
+const UINT32_MAX = 0xffffffff;
+const JS_PATH_SEGMENT = /^[A-Za-z0-9_-]+$/;
+const FORBIDDEN_SEGMENTS = new Set(['__proto__', 'prototype', 'constructor']);
+const RESERVED_ERROR_CODES = new Set([
+    'HOST_TRANSPORT',
+    'HOST_ENVELOPE_INVALID',
+]);
+export class AbiManifestError extends Error {
+    code;
+    path;
+    constructor(code, message, path) {
+        super(path ? `${message} (${path})` : message);
+        this.code = code;
+        this.path = path;
+        this.name = 'AbiManifestError';
+    }
+}
+export function validateAbiManifest(manifest) {
+    const normalized = validateManifestRoot(manifest);
+    ensureUniqueFnIds(normalized.functions);
+    ensureFunctionsSorted(normalized.functions);
+    ensureNoJsPathConflicts(normalized.functions);
+    return normalized;
+}
+export function encodeAbiManifest(manifest) {
+    const canonical = validateAbiManifest(manifest);
+    return encodeDv(canonical);
+}
+export function hashAbiManifest(manifest) {
+    const canonical = validateAbiManifest(manifest);
+    const bytes = encodeDv(canonical);
+    return {
+        bytes,
+        hash: hashAbiManifestBytes(bytes),
+        manifest: canonical,
+    };
+}
+export function hashAbiManifestBytes(bytes) {
+    const view = bytes instanceof Uint8Array
+        ? bytes
+        : bytes instanceof ArrayBuffer
+            ? new Uint8Array(bytes)
+            : new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return bytesToHex(sha256(view));
+}
+function validateManifestRoot(manifest) {
+    const value = expectPlainObject(manifest, 'manifest');
+    enforceExactKeys(value, ['abi_id', 'abi_version', 'functions'], 'manifest');
+    const abiId = expectNonEmptyString(value.abi_id, 'manifest.abi_id');
+    const abiVersion = expectUint32(value.abi_version, 'manifest.abi_version', {
+        min: 1,
+    });
+    const functions = expectArray(value.functions, 'manifest.functions').map((fn, index) => validateFunction(fn, `manifest.functions[${index}]`));
+    return {
+        abi_id: abiId,
+        abi_version: abiVersion,
+        functions,
+    };
+}
+function validateFunction(value, path) {
+    const fn = expectPlainObject(value, path);
+    enforceExactKeys(fn, [
+        'fn_id',
+        'js_path',
+        'effect',
+        'arity',
+        'arg_schema',
+        'return_schema',
+        'gas',
+        'limits',
+        'error_codes',
+    ], path);
+    const fnId = expectUint32(fn.fn_id, `${path}.fn_id`, { min: 1 });
+    const jsPath = validateJsPath(fn.js_path, `${path}.js_path`);
+    const effect = validateEffect(fn.effect, `${path}.effect`);
+    const arity = expectUint32(fn.arity, `${path}.arity`);
+    const argSchema = validateArgSchemas(expectArray(fn.arg_schema, `${path}.arg_schema`), arity, `${path}.arg_schema`);
+    const returnSchema = validateSchema(fn.return_schema, `${path}.return_schema`);
+    const gas = validateGas(fn.gas, `${path}.gas`);
+    const limits = validateLimits(fn.limits, argSchema, arity, `${path}.limits`);
+    const errorCodes = validateErrorCodes(expectArray(fn.error_codes, `${path}.error_codes`), `${path}.error_codes`);
+    ensureGasMaxChargeWithinBounds(gas, limits, `${path}.gas`);
+    return {
+        fn_id: fnId,
+        js_path: jsPath,
+        effect,
+        arity,
+        arg_schema: argSchema,
+        return_schema: returnSchema,
+        gas,
+        limits,
+        error_codes: errorCodes,
+    };
+}
+function validateJsPath(value, path) {
+    const segments = expectArray(value, path);
+    if (segments.length === 0) {
+        throw error('INVALID_VALUE', 'js_path must contain at least one segment', path);
+    }
+    return segments.map((segment, index) => {
+        const segmentPath = `${path}[${index}]`;
+        const str = expectNonEmptyString(segment, segmentPath);
+        if (!JS_PATH_SEGMENT.test(str)) {
+            throw error('INVALID_VALUE', `js_path segment must match ${JS_PATH_SEGMENT.source}: ${str}`, segmentPath);
+        }
+        if (FORBIDDEN_SEGMENTS.has(str)) {
+            throw error('INVALID_VALUE', `js_path segment is forbidden: ${str}`, segmentPath);
+        }
+        return str;
+    });
+}
+function validateEffect(value, path) {
+    if (value !== 'READ' && value !== 'EMIT' && value !== 'MUTATE') {
+        throw error('INVALID_VALUE', 'effect must be READ, EMIT, or MUTATE', path);
+    }
+    return value;
+}
+function validateArgSchemas(schemas, arity, path) {
+    if (schemas.length !== arity) {
+        throw error('INVALID_VALUE', `arg_schema length (${schemas.length}) must equal arity (${arity})`, path);
+    }
+    return schemas.map((schema, index) => validateSchema(schema, `${path}[${index}]`));
+}
+function validateSchema(value, path) {
+    const schema = expectPlainObject(value, path);
+    enforceExactKeys(schema, ['type'], path);
+    if (schema.type === 'string' ||
+        schema.type === 'dv' ||
+        schema.type === 'null') {
+        return { type: schema.type };
+    }
+    throw error('INVALID_VALUE', `unsupported schema type: ${String(schema.type)}`, path);
+}
+function validateGas(value, path) {
+    const gas = expectPlainObject(value, path);
+    enforceExactKeys(gas, ['schedule_id', 'base', 'k_arg_bytes', 'k_ret_bytes', 'k_units'], path);
+    return {
+        schedule_id: expectNonEmptyString(gas.schedule_id, `${path}.schedule_id`),
+        base: expectUint32(gas.base, `${path}.base`),
+        k_arg_bytes: expectUint32(gas.k_arg_bytes, `${path}.k_arg_bytes`),
+        k_ret_bytes: expectUint32(gas.k_ret_bytes, `${path}.k_ret_bytes`),
+        k_units: expectUint32(gas.k_units, `${path}.k_units`),
+    };
+}
+function validateLimits(value, argSchema, arity, path) {
+    const limits = expectPlainObject(value, path);
+    enforceExactKeys(limits, ['max_request_bytes', 'max_response_bytes', 'max_units', 'arg_utf8_max'], path, ['arg_utf8_max']);
+    const maxRequestBytes = expectUint32(limits.max_request_bytes, `${path}.max_request_bytes`, {
+        min: 1,
+        max: DV_LIMIT_DEFAULTS.maxEncodedBytes,
+    });
+    const maxResponseBytes = expectUint32(limits.max_response_bytes, `${path}.max_response_bytes`, {
+        min: 1,
+        max: DV_LIMIT_DEFAULTS.maxEncodedBytes,
+    });
+    const maxUnits = expectUint32(limits.max_units, `${path}.max_units`);
+    let argUtf8Max;
+    if (limits.arg_utf8_max !== undefined) {
+        const parsed = expectArray(limits.arg_utf8_max, `${path}.arg_utf8_max`);
+        if (parsed.length !== arity) {
+            throw error('INVALID_VALUE', `arg_utf8_max length (${parsed.length}) must equal arity (${arity})`, `${path}.arg_utf8_max`);
+        }
+        argUtf8Max = parsed.map((entry, index) => {
+            const limit = expectUint32(entry, `${path}.arg_utf8_max[${index}]`, {
+                min: 1,
+                max: DV_LIMIT_DEFAULTS.maxStringBytes,
+            });
+            if (argSchema[index].type !== 'string') {
+                throw error('INVALID_VALUE', 'arg_utf8_max may only be used for string arguments', `${path}.arg_utf8_max[${index}]`);
+            }
+            return limit;
+        });
+    }
+    return {
+        max_request_bytes: maxRequestBytes,
+        max_response_bytes: maxResponseBytes,
+        max_units: maxUnits,
+        ...(argUtf8Max ? { arg_utf8_max: argUtf8Max } : {}),
+    };
+}
+function validateErrorCodes(codes, path) {
+    const parsed = codes.map((entry, index) => validateErrorCode(entry, `${path}[${index}]`));
+    ensureErrorCodesSorted(parsed, path);
+    return parsed;
+}
+function validateErrorCode(value, path) {
+    const code = expectPlainObject(value, path);
+    enforceExactKeys(code, ['code', 'tag'], path);
+    const errorCode = expectNonEmptyString(code.code, `${path}.code`);
+    if (RESERVED_ERROR_CODES.has(errorCode)) {
+        throw error('INVALID_VALUE', `error_codes may not include reserved code "${errorCode}"`, `${path}.code`);
+    }
+    return {
+        code: errorCode,
+        tag: expectNonEmptyString(code.tag, `${path}.tag`),
+    };
+}
+function ensureFunctionsSorted(functions) {
+    for (let i = 1; i < functions.length; i += 1) {
+        if (functions[i - 1].fn_id >= functions[i].fn_id) {
+            throw error('UNSORTED', 'functions must be sorted by ascending fn_id without duplicates', 'manifest.functions');
+        }
+    }
+}
+function ensureUniqueFnIds(functions) {
+    const seen = new Set();
+    for (const fn of functions) {
+        if (seen.has(fn.fn_id)) {
+            throw error('DUPLICATE', `duplicate fn_id ${fn.fn_id}`, 'manifest.functions');
+        }
+        seen.add(fn.fn_id);
+    }
+}
+function ensureErrorCodesSorted(codes, path) {
+    for (let i = 1; i < codes.length; i += 1) {
+        const previous = codes[i - 1].code;
+        const current = codes[i].code;
+        if (previous > current) {
+            throw error('UNSORTED', 'error_codes must be sorted by code', path);
+        }
+        if (previous === current) {
+            throw error('DUPLICATE', `duplicate error code ${current}`, path);
+        }
+    }
+}
+function ensureNoJsPathConflicts(functions) {
+    for (let i = 0; i < functions.length; i += 1) {
+        for (let j = i + 1; j < functions.length; j += 1) {
+            if (isPathConflict(functions[i].js_path, functions[j].js_path)) {
+                throw error('PATH_CONFLICT', `js_path collision between "${functions[i].js_path.join('.')}" and "${functions[j].js_path.join('.')}"`, 'manifest.functions');
+            }
+        }
+    }
+}
+function isPathConflict(a, b) {
+    const len = Math.min(a.length, b.length);
+    for (let i = 0; i < len; i += 1) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+function expectPlainObject(value, path) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        throw error('INVALID_TYPE', 'expected object', path);
+    }
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null) {
+        throw error('INVALID_TYPE', 'expected plain object', path);
+    }
+    return value;
+}
+function expectArray(value, path) {
+    if (!Array.isArray(value)) {
+        throw error('INVALID_TYPE', 'expected array', path);
+    }
+    return value;
+}
+function expectNonEmptyString(value, path) {
+    if (typeof value !== 'string') {
+        throw error('INVALID_TYPE', 'expected string', path);
+    }
+    if (value.length === 0) {
+        throw error('INVALID_VALUE', 'string must be non-empty', path);
+    }
+    return value;
+}
+function expectUint32(value, path, bounds) {
+    if (typeof value !== 'number' || !Number.isInteger(value)) {
+        throw error('INVALID_TYPE', 'expected integer', path);
+    }
+    if (Object.is(value, -0)) {
+        throw error('INVALID_VALUE', 'integer must not be -0', path);
+    }
+    const min = bounds?.min ?? 0;
+    const max = bounds?.max ?? UINT32_MAX;
+    if (value < min || value > max) {
+        throw error('OUT_OF_RANGE', `value ${value} must be in [${min}, ${max}]`, path);
+    }
+    return value;
+}
+function enforceExactKeys(value, allowed, path, optional) {
+    const allowedSet = new Set(allowed);
+    const optionalSet = new Set(optional ?? []);
+    for (const key of Object.keys(value)) {
+        if (!allowedSet.has(key)) {
+            throw error('UNKNOWN_FIELD', `unknown field "${key}"`, path);
+        }
+    }
+    for (const key of allowed) {
+        if (optionalSet.has(key)) {
+            continue;
+        }
+        if (!Object.prototype.hasOwnProperty.call(value, key)) {
+            throw error('MISSING_FIELD', `missing required field "${key}"`, path);
+        }
+    }
+}
+function ensureGasMaxChargeWithinBounds(gas, limits, path) {
+    const UINT64_MAX = 0xffffffffffffffffn;
+    const base = BigInt(gas.base);
+    const argBytes = BigInt(gas.k_arg_bytes) * BigInt(limits.max_request_bytes);
+    const retBytes = BigInt(gas.k_ret_bytes) * BigInt(limits.max_response_bytes);
+    const hostUnits = BigInt(gas.k_units) * BigInt(limits.max_units);
+    const total = base + argBytes + retBytes + hostUnits;
+    if (total > UINT64_MAX) {
+        throw error('OUT_OF_RANGE', 'gas charges overflow uint64 bounds', path);
+    }
+}
+function error(code, message, path) {
+    return new AbiManifestError(code, message, path);
+}

package/dist/lib/host-v1-manifest.d.ts

@@ -0,0 +1,6 @@
+import type { AbiManifest } from './abi-manifest.js';
+export declare const HOST_V1_MANIFEST: AbiManifest;
+export declare const HOST_V1_BYTES_HEX = "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";
+export declare const HOST_V1_HASH = "e23b0b2ee169900bbde7aff78e6ce20fead1715c60f8a8e3106d9959450a3d34";
+export declare const HOST_V1_BYTES: Uint8Array<ArrayBufferLike>;
+//# sourceMappingURL=host-v1-manifest.d.ts.map

package/dist/lib/host-v1-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-v1-manifest.d.ts","sourceRoot":"","sources":["../../src/lib/host-v1-manifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAKrD,eAAO,MAAM,gBAAgB,EAAE,WA8E9B,CAAC;AAEF,eAAO,MAAM,iBAAiB,qlEACsjE,CAAC;AAErlE,eAAO,MAAM,YAAY,qEAC2C,CAAC;AAErE,eAAO,MAAM,aAAa,6BAAqC,CAAC"}

package/dist/lib/host-v1-manifest.js

@@ -0,0 +1,99 @@
+// These fixtures mirror the files in libs/test-harness/fixtures/abi-manifest.
+// They are inlined to avoid any Node-only dependencies so the constants remain
+// usable in browser environments.
+export const HOST_V1_MANIFEST = {
+    abi_id: 'Host.v1',
+    abi_version: 1,
+    functions: [
+        {
+            fn_id: 1,
+            js_path: ['document', 'get'],
+            effect: 'READ',
+            arity: 1,
+            arg_schema: [{ type: 'string' }],
+            return_schema: { type: 'dv' },
+            gas: {
+                schedule_id: 'doc-read-v1',
+                base: 20,
+                k_arg_bytes: 1,
+                k_ret_bytes: 1,
+                k_units: 1,
+            },
+            limits: {
+                max_request_bytes: 4096,
+                max_response_bytes: 262144,
+                max_units: 1000,
+                arg_utf8_max: [2048],
+            },
+            error_codes: [
+                { code: 'INVALID_PATH', tag: 'host/invalid_path' },
+                { code: 'LIMIT_EXCEEDED', tag: 'host/limit' },
+                { code: 'NOT_FOUND', tag: 'host/not_found' },
+            ],
+        },
+        {
+            fn_id: 2,
+            js_path: ['document', 'getCanonical'],
+            effect: 'READ',
+            arity: 1,
+            arg_schema: [{ type: 'string' }],
+            return_schema: { type: 'dv' },
+            gas: {
+                schedule_id: 'doc-read-v1',
+                base: 20,
+                k_arg_bytes: 1,
+                k_ret_bytes: 1,
+                k_units: 1,
+            },
+            limits: {
+                max_request_bytes: 4096,
+                max_response_bytes: 262144,
+                max_units: 1000,
+                arg_utf8_max: [2048],
+            },
+            error_codes: [
+                { code: 'INVALID_PATH', tag: 'host/invalid_path' },
+                { code: 'LIMIT_EXCEEDED', tag: 'host/limit' },
+                { code: 'NOT_FOUND', tag: 'host/not_found' },
+            ],
+        },
+        {
+            fn_id: 3,
+            js_path: ['emit'],
+            effect: 'EMIT',
+            arity: 1,
+            arg_schema: [{ type: 'dv' }],
+            return_schema: { type: 'null' },
+            gas: {
+                schedule_id: 'emit-v1',
+                base: 5,
+                k_arg_bytes: 1,
+                k_ret_bytes: 0,
+                k_units: 1,
+            },
+            limits: {
+                max_request_bytes: 32768,
+                max_response_bytes: 64,
+                max_units: 1024,
+            },
+            error_codes: [{ code: 'LIMIT_EXCEEDED', tag: 'host/limit' }],
+        },
+    ],
+};
+export const HOST_V1_BYTES_HEX = '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';
+export const HOST_V1_HASH = 'e23b0b2ee169900bbde7aff78e6ce20fead1715c60f8a8e3106d9959450a3d34';
+export const HOST_V1_BYTES = hexToUint8Array(HOST_V1_BYTES_HEX);
+function hexToUint8Array(hex) {
+    if (hex.length % 2 !== 0) {
+        throw new Error('hex string must have an even length');
+    }
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bytes.length; i += 1) {
+        const byte = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+        if (Number.isNaN(byte)) {
+            throw new Error(`invalid hex at position ${i * 2}`);
+        }
+        bytes[i] = byte;
+    }
+    return bytes;
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@blue-quickjs/abi-manifest",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@blue-quickjs/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "nx": {
+    "name": "abi-manifest"
+  },
+  "dependencies": {
+    "@noble/hashes": "^1.5.0",
+    "tslib": "^2.3.0",
+    "@blue-quickjs/dv": "0.1.0"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bluecontract/blue-quickjs.git"
+  }
+}