@greenpandastudios/aug-cli 0.19.0 → 0.21.0

package/runtime/aug_ir.h

@@ -0,0 +1,89 @@
+#ifndef AUG_IR_H
+#define AUG_IR_H
+#include "aug_runtime.h"
+
+/* Compiler-private pointer-call ABI. This is not the public native package ABI.
+   All target packs record these layouts; LLVM validates that record before use. */
+enum AugIrOperation {
+  AUG_IR_PRINT=1, AUG_IR_BINARY, AUG_IR_UNARY, AUG_IR_FIELD, AUG_IR_SET_FIELD,
+  AUG_IR_LIST, AUG_IR_TUPLE, AUG_IR_SET, AUG_IR_MAP, AUG_IR_MAP_SET,
+  AUG_IR_LIST_LENGTH, AUG_IR_LIST_GET, AUG_IR_LIST_AT, AUG_IR_LIST_APPEND,
+  AUG_IR_TUPLE_LENGTH, AUG_IR_TUPLE_GET, AUG_IR_SET_LENGTH, AUG_IR_SET_ADD,
+  AUG_IR_SET_CONTAINS, AUG_IR_MAP_LENGTH, AUG_IR_MAP_GET, AUG_IR_MAP_TAKE,
+  AUG_IR_MAP_CONTAINS, AUG_IR_STRING_LENGTH, AUG_IR_STRING_BYTES,
+  AUG_IR_STRING_SPLIT, AUG_IR_STRING_STARTS_WITH, AUG_IR_STRING_IS_TOKEN,
+  AUG_IR_BYTES_LENGTH, AUG_IR_BYTES_TEXT, AUG_IR_BYTES_BASE64URL,
+  AUG_IR_BASE64URL_DECODE, AUG_IR_C_INT, AUG_IR_READ_FILE, AUG_IR_WRITE_FILE,
+  AUG_IR_ARGUMENTS, AUG_IR_FREEZE, AUG_IR_ITER, AUG_IR_MAP_ITER, AUG_IR_IS_TYPE,
+  AUG_IR_SHARED, AUG_IR_SHARED_LOCK, AUG_IR_JSON_WRAP, AUG_IR_JSON_PARSE,
+  AUG_IR_JSON_STRINGIFY, AUG_IR_JSON_GET, AUG_IR_JSON_REQUIRE, AUG_IR_JSON_STRING,
+  AUG_IR_JSON_INTEGER, AUG_IR_JSON_BOOLEAN, AUG_IR_JSON_ITEMS, AUG_IR_TIME_NOW, AUG_IR_EXIT, AUG_IR_TEST_CASE
+};
+void aug_ir_operation(AugValue *out, int operation, AugValue *args, int count, const char *text, int64_t number);
+/* Specialized services keep managed inputs in the caller's rooted cells. */
+void aug_ir_print(const AugValue *value);
+void aug_ir_binary(AugValue *out,const char *operation,const AugValue *left,const AugValue *right);
+void aug_ir_unary(AugValue *out,const char *operation,const AugValue *value);
+void aug_ir_list_new(AugValue *out,AugValue *items,int count);
+void aug_ir_tuple_new(AugValue *out,AugValue *items,int count);
+void aug_ir_set_new(AugValue *out,AugValue *items,int count);
+void aug_ir_map(AugValue *out);
+void aug_ir_iter(AugValue *out,const AugValue *value);
+void aug_ir_map_iter(AugValue *out,const AugValue *value);
+void aug_ir_list_append(const AugValue *list,const AugValue *value);
+int64_t aug_ir_tuple_length(const AugValue *tuple);
+void aug_ir_tuple_get(AugValue *out,const AugValue *tuple,const AugValue *index);
+int64_t aug_ir_string_length(const AugValue *value);
+void aug_ir_string_bytes(AugValue *out,const AugValue *value);
+void aug_ir_string_split(AugValue *out,const AugValue *value,const AugValue *separator);
+void aug_ir_map_set(const AugValue *map,const AugValue *key,const AugValue *value);
+void aug_ir_set_add(const AugValue *set,const AugValue *value);
+uint8_t aug_ir_set_contains(const AugValue *set,const AugValue *value);
+uint8_t aug_ir_map_contains(const AugValue *map,const AugValue *key);
+int64_t aug_ir_list_length(const AugValue *list);
+int64_t aug_ir_set_length(const AugValue *set);
+int64_t aug_ir_map_length(const AugValue *map);
+void aug_ir_list_get(AugValue *out,const AugValue *list,const AugValue *index);
+void aug_ir_list_at(AugValue *out,const AugValue *list,const AugValue *index);
+void aug_ir_map_get(AugValue *out,const AugValue *map,const AugValue *key);
+void aug_ir_map_take(AugValue *out,const AugValue *map,const AugValue *key);
+void aug_ir_json_decode(AugValue *out, const AugValue *value, const AugSchema *schema);
+void aug_ir_string(AugValue *out, const void *text, uint64_t count);
+void aug_ir_assert(const AugValue *condition, const char *expression, const char *file, int line);
+void aug_ir_drop(AugValue *value);
+void aug_ir_failed_result(AugValue *value);
+void aug_ir_constructor_result(AugValue *value, const AugValue *result);
+void aug_ir_throw(const AugValue *value);
+void aug_ir_take_error(AugValue *out);
+void aug_ir_save_error_state(AugValue *error,AugValue *cancelled);
+void aug_ir_restore_error_state(const AugValue *error,const AugValue *cancelled);
+void aug_ir_task_wait(AugValue *out, AugValue *tasks, int count);
+bool aug_ir_has_error(void);
+bool aug_ir_cancelled(void);
+/* 0 = running, 1 = cancelled, 2 = checked error; cancellation wins. */
+uint8_t aug_ir_state(void);
+bool aug_ir_is_null(const AugValue *value);
+bool aug_ir_truthy(const AugValue *value);
+int64_t aug_ir_integer(const AugValue *value);
+double aug_ir_float(const AugValue *value);
+void aug_ir_frame_enter(AugFrame *frame, AugValue *values, uint64_t count);
+void aug_ir_method(AugValue *out, const AugValue *self, const char *name, AugValue *args, int count);
+void aug_ir_object(AugValue *out, const char *type, uint64_t fields, const unsigned char *owned,
+                   const AugMethodEntry *methods, uint64_t method_count, const char *const *names, bool record);
+void aug_ir_binding_get(AugValue *out, uint64_t index);
+void aug_ir_binding_set(uint64_t index, const AugValue *value);
+int aug_ir_exit_status(bool test);
+void *aug_ir_resource_pointer(const AugValue *value, const char *type);
+void aug_ir_resource(AugValue *out, void *pointer, const char *type, void (*release)(void *));
+void aug_ir_resource_move(AugValue *value);
+void aug_ir_contract_error(AugValue *out);
+void aug_ir_native_error(AugValue *out, AugPointerMethod factory, int32_t code, const void *text, uint64_t length);
+bool aug_ir_data(const AugValue *value, const void **data, uint64_t *count);
+bool aug_ir_floats(const AugValue *value, double **data, uint64_t *count);
+bool aug_ir_strings(const AugValue *value, const void ***data, uint64_t **lengths, uint64_t *count);
+void aug_ir_free(void *memory);
+void aug_ir_copy_bytes(AugValue *out, const void *bytes, uint64_t count);
+void aug_ir_copy_utf8(AugValue *out, const void *text, uint64_t count);
+void aug_ir_copy_bool(AugValue *out, uint8_t value);
+void aug_ir_copy_floats(AugValue *out, const double *values, uint64_t count);
+#endif

package/runtime/aug_json.c

@@ -116,6 +116,11 @@ AugValue aug_json_items(AugValue value) {
   for (size_t i = 0; i < value.as.object->field_count; i++) aug_list_append(roots[1], aug_json_wrap(value.as.object->fields[i]));
   AugValue result = roots[1]; aug_frame_leave(&frame); return result;
 }
+AugValue aug_schema_make(const AugSchema *schema, AugValue *fields, int count) {
+  if(schema->pointer_make){AugValue result=aug_null();schema->pointer_make(&result,NULL,fields,count);return result;}
+  if(schema->make)return schema->make(fields,count);
+  return invalid();
+}
 static AugValue decode(AugValue value, const AugSchema *schema, size_t depth) {
   if (depth > 64) return invalid();
   if (value.tag == AUG_NULL && schema->nullable) return value;
@@ -152,7 +157,7 @@ static AugValue decode(AugValue value, const AugSchema *schema, size_t depth) {
   }
   AugValue result = aug_null();
   if (!aug_has_error) {
-    if (schema->kind == AUG_SCHEMA_RECORD) result = schema->make(items, (int)count);
+    if (schema->kind == AUG_SCHEMA_RECORD) result = aug_schema_make(schema,items,(int)count);
     else if (schema->kind == AUG_SCHEMA_TUPLE) result = aug_tuple_new(items, count);
     else if (schema->kind == AUG_SCHEMA_SET) result = aug_set_new(items, count);
     else if (schema->kind == AUG_SCHEMA_MAP) { result = aug_map_new(); items[count] = result; for (size_t i = 0; i < count; i += 2) aug_map_set(result, items[i], items[i + 1]); }

package/runtime/aug_runtime.c

@@ -28,6 +28,10 @@ static size_t next_collection = 1024;
 static bool collecting = false;
 static AugValue cli_args = {0};
 static bool equal(AugValue left, AugValue right);
+/* Map-only metadata keeps ordinary object allocation sizes unchanged. The
+   first member permits the existing heap, roots and GC to use AugObject. */
+typedef struct { AugObject object; size_t *field_buckets; } AugMapObject;
+static size_t *map_field_buckets(AugObject *object) { return ((AugMapObject *)object)->field_buckets; }
 bool aug_test_failed = false;
 size_t aug_test_assertions = 0;
 
@@ -54,7 +58,7 @@ static AugObject *allocate(int kind, const char *type_name, size_t field_count,
                            const unsigned char *owned_fields,
                            const AugMethodEntry *methods, size_t method_count) {
   if (!collecting && object_count >= next_collection) aug_collect();
-  AugObject *object = calloc(1, sizeof(AugObject));
+  AugObject *object = calloc(1, kind == AUG_MAP_KIND ? sizeof(AugMapObject) : sizeof(AugObject));
   if (!object) fail("out of memory");
   object->kind = kind;
   object->type_name = type_name;
@@ -79,7 +83,7 @@ AugValue aug_string_n(const void *value, size_t length) {
   AugObject *object = allocate(AUG_STRING, "string", 0, NULL, NULL, 0);
   object->text = malloc(length + 1);
   if (!object->text) fail("out of memory");
-  memcpy(object->text, value, length);
+  if (length) memcpy(object->text, value, length);
   object->text[length] = 0;
   object->text_length = length;
   return (AugValue){ .tag = AUG_STRING, .as.object = object };
@@ -209,6 +213,18 @@ static size_t bucket_for(AugObject *object, AugValue key) { return bucket_for_ha
 
 static bool grow_table(AugObject *object, size_t stride) {
   size_t entries = object->field_count / stride;
+  if (object->field_count + stride > object->capacity) {
+    size_t capacity = object->capacity ? object->capacity * 2 : 8;
+    AugValue *fields = realloc(object->fields, capacity * sizeof(AugValue));
+    if (!fields) fail("out of memory");
+    object->fields = fields;
+    if (stride == 2) {
+      size_t *positions = realloc(map_field_buckets(object), (capacity / 2) * sizeof(size_t));
+      if (!positions) fail("out of memory");
+      ((AugMapObject *)object)->field_buckets = positions;
+    }
+    object->capacity = capacity;
+  }
   bool rehashed = !object->bucket_count || (entries + 1) * 10 > object->bucket_count * 7;
   if (rehashed) {
     size_t count = object->bucket_count ? object->bucket_count * 2 : 8;
@@ -217,15 +233,11 @@ static bool grow_table(AugObject *object, size_t stride) {
     free(object->buckets);
     object->buckets = buckets;
     object->bucket_count = count;
-    for (size_t i = 0; i < object->field_count; i += stride)
-      object->buckets[bucket_for(object, object->fields[i])] = i + 1;
-  }
-  if (object->field_count + stride > object->capacity) {
-    size_t capacity = object->capacity ? object->capacity * 2 : 8;
-    AugValue *fields = realloc(object->fields, capacity * sizeof(AugValue));
-    if (!fields) fail("out of memory");
-    object->fields = fields;
-    object->capacity = capacity;
+    for (size_t i = 0; i < object->field_count; i += stride) {
+      size_t bucket = bucket_for(object, object->fields[i]);
+      object->buckets[bucket] = i + 1;
+      if (stride == 2) map_field_buckets(object)[i / 2] = bucket;
+    }
   }
   return rehashed;
 }
@@ -251,6 +263,7 @@ void aug_map_set(AugValue map, AugValue key, AugValue value) {
     if (field) { object->fields[field] = value; return; }
   }
   if (grow_table(object, 2)) bucket = bucket_for_hash(object, key, hash);
+  map_field_buckets(object)[object->field_count / 2] = bucket;
   object->buckets[bucket] = object->field_count + 1;
   object->fields[object->field_count++] = key;
   object->fields[object->field_count++] = value;
@@ -264,12 +277,29 @@ AugValue aug_map_get(AugValue map, AugValue key) {
 }
 AugValue aug_map_take(AugValue map, AugValue key) {
   AugObject *object = expect_map(map); if (object->frozen) fail("cannot mutate a frozen Map");
-  if (!object->bucket_count) return aug_null(); size_t field = object->buckets[bucket_for(object, key)];
+  if (!object->bucket_count) return aug_null();
+  size_t bucket = bucket_for(object, key), field = object->buckets[bucket];
   if (!field) return aug_null(); AugValue result = object->fields[field]; size_t first = field - 1;
   memmove(object->fields + first, object->fields + first + 2, (object->field_count - first - 2) * sizeof(AugValue));
   object->field_count -= 2; object->fields[object->field_count] = aug_null(); object->fields[object->field_count + 1] = aug_null();
-  memset(object->buckets, 0, object->bucket_count * sizeof(size_t));
-  for (size_t i = 0; i < object->field_count; i += 2) object->buckets[bucket_for(object, object->fields[i])] = i + 1;
+  object->buckets[bucket] = 0;
+  /* Ordered fields remain dense. Adjust only moved entry offsets, then repair
+     the probe chain after the removed bucket. Neither step rehashes the map. */
+  size_t *positions = map_field_buckets(object);
+  for (size_t i = first / 2 + 1; i <= object->field_count / 2; i++)
+    object->buckets[positions[i]] -= 2;
+  memmove(positions + first / 2, positions + first / 2 + 1,
+          (object->field_count - first) / 2 * sizeof(size_t));
+  size_t mask = object->bucket_count - 1, hole = bucket;
+  for (size_t next = (hole + 1) & mask; object->buckets[next]; next = (next + 1) & mask) {
+    size_t home = (size_t)hash_value(object->fields[object->buckets[next] - 1]) & mask;
+    if (((next - home) & mask) >= ((next - hole) & mask)) {
+      object->buckets[hole] = object->buckets[next];
+      positions[(object->buckets[hole] - 1) / 2] = hole;
+      hole = next;
+    }
+  }
+  object->buckets[hole] = 0;
   return result;
 }
 
@@ -409,6 +439,10 @@ void aug_set_field(AugValue object, size_t index, AugValue value) {
     fail("invalid field assignment");
   if (object.as.object->dropped) fail("use of dropped object");
   if (object.as.object->frozen) fail("cannot assign a frozen field");
+  AugValue previous = object.as.object->fields[index];
+  if (object.as.object->owned_fields && object.as.object->owned_fields[index] &&
+      !(previous.tag == AUG_OBJECT && value.tag == AUG_OBJECT && previous.as.object == value.as.object))
+    aug_drop(previous);
   object.as.object->fields[index] = value;
 }
 
@@ -417,7 +451,10 @@ AugValue aug_call_method(AugValue object, const char *name, AugValue *args, int
   if (object.as.object->dropped) fail("use of dropped object");
   for (size_t i = 0; i < object.as.object->method_count; i++) {
     const AugMethodEntry *entry = &object.as.object->methods[i];
-    if (strcmp(entry->name, name) == 0) return entry->function(object, args, count);
+    if (strcmp(entry->name, name) == 0) {
+      if(entry->pointer_function){AugValue result=aug_null();entry->pointer_function(&result,&object,args,count);return result;}
+      return entry->function(object, args, count);
+    }
   }
   fprintf(stderr, "AugScript runtime error: %s has no method %s\n",
           object.as.object->type_name, name);
@@ -736,6 +773,7 @@ void aug_collect(void) {
       free(object->text);
       free(object->fields);
       free(object->buckets);
+      if (object->kind == AUG_MAP_KIND) free(map_field_buckets(object));
       free(object);
       object_count--;
     }
@@ -748,20 +786,48 @@ void aug_drop(AugValue value) {
   if (value.tag != AUG_OBJECT && value.tag != AUG_STRING) return;
   AugObject *object = value.as.object;
   if (!object || object->dropped) return;
+  AugValue roots[2] = {value, aug_error}; AugFrame frame; aug_frame_enter(&frame, roots, 2);
+  bool failed = aug_has_error, cancelled = aug_cancelled;
+  aug_error = aug_null(); aug_has_error = false; aug_cancelled = false;
   if (object->kind == AUG_OBJECT) {
     if (getenv("AUG_TRACE_DROPS")) fprintf(stderr, "drop: %s\n", object->type_name);
     for (size_t i = 0; i < object->method_count; i++)
       if (strcmp(object->methods[i].name, "drop") == 0) {
-        object->methods[i].function(value, NULL, 0);
+        if(object->methods[i].pointer_function){AugValue ignored=aug_null();object->methods[i].pointer_function(&ignored,&value,NULL,0);}
+        else object->methods[i].function(value, NULL, 0);
         break;
       }
   }
   object->dropped = true;
+  if(object->kind==AUG_NATIVE_RESOURCE_KIND&&object->finalize){
+    void *native=object->native;void(*release)(void *)=object->finalize;
+    object->native=NULL;object->finalize=NULL;
+    if(native)release(native);
+  }
   for (size_t i = 0; i < object->field_count; i++)
     if (object->owned_fields && object->owned_fields[i]) aug_drop(object->fields[i]);
+  if (failed) aug_throw(roots[1]); aug_cancelled = aug_cancelled || cancelled;
+  aug_frame_leave(&frame);
 }
 
 void aug_throw(AugValue value) { aug_error = value; aug_has_error = true; }
+void aug_constructor_result_cleanup(AugValue value, AugValue result) {
+  if (value.tag != AUG_OBJECT || !value.as.object || value.as.object->dropped) return;
+  if (aug_has_error || aug_cancelled || result.tag != AUG_OBJECT || result.as.object != value.as.object)
+    aug_drop(value);
+}
+void aug_drop_partial(AugValue value) {
+  if(value.tag!=AUG_OBJECT||!value.as.object||value.as.object->dropped)return;
+  AugValue roots[2]={value,aug_error};AugFrame frame;aug_frame_enter(&frame,roots,2);
+  bool pending=aug_has_error,cancelled=aug_cancelled;
+  aug_error=aug_null();aug_has_error=false;aug_cancelled=false;
+  AugObject *object=value.as.object;object->dropped=true;
+  for(size_t i=0;i<object->field_count;i++)
+    if(object->owned_fields&&object->owned_fields[i])aug_drop(object->fields[i]);
+  /* A constructor's checked failure remains primary during implicit cleanup. */
+  if(pending)aug_throw(roots[1]);aug_cancelled=aug_cancelled||cancelled;
+  aug_frame_leave(&frame);
+}
 AugValue aug_take_error(void) {
   AugValue value = aug_error;
   aug_error = aug_null();

package/runtime/aug_runtime.h

@@ -9,9 +9,10 @@
 typedef struct AugObject AugObject;
 typedef struct AugValue AugValue;
 typedef AugValue (*AugMethod)(AugValue self, AugValue *args, int count);
+typedef void (*AugPointerMethod)(AugValue *out, const 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 };
+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, AUG_NATIVE_RESOURCE_KIND };
 
 struct AugValue {
   int tag;
@@ -21,6 +22,7 @@ struct AugValue {
 typedef struct {
   const char *name;
   AugMethod function;
+  AugPointerMethod pointer_function;
 } AugMethodEntry;
 
 struct AugObject {
@@ -85,7 +87,11 @@ 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_start_owned(AugMethod function, AugValue receiver, AugValue *args, int count, const unsigned char *owned);
 AugValue aug_task_spawn(AugMethod function, AugValue receiver, AugValue *args, int count, AugTaskCompletion completion, void *data);
+/* Compiler-private entry points; native package callbacks have a separate ABI. */
+void aug_task_start_pointer(AugValue *out, AugPointerMethod function, const AugValue *receiver, AugValue *args, int count, const unsigned char *owned);
+void aug_task_spawn_pointer(AugValue *out, AugPointerMethod function, const 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);
@@ -134,6 +140,7 @@ 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);
+bool aug_valid_utf8(const void *text, size_t size);
 AugValue aug_bytes_base64url(AugValue value);
 AugValue aug_base64url_decode(AugValue value);
 
@@ -144,8 +151,10 @@ enum { AUG_SCHEMA_INT, AUG_SCHEMA_C_INT, AUG_SCHEMA_FLOAT, AUG_SCHEMA_BOOL, AUG_
 struct AugSchema {
   int kind; bool nullable; bool optional; size_t count;
   const AugSchema *const *fields; const char *const *names; AugFunction make;
+  AugPointerMethod pointer_make;
 };
 AugValue aug_json_decode(AugValue value, const AugSchema *schema);
+AugValue aug_schema_make(const AugSchema *schema, AugValue *fields, int count);
 AugValue aug_json_stringify(AugValue value);
 AugValue aug_json_get(AugValue value, AugValue name);
 AugValue aug_json_require(AugValue value, AugValue name);
@@ -155,15 +164,17 @@ bool aug_json_boolean(AugValue value);
 AugValue aug_json_items(AugValue value);
 AugValue aug_json_wrap(AugValue value);
 AugValue _aug_json_parse(AugValue input);
+AugValue _aug_time_now(void);
 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;
+typedef struct { const char *method; const char *path; AugFunction handler; int stream; int status; const AugHttpPolicy *policies;size_t policy_count; AugPointerMethod pointer_handler; } AugRoute;
 void aug_http_policy(const AugHttpPolicy *policy, AugValue request, AugValue dependency, AugValue second);
 AugValue aug_http_finish(AugValue response);
+bool aug_http_head_response(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);
@@ -236,6 +247,9 @@ void aug_scope_restore(size_t depth);
 void aug_collect(void);
 void aug_freeze(AugValue value);
 void aug_drop(AugValue value);
+/* Failed construction releases initialized ownership without invoking drop. */
+void aug_drop_partial(AugValue value);
+void aug_constructor_result_cleanup(AugValue value, AugValue result);
 void aug_throw(AugValue value);
 AugValue aug_take_error(void);
 bool aug_error_is(const char *name);

package/runtime/aug_tasks.c

@@ -7,10 +7,11 @@
 
 /* C stack suspension preserves ordinary August calls and their precise GC frames. */
 struct AugTask {
-  mco_coro *coroutine; AugExecution execution; AugMethod function;
+  mco_coro *coroutine; AugExecution execution; AugMethod function; AugPointerMethod pointer_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;
+  unsigned char *owned_inputs;
 };
 static AugTask *ready_first, *ready_last;
 void (*aug_scheduler_io)(bool wait);
@@ -32,7 +33,7 @@ void aug_task_wake(AugTask *task) {
 static void destroy_task(void *native) {
   AugTask *task = native;
   if (!task->complete) fatal("collected an unfinished task");
-  mco_destroy(task->coroutine); free(task);
+  mco_destroy(task->coroutine); free(task->owned_inputs); free(task);
 }
 void aug_task_release(AugValue value) {
   AugTask *task = task_of(value);
@@ -52,8 +53,22 @@ 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);
+    AugValue roots[2] = {aug_field(task->value, 0), aug_null()};
+    AugFrame frame; aug_frame_enter(&frame, roots, 2);
+    if (task->pointer_function) task->pointer_function(&roots[1], &roots[0], arguments.as.object->fields, (int)arguments.as.object->field_count);
+    else roots[1] = task->function(roots[0], arguments.as.object->fields, (int)arguments.as.object->field_count);
+    aug_set_field(task->value, 2, roots[1]);
+    aug_frame_leave(&frame);
+  } else if (task->owned_inputs) {
+    /* Ownership crossed at start, even if a sibling cancels this child before
+       entry. No callee ran to release these captures. Cleanup must run with
+       cancellation suspended, just as an always block does. */
+    AugValue pending = aug_error; AugFrame frame; aug_frame_enter(&frame, &pending, 1);
+    bool failed = aug_has_error; aug_error = aug_null(); aug_has_error = false; aug_cancelled = false;
+    for (size_t i = 0; i < arguments.as.object->field_count; i++) if (task->owned_inputs[i]) {
+      aug_drop(aug_field(arguments, i)); aug_set_field(arguments, i, aug_null());
+    }
+    if (failed) aug_throw(pending); aug_cancelled = true; aug_frame_leave(&frame);
   }
   aug_scope_restore(task->base_depth);
   if (aug_has_error) { aug_set_field(task->value, 3, aug_take_error()); cancel_group(task); }
@@ -110,14 +125,15 @@ static void join_scope(AugScope *scope) {
   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) {
+static AugValue spawn_task(AugMethod function, AugPointerMethod pointer_function, AugValue receiver, AugValue *args, int count, const unsigned char *owned, 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;
+  task->function = function; task->pointer_function = pointer_function; task->value = roots[2]; task->completion = completion; task->completion_data = data;
+  if (owned && count) { task->owned_inputs = malloc((size_t)count); if (!task->owned_inputs) fatal("out of memory"); memcpy(task->owned_inputs, owned, (size_t)count); }
   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;
@@ -128,10 +144,25 @@ AugValue aug_task_spawn(AugMethod function, AugValue receiver, AugValue *args, i
   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_spawn(AugMethod function, AugValue receiver, AugValue *args, int count, AugTaskCompletion completion, void *data) {
+  return spawn_task(function, NULL, receiver, args, count, NULL, completion, data);
+}
+void aug_task_spawn_pointer(AugValue *out, AugPointerMethod function, const AugValue *receiver, AugValue *args, int count, AugTaskCompletion completion, void *data) {
+  *out = spawn_task(NULL, function, receiver ? *receiver : aug_null(), args, count, NULL, completion, data);
+}
+void aug_task_start_pointer(AugValue *out, AugPointerMethod function, const AugValue *receiver, AugValue *args, int count, const unsigned char *owned) {
+  AugScope *scope = aug_execution_current()->scope_stack;
+  if (!scope) { *out = aug_error_named("ConcurrencyError"); return; }
+  *out = spawn_task(NULL, function, receiver ? *receiver : aug_null(), args, count, owned, NULL, NULL);
+  AugTask *task = task_of(*out); task->owner = scope; task->sibling = scope->tasks; scope->tasks = task;
+}
 AugValue aug_task_start(AugMethod function, AugValue receiver, AugValue *args, int count) {
+  return aug_task_start_owned(function, receiver, args, count, NULL);
+}
+AugValue aug_task_start_owned(AugMethod function, AugValue receiver, AugValue *args, int count, const unsigned char *owned) {
   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);
+  AugValue value = spawn_task(function, NULL, receiver, args, count, owned, 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) {

package/runtime/aug_values.c

@@ -25,22 +25,28 @@ AugValue aug_string_split(AugValue value, AugValue separator) {
   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;
+bool aug_valid_utf8(const void *data, size_t size) {
+  if (!data && size) return false;
+  const unsigned char *text = data;
   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");
+    if (extra < 0 || (size_t)extra > size - i) return false;
     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");
+      if ((next & 0xc0) != 0x80) return false;
       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");
+    if (code < (extra == 1 ? 0x80u : extra == 2 ? 0x800u : 0x10000u) || code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)) return false;
   }
+  return true;
+}
+AugValue aug_bytes_text(AugValue value) {
+  const void *text = value.as.object->text;
+  size_t size = value.as.object->text_length;
+  if (!aug_valid_utf8(text, size)) return aug_error_named("ConversionError");
   return aug_string_n(text, size);
 }