const std = @import("std"); pub const emergency_ceiling_bytes: usize = 64 * 1024 * 1024; pub const Name = enum {    skill_description_bytes,    skill_catalog_bytes,    skill_chunk_bytes,    skill_file_bytes,    mcp_description_bytes,    mcp_search_result_bytes,    mcp_server_instructions_bytes,    mcp_selected_schema_bytes,    project_instruction_file_bytes,    project_instructions_total_bytes,    image_adapter_output_bytes,     pub fn defaultBytes(self: Name) usize {        return switch (self) {            .skill_description_bytes => 1024,            .skill_catalog_bytes => 16 * 1024,            .skill_chunk_bytes => 20 * 1024,            .skill_file_bytes => 1024 * 1024,            .mcp_description_bytes => 1024,            .mcp_search_result_bytes => 16 * 1024,            .mcp_server_instructions_bytes => 2 * 1024,            .mcp_selected_schema_bytes => 64 * 1024,            .project_instruction_file_bytes => 64 * 1024,            .project_instructions_total_bytes => 128 * 1024,            .image_adapter_output_bytes => 20 * 1024,        };    }     pub fn parse(raw: []const u8) ?Name {        inline for (std.meta.fields(Name)) |field| {            if (std.mem.eql(u8, raw, field.name)) return @enumFromInt(field.value);        }        return null;    }}; pub const Source = enum {    compiled_default,    user_global,    user_workspace,    command_line,     pub fn label(self: Source) []const u8 {        return switch (self) {            .compiled_default => "compiled default",            .user_global => "global settings",            .user_workspace => "workspace settings",            .command_line => "command line",        };    }}; pub const Value = union(enum) {    bytes: usize,    off,     pub fn normalBytes(self: Value) ?usize {        return switch (self) {            .bytes => |bytes| bytes,            .off => null,        };    }     pub fn effectiveBytes(self: Value) usize {        return @min(self.normalBytes() orelse emergency_ceiling_bytes, emergency_ceiling_bytes);    }}; pub const Resolved = struct {    value: Value,    source: Source,     pub fn effectiveBytes(self: Resolved) usize {        return self.value.effectiveBytes();    }}; pub const Override = struct {    name: Name,    value: Value,}; pub const Values = struct {    skill_description_bytes: Resolved = defaultResolved(.skill_description_bytes),    skill_catalog_bytes: Resolved = defaultResolved(.skill_catalog_bytes),    skill_chunk_bytes: Resolved = defaultResolved(.skill_chunk_bytes),    skill_file_bytes: Resolved = defaultResolved(.skill_file_bytes),    mcp_description_bytes: Resolved = defaultResolved(.mcp_description_bytes),    mcp_search_result_bytes: Resolved = defaultResolved(.mcp_search_result_bytes),    mcp_server_instructions_bytes: Resolved = defaultResolved(.mcp_server_instructions_bytes),    mcp_selected_schema_bytes: Resolved = defaultResolved(.mcp_selected_schema_bytes),    project_instruction_file_bytes: Resolved = defaultResolved(.project_instruction_file_bytes),    project_instructions_total_bytes: Resolved = defaultResolved(.project_instructions_total_bytes),    image_adapter_output_bytes: Resolved = defaultResolved(.image_adapter_output_bytes),     pub fn get(self: Values, name: Name) Resolved {        return switch (name) {            inline else => |tag| @field(self, @tagName(tag)),        };    }     pub fn apply(self: *Values, overrides: Overrides) void {        inline for (std.meta.fields(Name)) |field| {            const name: Name = @enumFromInt(field.value);            if (overrides.get(name)) |value| @field(self, field.name) = value;        }    }     pub fn applyCommandLine(self: *Values, overrides: []const Override) void {        for (overrides) |override| {            self.set(override.name, .{ .value = override.value, .source = .command_line });        }    }     pub fn set(self: *Values, name: Name, value: Resolved) void {        switch (name) {            inline else => |tag| @field(self, @tagName(tag)) = value,        }    }}; pub const Overrides = struct {    skill_description_bytes: ?Resolved = null,    skill_catalog_bytes: ?Resolved = null,    skill_chunk_bytes: ?Resolved = null,    skill_file_bytes: ?Resolved = null,    mcp_description_bytes: ?Resolved = null,    mcp_search_result_bytes: ?Resolved = null,    mcp_server_instructions_bytes: ?Resolved = null,    mcp_selected_schema_bytes: ?Resolved = null,    project_instruction_file_bytes: ?Resolved = null,    project_instructions_total_bytes: ?Resolved = null,    image_adapter_output_bytes: ?Resolved = null,     pub fn get(self: Overrides, name: Name) ?Resolved {        return switch (name) {            inline else => |tag| @field(self, @tagName(tag)),        };    }     pub fn set(self: *Overrides, name: Name, value: Resolved) void {        switch (name) {            inline else => |tag| @field(self, @tagName(tag)) = value,        }    }     pub fn retag(self: *Overrides, source: Source) void {        inline for (std.meta.fields(Name)) |field| {            if (@field(self, field.name)) |*value| value.source = source;        }    }     pub fn merge(self: *Overrides, incoming: Overrides) void {        inline for (std.meta.fields(Name)) |field| {            if (@field(incoming, field.name)) |value| @field(self, field.name) = value;        }    }}; pub fn parseOverride(raw: []const u8) !Override {    const separator = std.mem.indexOfScalar(u8, raw, '=') orelse return error.InvalidContextLimitOverride;    const raw_name = std.mem.trim(u8, raw[0..separator], " \t\r\n");    const raw_value = std.mem.trim(u8, raw[separator + 1 ..], " \t\r\n");    if (raw_name.len == 0 or raw_value.len == 0) return error.InvalidContextLimitOverride;    return .{        .name = Name.parse(raw_name) orelse return error.UnknownContextLimit,        .value = try parseValueString(raw_value),    };} pub fn parseJsonObject(value: std.json.Value) !Overrides {    if (value != .object) return error.InvalidContextLimitsType;     var result = Overrides{};    var iterator = value.object.iterator();    while (iterator.next()) |entry| {        const name = Name.parse(entry.key_ptr.*) orelse return error.UnknownContextLimit;        result.set(name, .{            .value = try parseJsonValue(entry.value_ptr.*),            .source = .compiled_default,        });    }    return result;} fn parseJsonValue(value: std.json.Value) !Value {    return switch (value) {        .integer => |integer| .{ .bytes = std.math.cast(usize, integer) orelse return error.InvalidContextLimitValue },        .string => |string| parseValueString(string),        else => error.InvalidContextLimitValue,    };} fn parseValueString(raw: []const u8) !Value {    if (std.ascii.eqlIgnoreCase(raw, "off")) return .off;    return .{ .bytes = std.fmt.parseUnsigned(usize, raw, 10) catch return error.InvalidContextLimitValue };} fn defaultResolved(comptime name: Name) Resolved {    return .{        .value = .{ .bytes = name.defaultBytes() },        .source = .compiled_default,    };} pub fn utf8PrefixLength(bytes: []const u8, max_bytes: usize) usize {    var end = @min(max_bytes, bytes.len);    while (end > 0 and !std.unicode.utf8ValidateSlice(bytes[0..end])) : (end -= 1) {}    return end;} pub fn lineSafePrefixLength(bytes: []const u8, max_bytes: usize) usize {    const utf8_end = utf8PrefixLength(bytes, max_bytes);    if (utf8_end == bytes.len) return utf8_end;    if (std.mem.lastIndexOfScalar(u8, bytes[0..utf8_end], '\n')) |newline| return newline + 1;    return utf8_end;} test "defaults match the public context limit contract" {    const values = Values{};    inline for (std.meta.fields(Name)) |field| {        const name: Name = @enumFromInt(field.value);        try std.testing.expectEqual(name.defaultBytes(), values.get(name).effectiveBytes());        try std.testing.expectEqual(Source.compiled_default, values.get(name).source);    }} test "context limit overrides accept bytes and off" {    const bytes = try parseOverride("skill_chunk_bytes=4096");    try std.testing.expectEqual(Name.skill_chunk_bytes, bytes.name);    try std.testing.expectEqual(@as(usize, 4096), bytes.value.bytes);     const off = try parseOverride("mcp_description_bytes=off");    try std.testing.expectEqual(Name.mcp_description_bytes, off.name);    try std.testing.expectEqual(emergency_ceiling_bytes, off.value.effectiveBytes());} test "context limit overrides reject unknown names and malformed values" {    try std.testing.expectError(error.UnknownContextLimit, parseOverride("wat=1"));    try std.testing.expectError(error.InvalidContextLimitValue, parseOverride("skill_chunk_bytes=-1"));    try std.testing.expectError(error.InvalidContextLimitOverride, parseOverride("skill_chunk_bytes"));} test "line safe prefix preserves utf8 and complete lines when possible" {    try std.testing.expectEqual(@as(usize, 4), lineSafePrefixLength("one\ntwo\n", 7));    try std.testing.expectEqual(@as(usize, 0), lineSafePrefixLength("éclair", 1));    try std.testing.expectEqual(@as(usize, 2), lineSafePrefixLength("éclair", 2));    try std.testing.expectEqual(@as(usize, 3), lineSafePrefixLength(&.{ 'a', 'b', 'c', 0xe4 }, 4));}