const std = @import("std");const app_permission_runtime = @import("app_permission_runtime.zig");const js_host_config_store = @import("../config/js_host_config_store.zig");const mode_registry = @import("../modes/mode_registry.zig");const runtime_profile = @import("../hosts/runtime_profile.zig");const debug_trace = @import("../shared/debug_trace.zig");const session_codec = @import("../session/session_codec.zig");const types = @import("../shared/types.zig"); const Allocator = std.mem.Allocator;const PermissionMode = types.PermissionMode; pub fn Runtime(comptime App: type) type {    return struct {        pub fn restore(app: *App, modes: mode_registry.Registry) !void {            if (comptime !runtime_profile.allows(App, .js_host_config)) return;             if (try loadValue(app, "model")) |model| {                defer app.alloc.free(model);                if (session_codec.validateModelPreference(model)) |_| {                    app.selected_model.clearRetainingCapacity();                    try app.selected_model.appendSlice(app.alloc, model);                    try app.worker.syncQueuedPromptModel(std.heap.c_allocator, model);                } else |err| {                    debug_trace.logf(                        "host_config",                        "restore_ignored id=model reason=invalid_value err={s}",                        .{@errorName(err)},                    );                }            }             if (try loadValue(app, "mode")) |mode_id| {                defer app.alloc.free(mode_id);                if (modes.lookup(mode_id)) |mode| {                    app_permission_runtime.Runtime(App).setMode(app, mode.permission_mode);                } else {                    debug_trace.logf(                        "host_config",                        "restore_ignored id=mode reason=unknown_value",                        .{},                    );                }            }        }         fn loadValue(app: *App, id: []const u8) Allocator.Error!?[]u8 {            return js_host_config_store.load(app.alloc, id) catch |err| switch (err) {                error.OutOfMemory => error.OutOfMemory,                error.ValueTooLarge, error.HostFailure => {                    debug_trace.logf(                        "host_config",                        "restore_ignored id={s} reason=load_failed err={s}",                        .{ id, @errorName(err) },                    );                    return null;                },            };        }         pub fn persistModel(_: *App, model: []const u8) void {            if (comptime !runtime_profile.allows(App, .js_host_config)) return;            persist("model", model);        }         pub fn persistPermissionMode(_: *App, mode: PermissionMode) void {            if (comptime !runtime_profile.allows(App, .js_host_config)) return;            persist("mode", configIdForPermissionMode(mode));        }    };} fn persist(id: []const u8, value: []const u8) void {    js_host_config_store.setAccepted(id, value) catch |err| {        debug_trace.logf(            "host_config",            "persist_ignored id={s} reason=host_failure err={s}",            .{ id, @errorName(err) },        );    };} fn configIdForPermissionMode(mode: PermissionMode) []const u8 {    return switch (mode) {        .auto => "code",        .ask => "ask",        // The host persists product mode IDs. Yolo has no product mode, so its        // non-interactive behavior restores through the closest mode, code.        .yolo => "code",    };} test "host config maps permission modes to restorable product modes" {    try std.testing.expectEqualStrings("code", configIdForPermissionMode(.auto));    try std.testing.expectEqualStrings("ask", configIdForPermissionMode(.ask));    try std.testing.expectEqualStrings("code", configIdForPermissionMode(.yolo));}