Establish native micro runtime checkpoint

1 files changed, 146 insertions, 0 deletions

diff --git a/prototypes/workbench/native.zig b/prototypes/workbench/native.zig
new file mode 100644
index 0000000..36a99e4
--- /dev/null
+++ b/prototypes/workbench/native.zig
@@ -0,0 +1,146 @@
+//! Native C ABI. The caller supplies aligned instance storage; no global VM,
+//! allocator, OS call or browser dependency is part of this selected module.
+const Engine = @import("engine.zig").Engine;
+const fixed_definition = @hasDecl(@import("root"), "pure_definition");
+
+// Keep ReleaseSafe bounds/overflow checks. Unexpected internal invariant
+// failures trap without importing a process-wide stack unwinder or I/O layer.
+// Expected authored errors still return the ordinary scalar status codes.
+pub const panic = @import("std").debug.no_panic;
+
+export fn pure_scalar_bytes() usize {
+    return @sizeOf(Engine);
+}
+export fn pure_scalar_alignment() usize {
+    return @alignOf(Engine);
+}
+
+export fn pure_scalar_initialize(memory: ?*anyopaque, size: usize) ?*Engine {
+    const pointer = memory orelse return null;
+    if (size < @sizeOf(Engine) or @intFromPtr(pointer) % @alignOf(Engine) != 0) return null;
+    const instance: *Engine = @ptrCast(@alignCast(pointer));
+    instance.* = .{};
+    return instance;
+}
+
+export fn pure_scalar_reset_all(instance: *Engine) void {
+    instance.reset_all();
+}
+
+export fn pure_scalar_install_fixed(instance: *Engine, identity: *const [32]u8,
+                                    state_count: u32, input_count: u32, instruction_count: u32,
+                                    handler_count: u32, target_count: u32, restored: ?[*]const f64) u32 {
+    return instance.installFixed(identity, state_count, input_count, instruction_count,
+                                 handler_count, target_count, restored);
+}
+
+export fn pure_scalar_begin_program(instance: *Engine, state_count: u32, input_count: u32) u32 {
+    if (comptime fixed_definition) return 1;
+    return instance.begin_program(state_count, input_count);
+}
+
+export fn pure_scalar_abort_program(instance: *Engine) void {
+    if (comptime fixed_definition) return;
+    instance.abort_program();
+}
+
+export fn pure_scalar_put_state(instance: *Engine, id: u32, initial: f64, old_id: i32) u32 {
+    if (comptime fixed_definition) return 1;
+    return instance.put_state(id, initial, old_id);
+}
+
+export fn pure_scalar_put_instruction(instance: *Engine, op: u32, arg: u32, value: f64) u32 {
+    if (comptime fixed_definition) return 1;
+    return instance.put_instruction(op, arg, value);
+}
+
+export fn pure_scalar_put_handler(instance: *Engine, event: u32, start: u32, length: u32) u32 {
+    if (comptime fixed_definition) return 1;
+    return instance.put_handler(event, start, length);
+}
+
+export fn pure_scalar_bind_handler(instance: *Engine, handler: u32, base: u32, count: u32) u32 {
+    if (comptime fixed_definition) return 1;
+    return instance.bind_handler(handler, base, count);
+}
+
+export fn pure_scalar_put_pointer_target(instance: *Engine, input: u32, base: u32, count: u32) u32 {
+    if (comptime fixed_definition) return 1;
+    return instance.put_pointer_target(input, base, count);
+}
+
+export fn pure_scalar_bind_target_handler(instance: *Engine, handler: u32, count: u32) u32 {
+    if (comptime fixed_definition) return 1;
+    return instance.bind_target_handler(handler, count);
+}
+
+export fn pure_scalar_put_restored_value(instance: *Engine, id: u32, value: f64) u32 {
+    if (comptime fixed_definition) return 1;
+    return instance.put_restored_value(id, value);
+}
+
+export fn pure_scalar_commit_program(instance: *Engine) u32 {
+    if (comptime fixed_definition) return 1;
+    return instance.commit_program();
+}
+
+export fn pure_scalar_commit_restored_program(instance: *Engine) u32 {
+    if (comptime fixed_definition) return 1;
+    return instance.commit_restored_program();
+}
+
+export fn pure_scalar_reset_state(instance: *Engine) void {
+    instance.reset_state();
+}
+
+export fn pure_scalar_dispatch(instance: *Engine, event: u32, dt: f64) u32 {
+    return instance.dispatch(event, dt);
+}
+
+export fn pure_scalar_dispatch_point(instance: *Engine, event: u32, x: f64, y: f64) u32 {
+    return instance.dispatch_point(event, x, y);
+}
+
+export fn pure_scalar_dispatch_target(instance: *Engine, event: u32, target: u32, x: f64, y: f64) u32 {
+    return instance.dispatch_target(event, target, x, y);
+}
+
+export fn pure_scalar_dispatch_value(instance: *Engine, event: u32, value: f64) u32 {
+    return instance.dispatch_value(event, value);
+}
+
+export fn pure_scalar_eval_at(instance: *Engine, start: u32, length: u32) f64 {
+    return instance.eval_at(start, length);
+}
+
+export fn pure_scalar_configure_evaluation(instance: *Engine, cache: u32, history: u32) u32 {
+    return instance.configure_evaluation(cache, history);
+}
+
+export fn pure_scalar_forget_evaluation(instance: *Engine, flags: u32) void {
+    instance.forget_evaluation(flags);
+}
+
+export fn pure_scalar_begin_evaluation(instance: *Engine, limit: u32) void {
+    instance.begin_evaluation(limit);
+}
+
+export fn pure_scalar_eval_bounded(instance: *Engine, start: u32, length: u32) f64 {
+    return instance.eval_bounded(start, length);
+}
+
+export fn pure_scalar_evaluation_info(instance: *Engine, id: u32) u32 {
+    return instance.evaluation_info(id);
+}
+
+export fn pure_scalar_get_state(instance: *Engine, id: u32) f64 {
+    return instance.get_state(id);
+}
+
+export fn pure_scalar_info(instance: *Engine, id: u32) u32 {
+    return instance.info(id);
+}
+
+export fn pure_scalar_layout(instance: *Engine, id: u32) u32 {
+    return instance.layout(id);
+}