@greenpandastudios/aug-cli 0.19.0

package/runtime/aug_runtime.h

@@ -0,0 +1,245 @@
+#ifndef AUG_RUNTIME_H
+#define AUG_RUNTIME_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+typedef struct AugObject AugObject;
+typedef struct AugValue AugValue;
+typedef AugValue (*AugMethod)(AugValue self, AugValue *args, int count);
+
+enum { AUG_NULL, AUG_INT, AUG_FLOAT, AUG_BOOL, AUG_STRING, AUG_OBJECT };
+enum { AUG_LIST_KIND = 6, AUG_MAP_KIND, AUG_SET_KIND, AUG_TUPLE_KIND, AUG_RECORD_KIND, AUG_BYTES_KIND, AUG_PRIVATE_KEY_KIND, AUG_PUBLIC_KEY_KIND, AUG_JSON_KIND, AUG_HTTP_REQUEST_KIND, AUG_HTTP_RESPONSE_KIND, AUG_HEADERS_KIND, AUG_HTML_KIND, AUG_TASK_KIND, AUG_HTTP_ACTION_KIND };
+
+struct AugValue {
+  int tag;
+  union { int64_t integer; double floating; bool boolean; AugObject *object; } as;
+};
+
+typedef struct {
+  const char *name;
+  AugMethod function;
+} AugMethodEntry;
+
+struct AugObject {
+  AugObject *next;
+  bool marked;
+  bool dropped;
+  bool frozen;
+  bool html_actions;
+  int kind;
+  const char *type_name;
+  char *text;
+  size_t text_length;
+  AugValue *fields;
+  size_t field_count;
+  size_t capacity;
+  size_t *buckets;
+  size_t bucket_count;
+  const unsigned char *owned_fields;
+  const char *const *field_names;
+  const AugMethodEntry *methods;
+  size_t method_count;
+  void *native;
+  void (*finalize)(void *native);
+};
+
+typedef struct AugFrame {
+  AugValue *slots;
+  size_t count;
+  struct AugFrame *previous;
+} AugFrame;
+typedef struct AugRetained { AugValue *values; size_t count; struct AugRetained *next; } AugRetained;
+void aug_retain(AugRetained *root, AugValue *values, size_t count);
+void aug_release(AugRetained *root);
+
+typedef struct AugScope {
+  struct AugScope *previous; AugValue *values; const unsigned char *mask; void *tasks;
+} AugScope;
+typedef struct AugExecution {
+  AugFrame *root_frames; AugScope *scope_stack; size_t scope_depth;
+  AugValue error; bool has_error; bool cancelled; void *fiber;
+  struct AugExecution *next;
+  void *held_locks; size_t lock_depth;
+  void *http_job;
+} AugExecution;
+AugExecution *aug_execution_current(void);
+AugExecution *aug_execution_switch(AugExecution *execution);
+void aug_execution_init(AugExecution *execution);
+void aug_execution_dispose(AugExecution *execution);
+#define aug_error (aug_execution_current()->error)
+#define aug_has_error (aug_execution_current()->has_error)
+#define aug_cancelled (aug_execution_current()->cancelled)
+typedef void (*AugScopeJoin)(AugScope *scope);
+extern AugScopeJoin aug_scope_join_hook;
+AugValue aug_binding_get(size_t index);
+void aug_binding_set(size_t index, AugValue value);
+AugValue aug_shared_new(AugValue value);
+AugValue aug_shared_lock(AugValue value);
+size_t aug_lock_depth(void);
+void aug_lock_leave(void);
+void aug_lock_restore(size_t depth);
+extern void (*aug_mutex_wait_hook)(void);
+typedef struct AugTask AugTask;
+typedef void (*AugTaskCompletion)(AugValue task, void *data);
+AugValue aug_task_start(AugMethod function, AugValue receiver, AugValue *args, int count);
+AugValue aug_task_spawn(AugMethod function, AugValue receiver, AugValue *args, int count, AugTaskCompletion completion, void *data);
+AugValue aug_task_wait(AugValue *tasks, int count);
+AugTask *aug_task_current(void);
+bool aug_task_finished(AugValue task);
+void aug_task_cancel(AugValue task);
+void aug_task_release(AugValue task);
+void aug_task_suspend(void);
+void aug_task_wake(AugTask *task);
+void aug_task_checkpoint(void);
+extern void (*aug_task_checkpoint_hook)(void);
+bool aug_scheduler_step(void);
+extern void (*aug_scheduler_io)(bool wait);
+extern void (*aug_scheduler_notify)(void);
+extern bool aug_test_failed;
+extern size_t aug_test_assertions;
+
+AugValue aug_null(void);
+AugValue aug_int(int64_t value);
+AugValue aug_float(double value);
+AugValue aug_bool(bool value);
+/* The checker proves these operand types. Keep scalar arithmetic visible to
+   the C optimizer while preserving August's wrapping and checked semantics. */
+static inline AugValue aug_scalar_int(int64_t value) { return (AugValue){.tag=AUG_INT, .as.integer=value}; }
+static inline AugValue aug_scalar_float(double value) { return (AugValue){.tag=AUG_FLOAT, .as.floating=value}; }
+static inline AugValue aug_scalar_bool(bool value) { return (AugValue){.tag=AUG_BOOL, .as.boolean=value}; }
+static inline AugValue aug_scalar_null(void) { return (AugValue){.tag=AUG_NULL}; }
+static inline int64_t aug_signed_bits(uint64_t bits) {
+  /* Unsigned-to-signed casts are implementation-defined above INT64_MAX. */
+  int64_t value; memcpy(&value, &bits, sizeof(value)); return value;
+}
+AugValue aug_error_named(const char *name);
+static inline AugValue aug_scalar_int_divide(int64_t left, int64_t right) {
+  if (!right) return aug_error_named("ArithmeticError");
+  return aug_scalar_int(left == INT64_MIN && right == -1 ? INT64_MIN : left / right);
+}
+static inline AugValue aug_scalar_float_divide(double left, double right) {
+  if (right == 0) return aug_error_named("ArithmeticError");
+  return aug_scalar_float(left / right);
+}
+AugValue aug_string(const char *value);
+AugValue aug_string_n(const void *value, size_t length);
+AugValue aug_bytes(const void *value, size_t length, int kind);
+int64_t aug_string_length(AugValue value);
+AugValue aug_string_bytes(AugValue value);
+AugValue aug_string_split(AugValue value, AugValue separator);
+bool aug_string_starts_with(AugValue value, AugValue prefix);
+bool aug_string_is_token(AugValue value, int64_t minimum, int64_t maximum);
+int64_t aug_bytes_length(AugValue value);
+AugValue aug_bytes_text(AugValue value);
+AugValue aug_bytes_base64url(AugValue value);
+AugValue aug_base64url_decode(AugValue value);
+
+typedef struct AugSchema AugSchema;
+typedef AugValue (*AugFunction)(AugValue *args, int count);
+enum { AUG_SCHEMA_INT, AUG_SCHEMA_C_INT, AUG_SCHEMA_FLOAT, AUG_SCHEMA_BOOL, AUG_SCHEMA_STRING,
+       AUG_SCHEMA_LIST, AUG_SCHEMA_MAP, AUG_SCHEMA_SET, AUG_SCHEMA_TUPLE, AUG_SCHEMA_RECORD, AUG_SCHEMA_JSON };
+struct AugSchema {
+  int kind; bool nullable; bool optional; size_t count;
+  const AugSchema *const *fields; const char *const *names; AugFunction make;
+};
+AugValue aug_json_decode(AugValue value, const AugSchema *schema);
+AugValue aug_json_stringify(AugValue value);
+AugValue aug_json_get(AugValue value, AugValue name);
+AugValue aug_json_require(AugValue value, AugValue name);
+AugValue aug_json_string(AugValue value);
+int64_t aug_json_integer(AugValue value);
+bool aug_json_boolean(AugValue value);
+AugValue aug_json_items(AugValue value);
+AugValue aug_json_wrap(AugValue value);
+AugValue _aug_json_parse(AugValue input);
+typedef enum {
+  AUG_HTTP_POLICY_REQUIRE_LOGIN=1, AUG_HTTP_POLICY_REQUIRE_PERMISSION,
+  AUG_HTTP_POLICY_LOG_REQUEST, AUG_HTTP_POLICY_RATE_LIMIT, AUG_HTTP_POLICY_TIMEOUT,
+  AUG_HTTP_POLICY_CORS, AUG_HTTP_POLICY_COMPRESS
+} AugHttpPolicyKind;
+typedef struct {AugHttpPolicyKind kind;const char *permission;int64_t amount,seconds;bool credentials;const char *origins,*headers;} AugHttpPolicy;
+typedef struct { const char *method; const char *path; AugFunction handler; int stream; int status; const AugHttpPolicy *policies;size_t policy_count; } AugRoute;
+void aug_http_policy(const AugHttpPolicy *policy, AugValue request, AugValue dependency, AugValue second);
+AugValue aug_http_finish(AugValue response);
+AugValue aug_http_bind(AugValue request, const char *source, const char *name, const AugSchema *schema);
+AugValue aug_httprequest_form(AugValue request, const AugSchema *schema);
+AugValue aug_http_response(AugValue body, int status);
+AugValue aug_http_response_full(AugValue body, AugValue status, AugValue headers);
+AugValue aug_headers_new(void);
+AugValue aug_headers_with(AugValue headers, AugValue name, AugValue value);
+AugValue aug_headers_get(AugValue headers, AugValue name);
+AugValue aug_headers_all(AugValue headers, AugValue name);
+AugValue aug_html_element(const char *tag, AugValue *attributes, size_t count, AugValue *children, size_t child_count);
+AugValue aug_http_action(const char *route, AugValue *values, size_t count);
+AugValue aug_http_event(AugValue data, AugValue id, AugValue event, AugValue retry);
+void aug_http_yield(AugValue value);
+AugValue aug_http_test_client(const AugRoute *routes, size_t count);
+AugValue aug_httptestclient_request(AugValue client, AugValue method, AugValue path, AugValue headers, AugValue body);
+AugValue aug_html_transport(AugValue html);
+AugValue aug_http_problem(int status);
+int aug_http_error_status(void);
+void aug_http_serve(const AugRoute *routes, size_t count, int64_t port);
+void aug_http_configure(const char *host, const char *certificate, const char *private_key, const char *ca, size_t request_limit, size_t result_limit, bool http3);
+AugValue aug_new_object(const char *name, size_t field_count,
+                        const unsigned char *owned_fields,
+                        const AugMethodEntry *methods, size_t method_count);
+AugValue aug_list_new(AugValue *items, size_t count);
+void aug_list_append(AugValue list, AugValue item);
+AugValue aug_list_get(AugValue list, int64_t index);
+AugValue aug_list_at(AugValue list, int64_t index);
+AugValue aug_iter_snapshot(AugValue collection);
+AugValue aug_map_entries_snapshot(AugValue map);
+int64_t aug_list_length(AugValue list);
+AugValue aug_tuple_new(AugValue *items, size_t count);
+AugValue aug_tuple_get(AugValue tuple, int64_t index);
+int64_t aug_tuple_length(AugValue tuple);
+AugValue aug_set_new(AugValue *items, size_t count);
+void aug_set_add(AugValue set, AugValue item);
+bool aug_set_contains(AugValue set, AugValue item);
+int64_t aug_set_length(AugValue set);
+AugValue aug_map_new(void);
+void aug_map_set(AugValue map, AugValue key, AugValue value);
+AugValue aug_map_get(AugValue map, AugValue key);
+AugValue aug_map_take(AugValue map, AugValue key);
+bool aug_map_contains(AugValue map, AugValue key);
+int64_t aug_map_length(AugValue map);
+void aug_set_cli_args(int argc, char **argv);
+AugValue aug_arguments(void);
+AugValue aug_read_file(AugValue path);
+AugValue aug_write_file(AugValue path, AugValue content);
+AugValue aug_field(AugValue object, size_t index);
+void aug_set_field(AugValue object, size_t index, AugValue value);
+AugValue aug_call_method(AugValue object, const char *name, AugValue *args, int count);
+void aug_print(AugValue value);
+void aug_assert(AugValue condition, const char *expression, const char *file, int line);
+AugValue aug_binary(const char *op, AugValue left, AugValue right);
+AugValue aug_unary(const char *op, AugValue value);
+bool aug_truthy(AugValue value);
+const char *aug_cstring(AugValue value);
+int64_t aug_cint(AugValue value);
+AugValue aug_to_c_int(AugValue value);
+void aug_coverage_register(const char *file, size_t line);
+void aug_cover(const char *file, size_t line);
+double aug_cfloat(AugValue value);
+
+void aug_frame_enter(AugFrame *frame, AugValue *slots, size_t count);
+void aug_frame_leave(AugFrame *frame);
+void aug_register_globals(AugValue *values, size_t count);
+size_t aug_scope_depth(void);
+void aug_scope_enter(const unsigned char *mask);
+void aug_scope_leave(void);
+void aug_scope_join_to(size_t depth);
+void aug_scope_restore(size_t depth);
+void aug_collect(void);
+void aug_freeze(AugValue value);
+void aug_drop(AugValue value);
+void aug_throw(AugValue value);
+AugValue aug_take_error(void);
+bool aug_error_is(const char *name);
+void aug_report_error(void);
+void aug_shutdown(void);
+
+#endif

package/runtime/aug_tasks.c

@@ -0,0 +1,172 @@
+#include "aug_runtime.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#define MINICORO_IMPL
+#include "minicoro.h"
+
+/* C stack suspension preserves ordinary August calls and their precise GC frames. */
+struct AugTask {
+  mco_coro *coroutine; AugExecution execution; AugMethod function;
+  AugValue value; AugRetained retained; bool retained_active, queued, complete, observed;
+  size_t base_depth; struct AugTask *ready_next, *sibling; AugScope *owner;
+  AugTaskCompletion completion; void *completion_data; unsigned ticks;
+};
+static AugTask *ready_first, *ready_last;
+void (*aug_scheduler_io)(bool wait);
+void (*aug_scheduler_notify)(void);
+
+static void fatal(const char *message) { fprintf(stderr, "August scheduler: %s\n", message); abort(); }
+static AugTask *task_of(AugValue value) {
+  return value.tag == AUG_OBJECT && value.as.object->kind == AUG_TASK_KIND ? value.as.object->native : NULL;
+}
+AugTask *aug_task_current(void) { return aug_execution_current()->fiber; }
+bool aug_task_finished(AugValue value) { AugTask *task = task_of(value); return task && task->complete; }
+void aug_task_wake(AugTask *task) {
+  if (!task || task->complete || task->queued) return;
+  task->queued = true; task->ready_next = NULL;
+  if (ready_last) ready_last->ready_next = task; else ready_first = task;
+  ready_last = task;
+  if(aug_scheduler_notify)aug_scheduler_notify();
+}
+static void destroy_task(void *native) {
+  AugTask *task = native;
+  if (!task->complete) fatal("collected an unfinished task");
+  mco_destroy(task->coroutine); free(task);
+}
+void aug_task_release(AugValue value) {
+  AugTask *task = task_of(value);
+  if (task && task->retained_active) { aug_release(&task->retained); task->retained_active = false; }
+}
+void aug_task_cancel(AugValue value) {
+  AugTask *task = task_of(value);
+  if (!task || task->complete) return;
+  task->execution.cancelled = true; aug_task_wake(task);
+}
+static void cancel_group(AugTask *failed) {
+  if (!failed->owner) return;
+  for (AugTask *task = failed->owner->tasks; task; task = task->sibling)
+    if (task != failed) aug_task_cancel(task->value);
+}
+static void run_task(mco_coro *coroutine) {
+  AugTask *task = mco_get_user_data(coroutine);
+  AugValue arguments = aug_field(task->value, 1);
+  if (!aug_cancelled) {
+    AugValue result = task->function(aug_field(task->value, 0), arguments.as.object->fields, (int)arguments.as.object->field_count);
+    aug_set_field(task->value, 2, result);
+  }
+  aug_scope_restore(task->base_depth);
+  if (aug_has_error) { aug_set_field(task->value, 3, aug_take_error()); cancel_group(task); }
+  task->complete = true;
+}
+bool aug_scheduler_step(void) {
+  AugTask *task = ready_first;
+  if (!task) return false;
+  ready_first = task->ready_next; if (!ready_first) ready_last = NULL;
+  task->queued = false; task->ready_next = NULL;
+  if (task->complete) return true;
+  AugExecution *previous = aug_execution_switch(&task->execution);
+  if (mco_resume(task->coroutine) != MCO_SUCCESS) fatal("cannot resume task");
+  aug_execution_switch(previous);
+  if (task->complete) {
+    aug_execution_dispose(&task->execution);
+    if (task->completion) task->completion(task->value, task->completion_data);
+  }
+  return true;
+}
+void aug_task_suspend(void) {
+  AugTask *task = aug_task_current();
+  if (!task || mco_yield(task->coroutine) != MCO_SUCCESS) fatal("suspension outside a task");
+}
+void aug_task_checkpoint(void) {
+  if(aug_task_checkpoint_hook)aug_task_checkpoint_hook();
+  AugTask *task = aug_task_current();
+  if (task && !aug_lock_depth() && ++task->ticks % 128 == 0) { aug_task_wake(task); aug_task_suspend(); }
+}
+static void await_task(AugTask *task) {
+  while (!task->complete) {
+    if (aug_cancelled) aug_task_cancel(task->value);
+    if (aug_task_current()) { aug_task_wake(aug_task_current()); aug_task_suspend(); }
+    else if (!aug_scheduler_step()) {
+      if (!aug_scheduler_io) fatal("task deadlock: every child is suspended");
+      aug_scheduler_io(true);
+    }
+    if (aug_scheduler_io && !aug_task_current()) aug_scheduler_io(false);
+  }
+}
+static void join_scope(AugScope *scope) {
+  bool cancelling = aug_has_error || aug_cancelled;
+  AugValue first_error = aug_null(); AugFrame frame; aug_frame_enter(&frame, &first_error, 1);
+  for (AugTask *task = scope->tasks; task; task = task->sibling) {
+    if (cancelling) aug_task_cancel(task->value);
+    await_task(task);
+    AugValue error = aug_field(task->value, 3);
+    if (!task->observed && error.tag != AUG_NULL && first_error.tag == AUG_NULL) first_error = error;
+  }
+  for (AugTask *task = scope->tasks; task;) {
+    AugTask *next = task->sibling; task->owner = NULL; aug_task_release(task->value); task = next;
+  }
+  scope->tasks = NULL;
+  if (!aug_has_error && first_error.tag != AUG_NULL) aug_throw(first_error);
+  aug_frame_leave(&frame);
+}
+AugValue aug_task_spawn(AugMethod function, AugValue receiver, AugValue *args, int count, AugTaskCompletion completion, void *data) {
+  aug_scope_join_hook = join_scope;
+  AugValue roots[3] = {receiver, aug_null(), aug_null()}; AugFrame frame; aug_frame_enter(&frame, roots, 3);
+  roots[1] = aug_list_new(args, (size_t)count);
+  roots[2] = aug_new_object("Task", 4, NULL, NULL, 0); roots[2].as.object->kind = AUG_TASK_KIND;
+  aug_set_field(roots[2], 0, receiver); aug_set_field(roots[2], 1, roots[1]);
+  AugTask *task = calloc(1, sizeof(*task)); if (!task) fatal("out of memory");
+  task->function = function; task->value = roots[2]; task->completion = completion; task->completion_data = data;
+  aug_execution_init(&task->execution); task->execution.fiber = task;
+  AugExecution *parent = aug_execution_current();
+  task->execution.scope_stack = parent->scope_stack; task->execution.scope_depth = parent->scope_depth; task->base_depth = parent->scope_depth;
+  task->execution.http_job = parent->http_job; task->execution.cancelled = parent->cancelled;
+  task->retained_active = true; aug_retain(&task->retained, &task->value, 1);
+  roots[2].as.object->native = task; roots[2].as.object->finalize = destroy_task;
+  mco_desc description = mco_desc_init(run_task, 1024 * 1024); description.user_data = task;
+  if (mco_create(&task->coroutine, &description) != MCO_SUCCESS) fatal("cannot allocate coroutine stack");
+  aug_task_wake(task); AugValue result = roots[2]; aug_frame_leave(&frame); return result;
+}
+AugValue aug_task_start(AugMethod function, AugValue receiver, AugValue *args, int count) {
+  AugScope *scope = aug_execution_current()->scope_stack;
+  if (!scope) return aug_error_named("ConcurrencyError");
+  AugValue value = aug_task_spawn(function, receiver, args, count, NULL, NULL); AugTask *task = task_of(value);
+  task->owner = scope; task->sibling = scope->tasks; scope->tasks = task; return value;
+}
+static AugValue wait_one(AugValue value) {
+  AugTask *task = task_of(value); if (!task) return aug_error_named("ConcurrencyError");
+  await_task(task); AugValue error = aug_field(value, 3);
+  if (error.tag != AUG_NULL) { task->observed = true; aug_throw(error); return aug_null(); }
+  if (task->execution.cancelled) {
+    if (!aug_cancelled && task->owner) for (AugTask *sibling = task->owner->tasks; sibling; sibling = sibling->sibling) {
+      error = aug_field(sibling->value, 3);
+      if (!sibling->observed && error.tag != AUG_NULL) {
+        sibling->observed = true; aug_throw(error); return aug_null();
+      }
+    }
+    aug_cancelled = true;
+  }
+  return aug_field(value, 2);
+}
+AugValue aug_task_wait(AugValue *tasks, int count) {
+  if (count == 1 && task_of(tasks[0])) return wait_one(tasks[0]);
+  AugValue *items = tasks; size_t size = (size_t)count; bool list = false;
+  if (count == 1 && tasks[0].tag == AUG_OBJECT && tasks[0].as.object->kind == AUG_LIST_KIND) {
+    items = tasks[0].as.object->fields; size = tasks[0].as.object->field_count; list = true;
+  }
+  AugValue roots[2] = {aug_list_new(NULL, 0), aug_null()}; AugFrame frame; aug_frame_enter(&frame, roots, 2);
+  for (size_t i = 0; i < size; i++) {
+    AugTask *task = task_of(items[i]);
+    if (task && (roots[1].tag != AUG_NULL || aug_cancelled)) {
+      aug_task_cancel(task->value); await_task(task); task->observed = true;
+    } else {
+      AugValue value = wait_one(items[i]);
+      if (aug_has_error) {AugValue error = aug_take_error(); if (roots[1].tag == AUG_NULL) roots[1] = error;}
+      else if (!aug_cancelled) aug_list_append(roots[0], value);
+    }
+  }
+  if (!list) roots[0].as.object->kind = AUG_TUPLE_KIND;
+  if (roots[1].tag != AUG_NULL) aug_throw(roots[1]);
+  AugValue result = roots[0]; aug_frame_leave(&frame); return result;
+}

package/runtime/aug_time.c

@@ -0,0 +1,5 @@
+#include "aug_runtime.h"
+#include <time.h>
+AugValue _aug_time_now(void) {
+  time_t now = time(NULL); return now < 0 ? aug_error_named("TimeError") : aug_int((int64_t)now);
+}

package/runtime/aug_values.c

@@ -0,0 +1,80 @@
+#include "aug_runtime.h"
+#include <stdlib.h>
+#include <string.h>
+
+int64_t aug_string_length(AugValue value) { return (int64_t)value.as.object->text_length; }
+AugValue aug_string_bytes(AugValue value) { return aug_bytes(value.as.object->text, value.as.object->text_length, AUG_BYTES_KIND); }
+bool aug_string_starts_with(AugValue value, AugValue prefix) {
+  return prefix.as.object->text_length <= value.as.object->text_length &&
+    !memcmp(value.as.object->text, prefix.as.object->text, prefix.as.object->text_length);
+}
+AugValue aug_string_split(AugValue value, AugValue separator) {
+  AugValue roots[2] = {value, aug_null()}; AugFrame frame; aug_frame_enter(&frame, roots, 2);
+  roots[1] = aug_list_new(NULL, 0);
+  size_t size = value.as.object->text_length, step = separator.as.object->text_length, begin = 0;
+  if (!step) { aug_list_append(roots[1], value); }
+  else {
+    for (size_t i = 0; i + step <= size;) {
+      if (!memcmp(value.as.object->text + i, separator.as.object->text, step)) {
+        AugValue part = aug_string_n(value.as.object->text + begin, i - begin);
+        aug_list_append(roots[1], part); i += step; begin = i;
+      } else i++;
+    }
+    aug_list_append(roots[1], aug_string_n(value.as.object->text + begin, size - begin));
+  }
+  AugValue result = roots[1]; aug_frame_leave(&frame); return result;
+}
+int64_t aug_bytes_length(AugValue value) { return (int64_t)value.as.object->text_length; }
+AugValue aug_bytes_text(AugValue value) {
+  const unsigned char *text = (const unsigned char *)value.as.object->text;
+  size_t size = value.as.object->text_length;
+  for (size_t i = 0; i < size;) {
+    unsigned char first = text[i++];
+    if (first < 0x80) continue;
+    int extra = first >= 0xc2 && first <= 0xdf ? 1 : first >= 0xe0 && first <= 0xef ? 2 : first >= 0xf0 && first <= 0xf4 ? 3 : -1;
+    if (extra < 0 || i + (size_t)extra > size) return aug_error_named("ConversionError");
+    uint32_t code = first & (extra == 1 ? 0x1f : extra == 2 ? 0x0f : 0x07);
+    for (int j = 0; j < extra; j++) {
+      unsigned char next = text[i++];
+      if ((next & 0xc0) != 0x80) return aug_error_named("ConversionError");
+      code = (code << 6) | (next & 0x3f);
+    }
+    if (code < (extra == 1 ? 0x80u : extra == 2 ? 0x800u : 0x10000u) || code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)) return aug_error_named("ConversionError");
+  }
+  return aug_string_n(text, size);
+}
+
+static const char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+AugValue aug_bytes_base64url(AugValue value) {
+  const unsigned char *bytes = (const unsigned char *)value.as.object->text;
+  size_t size = value.as.object->text_length, length = (size * 8 + 5) / 6;
+  char *text = malloc(length + 1); if (!text) abort();
+  uint32_t bits = 0; int count = 0; size_t next = 0;
+  for (size_t i = 0; i < size; i++) {
+    bits = (bits << 8) | bytes[i]; count += 8;
+    while (count >= 6) { count -= 6; text[next++] = alphabet[(bits >> count) & 63]; }
+  }
+  if (count) text[next++] = alphabet[(bits << (6 - count)) & 63];
+  AugValue result = aug_string_n(text, next); free(text); return result;
+}
+AugValue aug_base64url_decode(AugValue value) {
+  size_t length = value.as.object->text_length;
+  if (length % 4 == 1) return aug_error_named("CryptoError");
+  unsigned char *output = malloc(length * 3 / 4 + 1); if (!output) abort();
+  uint32_t bits = 0; int count = 0; size_t next = 0;
+  for (size_t i = 0; i < length; i++) {
+    unsigned char c = (unsigned char)value.as.object->text[i];
+    const char *found = c ? strchr(alphabet, c) : NULL;
+    if (!found) { free(output); return aug_error_named("CryptoError"); }
+    bits = (bits << 6) | (uint32_t)(found - alphabet); count += 6;
+    if (count >= 8) { count -= 8; output[next++] = (unsigned char)(bits >> count); }
+  }
+  if (count && (bits & ((1u << count) - 1))) { free(output); return aug_error_named("CryptoError"); }
+  AugValue result = aug_bytes(output, next, AUG_BYTES_KIND); free(output); return result;
+}
+bool aug_string_is_token(AugValue value, int64_t minimum, int64_t maximum) {
+  size_t size = value.as.object->text_length; if (minimum < 0 || maximum < minimum || size < (uint64_t)minimum || size > (uint64_t)maximum) return false;
+  for (size_t i = 0; i < size; i++) {unsigned char c = (unsigned char)value.as.object->text[i];
+    if (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '-' || c == '_' || c == '.' || c == '~')) return false;
+  } return true;
+}

package/scripts/bootstrap-native.mjs

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+/** Build the pinned C dependencies privately; never install into system directories. */
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, openSync, closeSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { availableParallelism } from 'node:os';
+import { nativeHome } from './native-home.mjs';
+
+const root = resolve(import.meta.dirname, '..');
+const lock = JSON.parse(readFileSync(join(import.meta.dirname, 'native-dependencies.lock.json'), 'utf8'));
+const extractOnly = process.argv.includes('--extract-only');
+const onlyIndex = process.argv.indexOf('--only');
+const selected = onlyIndex >= 0 ? process.argv[onlyIndex + 1]?.split(',') : undefined;
+if (onlyIndex >= 0 && (!extractOnly || !selected?.length || selected.some(name => !lock.dependencies.some(dependency => dependency.name === name))))
+  throw new Error('--only requires --extract-only and comma-separated names from native-dependencies.lock.json.');
+const directory = nativeHome(root);
+const prefix = join(directory, 'prefix');
+const downloads = join(directory, 'downloads');
+const sources = join(directory, 'sources');
+const logs = join(directory, 'logs');
+for (const path of [prefix, downloads, sources, logs]) mkdirSync(path, { recursive: true });
+if (!extractOnly && !lock.platforms.includes(process.platform)) throw new Error(`Full native bootstrap supports ${lock.platforms.join(' and ')}; this host is ${process.platform}. Use --extract-only --only minicoro,yyjson for portable source dependencies.`);
+
+function run(command, args, cwd, label, env = process.env) {
+  const path = join(logs, label + '.log');
+  const descriptor = openSync(path, 'w');
+  let result;
+  try { result = spawnSync(command, args, { cwd, env, stdio: ['ignore', descriptor, descriptor] }); }
+  finally { closeSync(descriptor); }
+  if (result.error || result.status !== 0) throw new Error(`${label} failed: ${result.error?.message ?? result.status}. See ${path}\n` + readFileSync(path, 'utf8').split('\n').slice(-24).join('\n'));
+}
+
+const dependencies = lock.dependencies.filter(dependency => (!dependency.platforms || dependency.platforms.includes(process.platform)) && (!selected || selected.includes(dependency.name)));
+if (selected?.some(name => !dependencies.some(dependency => dependency.name === name)))
+  throw new Error(`One or more selected dependencies do not support ${process.platform}.`);
+for (const dependency of dependencies) {
+  const archive = join(downloads, dependency.archive);
+  if (!existsSync(archive)) {
+    process.stdout.write(`Downloading ${dependency.name} ${dependency.version}\n`);
+    const response = await fetch(dependency.url);
+    if (!response.ok) throw new Error(`${dependency.name}: HTTP ${response.status}`);
+    writeFileSync(archive, Buffer.from(await response.arrayBuffer()));
+  }
+  const hash = createHash('sha256').update(readFileSync(archive)).digest('hex');
+  if (hash !== dependency.sha256) throw new Error(`${dependency.name}: archive checksum mismatch`);
+  const source = join(sources, dependency.name);
+  if (!existsSync(join(source, '.archive-sha256'))) {
+    mkdirSync(source, { recursive: true });
+    run('/usr/bin/tar', ['-xf', archive, '-C', source, '--strip-components=1'], directory, 'extract-' + dependency.name);
+    writeFileSync(join(source, '.archive-sha256'), hash + '\n');
+  } else if (readFileSync(join(source, '.archive-sha256'), 'utf8').trim() !== hash) {
+    throw new Error(`${dependency.name}: source tree differs from the dependency lock; choose a new build directory.`);
+  }
+}
+if (extractOnly) process.exit(0);
+
+const sdk = '/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk';
+const mac = process.platform === 'darwin';
+const cc = process.env.CC ?? (mac ? '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang' : 'clang');
+const sysroot = mac && existsSync(sdk) ? ' -isysroot ' + sdk : '';
+const environment = { ...process.env, ...(mac ? { SDKROOT: sdk } : {}), CC: cc, CC_FOR_BUILD: cc, CXX: process.env.CXX ?? cc.replace(/clang$/, 'clang++'),
+  CFLAGS: `-O2 -fPIC${sysroot}`,
+  CXXFLAGS: `-O2 -fPIC${sysroot}`,
+  CPPFLAGS: `-I${prefix}/include${sysroot}`, LDFLAGS: `-L${prefix}/lib -Wl,-rpath,${prefix}/lib`,
+  PKG_CONFIG: join(prefix, 'bin', 'pkgconf'), PKG_CONFIG_PATH: join(prefix, 'lib', 'pkgconfig'),
+  LD_LIBRARY_PATH: `${prefix}/lib${process.env.LD_LIBRARY_PATH ? ':' + process.env.LD_LIBRARY_PATH : ''}`,
+  PATH: join(prefix, 'bin') + ':' + process.env.PATH,
+};
+const parallel = String(Math.min(8, availableParallelism()));
+for (const name of ['pkgconf', 'gmp', 'nettle', 'gnutls']) {
+  const marker = join(prefix, '.built-' + name);
+  const checksum = lock.dependencies.find(dependency => dependency.name === name).sha256;
+  if (existsSync(marker)) {
+    if (readFileSync(marker, 'utf8').trim() !== checksum) throw new Error(`${name}: installed build differs from the dependency lock; choose a new build directory.`);
+    continue;
+  }
+  const source = join(sources, name);
+  const extra = name === 'gmp' ? ['--disable-cxx', '--with-pic'] : name === 'nettle' ? ['--disable-documentation'] : name === 'gnutls' ? [
+    '--disable-doc', '--disable-tests', '--disable-tools', '--disable-cxx', '--disable-guile',
+    '--disable-nls', '--disable-idn', '--without-p11-kit', '--without-brotli', '--without-zstd',
+    '--with-included-libtasn1', '--with-included-unistring', '--disable-libdane',
+  ] : [];
+  // GnuTLS 3.8.13's audit header does not define this diagnostic-only macro
+  // when Clang 14 reports __has_c_attribute but lacks [[maybe_unused]].
+  const buildEnvironment = name === 'gnutls' && !mac ?
+    {...environment, CFLAGS: environment.CFLAGS + ' -DCRAU_MAYBE_UNUSED='} : environment;
+  process.stdout.write(`Building ${name}; logs: ${logs}\n`);
+  run(join(source, 'configure'), ['--prefix=' + prefix, '--libdir=' + join(prefix, 'lib'), '--enable-shared', '--disable-static', ...extra], source, name + '-configure', buildEnvironment);
+  run('/usr/bin/make', ['-j' + parallel], source, name + '-build', buildEnvironment);
+  run('/usr/bin/make', ['install'], source, name + '-install', buildEnvironment);
+  if (name === 'nettle') run(join(prefix, 'bin', 'pkgconf'), ['--modversion', 'nettle', 'hogweed'], root, 'nettle-pkgconf', environment);
+  writeFileSync(marker, checksum + '\n');
+}
+
+const cmake = mac ? join(sources, 'cmake', 'CMake.app', 'Contents', 'bin', 'cmake') : 'cmake';
+const build = join(directory, 'build-libwebsockets');
+const webMarker = join(prefix, '.built-libwebsockets');
+const webChecksum = lock.dependencies.find(dependency => dependency.name === 'libwebsockets').sha256;
+if (existsSync(webMarker) && readFileSync(webMarker, 'utf8').trim() !== webChecksum)
+  throw new Error('libwebsockets: installed build differs from the dependency lock; choose a new build directory.');
+if (!existsSync(webMarker)) {
+  process.stdout.write(`Building libwebsockets with GnuTLS, HTTP/2 and HTTP/3\n`);
+  run(cmake, ['-S', join(sources, 'libwebsockets'), '-B', build,
+    '-DCMAKE_BUILD_TYPE=Release', '-DCMAKE_INSTALL_PREFIX=' + prefix, '-DCMAKE_INSTALL_LIBDIR=lib', '-DCMAKE_PREFIX_PATH=' + prefix,
+    '-DCMAKE_C_COMPILER=' + cc, ...(mac ? ['-DCMAKE_OSX_SYSROOT=' + sdk] : []),
+    '-DLWS_GNUTLS_LIBRARIES=' + join(prefix, 'lib', mac ? 'libgnutls.dylib' : 'libgnutls.so'),
+    '-DLWS_GNUTLS_INCLUDE_DIRS=' + join(prefix, 'include'),
+    '-DLWS_WITH_GNUTLS=ON', '-DLWS_WITH_HTTP2=ON', '-DLWS_WITH_HTTP3=ON',
+    '-DLWS_WITH_STATIC=ON', '-DLWS_WITH_SHARED=OFF', '-DLWS_WITHOUT_TESTAPPS=ON',
+    '-DLWS_WITHOUT_TEST_SERVER=ON', '-DLWS_WITHOUT_TEST_CLIENT=ON',
+    '-DLWS_WITH_LIBUV=OFF', '-DLWS_WITH_LIBEVENT=OFF', '-DLWS_WITH_LIBEV=OFF',
+    '-DLWS_WITH_GLIB=OFF', '-DLWS_WITHOUT_EXTENSIONS=ON', '-DLWS_WITH_ZLIB=OFF',
+  ], root, 'libwebsockets-configure', environment);
+  run(cmake, ['--build', build, '--parallel', parallel], root, 'libwebsockets-build', environment);
+  run(cmake, ['--install', build], root, 'libwebsockets-install', environment);
+  writeFileSync(webMarker, webChecksum + '\n');
+}
+writeFileSync(join(prefix, 'aug-native-manifest.json'), JSON.stringify({ platform: process.platform, architecture: process.arch,
+  dependencies: dependencies.map(({name, version, revision, sha256}) => ({name, version, revision, sha256})) }, null, 2) + '\n');
+process.stdout.write(`Native dependencies ready at ${prefix}\n`);