Deliver the shared offline core and Omarchy Fcitx5 installation

.agents/skills/inkflow-mixed-input-maintenance/references/rules.md

@@ -31,7 +31,7 @@ The implemented baseline. Recheck the sources linked from the [skill entrypoint]
 7. **Mixed decoding is native, filtering is customized.** The supplemental dictionary imports `pinyin_simp`; Rime's `script_translator` performs segmentation and sentence generation with completion disabled. Lua emits only candidates reaching the current segment end and containing both ASCII letters and non-ASCII bytes. Public rows still require every contiguous ASCII run in the output to be an exact entry in the admitted mixed dictionary, cached only for the current input. This prevents separately admitted fragments such as `WOMEN` and `S` from reconstructing an excluded `WOMENS`. The byte test assumes the dictionary's Chinese/English contents; it is not a general Han-script detector. Partial results and pure Chinese/English results are filtered out. Unknown Latin tails are not appended as a mixed fallback. The translator qualities `-0.5` for mixed and `-1` for standalone English shape the native stream but are not the final ordering policy for equivalent page candidates.
 8. **Personal mixed decoding uses real native spans.** `InkFlowRimeNative` registers `inkflow_mixed_personal` after every Rime initialization. For input up to `mixed_personal/max_input_length` (64 bytes by default), a one-row native predictive lookup prunes impossible prefixes; non-predictive lookup retains every exact, positively confirmed display variant from `inkflow_shared_english.userdb`. A real personal edge is inserted between native dictionary/syllabifier graphs of its actual surroundings; native `Poet` chooses a complete path through that edge. No input rewriting, invented syllable IDs, personal prefix completion, first-N lexicon scan, rebuild or new store is used. Mixed candidates retain component provenance and original input cursor spans. Their distinct read-only language has no corresponding Memory, so neither Chinese nor English learns the assembled sentence. The translator-lifetime reader never changes transactions during queries.
 9. **Ambiguity and boundaries use native spelling evidence.** An unmarked lowercase personal code is excluded if it is one letter or a complete sequence of normal native Pinyin spellings. Actual uppercase input supplies explicit English intent; stored uppercase display alone does not. Native normal spans in the uncut input reject cuts inside reachable surrounding syllables. Abbreviation, correction and fuzzy paths are not evidence for this rejection. Both surroundings need complete native coverage. Personal display is one printable nonspace ASCII run, including aliases such as `cpp` → `C++`; adjacent public ASCII output cannot join it. Public ASCII runs remain independently admitted. All exact display variants remain distinct. Preedit derives from real input slices and native formatting, and candidate text retains exact stored display. Over-limit input uses the ordinary Chinese/public paths. This general policy replaces the former personal short-code blacklist.
-10. **Compilation and Pinyin.** The dependency-only `easy_en` schema compiles literal English independently of Pinyin algebra. The mixed and primary schemas retain the `n/l` `ue`→`ve` and `j/q/x/y` `u`→`v` spelling derivations. `prepare-spelling.sh` and the dictionary update worker share `IFSpellingGenerator` to generate 32 dependency-only Chinese prisms for abbreviation, typo tolerance and three independent fuzzy pairs; all reuse the original Chinese table/user dictionary. Automatic typo aliases cannot occupy legal full syllables from the generated dictionary and the profile's normal/fuzzy equivalents. Native algebra guards the final aliases after combined typo transformations; legal-to-legal typos lose that automatic alias, while explicit fuzzy pairs remain available. The main schema includes the generated profile 2 algebra. The mixed schema has no generic abbreviation, so English words are not abbreviated. Abbreviation can add full-coverage Chinese candidates ahead of existing mixed results without changing ranking policy; test recall and exact selection instead of a fixed mixed first position. The main speller accepts upper/lower ASCII letters and declares space/apostrophe delimiters. These remain native Pinyin delimiters, not an English phrase-input API; `xi'an` continues to produce 西安.
+10. **Compilation and Pinyin.** The dependency-only `easy_en` schema compiles literal English independently of Pinyin algebra. The mixed and primary schemas retain the `n/l` `ue`→`ve` and `j/q/x/y` `u`→`v` spelling derivations. `prepare-spelling.sh` and the dictionary update worker share the Rust spelling generator under `Core/Portable/dictionary/` (the worker calls it through `IFSpellingGenerator`) to generate 32 dependency-only Chinese prisms for abbreviation, typo tolerance and three independent fuzzy pairs; all reuse the original Chinese table/user dictionary. Automatic typo aliases cannot occupy legal full syllables from the generated dictionary and the profile's normal/fuzzy equivalents. Native algebra guards the final aliases after combined typo transformations; legal-to-legal typos lose that automatic alias, while explicit fuzzy pairs remain available. The main schema includes the generated profile 2 algebra. The mixed schema has no generic abbreviation, so English words are not abbreviated. Abbreviation can add full-coverage Chinese candidates ahead of existing mixed results without changing ranking policy; test recall and exact selection instead of a fixed mixed first position. The main speller accepts upper/lower ASCII letters and declares space/apostrophe delimiters. These remain native Pinyin delimiters, not an English phrase-input API; `xi'an` continues to produce 西安.
 11. **Canonical English learning is isolated.** The original Chinese dictionary/translator and `pinyin_simp.userdb` remain independent. Standalone English uses Rime `Phrase`/`ShadowCandidate` selection learning in the named `inkflow_shared_english.userdb`. Records keep the exact displayed text with a lowercase normalized Latin lookup code, so `Hello` selected through `Hello` is recalled by `hello` without changing its display. Mixed decoding keeps its own user dictionary disabled and only reads exact committed records from that shared namespace; displaying or selecting a mixed candidate does not update the record. Only selecting a learnable standalone English candidate updates this namespace. Display, raw Return, cancellation, immediate undo, and ordinary Chinese selection do not learn English.
 12. **Selection and editing share the existing engine/controller.** Paging, number/space selection, backspace, cursor edits, cancellation and session isolation are not separate English features. Swift stores a display-to-native permutation and applies every selection through its original native index. A selected standalone English completion learns its canonical full dictionary code, not the typed prefix. Any selected prefix bypasses final ranking; clearing or ending a composition discards its bounded preceding context. Unknown metadata preserves native order, and partial candidates remain selectable in their original slots.
 13. **Explicit ASCII mode is native passthrough.** It does not consult either dictionary and remains available for excluded words. A standalone left Shift press-release toggles the requested mode; using left Shift as a modifier and pressing right Shift do not toggle. Shift and menu changes wait for the current composition to commit or cancel. ASCII punctuation is literal and does not overwrite the persisted Chinese punctuation preference. The compilation-only English/mixed/spelling schemas do not add separate selectable input sources.

.github/workflows/ci.yml

@@ -67,10 +67,14 @@ jobs:
         run: bash Core/Portable/dictionary/test.sh
 
   scripts:
-    name: Remote runner tests
+    name: Script and frontend helper tests
     runs-on: ubuntu-24.04
     timeout-minutes: 10
     steps:
       - uses: actions/checkout@v5
       - name: Test scripts/mac-remote.py
         run: python3 -B scripts/tests/test_mac_remote.py
+      - name: Test Linux installer and frontend helpers
+        run: |
+          python3 -B Linux/scripts/test_install.py
+          bash Linux/fcitx5/test.sh

Core/Package.swift

@@ -60,7 +60,13 @@ let package = Package(
         .executableTarget(name: "AIAdoptionLearningTests", dependencies: ["InkFlowDomain", "InkFlowRime", "InkFlowCoreTestSupport"], path: "Tests/AIAdoptionLearningTests", swiftSettings: strictSwiftSettings, linkerSettings: buildRimeRuntime),
         .executableTarget(name: "RankingTests", dependencies: ["InkFlowRankingTestSupport"], path: "Tests/RankingTests", swiftSettings: strictSwiftSettings, linkerSettings: buildRimeRuntime),
 
-        .target(name: "InkFlowDomain", swiftSettings: strictSwiftSettings),
+        .target(name: "InkFlowDictionary", path: "Sources/InkFlowDictionary",
+                publicHeadersPath: "include",
+                cSettings: [.unsafeFlags(["-I\(repository.path)/build/dictionary/include"])],
+                linkerSettings: [.unsafeFlags(["-L\(repository.path)/build/dictionary/cargo/release"]),
+                    .linkedLibrary("inkflow_dictionary"), .linkedLibrary("resolv"), .linkedLibrary("iconv")]),
+        .target(name: "InkFlowDomain", dependencies: ["InkFlowDictionary"], path: "Sources/InkFlowDomain",
+                swiftSettings: strictSwiftSettings),
         .target(name: "CRime", dependencies: ["InkFlowRimeNative"], publicHeadersPath: "include",
                 cSettings: strictCSettings + [.unsafeFlags(["-I\(dependencyRoot)/include"])],
                 linkerSettings: rimeLinkerSettings),

Core/Portable/Cargo.toml

@@ -7,3 +7,9 @@ build = "build.rs"
 
 [lib]
 path = "src/lib.rs"
+crate-type = ["rlib", "cdylib", "staticlib"]
+
+[dependencies]
+serde_json = "=1.0.151"
+unicode-normalization = "=0.1.25"
+unicode-segmentation = "=1.13.3"