# coding: utf-8
from pathlib import Path
import hashlib,json,shutil
R=Path('/Users/korizatou114/Projects/とりにく工房ゲーム制作部');A=R/'artifacts/original-completion-2026-10-02';C=A/'p23-02-native-integer-window-codec-candidate-r285';P=A/'p23-02-native-pure-tag-projection-candidate-r274/source';assert not C.exists();assert shutil.disk_usage(A).free>=528*1048576
(C/'source').mkdir(parents=True);original=(P/'tree_numeric_core.cpp').read_text();text=original
helpers=r'''
    // Godot ed1daf0bf's integer Array wire layout; checked against this engine
    // once per core, never sample values. Every caller-owned Array stays intact.
    bool integer_wire_checked=false;
    bool integer_wire_compatible=false;
    static void wire32(uint8_t *p,uint32_t value) {
        for (unsigned i=0;i<4;++i) p[i]=uint8_t(value>>(8*i));
    }
    static void wire64(uint8_t *p,uint64_t value) {
        for (unsigned i=0;i<8;++i) p[i]=uint8_t(value>>(8*i));
    }
    static int64_t integer_wire_width(int64_t value) {
        return value<int64_t(INT32_MIN) || value>int64_t(INT32_MAX) ? 12 : 8;
    }
    static void wire_integer(uint8_t *p,int64_t value) {
        const bool wide=integer_wire_width(value)==12;
        wire32(p,uint32_t(Variant::INT) | (wide ? uint32_t(1)<<16 : 0));
        if (wide) wire64(p+4,uint64_t(value)); else wire32(p+4,uint32_t(value));
    }
    static bool integer_wire_encode(const Array &values,PackedByteArray &out) {
        const bool typed=values.is_typed();
        if (typed && (values.get_typed_builtin()!=Variant::INT ||
                !values.get_typed_class_name().is_empty() || values.get_typed_script().get_type()!=Variant::NIL)) return false;
        const int64_t count=values.size(),header=typed ? 12 : 8;
        // The engine encoder uses a signed-int byte length. Preserve fallback
        // for oversized inputs and failed allocations, before owner mutation.
        if (count<0 || count>(int64_t(INT32_MAX)-header)/12) return false;
        std::vector<int64_t> integers;
        integers.reserve(size_t(count));
        int64_t size=header;
        for (int64_t i=0;i<count;++i) {
            const Variant value=values[i];
            if (value.get_type()!=Variant::INT) return false;
            const int64_t integer=value;
            integers.push_back(integer);size+=integer_wire_width(integer);
        }
        if (out.resize(size)!=OK) return false;
        uint8_t *p=out.ptrw();
        wire32(p,uint32_t(Variant::ARRAY) | (typed ? uint32_t(1)<<16 : 0));
        int64_t offset=4;
        if (typed) {wire32(p+offset,uint32_t(Variant::INT));offset+=4;}
        wire32(p+offset,uint32_t(count));offset+=4;
        for (const int64_t value: integers) {wire_integer(p+offset,value);offset+=integer_wire_width(value);}
        return offset==size;
    }
    bool integer_wire_ready() {
        if (integer_wire_checked) return integer_wire_compatible;
        Array empty,probe;
        TypedArray<int64_t> typed_empty,typed_probe;
        const int64_t boundaries[]={INT64_MIN,int64_t(INT32_MIN)-1,INT32_MIN,-1,0,1,INT32_MAX,int64_t(INT32_MAX)+1,INT64_MAX};
        for (const int64_t value: boundaries) {probe.append(value);typed_probe.append(value);}
        bool matches=true;
        for (const Array &value: {empty,probe,Array(typed_empty),Array(typed_probe)}) {
            PackedByteArray encoded;
            matches=integer_wire_encode(value,encoded) && encoded==UtilityFunctions::var_to_bytes(value) && matches;
        }
        integer_wire_compatible=matches;integer_wire_checked=true;
        return matches;
    }
    static bool integer_wire_update(const PackedByteArray &before,bool typed,int64_t old_count,
            int64_t appended,bool pop_front,PackedByteArray &after) {
        const int64_t header=typed ? 12 : 8;
        if (before.size()<header || old_count<0) return false;
        const bool remove_appended=pop_front && old_count==0;
        int64_t skipped=0;
        if (pop_front && old_count>0) {
            if (before.size()<header+8) return false;
            // Exact INT header was produced locally from the current values.
            skipped=(before[header+2] & 1) ? 12 : 8;
            if (before.size()<header+skipped) return false;
        }
        const int64_t added=remove_appended ? 0 : integer_wire_width(appended);
        const int64_t size=before.size()-skipped+added;
        if (size>INT32_MAX || after.resize(size)!=OK) return false;
        uint8_t *p=after.ptrw();const uint8_t *q=before.ptr();
        std::memcpy(p,q,size_t(header));
        wire32(p+header-4,uint32_t(old_count+1-(pop_front ? 1 : 0)));
        const int64_t kept=before.size()-header-skipped;
        if (kept>0) std::memcpy(p+header,q+header+skipped,size_t(kept));
        if (added>0) wire_integer(p+header+kept,appended);
        return true;
    }
'''
text=text.replace('#include <cmath>','#include <cmath>\n#include <cstdint>\n#include <cstring>',1)
needle='    std::map<I, std::vector<Edge>> cached_edges;';assert text.count(needle)==1;text=text.replace(needle,needle+helpers,1)
needle='        ClassDB::bind_method(D_METHOD("performance_record_sample", "owner", "metric_id", "duration_us"), &TheTreeNumericCore::performance_record_sample);';assert text.count(needle)==1
text=text.replace(needle,needle+'\n        ClassDB::bind_method(D_METHOD("encode_integer_window", "values"), &TheTreeNumericCore::encode_integer_window);',1)
needle='    // Whole builtin integer record operation.'
method='''    Dictionary encode_integer_window(const Array &values) {
        Dictionary result;const StringName supported("supported",false),bytes("bytes",false);
        result[supported]=false;PackedByteArray encoded;
        if (!integer_wire_ready() || !integer_wire_encode(values,encoded)) return result;
        result[supported]=true;result[bytes]=encoded;return result;
    }
'''
assert text.count(needle)==1;text=text.replace(needle,method+needle,1)
old='        for (int64_t i=0;i<values.size();++i) if (values[i].get_type()!=Variant::INT) return unsupported;';assert text.count(old)==1;text=text.replace(old,'',1)
old='        PackedByteArray before=UtilityFunctions::var_to_bytes(values);';assert text.count(old)==1
new='''        PackedByteArray before;
        const bool fast_wire=integer_wire_ready() && integer_wire_encode(values,before);
        if (!fast_wire) {
            for (int64_t i=0;i<values.size();++i) if (values[i].get_type()!=Variant::INT) return unsupported;
            before=UtilityFunctions::var_to_bytes(values);
        }
        const int64_t old_count=values.size();
''';text=text.replace(old,new.rstrip(),1)
old='        PackedByteArray after=UtilityFunctions::var_to_bytes(values);';assert text.count(old)==1
new='''        PackedByteArray after;
        const bool popped=old_count+1>int64_t(capacityv);
        if (!fast_wire || !integer_wire_update(before,values.is_typed(),old_count,duration,popped,after))
            after=UtilityFunctions::var_to_bytes(values);''';text=text.replace(old,new,1)
(C/'source/tree_numeric_core.cpp').write_text(text);shutil.copyfile(P/'tree_core.hpp',C/'source/tree_core.hpp')
def pin(p):b=p.read_bytes();return dict(path=str(p),bytes=len(b),sha256=hashlib.sha256(b).hexdigest())
D=R/'docs/plans/original-completion-2026-10-02'
with (C/'input.json').open('x') as f:json.dump(dict(parent_cpp=pin(P/'tree_numeric_core.cpp'),parent_header=pin(P/'tree_core.hpp'),candidate_cpp=pin(C/'source/tree_numeric_core.cpp'),candidate_header=pin(C/'source/tree_core.hpp'),author=pin(Path(__file__)),primary_encoder=pin(A/'p23-02-integer-window-codec-source-r284/marshalls.cpp'),primary_encoder_reference=pin(A/'p23-02-integer-window-codec-source-r284/source.json'),budget=pin(A/'p23-02-native-budget-record-candidate-r257-r04/performance_budget.candidate.gd'),ledger_review=pin(A/'p23-02-progress-integration-actual-independent-review-r282.json'),doc4={n:pin(D/n) for n in ['IMPLEMENTATION_PLAN.md','PROGRESS_INTEGRATION.md','work_packages.json','progress_snapshot.json']},scope='source-only integer Array exact bytes encode and append/pop transformation; per-object engine format check, no cached sample values; old encoding fallback retained; report/values/thresholds/notifications/typed/ownership unchanged; performance and load unproven',engine_runs=0,compiler_runs=0,stage_clones=0,candidate_adopted=False,unit_accepted=False),f,ensure_ascii=False,indent=2)
print('source candidate prepared; source-only, no build or engine')