@greenpandastudios/aug-cli 0.20.1 → 0.21.0

package/runtime/aug_http.c

@@ -23,11 +23,17 @@ typedef struct {
 } AugHttpSession;
 struct AugHttpJob {
   struct lws *wsi; AugHttpSession *session; AugValue task;
-  /* Request and loggers outlive transport session cleanup on a disconnect. */
-  AugValue roots[2]; AugRetained retained;
-  bool test, transport_complete, timed_out; int64_t started,deadline;
+  /* Request, loggers and the prepared HEAD response outlive transport cleanup. */
+  AugValue roots[3]; AugRetained retained;
+  bool test, transport_complete, timed_out, head_complete; int64_t started,deadline;
 };
 static const AugRoute *served_routes;
+static AugValue route_call(const AugRoute *route,AugValue *args,int count) {
+  AugValue result=aug_null();
+  if(route->pointer_handler)route->pointer_handler(&result,NULL,args,count);
+  else result=route->handler(args,count);
+  return result;
+}
 static size_t served_count;
 static size_t body_limit = 1024 * 1024;
 static size_t response_limit = 4 * 1024 * 1024;
@@ -93,6 +99,14 @@ AugValue aug_headers_with(AugValue headers, AugValue name, AugValue value) {
   header_add(result, name.as.object->text, name.as.object->text_length, value.as.object->text, value.as.object->text_length);
   aug_freeze(result); aug_release(&retained); aug_frame_leave(&frame); return result;
 }
+static AugValue headers_with_name(AugValue headers, const char *name, AugValue value) {
+  /* Root the value before allocating the name: either allocation can collect. */
+  AugValue roots[3] = {headers, value, aug_null()};
+  AugFrame frame; aug_frame_enter(&frame, roots, 3);
+  roots[2] = aug_string(name);
+  AugValue result = aug_headers_with(roots[0], roots[2], roots[1]);
+  aug_frame_leave(&frame); return result;
+}
 AugValue aug_headers_get(AugValue headers, AugValue name) {AugValue value = header_get(headers, aug_cstring(name), false); return value.tag == AUG_NULL ? aug_null() : value;}
 AugValue aug_headers_all(AugValue headers, AugValue name) {
   AugValue result = aug_list_new(NULL, 0); AugFrame frame; aug_frame_enter(&frame, &result, 1); AugValue entries = aug_field(headers, 0);
@@ -165,7 +179,7 @@ static const AugRoute *select_route(AugValue request, const AugRoute *routes, si
       for(size_t layer=0;layer<routes[i].policy_count;layer++)if(routes[i].policies[layer].kind==AUG_HTTP_POLICY_CORS){
         AugValue headers=aug_headers_new();AugFrame frame;aug_frame_enter(&frame,&headers,1);
         if(cors_apply(&routes[i].policies[layer],request,&headers,true)) {
-          headers=aug_headers_with(headers,aug_string("access-control-allow-methods"),requested);
+          headers=headers_with_name(headers,"access-control-allow-methods",requested);
           *failure=aug_http_response_full(aug_null(),aug_int(204),headers);
         }else {int status=aug_has_error?aug_http_error_status():403;if(aug_has_error)aug_take_error();*failure=aug_http_problem(status);}
         aug_frame_leave(&frame);return NULL;
@@ -255,9 +269,9 @@ static bool cors_apply(const AugHttpPolicy *policy,AugValue request,AugValue *he
   AugValue origin=header_get(aug_field(request,2),"origin",true);if(aug_has_error)return false;if(origin.tag==AUG_NULL)return !preflight;
   const char *name=aug_cstring(origin);bool wildcard=listed(policy->origins,"*");
   if(!wildcard&&!listed(policy->origins,name)){request_error("HttpForbidden");return false;}
-  *headers=aug_headers_with(*headers,aug_string("access-control-allow-origin"),wildcard?aug_string("*"):origin);
-  *headers=aug_headers_with(*headers,aug_string("vary"),aug_string("Origin"));
-  if(policy->credentials)*headers=aug_headers_with(*headers,aug_string("access-control-allow-credentials"),aug_string("true"));
+  *headers=headers_with_name(*headers,"access-control-allow-origin",wildcard?aug_string("*"):origin);
+  *headers=headers_with_name(*headers,"vary",aug_string("Origin"));
+  if(policy->credentials)*headers=headers_with_name(*headers,"access-control-allow-credentials",aug_string("true"));
   if(preflight) {
     AugValue asked=header_get(aug_field(request,2),"access-control-request-headers",true);if(aug_has_error)return false;
     if(asked.tag==AUG_STRING){char *copy=strdup(aug_cstring(asked));if(!copy)abort();char *save=NULL;
@@ -265,7 +279,7 @@ static bool cors_apply(const AugHttpPolicy *policy,AugValue request,AugValue *he
         bool found=false;const char *allowed=policy->headers;while(*allowed){const char *end=strchr(allowed,',');if(!end)end=allowed+strlen(allowed);if((size_t)(end-allowed)==size&&!strncasecmp(allowed,part,size))found=true;allowed=*end?end+1:end;while(*allowed==' ')allowed++;}
         if(!size||!found){free(copy);request_error("HttpForbidden");return false;}}
       free(copy);}
-    *headers=aug_headers_with(*headers,aug_string("access-control-allow-headers"),aug_string(policy->headers));
+    *headers=headers_with_name(*headers,"access-control-allow-headers",aug_string(policy->headers));
   }
   return !aug_has_error;
 }
@@ -317,7 +331,7 @@ static AugValue policy_response(AugHttpSession *session,AugValue response) {
   if(session->roots[4].tag==AUG_NULL&&!session->compress)return response;
   AugValue roots[2]={response,aug_field(response,2)};AugFrame frame;aug_frame_enter(&frame,roots,2);
   if(session->roots[4].tag==AUG_OBJECT){AugValue entries=aug_field(session->roots[4],0);for(size_t i=0;i<entries.as.object->field_count;i++){AugValue pair=entries.as.object->fields[i];roots[1]=aug_headers_with(roots[1],aug_field(pair,0),aug_field(pair,1));}}
-  if(session->compress){roots[1]=aug_headers_with(roots[1],aug_string("content-encoding"),aug_string("gzip"));roots[1]=aug_headers_with(roots[1],aug_string("vary"),aug_string("Accept-Encoding"));}
+  if(session->compress){roots[1]=headers_with_name(roots[1],"content-encoding",aug_string("gzip"));roots[1]=headers_with_name(roots[1],"vary",aug_string("Accept-Encoding"));}
   AugValue result=aug_http_response_full(aug_field(roots[0],0),aug_field(roots[0],1),roots[1]);aug_frame_leave(&frame);return result;
 }
 AugValue _aug_http_log(AugValue method,AugValue path,AugValue status,AugValue milliseconds) {
@@ -353,9 +367,9 @@ AugValue aug_httptestclient_request(AugValue client,AugValue method,AugValue tar
   if(aug_field(session.roots[0],3).as.object->text_length>body_limit){session.roots[1]=aug_http_problem(413);goto serialize;}
   aug_freeze(session.roots[0]);
   AugHttpJob job={.session=&session,.test=true,.roots={session.roots[0],aug_null()}};
-  aug_retain(&job.retained,job.roots,2);
+  aug_retain(&job.retained,job.roots,3);
   void *previous=aug_execution_current()->http_job;bool previous_cancelled=aug_cancelled;aug_execution_current()->http_job=&job;
-  session.roots[1]=session.route->handler(session.roots,1);aug_execution_current()->http_job=previous;aug_release(&job.retained);
+  session.roots[1]=route_call(session.route,session.roots,1);aug_execution_current()->http_job=previous;aug_release(&job.retained);
   if(job.timed_out)aug_cancelled=previous_cancelled;
   if(aug_has_error){aug_report_error();aug_take_error();session.roots[1]=aug_http_problem(500);}
   if(session.streaming&&aug_cint(aug_field(session.roots[1],1))>=400){aug_frame_leave(&frame);return request_error("HttpError");}
@@ -369,7 +383,7 @@ serialize:;
   if(session.compress&&!session.streaming)session.roots[2]=gzip_bytes(session.roots[2]);
   if(aug_has_error||session.roots[2].as.object->text_length>response_limit){if(aug_has_error)aug_take_error();session.roots[1]=aug_http_problem(500);status=500;session.roots[2]=aug_json_stringify(aug_field(session.roots[1],0));}
   session.roots[3]=aug_field(session.roots[1],2);
-  if(header_get(session.roots[3],"content-type",false).tag==AUG_NULL)session.roots[3]=aug_headers_with(session.roots[3],aug_string("content-type"),aug_string(type));
+  if(header_get(session.roots[3],"content-type",false).tag==AUG_NULL)session.roots[3]=headers_with_name(session.roots[3],"content-type",aug_string(type));
   if(!strcmp(aug_cstring(method),"HEAD")||status==204||status==304)session.roots[2]=aug_bytes("",0,AUG_BYTES_KIND);
   session.roots[1]=aug_http_response_full(session.roots[2],aug_int(status),session.roots[3]);
   AugValue result=session.roots[1];aug_frame_leave(&frame);return result;
@@ -431,7 +445,7 @@ AugValue aug_http_bind(AugValue request, const char *source, const char *name, c
       bool known = false; for (size_t j = 0; j < schema->count; j++) if (!strcmp(aug_cstring(map.as.object->fields[i]), schema->names[j])) known = true;
       if (!known) request_error("HttpBadRequest");
     }
-    AugValue result = aug_has_error ? aug_null() : schema->make(fields, (int)schema->count);
+    AugValue result = aug_has_error ? aug_null() : aug_schema_make(schema,fields,(int)schema->count);
     aug_frame_leave(&field_frame); free(fields); aug_frame_leave(&frame); return result;
   }
   if (!strcmp(source, "body")) {
@@ -484,7 +498,7 @@ static void cleanup(AugHttpSession *session) {
   free(session->body); memset(session, 0, sizeof(*session));
 }
 static AugValue request_task(AugValue self, AugValue *args, int count) {
-  (void)self; (void)count; aug_execution_current()->http_job=(void *)(intptr_t)aug_cint(args[2]); size_t index = (size_t)aug_cint(args[1]); return served_routes[index].handler(args, 1);
+  (void)self; (void)count; aug_execution_current()->http_job=(void *)(intptr_t)aug_cint(args[2]); size_t index = (size_t)aug_cint(args[1]); return route_call(&served_routes[index],args,1);
 }
 AugValue aug_http_event(AugValue data, AugValue id, AugValue event, AugValue retry) {
   AugValue values[]={data,id,event,retry};
@@ -522,18 +536,26 @@ void aug_http_yield(AugValue value) {
   }
   session->roots[1]=policy_response(session,aug_http_response(aug_null(),session->route->status));session->roots[3]=encoded;session->streaming=true;session->stream_pending=true;session->sent=0;
   lws_callback_on_writable(job->wsi);
-  if(session->head){session->stream_pending=false;aug_cancelled=true;goto finished;}
+  if(session->head){session->stream_pending=false;job->roots[2]=session->roots[1];job->head_complete=true;aug_cancelled=true;goto finished;}
   while(job->session&&job->session->stream_pending&&!aug_cancelled)aug_task_suspend();
 finished:
   aug_frame_leave(&frame);
 }
+bool aug_http_head_response(AugValue *response) {
+  AugHttpJob *job=aug_execution_current()->http_job;
+  if(!aug_cancelled||aug_has_error||!job||!job->head_complete||job->timed_out||(!job->session&&!job->transport_complete))return false;
+  /* The first yield already established this response. Cancellation stops the
+     producer and its children; it is not an error or a client disconnect. */
+  *response=job->roots[2];return response->tag==AUG_OBJECT;
+}
 AugValue aug_http_finish(AugValue response) {
   AugHttpJob *job=aug_execution_current()->http_job;if(!job)return response;
   AugHttpSession *session=job->session;AugValue roots[3]={response,job->roots[1],job->roots[0]};AugFrame frame;aug_frame_enter(&frame,roots,3);
   if(job->timed_out)roots[0]=aug_http_problem(504);
   else if(job->test&&job->deadline&&monotonic_ms()>=job->deadline)roots[0]=aug_http_problem(504);
   if(session) {
-    roots[0]=policy_response(session,roots[0]);
+    bool prepared_head=job->head_complete&&roots[0].tag==AUG_OBJECT&&session->roots[1].tag==AUG_OBJECT&&roots[0].as.object==session->roots[1].as.object;
+    if(!prepared_head)roots[0]=policy_response(session,roots[0]);
     bool stream_success=session->route->stream&&aug_cint(aug_field(roots[0],1))<400;
     if(job->test&&stream_success&&!session->streaming) {
       session->roots[2]=aug_bytes("",0,AUG_BYTES_KIND);
@@ -548,10 +570,12 @@ AugValue aug_http_finish(AugValue response) {
         else session->streaming=false;
         lws_callback_on_writable(job->wsi);
       }
-      while(job->session&&!job->transport_complete&&!aug_cancelled)aug_task_suspend();
+      while(job->session&&!job->transport_complete&&(!aug_cancelled||(job->head_complete&&!job->timed_out)))aug_task_suspend();
     }
   }
-  int status=aug_cancelled&&!job->timed_out?499:(int)aug_cint(aug_field(roots[0],1));
+  /* A deadline may have fired while finish was suspended on transport. */
+  if(job->timed_out)roots[0]=aug_http_problem(504);
+  int status=aug_cancelled&&!job->timed_out&&(!job->head_complete||!job->transport_complete)?499:(int)aug_cint(aug_field(roots[0],1));
   bool cancelled=aug_cancelled;aug_cancelled=false;aug_execution_current()->http_job=NULL;
   if(roots[1].tag==AUG_OBJECT)for(size_t i=roots[1].as.object->field_count;i>0;i--){
     AugValue arguments[]={aug_field(roots[2],0),aug_field(roots[2],1),aug_int(status),aug_int(monotonic_ms()-job->started)};
@@ -582,7 +606,7 @@ static void dispatch(struct lws *wsi, AugHttpSession *session) {
   if (!session->route) {session->roots[1] = aug_http_problem(404); lws_callback_on_writable(wsi); return;}
   AugHttpJob *job = calloc(1, sizeof(*job)); if (!job) return;
   job->wsi = wsi; job->session = session; session->job = job;job->started=monotonic_ms();
-  job->roots[0]=session->roots[0];aug_retain(&job->retained,job->roots,2);
+  job->roots[0]=session->roots[0];aug_retain(&job->retained,job->roots,3);
   AugValue arguments[3] = {session->roots[0], aug_int(session->route - served_routes),aug_int((int64_t)(intptr_t)job)};
   job->task = aug_task_spawn(request_task, aug_null(), arguments, 3, request_complete, job);
 }
@@ -660,8 +684,11 @@ static int callback_http(struct lws *wsi, enum lws_callback_reasons reason, void
           snprintf(name, sizeof(name), "%s:", label.as.object->text);
           if (lws_add_http_header_by_name(wsi, (unsigned char *)name, (unsigned char *)value.as.object->text, (int)value.as.object->text_length, &next, end)) return -1;
         }
-        if (lws_finalize_write_http_header(wsi, start, &next, end)) return -1;
-        session->headers_sent = true; lws_callback_on_writable(wsi); return 0;
+        enum lws_write_protocol flags=LWS_WRITE_HTTP_HEADERS|(session->head?LWS_WRITE_H2_STREAM_END:0);
+        if (lws_finalize_write_http_header_flags(wsi, start, &next, end, flags)) return -1;
+        session->headers_sent = true;
+        if(session->head){if(session->job)session->job->transport_complete=true;cleanup(session);return lws_http_transaction_completed(wsi)?-1:0;}
+        lws_callback_on_writable(wsi); return 0;
       }
       if(session->streaming&&!session->stream_pending&&!session->stream_done)return 0;
       AugValue encoded = session->streaming&&session->stream_pending?session->roots[3]:session->roots[2]; size_t remaining = session->head ? 0 : encoded.as.object->text_length - session->sent;

package/runtime/aug_http_ir.c

@@ -0,0 +1,30 @@
+#include "aug_http_ir.h"
+void aug_ir_http_operation(AugValue *out,int op,AugValue *a,int count,const char *text,int64_t number) {
+  (void)number;*out=aug_null();
+  switch(op){
+    case AUG_IR_HTTP_HEADERS:*out=aug_headers_new();break;
+    case AUG_IR_HTTP_HEADERS_WITH:*out=aug_headers_with(a[0],a[1],a[2]);break;
+    case AUG_IR_HTTP_HEADERS_GET:*out=aug_headers_get(a[0],a[1]);break;
+    case AUG_IR_HTTP_HEADERS_ALL:*out=aug_headers_all(a[0],a[1]);break;
+    case AUG_IR_HTTP_RESPONSE:*out=aug_http_response_full(a[0],a[1],a[2]);break;
+    case AUG_IR_HTTP_RESPONSE_STATUS:*out=aug_http_response(a[0],(int)aug_cint(a[1]));break;
+    case AUG_IR_HTTP_FINISH:*out=aug_http_finish(a[0]);break;
+    case AUG_IR_HTTP_EVENT:*out=aug_http_event(a[0],a[1],a[2],a[3]);break;
+    case AUG_IR_HTTP_YIELD:aug_http_yield(a[0]);break;
+    case AUG_IR_HTTP_CLIENT_REQUEST:*out=aug_httptestclient_request(a[0],a[1],a[2],a[3],a[4]);break;
+    case AUG_IR_HTTP_ACTION:*out=aug_http_action(text,a,(size_t)count);break;
+    default:aug_error_named("NativeContractError");break;
+  }
+}
+void aug_ir_http_bind(AugValue *out,const AugValue *request,const char *source,const char *name,const AugSchema *schema){*out=aug_http_bind(*request,source,name,schema);}
+void aug_ir_http_form(AugValue *out,const AugValue *request,const AugSchema *schema){*out=aug_httprequest_form(*request,schema);}
+void aug_ir_http_policy(const AugHttpPolicy *policy,AugValue *args){aug_http_policy(policy,args[0],args[1],args[2]);}
+void aug_ir_http_failure(AugValue *out,const AugIrHttpError *errors,int count){
+  if(aug_http_head_response(out))return;
+  int status=aug_http_error_status();
+  for(int i=0;i<count;i++)if(aug_error_is(errors[i].type))status=errors[i].status;
+  if(status==500)aug_report_error();aug_take_error();*out=aug_http_problem(status);
+}
+void aug_ir_http_test_client(AugValue *out,const AugRoute *routes,int count){*out=aug_http_test_client(routes,(size_t)count);}
+void aug_ir_http_serve(const AugRoute *routes,int count,const AugValue *port){aug_http_serve(routes,(size_t)count,aug_cint(*port));}
+void aug_ir_html(AugValue *out,const char *tag,AugValue *attributes,int count,AugValue *children,int child_count){*out=aug_html_element(tag,attributes,(size_t)count,children,(size_t)child_count);}

package/runtime/aug_http_ir.h

@@ -0,0 +1,18 @@
+#ifndef AUG_HTTP_IR_H
+#define AUG_HTTP_IR_H
+#include "aug_ir.h"
+enum AugIrHttpOperation {
+  AUG_IR_HTTP_HEADERS=1,AUG_IR_HTTP_HEADERS_WITH,AUG_IR_HTTP_HEADERS_GET,AUG_IR_HTTP_HEADERS_ALL,
+  AUG_IR_HTTP_RESPONSE,AUG_IR_HTTP_RESPONSE_STATUS,AUG_IR_HTTP_FINISH,AUG_IR_HTTP_EVENT,
+  AUG_IR_HTTP_YIELD,AUG_IR_HTTP_CLIENT_REQUEST,AUG_IR_HTTP_ACTION
+};
+typedef struct {const char *type; int status;} AugIrHttpError;
+void aug_ir_http_operation(AugValue *out,int op,AugValue *args,int count,const char *text,int64_t number);
+void aug_ir_http_bind(AugValue *out,const AugValue *request,const char *source,const char *name,const AugSchema *schema);
+void aug_ir_http_form(AugValue *out,const AugValue *request,const AugSchema *schema);
+void aug_ir_http_policy(const AugHttpPolicy *policy,AugValue *args);
+void aug_ir_http_failure(AugValue *out,const AugIrHttpError *errors,int count);
+void aug_ir_http_test_client(AugValue *out,const AugRoute *routes,int count);
+void aug_ir_http_serve(const AugRoute *routes,int count,const AugValue *port);
+void aug_ir_html(AugValue *out,const char *tag,AugValue *attributes,int count,AugValue *children,int child_count);
+#endif

package/runtime/aug_ir.c

@@ -0,0 +1,209 @@
+#include "aug_ir.h"
+#include <limits.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+_Static_assert(sizeof(AugValue)==16, "LLVM pack must record its actual AugValue layout");
+_Static_assert(offsetof(AugValue,as)==8, "LLVM pack must record its actual payload offset");
+
+void aug_ir_operation(AugValue *out,int op,AugValue *a,int count,const char *text,int64_t n) {
+  (void)count; *out=aug_null();
+  switch(op) {
+    case AUG_IR_PRINT: aug_print(a[0]); break;
+    case AUG_IR_BINARY: *out=aug_binary(text,a[0],a[1]); break;
+    case AUG_IR_UNARY: *out=aug_unary(text,a[0]); break;
+    case AUG_IR_FIELD: *out=aug_field(a[0],(size_t)n); break;
+    case AUG_IR_SET_FIELD: aug_set_field(a[0],(size_t)n,a[1]); break;
+    case AUG_IR_LIST: *out=aug_list_new(a,(size_t)count); break;
+    case AUG_IR_TUPLE: *out=aug_tuple_new(a,(size_t)count); break;
+    case AUG_IR_SET: *out=aug_set_new(a,(size_t)count); break;
+    case AUG_IR_MAP: *out=aug_map_new(); break;
+    case AUG_IR_MAP_SET: aug_map_set(a[0],a[1],a[2]); break;
+    case AUG_IR_LIST_LENGTH: *out=aug_int(aug_list_length(a[0])); break;
+    case AUG_IR_LIST_GET: *out=aug_list_get(a[0],aug_cint(a[1])); break;
+    case AUG_IR_LIST_AT: *out=aug_list_at(a[0],aug_cint(a[1])); break;
+    case AUG_IR_LIST_APPEND: aug_list_append(a[0],a[1]); break;
+    case AUG_IR_TUPLE_LENGTH: *out=aug_int(aug_tuple_length(a[0])); break;
+    case AUG_IR_TUPLE_GET: *out=aug_tuple_get(a[0],aug_cint(a[1])); break;
+    case AUG_IR_SET_LENGTH: *out=aug_int(aug_set_length(a[0])); break;
+    case AUG_IR_SET_ADD: aug_set_add(a[0],a[1]); break;
+    case AUG_IR_SET_CONTAINS: *out=aug_bool(aug_set_contains(a[0],a[1])); break;
+    case AUG_IR_MAP_LENGTH: *out=aug_int(aug_map_length(a[0])); break;
+    case AUG_IR_MAP_GET: *out=aug_map_get(a[0],a[1]); break;
+    case AUG_IR_MAP_TAKE: *out=aug_map_take(a[0],a[1]); break;
+    case AUG_IR_MAP_CONTAINS: *out=aug_bool(aug_map_contains(a[0],a[1])); break;
+    case AUG_IR_STRING_LENGTH: *out=aug_int(aug_string_length(a[0])); break;
+    case AUG_IR_STRING_BYTES: *out=aug_string_bytes(a[0]); break;
+    case AUG_IR_STRING_SPLIT: *out=aug_string_split(a[0],a[1]); break;
+    case AUG_IR_STRING_STARTS_WITH: *out=aug_bool(aug_string_starts_with(a[0],a[1])); break;
+    case AUG_IR_STRING_IS_TOKEN: *out=aug_bool(aug_string_is_token(a[0],aug_cint(a[1]),aug_cint(a[2]))); break;
+    case AUG_IR_BYTES_LENGTH: *out=aug_int(aug_bytes_length(a[0])); break;
+    case AUG_IR_BYTES_TEXT: *out=aug_bytes_text(a[0]); break;
+    case AUG_IR_BYTES_BASE64URL: *out=aug_bytes_base64url(a[0]); break;
+    case AUG_IR_BASE64URL_DECODE: *out=aug_base64url_decode(a[0]); break;
+    case AUG_IR_C_INT: *out=aug_to_c_int(a[0]); break;
+    case AUG_IR_READ_FILE: *out=aug_read_file(a[0]); break;
+    case AUG_IR_WRITE_FILE: *out=aug_write_file(a[0],a[1]); break;
+    case AUG_IR_ARGUMENTS: *out=aug_arguments(); break;
+    case AUG_IR_FREEZE: aug_freeze(a[0]); *out=a[0]; break;
+    case AUG_IR_ITER: *out=aug_iter_snapshot(a[0]); break;
+    case AUG_IR_MAP_ITER: *out=aug_map_entries_snapshot(a[0]); break;
+    case AUG_IR_IS_TYPE: *out=aug_bool(a[0].tag==AUG_OBJECT&&a[0].as.object&&!strcmp(a[0].as.object->type_name,text)); break;
+    case AUG_IR_SHARED: *out=aug_shared_new(a[0]); break;
+    case AUG_IR_SHARED_LOCK: *out=aug_shared_lock(a[0]); break;
+    case AUG_IR_JSON_WRAP: *out=aug_json_wrap(a[0]); break;
+    case AUG_IR_JSON_PARSE: *out=_aug_json_parse(a[0]); break;
+    case AUG_IR_JSON_STRINGIFY: *out=aug_json_stringify(a[0]); break;
+    case AUG_IR_JSON_GET: *out=aug_json_get(a[0],a[1]); break;
+    case AUG_IR_JSON_REQUIRE: *out=aug_json_require(a[0],a[1]); break;
+    case AUG_IR_JSON_STRING: *out=aug_json_string(a[0]); break;
+    case AUG_IR_JSON_INTEGER: *out=aug_int(aug_json_integer(a[0])); break;
+    case AUG_IR_JSON_BOOLEAN: *out=aug_bool(aug_json_boolean(a[0])); break;
+    case AUG_IR_JSON_ITEMS: *out=aug_json_items(a[0]); break;
+    case AUG_IR_TIME_NOW: *out=_aug_time_now(); break;
+    case AUG_IR_EXIT: {int64_t status=aug_cint(a[0]);aug_cancelled=true;aug_shutdown();exit(status>=0&&status<=255?(int)status:1);}
+    case AUG_IR_TEST_CASE: aug_test_assertions=0;break;
+    default: *out=aug_error_named("NativeContractError"); break;
+  }
+}
+void aug_ir_json_decode(AugValue *out,const AugValue *value,const AugSchema *schema){*out=aug_json_decode(*value,schema);}
+void aug_ir_print(const AugValue *value){aug_print(*value);}
+void aug_ir_binary(AugValue *out,const char *operation,const AugValue *left,const AugValue *right){*out=aug_binary(operation,*left,*right);}
+void aug_ir_unary(AugValue *out,const char *operation,const AugValue *value){*out=aug_unary(operation,*value);}
+void aug_ir_list_new(AugValue *out,AugValue *items,int count){*out=aug_list_new(items,(size_t)count);}
+void aug_ir_tuple_new(AugValue *out,AugValue *items,int count){*out=aug_tuple_new(items,(size_t)count);}
+void aug_ir_set_new(AugValue *out,AugValue *items,int count){*out=aug_set_new(items,(size_t)count);}
+void aug_ir_map(AugValue *out){*out=aug_map_new();}
+void aug_ir_iter(AugValue *out,const AugValue *value){*out=aug_iter_snapshot(*value);}
+void aug_ir_map_iter(AugValue *out,const AugValue *value){*out=aug_map_entries_snapshot(*value);}
+void aug_ir_list_append(const AugValue *list,const AugValue *value){aug_list_append(*list,*value);}
+int64_t aug_ir_tuple_length(const AugValue *tuple){return aug_tuple_length(*tuple);}
+void aug_ir_tuple_get(AugValue *out,const AugValue *tuple,const AugValue *index){*out=aug_tuple_get(*tuple,aug_cint(*index));}
+int64_t aug_ir_string_length(const AugValue *value){return aug_string_length(*value);}
+void aug_ir_string_bytes(AugValue *out,const AugValue *value){*out=aug_string_bytes(*value);}
+void aug_ir_string_split(AugValue *out,const AugValue *value,const AugValue *separator){*out=aug_string_split(*value,*separator);}
+void aug_ir_map_set(const AugValue *map,const AugValue *key,const AugValue *value){aug_map_set(*map,*key,*value);}
+void aug_ir_set_add(const AugValue *set,const AugValue *value){aug_set_add(*set,*value);}
+uint8_t aug_ir_set_contains(const AugValue *set,const AugValue *value){return aug_set_contains(*set,*value)?1:0;}
+uint8_t aug_ir_map_contains(const AugValue *map,const AugValue *key){return aug_map_contains(*map,*key)?1:0;}
+int64_t aug_ir_list_length(const AugValue *list){return (int64_t)aug_list_length(*list);}
+int64_t aug_ir_set_length(const AugValue *set){return (int64_t)aug_set_length(*set);}
+int64_t aug_ir_map_length(const AugValue *map){return (int64_t)aug_map_length(*map);}
+void aug_ir_list_get(AugValue *out,const AugValue *list,const AugValue *index){*out=aug_list_get(*list,aug_cint(*index));}
+void aug_ir_list_at(AugValue *out,const AugValue *list,const AugValue *index){*out=aug_list_at(*list,aug_cint(*index));}
+void aug_ir_map_get(AugValue *out,const AugValue *map,const AugValue *key){*out=aug_map_get(*map,*key);}
+void aug_ir_map_take(AugValue *out,const AugValue *map,const AugValue *key){*out=aug_map_take(*map,*key);}
+void aug_ir_string(AugValue *out,const void *text,uint64_t count){*out=aug_string_n(text,(size_t)count);}
+void aug_ir_assert(const AugValue *condition,const char *expression,const char *file,int line){aug_assert(*condition,expression,file,line);}
+void aug_ir_drop(AugValue *value){aug_drop(*value);*value=aug_null();}
+void aug_ir_failed_result(AugValue *value){if(aug_has_error){aug_drop_partial(*value);*value=aug_null();}}
+void aug_ir_constructor_result(AugValue *value,const AugValue *result){aug_constructor_result_cleanup(*value,*result);*value=aug_null();}
+void aug_ir_throw(const AugValue *value){aug_throw(*value);}
+void aug_ir_take_error(AugValue *out){*out=aug_take_error();}
+void aug_ir_save_error_state(AugValue *error,AugValue *cancelled){
+  *error=aug_has_error?aug_take_error():aug_null();*cancelled=aug_bool(aug_cancelled);aug_cancelled=false;
+}
+void aug_ir_restore_error_state(const AugValue *error,const AugValue *cancelled){
+  aug_cancelled=aug_truthy(*cancelled);if(!aug_has_error&&error->tag!=AUG_NULL)aug_throw(*error);
+}
+bool aug_ir_has_error(void){return aug_has_error;}
+void aug_ir_task_wait(AugValue *out,AugValue *tasks,int count){*out=aug_task_wait(tasks,count);}
+bool aug_ir_cancelled(void){return aug_cancelled;}
+uint8_t aug_ir_state(void){
+  AugExecution *execution=aug_execution_current();
+  return execution->cancelled?1:execution->has_error?2:0;
+}
+bool aug_ir_is_null(const AugValue *value){return value->tag==AUG_NULL;}
+bool aug_ir_truthy(const AugValue *value){return aug_truthy(*value);}
+int64_t aug_ir_integer(const AugValue *value){return aug_cint(*value);}
+double aug_ir_float(const AugValue *value){return aug_cfloat(*value);}
+void aug_ir_frame_enter(AugFrame *frame,AugValue *values,uint64_t count){aug_frame_enter(frame,values,(size_t)count);}
+void aug_ir_method(AugValue *out,const AugValue *self,const char *name,AugValue *args,int count){*out=aug_call_method(*self,name,args,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){
+  *out=aug_new_object(type,(size_t)fields,owned,methods,(size_t)method_count);
+  out->as.object->field_names=names;if(record)out->as.object->kind=AUG_RECORD_KIND;
+}
+void aug_ir_binding_get(AugValue *out,uint64_t index){*out=aug_binding_get((size_t)index);}
+void aug_ir_binding_set(uint64_t index,const AugValue *value){aug_binding_set((size_t)index,*value);}
+int aug_ir_exit_status(bool test){
+  if(aug_has_error){aug_report_error();return 1;}
+  if(test&&!aug_test_assertions){fputs("Test executed no assertions\n",stderr);return 1;}
+  return aug_test_failed?1:0;
+}
+void *aug_ir_resource_pointer(const AugValue *value,const char *type){
+  if(value->tag!=AUG_OBJECT||!value->as.object||value->as.object->kind!=AUG_NATIVE_RESOURCE_KIND||value->as.object->dropped||!value->as.object->native||strcmp(value->as.object->type_name,type)){
+    aug_error_named("NativeContractError");return NULL;
+  }
+  return value->as.object->native;
+}
+void aug_ir_resource(AugValue *out,void *pointer,const char *type,void(*release)(void *)){
+  if(!pointer||!release){*out=aug_null();aug_error_named("NativeContractError");return;}
+  *out=aug_new_object(type,0,NULL,NULL,0);out->as.object->kind=AUG_NATIVE_RESOURCE_KIND;
+  out->as.object->native=pointer;out->as.object->finalize=release;
+}
+void aug_ir_resource_move(AugValue *value){
+  if(value->tag==AUG_OBJECT&&value->as.object&&value->as.object->kind==AUG_NATIVE_RESOURCE_KIND){
+    value->as.object->native=NULL;value->as.object->finalize=NULL;value->as.object->dropped=true;
+  }
+  *value=aug_null();
+}
+void aug_ir_contract_error(AugValue *out){*out=aug_null();if(!aug_has_error)aug_error_named("NativeContractError");}
+void aug_ir_native_error(AugValue *out,AugPointerMethod factory,int32_t code,const void *text,uint64_t length){
+  if(aug_has_error)return;
+  if(!factory){aug_ir_contract_error(out);return;}
+  if(length>512||!aug_valid_utf8(text,(size_t)length)){text="Native library returned an invalid error message";length=strlen(text);}
+  if(!length){text="Native call rejected its input or supplied no error message";length=strlen(text);}
+  AugValue roots[3]={0};AugFrame frame;aug_frame_enter(&frame,roots,3);
+  roots[0]=aug_int(code);roots[1]=aug_string_n(text,(size_t)length);
+  factory(&roots[2],NULL,roots,2);
+  if(!aug_has_error)aug_throw(roots[2]);aug_frame_leave(&frame);
+}
+bool aug_ir_data(const AugValue *v,const void **data,uint64_t *count){
+  *data=NULL;*count=0;
+  if((v->tag!=AUG_STRING&&v->tag!=AUG_OBJECT)||!v->as.object||v->as.object->dropped||(v->tag==AUG_OBJECT&&v->as.object->kind!=AUG_BYTES_KIND)){
+    aug_error_named("NativeContractError");return false;
+  }
+  *data=v->as.object->text;*count=v->as.object->text_length;return true;
+}
+bool aug_ir_floats(const AugValue *v,double **data,uint64_t *count){
+  *data=NULL;*count=0;
+  if(v->tag!=AUG_OBJECT||!v->as.object||v->as.object->kind!=AUG_LIST_KIND||v->as.object->dropped||v->as.object->field_count>SIZE_MAX/sizeof(double)){
+    aug_error_named("NativeContractError");return false;
+  }
+  size_t n=v->as.object->field_count;double *items=malloc((n?n:1)*sizeof(double));
+  if(!items){aug_error_named("NativeContractError");return false;}
+  for(size_t i=0;i<n;i++){
+    AugValue item=v->as.object->fields[i];if(item.tag!=AUG_FLOAT&&item.tag!=AUG_INT){free(items);aug_error_named("NativeContractError");return false;}
+    items[i]=item.tag==AUG_FLOAT?item.as.floating:(double)item.as.integer;
+  }
+  *data=items;*count=n;return true;
+}
+bool aug_ir_strings(const AugValue *v,const void ***data,uint64_t **lengths,uint64_t *count){
+  *data=NULL;*lengths=NULL;*count=0;
+  if(v->tag!=AUG_OBJECT||!v->as.object||v->as.object->kind!=AUG_LIST_KIND||v->as.object->dropped||v->as.object->field_count>SIZE_MAX/sizeof(uint64_t)){
+    aug_error_named("NativeContractError");return false;
+  }
+  size_t n=v->as.object->field_count;const void **items=calloc(n?n:1,sizeof(void *));uint64_t *sizes=calloc(n?n:1,sizeof(uint64_t));
+  if(!items||!sizes){free(items);free(sizes);aug_error_named("NativeContractError");return false;}
+  for(size_t i=0;i<n;i++){
+    AugValue item=v->as.object->fields[i];if(item.tag!=AUG_STRING||!item.as.object||item.as.object->dropped){free(items);free(sizes);aug_error_named("NativeContractError");return false;}
+    items[i]=item.as.object->text;sizes[i]=item.as.object->text_length;
+  }
+  *data=items;*lengths=sizes;*count=n;return true;
+}
+void aug_ir_free(void *memory){free(memory);}
+void aug_ir_copy_bytes(AugValue *out,const void *bytes,uint64_t count){
+  if(count>SIZE_MAX-1||(!bytes&&count)){*out=aug_error_named("NativeContractError");return;}
+  *out=aug_bytes(bytes,(size_t)count,AUG_BYTES_KIND);
+}
+void aug_ir_copy_utf8(AugValue *out,const void *text,uint64_t count){
+  if(count>SIZE_MAX-1||!aug_valid_utf8(text,(size_t)count)){*out=aug_error_named("NativeContractError");return;}
+  *out=aug_string_n(text,(size_t)count);
+}
+void aug_ir_copy_bool(AugValue *out,uint8_t value){*out=value>1?aug_error_named("NativeContractError"):aug_bool(value!=0);}
+void aug_ir_copy_floats(AugValue *out,const double *values,uint64_t count){
+  if(count>SIZE_MAX/sizeof(AugValue)||(!values&&count)){*out=aug_error_named("NativeContractError");return;}
+  AugValue *items=malloc((count?count:1)*sizeof(AugValue));if(!items){*out=aug_error_named("NativeContractError");return;}
+  for(uint64_t i=0;i<count;i++)items[i]=aug_float(values[i]);
+  *out=aug_list_new(items,(size_t)count);free(items);
+}

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]); }