@robinpath/cli 1.73.0

package/modules/_helpers.js

@@ -0,0 +1,33 @@
+/**
+ * Shared helpers for RobinPath native modules.
+ */
+import { resolve } from 'node:path';
+
+/** Coerce value to string with fallback */
+export function toStr(val, fallback = '') {
+    return val == null ? fallback : String(val);
+}
+
+/** Coerce value to number with fallback */
+export function toNum(val, fallback = 0) {
+    const n = Number(val);
+    return Number.isNaN(n) ? fallback : n;
+}
+
+/** Coerce value to boolean */
+export function toBool(val) {
+    if (val === 'false' || val === '0' || val === '') return false;
+    return Boolean(val);
+}
+
+/** Require minimum number of arguments or throw */
+export function requireArgs(funcName, args, min) {
+    if (!args || args.length < min) {
+        throw new Error(`${funcName} requires at least ${min} argument(s)`);
+    }
+}
+
+/** Resolve a file path (handles relative + absolute) */
+export function toPath(val) {
+    return resolve(String(val ?? ''));
+}

package/modules/assert.js

@@ -0,0 +1,270 @@
+/**
+ * Native assert module for RobinPath.
+ * Testing assertions with clear error messages.
+ */
+import { toStr, requireArgs } from './_helpers.js';
+
+function fail(message) {
+    const err = new Error(message);
+    err.__formattedMessage = message;
+    throw err;
+}
+
+export const AssertFunctions = {
+
+    ok: (args) => {
+        requireArgs('assert.ok', args, 1);
+        const val = args[0];
+        const msg = args[1] ? toStr(args[1]) : `Expected truthy, got ${JSON.stringify(val)}`;
+        if (!val) fail(msg);
+        return true;
+    },
+
+    equal: (args) => {
+        requireArgs('assert.equal', args, 2);
+        const actual = args[0];
+        const expected = args[1];
+        const msg = args[2] ? toStr(args[2]) : `Expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`;
+        if (actual != expected) fail(msg);
+        return true;
+    },
+
+    strictEqual: (args) => {
+        requireArgs('assert.strictEqual', args, 2);
+        const actual = args[0];
+        const expected = args[1];
+        const msg = args[2] ? toStr(args[2]) : `Expected strict ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`;
+        if (actual !== expected) fail(msg);
+        return true;
+    },
+
+    notEqual: (args) => {
+        requireArgs('assert.notEqual', args, 2);
+        const actual = args[0];
+        const expected = args[1];
+        const msg = args[2] ? toStr(args[2]) : `Expected not equal to ${JSON.stringify(expected)}`;
+        if (actual == expected) fail(msg);
+        return true;
+    },
+
+    deepEqual: (args) => {
+        requireArgs('assert.deepEqual', args, 2);
+        const actual = args[0];
+        const expected = args[1];
+        const msg = args[2] ? toStr(args[2]) : `Deep equal assertion failed`;
+        try {
+            if (JSON.stringify(actual) !== JSON.stringify(expected)) fail(msg);
+        } catch {
+            fail(msg);
+        }
+        return true;
+    },
+
+    notDeepEqual: (args) => {
+        requireArgs('assert.notDeepEqual', args, 2);
+        const msg = args[2] ? toStr(args[2]) : `Expected objects to not be deeply equal`;
+        try {
+            if (JSON.stringify(args[0]) === JSON.stringify(args[1])) fail(msg);
+        } catch {
+            return true;
+        }
+        return true;
+    },
+
+    truthy: (args) => {
+        requireArgs('assert.truthy', args, 1);
+        const msg = args[1] ? toStr(args[1]) : `Expected truthy, got ${JSON.stringify(args[0])}`;
+        if (!args[0]) fail(msg);
+        return true;
+    },
+
+    falsy: (args) => {
+        requireArgs('assert.falsy', args, 1);
+        const msg = args[1] ? toStr(args[1]) : `Expected falsy, got ${JSON.stringify(args[0])}`;
+        if (args[0]) fail(msg);
+        return true;
+    },
+
+    isNull: (args) => {
+        requireArgs('assert.isNull', args, 1);
+        const msg = args[1] ? toStr(args[1]) : `Expected null, got ${JSON.stringify(args[0])}`;
+        if (args[0] !== null) fail(msg);
+        return true;
+    },
+
+    isNotNull: (args) => {
+        requireArgs('assert.isNotNull', args, 1);
+        const msg = args[1] ? toStr(args[1]) : `Expected non-null value`;
+        if (args[0] === null) fail(msg);
+        return true;
+    },
+
+    isType: (args) => {
+        requireArgs('assert.isType', args, 2);
+        const val = args[0];
+        const expectedType = toStr(args[1]);
+        const actualType = val === null ? 'null' : Array.isArray(val) ? 'array' : typeof val;
+        const msg = args[2] ? toStr(args[2]) : `Expected type ${expectedType}, got ${actualType}`;
+        if (actualType !== expectedType) fail(msg);
+        return true;
+    },
+
+    contains: (args) => {
+        requireArgs('assert.contains', args, 2);
+        const haystack = args[0];
+        const needle = args[1];
+        const msg = args[2] ? toStr(args[2]) : `Expected to contain ${JSON.stringify(needle)}`;
+        if (typeof haystack === 'string') {
+            if (!haystack.includes(toStr(needle))) fail(msg);
+        } else if (Array.isArray(haystack)) {
+            if (!haystack.includes(needle)) fail(msg);
+        } else {
+            fail(`assert.contains: first argument must be string or array`);
+        }
+        return true;
+    },
+
+    notContains: (args) => {
+        requireArgs('assert.notContains', args, 2);
+        const haystack = args[0];
+        const needle = args[1];
+        const msg = args[2] ? toStr(args[2]) : `Expected to not contain ${JSON.stringify(needle)}`;
+        if (typeof haystack === 'string') {
+            if (haystack.includes(toStr(needle))) fail(msg);
+        } else if (Array.isArray(haystack)) {
+            if (haystack.includes(needle)) fail(msg);
+        }
+        return true;
+    },
+
+    match: (args) => {
+        requireArgs('assert.match', args, 2);
+        const str = toStr(args[0]);
+        const pattern = toStr(args[1]);
+        const msg = args[2] ? toStr(args[2]) : `Expected "${str}" to match ${pattern}`;
+        if (!new RegExp(pattern).test(str)) fail(msg);
+        return true;
+    },
+
+    notMatch: (args) => {
+        requireArgs('assert.notMatch', args, 2);
+        const str = toStr(args[0]);
+        const pattern = toStr(args[1]);
+        const msg = args[2] ? toStr(args[2]) : `Expected "${str}" to not match ${pattern}`;
+        if (new RegExp(pattern).test(str)) fail(msg);
+        return true;
+    },
+
+    greaterThan: (args) => {
+        requireArgs('assert.greaterThan', args, 2);
+        const a = Number(args[0]);
+        const b = Number(args[1]);
+        const msg = args[2] ? toStr(args[2]) : `Expected ${a} > ${b}`;
+        if (!(a > b)) fail(msg);
+        return true;
+    },
+
+    lessThan: (args) => {
+        requireArgs('assert.lessThan', args, 2);
+        const a = Number(args[0]);
+        const b = Number(args[1]);
+        const msg = args[2] ? toStr(args[2]) : `Expected ${a} < ${b}`;
+        if (!(a < b)) fail(msg);
+        return true;
+    },
+
+    between: (args) => {
+        requireArgs('assert.between', args, 3);
+        const val = Number(args[0]);
+        const min = Number(args[1]);
+        const max = Number(args[2]);
+        const msg = args[3] ? toStr(args[3]) : `Expected ${val} between ${min} and ${max}`;
+        if (val < min || val > max) fail(msg);
+        return true;
+    },
+
+    lengthOf: (args) => {
+        requireArgs('assert.lengthOf', args, 2);
+        const val = args[0];
+        const expected = Number(args[1]);
+        const actual = (typeof val === 'string' || Array.isArray(val)) ? val.length : Object.keys(val).length;
+        const msg = args[2] ? toStr(args[2]) : `Expected length ${expected}, got ${actual}`;
+        if (actual !== expected) fail(msg);
+        return true;
+    },
+
+    hasProperty: (args) => {
+        requireArgs('assert.hasProperty', args, 2);
+        const obj = args[0];
+        const prop = toStr(args[1]);
+        const msg = args[2] ? toStr(args[2]) : `Expected object to have property "${prop}"`;
+        if (typeof obj !== 'object' || obj === null || !(prop in obj)) fail(msg);
+        return true;
+    },
+
+    throws: async (args, callback) => {
+        const msg = args[0] ? toStr(args[0]) : 'Expected an error to be thrown';
+        if (!callback) fail('assert.throws requires a callback block');
+        try {
+            await callback([]);
+            fail(msg);
+        } catch {
+            return true;
+        }
+    },
+
+    doesNotThrow: async (args, callback) => {
+        const msg = args[0] ? toStr(args[0]) : 'Expected no error to be thrown';
+        if (!callback) fail('assert.doesNotThrow requires a callback block');
+        try {
+            await callback([]);
+            return true;
+        } catch (err) {
+            fail(`${msg}: ${err.message}`);
+        }
+    },
+
+    fail: (args) => {
+        const msg = args[0] ? toStr(args[0]) : 'Assertion failed';
+        fail(msg);
+    }
+};
+
+export const AssertFunctionMetadata = {
+    ok: { description: 'Assert value is truthy', parameters: [{ name: 'value', dataType: 'any', description: 'Value to check', formInputType: 'json', required: true }, { name: 'message', dataType: 'string', description: 'Error message', formInputType: 'text', required: false }], returnType: 'boolean', returnDescription: 'true if passes', example: 'assert.ok $val' },
+    equal: { description: 'Assert loose equality (==)', parameters: [{ name: 'actual', dataType: 'any', description: 'Actual value', formInputType: 'json', required: true }, { name: 'expected', dataType: 'any', description: 'Expected value', formInputType: 'json', required: true }], returnType: 'boolean', returnDescription: 'true if equal', example: 'assert.equal $a $b' },
+    strictEqual: { description: 'Assert strict equality (===)', parameters: [{ name: 'actual', dataType: 'any', description: 'Actual', formInputType: 'json', required: true }, { name: 'expected', dataType: 'any', description: 'Expected', formInputType: 'json', required: true }], returnType: 'boolean', returnDescription: 'true if strict equal', example: 'assert.strictEqual $a $b' },
+    notEqual: { description: 'Assert not equal', parameters: [{ name: 'actual', dataType: 'any', description: 'Actual', formInputType: 'json', required: true }, { name: 'expected', dataType: 'any', description: 'Not expected', formInputType: 'json', required: true }], returnType: 'boolean', returnDescription: 'true if not equal', example: 'assert.notEqual $a $b' },
+    deepEqual: { description: 'Assert deep equality', parameters: [{ name: 'actual', dataType: 'any', description: 'Actual', formInputType: 'json', required: true }, { name: 'expected', dataType: 'any', description: 'Expected', formInputType: 'json', required: true }], returnType: 'boolean', returnDescription: 'true if deeply equal', example: 'assert.deepEqual $a $b' },
+    truthy: { description: 'Assert truthy', parameters: [{ name: 'value', dataType: 'any', description: 'Value', formInputType: 'json', required: true }], returnType: 'boolean', returnDescription: 'true', example: 'assert.truthy $val' },
+    falsy: { description: 'Assert falsy', parameters: [{ name: 'value', dataType: 'any', description: 'Value', formInputType: 'json', required: true }], returnType: 'boolean', returnDescription: 'true', example: 'assert.falsy $val' },
+    isNull: { description: 'Assert null', parameters: [{ name: 'value', dataType: 'any', description: 'Value', formInputType: 'json', required: true }], returnType: 'boolean', returnDescription: 'true if null', example: 'assert.isNull $val' },
+    isNotNull: { description: 'Assert not null', parameters: [{ name: 'value', dataType: 'any', description: 'Value', formInputType: 'json', required: true }], returnType: 'boolean', returnDescription: 'true if not null', example: 'assert.isNotNull $val' },
+    isType: { description: 'Assert value type', parameters: [{ name: 'value', dataType: 'any', description: 'Value', formInputType: 'json', required: true }, { name: 'type', dataType: 'string', description: 'Expected type', formInputType: 'text', required: true }], returnType: 'boolean', returnDescription: 'true if type matches', example: 'assert.isType $val "string"' },
+    contains: { description: 'Assert string/array contains value', parameters: [{ name: 'haystack', dataType: 'any', description: 'String or array', formInputType: 'json', required: true }, { name: 'needle', dataType: 'any', description: 'Value to find', formInputType: 'json', required: true }], returnType: 'boolean', returnDescription: 'true if contains', example: 'assert.contains "hello world" "world"' },
+    match: { description: 'Assert string matches regex', parameters: [{ name: 'string', dataType: 'string', description: 'String to test', formInputType: 'text', required: true }, { name: 'pattern', dataType: 'string', description: 'Regex pattern', formInputType: 'text', required: true }], returnType: 'boolean', returnDescription: 'true if matches', example: 'assert.match "hello" "^he"' },
+    greaterThan: { description: 'Assert a > b', parameters: [{ name: 'a', dataType: 'number', description: 'Value', formInputType: 'number', required: true }, { name: 'b', dataType: 'number', description: 'Comparison', formInputType: 'number', required: true }], returnType: 'boolean', returnDescription: 'true if a > b', example: 'assert.greaterThan 5 3' },
+    lessThan: { description: 'Assert a < b', parameters: [{ name: 'a', dataType: 'number', description: 'Value', formInputType: 'number', required: true }, { name: 'b', dataType: 'number', description: 'Comparison', formInputType: 'number', required: true }], returnType: 'boolean', returnDescription: 'true if a < b', example: 'assert.lessThan 3 5' },
+    between: { description: 'Assert value is between min and max', parameters: [{ name: 'value', dataType: 'number', description: 'Value', formInputType: 'number', required: true }, { name: 'min', dataType: 'number', description: 'Minimum', formInputType: 'number', required: true }, { name: 'max', dataType: 'number', description: 'Maximum', formInputType: 'number', required: true }], returnType: 'boolean', returnDescription: 'true if in range', example: 'assert.between 5 1 10' },
+    lengthOf: { description: 'Assert length of string/array/object', parameters: [{ name: 'value', dataType: 'any', description: 'Value', formInputType: 'json', required: true }, { name: 'length', dataType: 'number', description: 'Expected length', formInputType: 'number', required: true }], returnType: 'boolean', returnDescription: 'true if length matches', example: 'assert.lengthOf [1,2,3] 3' },
+    hasProperty: { description: 'Assert object has a property', parameters: [{ name: 'object', dataType: 'object', description: 'Object', formInputType: 'json', required: true }, { name: 'property', dataType: 'string', description: 'Property name', formInputType: 'text', required: true }], returnType: 'boolean', returnDescription: 'true if has property', example: 'assert.hasProperty $obj "name"' },
+    notDeepEqual: { description: 'Assert not deeply equal', parameters: [{ name: 'actual', dataType: 'any', description: 'Actual', formInputType: 'json', required: true }, { name: 'expected', dataType: 'any', description: 'Not expected', formInputType: 'json', required: true }], returnType: 'boolean', returnDescription: 'true if not deeply equal', example: 'assert.notDeepEqual $a $b' },
+    notContains: { description: 'Assert string/array does not contain value', parameters: [{ name: 'haystack', dataType: 'any', description: 'String or array', formInputType: 'json', required: true }, { name: 'needle', dataType: 'any', description: 'Value to check absence', formInputType: 'json', required: true }], returnType: 'boolean', returnDescription: 'true if not contains', example: 'assert.notContains "hello" "xyz"' },
+    notMatch: { description: 'Assert string does not match regex', parameters: [{ name: 'string', dataType: 'string', description: 'String to test', formInputType: 'text', required: true }, { name: 'pattern', dataType: 'string', description: 'Regex pattern', formInputType: 'text', required: true }], returnType: 'boolean', returnDescription: 'true if not matches', example: 'assert.notMatch "hello" "^xyz"' },
+    throws: { description: 'Assert callback throws an error', parameters: [{ name: 'message', dataType: 'string', description: 'Error message if no throw', formInputType: 'text', required: false }], returnType: 'boolean', returnDescription: 'true if threw', example: 'assert.throws "Should error"' },
+    doesNotThrow: { description: 'Assert callback does not throw', parameters: [{ name: 'message', dataType: 'string', description: 'Error message if throws', formInputType: 'text', required: false }], returnType: 'boolean', returnDescription: 'true if no throw', example: 'assert.doesNotThrow "Should not error"' },
+    fail: { description: 'Force assertion failure', parameters: [{ name: 'message', dataType: 'string', description: 'Failure message', formInputType: 'text', required: false }], returnType: 'null', returnDescription: 'Always throws', example: 'assert.fail "Not implemented"' }
+};
+
+export const AssertModuleMetadata = {
+    description: 'Assertions: equal, deepEqual, truthy, falsy, contains, match, greaterThan, throws, and more',
+    methods: Object.keys(AssertFunctions)
+};
+
+export default {
+    name: 'assert',
+    functions: AssertFunctions,
+    functionMetadata: AssertFunctionMetadata,
+    moduleMetadata: AssertModuleMetadata,
+    global: false
+};

package/modules/buffer.js

@@ -0,0 +1,245 @@
+/**
+ * Native buffer module for RobinPath.
+ * Buffer operations for binary data handling.
+ */
+import { toStr, toNum, requireArgs } from './_helpers.js';
+
+export const BufferFunctions = {
+
+    alloc: (args) => {
+        const size = toNum(args[0], 0);
+        const fill = args[1] != null ? toNum(args[1], 0) : 0;
+        return Buffer.alloc(size, fill).toString('base64');
+    },
+
+    from: (args) => {
+        requireArgs('buffer.from', args, 1);
+        const data = args[0];
+        const encoding = toStr(args[1], 'utf-8');
+        if (typeof data === 'string') {
+            return Buffer.from(data, encoding).toString('base64');
+        }
+        if (Array.isArray(data)) {
+            return Buffer.from(data).toString('base64');
+        }
+        return Buffer.from(String(data)).toString('base64');
+    },
+
+    toString: (args) => {
+        requireArgs('buffer.toString', args, 1);
+        const base64 = toStr(args[0]);
+        const encoding = toStr(args[1], 'utf-8');
+        return Buffer.from(base64, 'base64').toString(encoding);
+    },
+
+    toJSON: (args) => {
+        requireArgs('buffer.toJSON', args, 1);
+        const buf = Buffer.from(toStr(args[0]), 'base64');
+        return { type: 'Buffer', data: Array.from(buf) };
+    },
+
+    concat: (args) => {
+        if (!Array.isArray(args[0])) throw new Error('buffer.concat requires an array of base64 buffers');
+        const buffers = args[0].map(b => Buffer.from(toStr(b), 'base64'));
+        return Buffer.concat(buffers).toString('base64');
+    },
+
+    compare: (args) => {
+        requireArgs('buffer.compare', args, 2);
+        const a = Buffer.from(toStr(args[0]), 'base64');
+        const b = Buffer.from(toStr(args[1]), 'base64');
+        return Buffer.compare(a, b);
+    },
+
+    equals: (args) => {
+        requireArgs('buffer.equals', args, 2);
+        const a = Buffer.from(toStr(args[0]), 'base64');
+        const b = Buffer.from(toStr(args[1]), 'base64');
+        return a.equals(b);
+    },
+
+    slice: (args) => {
+        requireArgs('buffer.slice', args, 1);
+        const buf = Buffer.from(toStr(args[0]), 'base64');
+        const start = toNum(args[1], 0);
+        const end = args[2] != null ? toNum(args[2]) : buf.length;
+        return buf.subarray(start, end).toString('base64');
+    },
+
+    length: (args) => {
+        requireArgs('buffer.length', args, 1);
+        return Buffer.from(toStr(args[0]), 'base64').length;
+    },
+
+    byteLength: (args) => {
+        requireArgs('buffer.byteLength', args, 1);
+        const data = toStr(args[0]);
+        const encoding = toStr(args[1], 'utf-8');
+        return Buffer.byteLength(data, encoding);
+    },
+
+    isBuffer: (args) => {
+        requireArgs('buffer.isBuffer', args, 1);
+        // In RobinPath, buffers are base64 strings — check if valid base64
+        try {
+            const str = toStr(args[0]);
+            const buf = Buffer.from(str, 'base64');
+            return buf.toString('base64') === str;
+        } catch { return false; }
+    },
+
+    fill: (args) => {
+        requireArgs('buffer.fill', args, 2);
+        const buf = Buffer.from(toStr(args[0]), 'base64');
+        const value = toNum(args[1], 0);
+        buf.fill(value);
+        return buf.toString('base64');
+    },
+
+    indexOf: (args) => {
+        requireArgs('buffer.indexOf', args, 2);
+        const buf = Buffer.from(toStr(args[0]), 'base64');
+        const search = toStr(args[1]);
+        return buf.indexOf(search);
+    },
+
+    copy: (args) => {
+        requireArgs('buffer.copy', args, 1);
+        const buf = Buffer.from(toStr(args[0]), 'base64');
+        return Buffer.from(buf).toString('base64');
+    },
+
+    toHex: (args) => {
+        requireArgs('buffer.toHex', args, 1);
+        return Buffer.from(toStr(args[0]), 'base64').toString('hex');
+    },
+
+    fromHex: (args) => {
+        requireArgs('buffer.fromHex', args, 1);
+        return Buffer.from(toStr(args[0]), 'hex').toString('base64');
+    }
+};
+
+export const BufferFunctionMetadata = {
+    alloc: {
+        description: 'Allocate a buffer of given size',
+        parameters: [
+            { name: 'size', dataType: 'number', description: 'Size in bytes', formInputType: 'number', required: true },
+            { name: 'fill', dataType: 'number', description: 'Fill value (default: 0)', formInputType: 'number', required: false, defaultValue: 0 }
+        ],
+        returnType: 'string', returnDescription: 'Base64-encoded buffer', example: 'buffer.alloc 16'
+    },
+    from: {
+        description: 'Create a buffer from string or array',
+        parameters: [
+            { name: 'data', dataType: 'any', description: 'Input data', formInputType: 'text', required: true },
+            { name: 'encoding', dataType: 'string', description: 'Input encoding (default: utf-8)', formInputType: 'text', required: false, defaultValue: 'utf-8' }
+        ],
+        returnType: 'string', returnDescription: 'Base64-encoded buffer', example: 'buffer.from "hello"'
+    },
+    toString: {
+        description: 'Convert buffer to string',
+        parameters: [
+            { name: 'buffer', dataType: 'string', description: 'Base64-encoded buffer', formInputType: 'text', required: true },
+            { name: 'encoding', dataType: 'string', description: 'Output encoding (default: utf-8)', formInputType: 'text', required: false, defaultValue: 'utf-8' }
+        ],
+        returnType: 'string', returnDescription: 'Decoded string', example: 'buffer.toString $buf'
+    },
+    toJSON: {
+        description: 'Convert buffer to JSON representation',
+        parameters: [{ name: 'buffer', dataType: 'string', description: 'Base64-encoded buffer', formInputType: 'text', required: true }],
+        returnType: 'object', returnDescription: '{type, data} object', example: 'buffer.toJSON $buf'
+    },
+    concat: {
+        description: 'Concatenate multiple buffers',
+        parameters: [{ name: 'buffers', dataType: 'array', description: 'Array of base64-encoded buffers', formInputType: 'json', required: true }],
+        returnType: 'string', returnDescription: 'Concatenated base64-encoded buffer', example: 'buffer.concat [$buf1, $buf2]'
+    },
+    compare: {
+        description: 'Compare two buffers (-1, 0, 1)',
+        parameters: [
+            { name: 'a', dataType: 'string', description: 'First buffer', formInputType: 'text', required: true },
+            { name: 'b', dataType: 'string', description: 'Second buffer', formInputType: 'text', required: true }
+        ],
+        returnType: 'number', returnDescription: '-1, 0, or 1', example: 'buffer.compare $buf1 $buf2'
+    },
+    equals: {
+        description: 'Check if two buffers are equal',
+        parameters: [
+            { name: 'a', dataType: 'string', description: 'First buffer', formInputType: 'text', required: true },
+            { name: 'b', dataType: 'string', description: 'Second buffer', formInputType: 'text', required: true }
+        ],
+        returnType: 'boolean', returnDescription: 'true if equal', example: 'buffer.equals $buf1 $buf2'
+    },
+    slice: {
+        description: 'Get a slice of a buffer',
+        parameters: [
+            { name: 'buffer', dataType: 'string', description: 'Base64-encoded buffer', formInputType: 'text', required: true },
+            { name: 'start', dataType: 'number', description: 'Start index (default: 0)', formInputType: 'number', required: false, defaultValue: 0 },
+            { name: 'end', dataType: 'number', description: 'End index (default: length)', formInputType: 'number', required: false }
+        ],
+        returnType: 'string', returnDescription: 'Base64-encoded slice', example: 'buffer.slice $buf 0 10'
+    },
+    length: {
+        description: 'Get buffer length in bytes',
+        parameters: [{ name: 'buffer', dataType: 'string', description: 'Base64-encoded buffer', formInputType: 'text', required: true }],
+        returnType: 'number', returnDescription: 'Length in bytes', example: 'buffer.length $buf'
+    },
+    byteLength: {
+        description: 'Get byte length of a string',
+        parameters: [
+            { name: 'string', dataType: 'string', description: 'Input string', formInputType: 'text', required: true },
+            { name: 'encoding', dataType: 'string', description: 'Encoding (default: utf-8)', formInputType: 'text', required: false, defaultValue: 'utf-8' }
+        ],
+        returnType: 'number', returnDescription: 'Byte length', example: 'buffer.byteLength "hello"'
+    },
+    isBuffer: {
+        description: 'Check if value is a valid base64 buffer',
+        parameters: [{ name: 'value', dataType: 'any', description: 'Value to check', formInputType: 'text', required: true }],
+        returnType: 'boolean', returnDescription: 'true if valid buffer', example: 'buffer.isBuffer $val'
+    },
+    fill: {
+        description: 'Fill buffer with a value',
+        parameters: [
+            { name: 'buffer', dataType: 'string', description: 'Base64-encoded buffer', formInputType: 'text', required: true },
+            { name: 'value', dataType: 'number', description: 'Fill value', formInputType: 'number', required: true }
+        ],
+        returnType: 'string', returnDescription: 'Filled base64-encoded buffer', example: 'buffer.fill $buf 0'
+    },
+    indexOf: {
+        description: 'Find position of a value in buffer',
+        parameters: [
+            { name: 'buffer', dataType: 'string', description: 'Base64-encoded buffer', formInputType: 'text', required: true },
+            { name: 'search', dataType: 'string', description: 'Value to find', formInputType: 'text', required: true }
+        ],
+        returnType: 'number', returnDescription: 'Index or -1', example: 'buffer.indexOf $buf "hello"'
+    },
+    copy: {
+        description: 'Copy a buffer',
+        parameters: [{ name: 'buffer', dataType: 'string', description: 'Base64-encoded buffer', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Copied base64-encoded buffer', example: 'buffer.copy $buf'
+    },
+    toHex: {
+        description: 'Convert buffer to hex string',
+        parameters: [{ name: 'buffer', dataType: 'string', description: 'Base64-encoded buffer', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Hex string', example: 'buffer.toHex $buf'
+    },
+    fromHex: {
+        description: 'Create buffer from hex string',
+        parameters: [{ name: 'hex', dataType: 'string', description: 'Hex string', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Base64-encoded buffer', example: 'buffer.fromHex "68656c6c6f"'
+    }
+};
+
+export const BufferModuleMetadata = {
+    description: 'Buffer operations for binary data: alloc, from, concat, compare, slice, encode/decode',
+    methods: Object.keys(BufferFunctions)
+};
+
+export default {
+    name: 'buffer',
+    functions: BufferFunctions,
+    functionMetadata: BufferFunctionMetadata,
+    moduleMetadata: BufferModuleMetadata,
+    global: false
+};