bundling: fs/process stdlib + post-link callback + Apple .app in sx

Campaign Weeks 3-6 of /Users/agra/.claude/plans/lets-plan-to-move-splendid-pumpkin.md
land in one push: the bundling pipeline that used to live in
src/target.zig (createBundle, embedFramework, extractEntitlements,
buildInfoPlist, codesign) now lives in
library/modules/platform/bundle.sx and runs in the IR interpreter
after target.link() returns.

New language-side surface:
- library/modules/fs.sx — POSIX libc bindings (open/read/write/close,
  mkdir/unlink/rmdir, chmod, rename, access, basename/dirname). Variadic
  open() lowers to C's varargs via the new args: ..T form. Direct libc
  calls bypass *File method dispatch so they work from the post-link
  IR interpreter.
- library/modules/process.sx — popen-based run(cmd) returning
  ProcessResult{ exit_code, stdout }, plus env() and find_executable().
- library/modules/std.sx — xml_escape(s) and variadic path_join(parts).
- library/modules/compiler.sx — BuildOptions grows
  set_post_link_callback / set_post_link_module / binary_path
  accessors; bundle_path/bundle_id/codesign_identity/provisioning_profile
  setters + accessors; per-target predicates is_macos/is_ios/
  is_ios_device/is_ios_simulator + target_triple; framework_count /
  framework_at(i) / framework_path_count / framework_path_at(i);
  add_asset_dir(src, dest) + asset_dir_count / src_at / dest_at.

Compiler-side wiring:
- src/ir/compiler_hooks.zig — BuildConfig now carries post_link_callback_fn,
  post_link_module, binary_path, bundle_*, target_triple,
  target_frameworks, target_framework_paths, asset_dirs. Hook registry
  exposes every accessor; getters return "" / 0 for unset fields so
  bundle.sx can treat absent values uniformly.
- src/ir/host_ffi.zig (new) — dlsym(RTLD_DEFAULT) + arity-switched cdecl
  trampolines so #foreign("c") declarations resolve through the host
  libc during #run / post-link interpretation.
- src/ir/interp.zig — callForeign dispatch; build_config pointer
  injection so accessor hooks see live state during re-entry.
- src/core.zig — keeps the IR module alive past generateCode; exposes
  invokeByName / invokeByFuncId so main.zig can re-enter the
  interpreter after linking.
- src/main.zig — wires bundle/codesign/provisioning CLI flags +
  target_triple + framework lists into BuildConfig; invokes the
  post-link callback (by FuncId or by <module>.bundle_main lookup) once
  target.link() returns. When --bundle is set but no callback is
  registered, auto-falls-back to post_link_module = "platform.bundle"
  so the legacy --bundle CLI keeps working for any program that imports
  modules/platform/bundle.sx.

Apple .app bundler (library/modules/platform/bundle.sx):
- Single bundle_main entry covers macOS, iOS simulator, iOS device.
  Per-target Info.plist switch keys off is_ios()/is_ios_simulator() —
  iOS emits UIDeviceFamily / LSRequiresIPhoneOS /
  UIApplicationSceneManifest / DTPlatformName (iPhoneOS or
  iPhoneSimulator); macOS emits the minimal CFBundle* set.
- iOS-only steps:
  - Provisioning embed: fs.read_file + fs.write_file to
    <bundle>/embedded.mobileprovision.
  - Framework embed: recursive cp -R per -F search path into
    <bundle>/Frameworks/<Name>.framework/ (until fs.sx grows list_dir).
  - Entitlements extraction: four process.run calls (security cms -D,
    plutil -extract Entitlements xml1, plutil -extract
    ApplicationIdentifierPrefix.0, plutil -replace application-identifier)
    resolving the wildcard <TEAM>.* -> <TEAM>.<bundle_id>.
  - Real codesign with --entitlements when present.
- Asset dirs (add_asset_dir): recursive cp -R src/. into <bundle>/dest/.
  Missing src is treated as "nothing to do" so projects can register
  add_asset_dir("assets", "assets") unconditionally.

Parser:
- parseStmt() now accepts #import \"path\"; and #framework \"Name\"; as
  statement-position tokens. Needed for top-level
  inline if OS == .android { #import \"modules/platform/android.sx\"; }
  blocks (issue-0042 flatten pass surfaces them); chess's
  inline-if-with-#import was rejected at parse time before this fix.

Removals from src/target.zig:
- createBundle, embedFramework, extractEntitlements, buildInfoPlist,
  codesign (~210 lines). main.zig no longer calls createBundle after
  link(); the sx callback is the single entry point.

Tests / regression markers (all run under sx run host JIT):
- examples/115-post-link-callback.sx — callback registration round-trip.
- examples/116-fs-roundtrip.sx — fs.write_file -> fs.read_file -> exists.
- examples/117-process-roundtrip.sx — process.run + env + find_executable.
- examples/118-macos-bundle.sx — macOS .app via bundle_main callback.
- examples/119-interp-cast-ptr-cmp.sx — cast(T) val under interpreter.
- examples/120-interp-variadic-any.sx — variadic ..Any indexing in IR
  interpreter.
- examples/121-ios-sim-bundle.sx — iOS-sim cross-compile + .app with
  iOS-shaped Info.plist (added to tests/cross_compile.sh as the
  ios-sim tuple).
- examples/122-ios-device-bundle.sx — iOS device cross-compile +
  full codesign pipeline (provisioning embed + entitlements
  extraction + --entitlements codesign). Manually verified end-to-end:
  installed via xcrun devicectl device install app + launched
  successfully on iPhone 17 Pro.
- examples/123-inline-if-import-in-body.sx — locks in the parser fix.

zig build && zig build test && bash tests/run_examples.sh => 141 passed,
0 failed; bash tests/cross_compile.sh => 7 passed, 0 failed.

src/parser.zig

@@ -18,6 +18,11 @@ pub const Parser = struct {
     diagnostics: ?*errors.DiagnosticList = null,
     /// Type param names from enclosing generic struct (set while parsing methods)
     struct_type_params: []const []const u8 = &.{},
+    /// When true (set while parsing methods inside `struct #compiler { ... }`),
+    /// a missing function body (just `name :: (params);`) is synthesized as
+    /// a `.compiler_expr` body so the per-method `#compiler` suffix can be
+    /// omitted.
+    struct_default_compiler: bool = false,
 
     pub fn init(allocator: std.mem.Allocator, source: [:0]const u8) Parser {
         var lexer = Lexer.init(source);
@@ -760,6 +765,15 @@ pub const Parser = struct {
     fn parseStructDecl(self: *Parser, name: []const u8, start_pos: u32) anyerror!*Node {
         self.advance(); // skip 'struct'
 
+        // Optional `#compiler` attribute: all methods inside this struct are
+        // implicitly compiler hooks (no per-method `#compiler` suffix needed).
+        // Mirrors `protocol #inline { ... }` shape.
+        var is_compiler_struct = false;
+        if (self.current.tag == .hash_compiler) {
+            is_compiler_struct = true;
+            self.advance();
+        }
+
         // Optional type params: struct($N: u32, $T: Type) { ... }
         var type_params = std.ArrayList(ast.StructTypeParam).empty;
         if (self.current.tag == .l_paren) {
@@ -805,6 +819,13 @@ pub const Parser = struct {
         self.struct_type_params = tp_names.items;
         defer self.struct_type_params = saved_struct_type_params;
 
+        // Propagate the struct-level `#compiler` flag to nested method
+        // parsing so a bodyless `name :: (params);` synthesizes a
+        // `.compiler_expr` body.
+        const saved_struct_default_compiler = self.struct_default_compiler;
+        self.struct_default_compiler = is_compiler_struct;
+        defer self.struct_default_compiler = saved_struct_default_compiler;
+
         var field_names = std.ArrayList([]const u8).empty;
         var field_types = std.ArrayList(*Node).empty;
         var field_defaults = std.ArrayList(?*Node).empty;
@@ -1486,7 +1507,14 @@ pub const Parser = struct {
                     is_comptime_param = true;
                 }
             }
-            try params.append(self.allocator, .{ .name = param_name, .name_span = param_name_span, .type_expr = param_type, .is_variadic = is_variadic, .is_comptime = is_comptime_param });
+            // Optional default value: `param: T = expr`. Stored on the Param
+            // node; lowering fills it in for callers that omit this positional arg.
+            var default_expr: ?*Node = null;
+            if (self.current.tag == .equal) {
+                self.advance(); // consume '='
+                default_expr = try self.parseExpr();
+            }
+            try params.append(self.allocator, .{ .name = param_name, .name_span = param_name_span, .type_expr = param_type, .is_variadic = is_variadic, .is_comptime = is_comptime_param, .default_expr = default_expr });
         }
         for (params.items, 0..) |param, i| {
             if (param.is_variadic and i != params.items.len - 1) {
@@ -1570,6 +1598,12 @@ pub const Parser = struct {
             self.advance();
             try self.expect(.semicolon);
             break :blk try self.createNode(ci_start, .{ .compiler_expr = {} });
+        } else if (self.struct_default_compiler and self.current.tag == .semicolon) blk: {
+            // Inside `struct #compiler { ... }`: a bodyless method is
+            // implicitly a `#compiler` hook.
+            const ci_start = self.current.loc.start;
+            self.advance();
+            break :blk try self.createNode(ci_start, .{ .compiler_expr = {} });
         } else if (self.current.tag == .hash_foreign) blk: {
             const fi_start = self.current.loc.start;
             self.advance();
@@ -1741,6 +1775,36 @@ pub const Parser = struct {
             return try self.createNode(start, .{ .insert_expr = .{ .expr = inner } });
         }
 
+        // `#import "path";` / `#framework "Name";` inside a block body.
+        // Only meaningful inside an `inline if OS == ... { ... }` arm —
+        // the imports.zig flatten pass (issue-0042) surfaces those
+        // declarations to the top level before resolution. Anywhere else
+        // these nodes survive into lowering and produce a clear error.
+        if (self.current.tag == .hash_import) {
+            const start = self.current.loc.start;
+            self.advance();
+            if (self.current.tag != .string_literal) {
+                return self.fail("expected string path after '#import'");
+            }
+            const raw = self.tokenSlice(self.current);
+            const path = raw[1 .. raw.len - 1];
+            self.advance();
+            try self.expect(.semicolon);
+            return try self.createNode(start, .{ .import_decl = .{ .path = path, .name = null } });
+        }
+        if (self.current.tag == .hash_framework) {
+            const start = self.current.loc.start;
+            self.advance();
+            if (self.current.tag != .string_literal) {
+                return self.fail("expected string after '#framework'");
+            }
+            const raw = self.tokenSlice(self.current);
+            const fw_name = raw[1 .. raw.len - 1];
+            self.advance();
+            try self.expect(.semicolon);
+            return try self.createNode(start, .{ .framework_decl = .{ .name = fw_name } });
+        }
+
         // inline if — compile-time conditional
         if (self.current.tag == .kw_inline) {
             if (self.peekNext() == .kw_if) {
@@ -2777,6 +2841,10 @@ pub const Parser = struct {
 
     fn isFunctionDef(self: *Parser) bool {
         const tag = self.peekPastParens() orelse return false;
+        // Inside `struct #compiler { ... }`, a bodyless method declaration
+        // ends with `;` directly after the param list — recognise it as a
+        // function def (not a constant) so it goes through parseFnDecl.
+        if (self.struct_default_compiler and tag == .semicolon) return true;
         return tag == .l_brace or tag == .arrow or tag == .hash_builtin or tag == .hash_compiler or tag == .hash_foreign or tag == .fat_arrow or tag == .kw_callconv;
     }