@greenpandastudios/aug-cli 0.19.0

package/scripts/native-dependencies.lock.json

@@ -0,0 +1,65 @@
+{
+  "format": 1,
+  "platforms": ["darwin", "linux"],
+  "dependencies": [
+    {
+      "name": "cmake",
+      "platforms": ["darwin"],
+      "version": "4.1.1",
+      "url": "https://github.com/Kitware/CMake/releases/download/v4.1.1/cmake-4.1.1-macos-universal.tar.gz",
+      "archive": "cmake.tar.gz",
+      "sha256": "3cd1da5341618645bdc85a3b99e273f29c4d48db2f545925a658db992e61f6f9"
+    },
+    {
+      "name": "gmp",
+      "version": "6.3.0",
+      "url": "https://ftp.gnu.org/gnu/gmp/gmp-6.3.0.tar.xz",
+      "archive": "gmp.tar.xz",
+      "sha256": "a3c2b80201b89e68616f4ad30bc66aee4927c3ce50e33929ca819d5c43538898"
+    },
+    {
+      "name": "nettle",
+      "version": "3.10.2",
+      "url": "https://ftp.gnu.org/gnu/nettle/nettle-3.10.2.tar.gz",
+      "archive": "nettle.tar.gz",
+      "sha256": "fe9ff51cb1f2abb5e65a6b8c10a92da0ab5ab6eaf26e7fc2b675c45f1fb519b5"
+    },
+    {
+      "name": "gnutls",
+      "version": "3.8.13",
+      "url": "https://www.gnupg.org/ftp/gcrypt/gnutls/v3.8/gnutls-3.8.13.tar.xz",
+      "archive": "gnutls.tar.xz",
+      "sha256": "ffed8ec1bf09c2426d4f14aae377de4753b53e537d685e604e99a8b16ca9c97e"
+    },
+    {
+      "name": "pkgconf",
+      "version": "2.3.0",
+      "url": "https://distfiles.ariadne.space/pkgconf/pkgconf-2.3.0.tar.xz",
+      "archive": "pkgconf.tar.xz",
+      "sha256": "3a9080ac51d03615e7c1910a0a2a8df08424892b5f13b0628a204d3fcce0ea8b"
+    },
+    {
+      "name": "libwebsockets",
+      "version": "5.0-stable",
+      "revision": "a842936f881921b6462b3328cce8e700b7a7ecd2",
+      "url": "https://codeload.github.com/warmcat/libwebsockets/tar.gz/a842936f881921b6462b3328cce8e700b7a7ecd2",
+      "archive": "libwebsockets.tar.gz",
+      "sha256": "aec47546b8b298fb10b021896873637d9bd1efcb9e0f6f165ac045f24e275cc2"
+    },
+    {
+      "name": "yyjson",
+      "version": "0.12.0",
+      "url": "https://codeload.github.com/ibireme/yyjson/tar.gz/refs/tags/0.12.0",
+      "archive": "yyjson.tar.gz",
+      "sha256": "b16246f617b2a136c78d73e5e2647c6f1de1313e46678062985bdcf1f40bb75d"
+    },
+    {
+      "name": "minicoro",
+      "version": "0.1.3",
+      "revision": "8673ca62ed938c0b436bc2a548f172865f65bf1d",
+      "url": "https://codeload.github.com/edubart/minicoro/tar.gz/8673ca62ed938c0b436bc2a548f172865f65bf1d",
+      "archive": "minicoro-0.1.3.tar.gz",
+      "sha256": "604a7b57615f7bbf38e72bad43e8f12d03b37aa8b9573f48bd056925924cc57d"
+    }
+  ]
+}

package/scripts/native-home.mjs

@@ -0,0 +1,11 @@
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+/** Source checkouts use a local build; installations use a writable, versioned cache. */
+export function nativeHome(compilerRoot) {
+  if (process.env.AUG_NATIVE_HOME) return resolve(process.env.AUG_NATIVE_HOME);
+  const manifest = JSON.parse(readFileSync(join(compilerRoot, 'package.json'), 'utf8'));
+  return manifest.private ? join(compilerRoot, '.aug-native') :
+    join(homedir(), '.cache', 'augscript', 'native', manifest.version, `${process.platform}-${process.arch}`);
+}

package/src/actions.js

@@ -0,0 +1,109 @@
+import { schemaType } from "./schemas.js";
+/** Form transport uses the same checked record shape as the server decoder. */
+export function actionSchema(project, type, seen = new Set()) {
+    const result = { kind: type.name, optional: !!type.optional, nullable: type.nullable };
+    if (seen.has(type.id))
+        return { ...result, kind: 'json' };
+    if (type.def?.node.kind === 'class' && type.def.node.record) {
+        const node = type.def.node, types = new Map(node.typeParams.map((name, index) => [name, type.args[index]]));
+        result.kind = 'record';
+        result.fields = Object.fromEntries(node.fields.map(field => [field.name, actionSchema(project, schemaType(project, field.type, type.def.file, types), new Set([...seen, type.id]))]));
+    }
+    return result;
+}
+/** Only event-to-HTTP transport runs in the browser; application handlers remain August. */
+export const actionTransport = `(() => {
+  if (globalThis.__augActions) return;
+  globalThis.__augActions = true;
+  const own = (object,key) => Object.prototype.hasOwnProperty.call(object,key);
+  const minInt = -(1n << 63n), maxInt = (1n << 63n)-1n;
+  // Captures carry JSON text so JavaScript never rounds a native int64 token.
+  function parse(text) {
+    let at=0;
+    const space=()=>{while(/[ \\t\\r\\n]/.test(text[at]||'!'))at++;};
+    function read(depth=0) {
+      if(depth>64)throw Error('JSON nesting exceeds 64 levels');space();const start=at, token=text[at++];
+      if(token==='"') {
+        while(at<text.length) {const next=text[at++];if(next==='"')return JSON.parse(text.slice(start,at));if(next==='\\\\')at++;}
+      } else if(token==='[' || token==='{') {
+        const object=token==='{', end=object?'}':']', result=object?Object.create(null):[];
+        space();if(text[at]===end){at++;return result;}
+        while(at<text.length) {
+          if(object) {
+            space();if(text[at]!=='"')break;const name=read(depth+1);space();
+            if(text[at++]!==':'||own(result,name))break;result[name]=read(depth+1);
+          } else result.push(read(depth+1));
+          space();const next=text[at++];if(next===end)return result;if(next!==',')break;
+        }
+      } else {
+        at=start;
+        for(const [word,value] of [['true',true],['false',false],['null',null]])if(text.startsWith(word,at)){at+=word.length;return value;}
+        const number=/^-?(0|[1-9][0-9]*)([.][0-9]+)?([eE][+-]?[0-9]+)?/.exec(text.slice(at));
+        if(number) {
+          at+=number[0].length;
+          if(!number[2]&&!number[3]){const value=BigInt(number[0]);if(value>=minInt&&value<=maxInt)return value;}
+          else if(Number.isFinite(Number(number[0])))return Number(number[0]);
+        }
+      }
+      throw Error('Invalid JSON value');
+    }
+    const result=read();space();if(at!==text.length)throw Error('Invalid JSON value');return result;
+  }
+  function json(value,depth=0) {
+    if(depth>64)throw Error('JSON nesting exceeds 64 levels');
+    if(typeof value==='bigint')return value.toString();
+    if(Array.isArray(value))return '['+value.map(item=>json(item,depth+1)).join(',')+']';
+    if(value!==null&&typeof value==='object')return '{'+Object.entries(value).map(([name,item])=>JSON.stringify(name)+':'+json(item,depth+1)).join(',')+'}';
+    return JSON.stringify(value);
+  }
+  function scalar(text,schema,label) {
+    if (text === 'null' && schema.nullable) return null;
+    if (schema.kind === 'string') return text;
+    if (schema.kind === 'bool') {if (text === 'true') return true;if (text === 'false') return false;}
+    if (schema.kind === 'int' || schema.kind === 'c_int') {if (/^-?(0|[1-9][0-9]*)$/.test(text)) {const value=BigInt(text), min=schema.kind==='c_int'?-(1n<<31n):minInt, max=schema.kind==='c_int'?(1n<<31n)-1n:maxInt;if(value>=min&&value<=max)return value;}}
+    if (schema.kind === 'float') {if (/^-?(0|[1-9][0-9]*)([.][0-9]+)?([eE][+-]?[0-9]+)?$/.test(text) && Number.isFinite(Number(text))) return Number(text);}
+    if (['List','Set','Tuple','Map','record','Json','json'].includes(schema.kind)) return parse(text);
+    throw Error(label + ' has an invalid ' + schema.kind + ' value');
+  }
+  function formValue(form,schema) {
+    const data = new FormData(form), value = Object.create(null), fields = schema.fields;
+    for (const [name,item] of data) {
+      if (!own(fields,name)) throw Error('Unknown form field ' + name);
+      if (own(value,name)) throw Error('Duplicate form field ' + name);
+      if (typeof item !== 'string') throw Error('File fields require an upload endpoint');
+      if (item === '' && fields[name].optional) continue;
+      value[name] = scalar(item,fields[name],name);
+    }
+    for (const [name,field] of Object.entries(fields)) if (!field.optional && !own(value,name)) throw Error('Missing form field ' + name);
+    return value;
+  }
+  function build(action,form) {
+    let path = action.route.path, body;
+    const query = new URLSearchParams(), headers = new Headers();
+    action.route.parameters.forEach((param,index) => {
+      if (!action.present[index] && !param.form) return;
+      const value = param.form ? formValue(form,param.schema) : parse(action.values[index]);
+      if (param.source === 'path') path = path.replace('{'+param.name+'}',encodeURIComponent(String(value)));
+      else if (param.source === 'query') query.append(param.name,String(value));
+      else if (param.source === 'header') headers.append(param.name,String(value));
+      else if (param.source === 'body') {body=json(value);headers.set('content-type','application/json');}
+      else if (param.source === 'form') {const encoded=new URLSearchParams();for(const [name,item] of Object.entries(value)) encoded.append(name,['List','Set','Tuple','Map','record','Json','json'].includes(param.schema.fields[name].kind)?json(item):item===null?'null':String(item));body=encoded;headers.set('content-type','application/x-www-form-urlencoded');}
+    });
+    const url = new URL(path+(query.size?'?'+query.toString():''),location.origin);
+    if(url.origin!==location.origin) throw Error('HTTP actions must use the application origin');
+    return {url,options:{method:action.route.method,headers,body,credentials:'same-origin',redirect:'follow'}};
+  }
+  async function send(event,element,form) {
+    event.preventDefault();if(element.dataset.augBusy) return;element.dataset.augBusy='true';
+    let output;
+    try {
+      const request=build(JSON.parse(element.dataset.augAction),form), response=await fetch(request.url,request.options);
+      if(!response.ok) {let message='Request failed ('+response.status+')';try {const problem=await response.json();message=problem.detail||problem.title||problem.error||message;}catch {}throw Error(message);}
+      if(response.redirected) location.assign(response.url);else location.reload();
+    } catch(error) {
+      output=document.createElement('p');output.setAttribute('role','alert');output.textContent=error.message||'Request failed';element.after(output);
+    } finally {delete element.dataset.augBusy;}
+  }
+  document.addEventListener('submit',event=>{const form=event.target;if(form.matches('form[data-aug-event="submit"]')) send(event,form,form);});
+  document.addEventListener('click',event=>{const button=event.target.closest('button[data-aug-event="click"]');if(button)send(event,button,button.form);});
+})();`;

package/src/ast.js

@@ -0,0 +1,19 @@
+export function isStatement(item) {
+    return !['import', 'export', 'bind', 'composition', 'include', 'class', 'interface', 'interceptor', 'function', 'test'].includes(item.kind);
+}
+export function typeName(type) {
+    return (type.optional || type.nullable ? 'optional ' : '') + type.name + (type.args.length ? `<${type.args.map(typeName).join(',')}>` : '');
+}
+export function syntheticType(name, span) {
+    return { name, args: [], nullable: false, span };
+}
+/** Stored fields include constructor inputs and internal, purely initialized state. */
+export function fieldsOf(node) {
+    return [...node.fields, ...(node.kind === 'class' ? node.stateFields ?? [] : [])];
+}
+export function initializationOf(node) {
+    return [...(node.stateFields ?? []).map(field => ({ kind: 'assign',
+            target: { kind: 'name', name: field.name, span: field.span }, value: field.initializer,
+            ownership: field.ownership === 'own' ? 'own' : 'managed', span: field.span })),
+        ...(node.constructorBody ?? [])];
+}

package/src/builtins.js

@@ -0,0 +1,93 @@
+export const builtinTypes = {
+    int: { arity: 0 }, c_int: { arity: 0 }, float: { arity: 0 }, bool: { arity: 0 }, string: { arity: 0 }, void: { arity: 0 },
+    Error: { arity: 0 }, FileError: { arity: 0, error: true }, IndexError: { arity: 0, error: true }, ArithmeticError: { arity: 0, error: true }, ConversionError: { arity: 0, error: true },
+    List: { arity: 1 }, Set: { arity: 1 }, Map: { arity: 2 }, Tuple: { arity: -1 },
+    Bytes: { arity: 0 }, RsaPrivateKey: { arity: 0 }, RsaPublicKey: { arity: 0 },
+    CryptoError: { arity: 0, error: true }, JsonError: { arity: 0, error: true },
+    Json: { arity: 0 },
+    Task: { arity: 1 }, ConcurrencyError: { arity: 0, error: true },
+    HttpResponse: { arity: 1 }, HttpRequest: { arity: 0 }, Headers: { arity: 0 }, Html: { arity: 0 }, HttpAction: { arity: 0 },
+    ServerEvent: { arity: 1 }, HttpTestClient: { arity: 0 },
+    HttpError: { arity: 0, error: true },
+    Shared: { arity: 1 },
+    TimeError: { arity: 0, error: true },
+    Data: { arity: 0 },
+};
+export const errorNames = Object.keys(builtinTypes).filter(name => 'error' in builtinTypes[name]);
+export const builtinType = (name) => ({ id: `builtin:${name}`, name,
+    kind: name === 'Error' || name === 'Data' ? 'interface' : errorNames.includes(name) ? 'class' : 'builtin', args: [], nullable: false });
+export const builtinProperties = {
+    HttpResponse: [{ name: 'body', type: 'T', documentation: 'The typed response body.' },
+        { name: 'status', type: 'int', documentation: 'HTTP response status.' }, { name: 'headers', type: 'Headers', documentation: 'Immutable response headers. Duplicate Set-Cookie values are preserved.' }],
+    HttpRequest: [{ name: 'method', type: 'string', documentation: 'The HTTP method.' }, { name: 'path', type: 'string', documentation: 'Decoded request path.' },
+        { name: 'headers', type: 'Headers', documentation: 'Immutable request headers.' }, { name: 'body', type: 'Bytes', documentation: 'Bounded buffered request bytes.' }],
+};
+const length = { name: 'length', parameters: [], returns: 'int', documentation: 'Read the number of elements.', native: 'length' };
+export const collectionOperations = {
+    HttpTestClient: [{ name: 'request', parameters: [{ label: 'method', type: 'string' }, { label: 'path', type: 'string' }, { label: 'headers', type: 'optional Headers' }, { label: 'body', type: 'optional Bytes' }], returns: 'HttpResponse<Bytes>', errors: ['HttpError'], documentation: 'Run this suite’s endpoint through native routing, typed binding, request-scoped DI, policies, and response serialization. No listening socket is opened. Streaming output is collected up to the configured response limit.', native: 'request' }],
+    HttpRequest: [{ name: 'form', parameters: [], returns: 'decoded', errors: ['HttpError'], documentation: 'Decode a form record inside a handler so protocol-specific error responses can be returned.', native: 'form' }],
+    Headers: [
+        { name: 'with', parameters: [{ label: 'name', type: 'string' }, { label: 'value', type: 'string' }], returns: 'Headers', errors: ['HttpError'], documentation: 'Return new headers with one additional validated field. Header names ignore case; duplicate values remain separate.', native: 'with' },
+        { name: 'get', parameters: [{ label: 'name', type: 'string' }], returns: 'optional string', documentation: 'Read the first case-insensitive header value, or null.', native: 'get' },
+        { name: 'all', parameters: [{ label: 'name', type: 'string' }], returns: 'List<string>', documentation: 'Read every value of this header in wire order.', native: 'all' },
+    ],
+    Json: [
+        { name: 'stringify', parameters: [], returns: 'string', errors: ['JsonError'], documentation: 'Serialize this JSON value with checked UTF-8 escaping and exact int64 values.', native: 'stringify' },
+        { name: 'get', parameters: [{ label: 'name', type: 'string' }], returns: 'optional Json', documentation: 'Read an object member. An absent member or JSON null returns null.', native: 'get' },
+        { name: 'require', parameters: [{ label: 'name', type: 'string' }], returns: 'Json', errors: ['JsonError'], documentation: 'Read a required object member or raise JsonError.', native: 'require' },
+        { name: 'string', parameters: [], returns: 'string', errors: ['JsonError'], documentation: 'Require a JSON string.', native: 'string' },
+        { name: 'integer', parameters: [], returns: 'int', errors: ['JsonError'], documentation: 'Require an exact signed 64-bit JSON integer.', native: 'integer' },
+        { name: 'boolean', parameters: [], returns: 'bool', errors: ['JsonError'], documentation: 'Require a JSON bool.', native: 'boolean' },
+        { name: 'items', parameters: [], returns: 'List<Json>', errors: ['JsonError'], documentation: 'Read an immutable JSON array.', native: 'items' },
+        { name: 'decode', parameters: [], returns: 'decoded', errors: ['JsonError'], documentation: 'Decode a checked record or data type: json.decode<Profile>(). Unknown fields, type mismatches, and validation errors are rejected.', native: 'decode' },
+    ],
+    string: [
+        { name: 'isToken', parameters: [{ label: 'min', type: 'int' }, { label: 'max', type: 'int' }], returns: 'bool', documentation: 'Require an ASCII RFC 3986 unreserved token with a bounded length.', native: 'is_token' },
+        { ...length, documentation: 'Read the number of UTF-8 bytes. Unicode text is preserved losslessly.' },
+        { name: 'bytes', parameters: [], returns: 'Bytes', documentation: 'Encode this string as immutable UTF-8 bytes.', native: 'bytes' },
+        { name: 'split', parameters: [{ label: 'separator', type: 'string' }], returns: 'List<string>', documentation: 'Split at an exact separator, preserving empty parts.', native: 'split' },
+        { name: 'startsWith', parameters: [{ label: 'prefix', type: 'string' }], returns: 'bool', documentation: 'Test an exact prefix.', native: 'starts_with' },
+    ],
+    Bytes: [length,
+        { name: 'text', parameters: [], returns: 'string', errors: ['ConversionError'], documentation: 'Decode UTF-8 strictly. Invalid input raises ConversionError; embedded NUL is preserved.', native: 'text' },
+        { name: 'base64url', parameters: [], returns: 'string', documentation: 'Encode immutable bytes as unpadded RFC 4648 URL-safe base64.', native: 'base64url' },
+    ],
+    List: [
+        { name: 'append', parameters: [{ label: 'value', type: 'T' }], returns: 'void', changes: true,
+            documentation: 'Append an element with exclusive mutable access. Read-only and owned aliases cannot be stored here.', native: 'append' },
+        { name: 'get', parameters: [{ label: 'index', type: 'int' }], returns: 'T', errors: ['IndexError'],
+            documentation: 'Read a zero-based position. An invalid index raises checked IndexError. Reference results grant reading.', native: 'get' },
+        { name: 'at', parameters: [{ label: 'index', type: 'int' }], returns: 'optional T',
+            documentation: 'Read a zero-based position, returning null when it is absent. Narrow the result before using it.', native: 'at' }, length,
+    ],
+    Set: [
+        { name: 'add', parameters: [{ label: 'value', type: 'T' }], returns: 'void', changes: true,
+            documentation: 'Insert a unique element with exclusive mutable access.', native: 'add' },
+        { name: 'contains', parameters: [{ label: 'value', type: 'T' }], returns: 'bool', documentation: 'Test structural or identity equality with a stored element.', native: 'contains' }, length,
+    ],
+    Map: [
+        { name: 'take', parameters: [{ label: 'key', type: 'K' }], returns: 'optional V', changes: true, documentation: 'Remove and return an entry under exclusive access. An absent key returns null.', native: 'take' },
+        { name: 'set', parameters: [{ label: 'key', type: 'K' }, { label: 'value', type: 'V' }], returns: 'void', changes: true,
+            documentation: 'Insert or replace an entry with exclusive mutable access.', native: 'set' },
+        { name: 'get', parameters: [{ label: 'key', type: 'K' }], returns: 'optional V', documentation: 'Read a value by key; an absent key returns null. contains distinguishes an absent key from a stored null.', native: 'get' },
+        { name: 'contains', parameters: [{ label: 'key', type: 'K' }], returns: 'bool', documentation: 'Check for a key, including entries whose value is null.', native: 'contains' }, length,
+    ],
+    Tuple: [{ name: 'get', parameters: [{ label: 'index', type: 'int' }], returns: 'position', documentation: 'Read a statically checked constant position. Prefer tuple destructuring when reading several positions.', native: 'get' }, length],
+};
+export function operationType(text, receiver, position) {
+    const optional = text.startsWith('optional '), name = text.replace(/^optional /, '').replace(/\?$/, '');
+    const generic = /^(\w+)<(.+)>$/.exec(name);
+    const type = generic ? { ...builtinType(generic[1]), args: generic[2].split(',').map(arg => operationType(arg.trim(), receiver)) } : name === 'position' ? receiver.args[position ?? -1] : name === 'T' || name === 'K' ? receiver.args[0] : name === 'V' ? receiver.args[1] : builtinType(name);
+    const nullable = optional || text.endsWith('?') || !!type?.nullable || !!type?.optional;
+    return { ...(type ?? builtinType('<error>')), nullable, optional: nullable || undefined };
+}
+export const builtinFunctions = [
+    { name: 'exit', parameters: [{ label: 'status', type: 'int' }], returns: 'void', documentation: 'Exit from main with a status from 0 to 255 after cancellation and cleanup.', native: 'exit' },
+    { name: 'c_int', parameters: [{ label: 'value', type: 'int' }], returns: 'c_int', errors: ['ConversionError'], documentation: 'Checked conversion to a signed 32-bit C int. Overflow raises ConversionError. AugScript int maps to int64_t at the C boundary.', native: 'to_c_int' },
+    { name: 'int', parameters: [{ label: 'value', type: 'c_int' }], returns: 'int', documentation: 'Widen a C int to the signed 64-bit AugScript integer without loss.', native: 'to_int' },
+    { name: 'print', parameters: [{ label: 'value', type: 'any' }], returns: 'void', documentation: 'Composition and test output. Other callables receive Console and declare uses console.write.', native: 'print' },
+    { name: 'assert', parameters: [{ label: 'condition', type: 'bool' }], returns: 'void', documentation: 'Assert a bool in a test case or its setup. Catching an assertion failure cannot make the case pass; every case must execute an assertion.', native: 'assert' },
+    { name: 'arguments', parameters: [], returns: 'List<string>', documentation: 'Composition arguments. Other callables receive the Arguments capability.', native: 'arguments' },
+    { name: 'read_file', parameters: [{ label: 'path', type: 'string' }], returns: 'string', errors: ['FileError'], documentation: 'Root-only UTF-8 text input. Other callables receive FileReader. Invalid Unicode and NUL raise FileError.', native: 'read_file' },
+    { name: 'write_file', parameters: [{ label: 'path', type: 'string' }, { label: 'content', type: 'string' }], returns: 'void', errors: ['FileError'], documentation: 'Root-only UTF-8 text output. Other callables receive FileWriter.', native: 'write_file' },
+];