@fraczak/k 6.10.5 → 7.0.0

package/Examples/karatsuba-mult.k

@@ -2,23 +2,22 @@
 -- Self-contained and minimal implementation
 -- for arbitrary-precision integers
 
-$ yes_no = < {} yes, {} no >;
-yes = {} | yes $yes_no;
-no = {} | no $yes_no;
+yes = {} | yes;
+no = {} | no;
 
-$ bits = < {} _, bits 0, bits 1 >;
+bits = ?< {} _, bits 0, bits 1 > = bits;
 0b = {} | _;
 0 = 0b |0;
 1 = 0b |1;
 
-$ unat = < {} _, unat 1 >;
-0u = {} | _ $unat;
+unat = ?< {} _, unat 1 > = unat;
+0u = {} | _;
 
-empty = $bits < /_ yes, no >;
+empty = < /_ yes, no >;
 empty? = {empty /yes if, () then} .then;
 
 inv = {()x, 0b r} _inv;
-_inv = ${bits x, bits r}
+_inv = ?{ <X 0, X 1, {} _>=X x, ... }
 <
   {.x empty? if, .r then} .then,
   <
@@ -27,8 +26,8 @@ _inv = ${bits x, bits r}
   > _inv
 >;
 
-concat = ${bits x, bits y} {.x inv x, .y y} concat_;
-concat_ = ${bits x, bits y}
+concat = {.x inv x, .y y} concat_;
+concat_ = ?{ <X 0, X 1, {} _>=X x, ... }
 <
   {.x empty? if, .y then} .then,
   <
@@ -40,21 +39,18 @@ concat_ = ${bits x, bits y}
 remove_leading_zeros = < /0 remove_leading_zeros, () >;
 nat = remove_leading_zeros <empty? 0, ()>;
 
-$ int = < bits '+', bits '-' >;
-int = nat | '+' $int;
-abs = $int </'+', /'-'>;
+int = nat | '+';
+abs = </'+', /'-'>;
 
-$ sign = < {} '+', {} '-' >;
-sign_plus = {} | '+' $sign;
-sign_minus = {} | '-' $sign;
+sign_plus = {} | '+';
+sign_minus = {} | '-';
 swap_sign = < /'+' | '-', /'-' | '+' >;
 
-$ carry = < {} 0, {} 1 >;
-c0 = {} | 0 $carry;
-c1 = {} | 1 $carry;
+c0 = {} | 0;
+c1 = {} | 1;
 
 _plus = {.x x, .y y, .c c, 0b r} _plus_;
-_plus_ = ${bits x, bits y, carry c, bits r}
+_plus_ = ?{ <X 0, X 1, {} _>=X x, ... }
 <
   {.x empty? if, .y empty? and, .c/0 c, .r inv then} .then,
   {.x empty? if, .y empty? and, {.r x, 1 r} _inv then} .then,
@@ -74,7 +70,7 @@ _plus_ = ${bits x, bits y, carry c, bits r}
 >;
 
 _minus = {.x x, .y y, .c c, 0b r} _minus_;
-_minus_ = ${bits x, bits y, carry c, bits r}
+_minus_ = ?{ <X 0, X 1, {} _>=X x, ... }
 <
   {.y empty? if, .c/0 and, {.r x, .x r} _inv then} .then,
   <
@@ -91,10 +87,10 @@ _minus_ = ${bits x, bits y, carry c, bits r}
   > _minus_
 >;
 
-plus_bits = ${bits x, bits y} {.x inv x, .y inv y, c0 c} _plus inv nat;
-minus_bits = ${bits x, bits y} {.x inv x, .y inv y, c0 c} _minus inv nat;
+plus_bits = {.x inv x, .y inv y, c0 c} _plus inv nat;
+minus_bits = {.x inv x, .y inv y, c0 c} _minus inv nat;
 
-_times = ${bits result, bits _x, bits y}
+_times = ?{ <Y 0, Y 1, {} _>=Y y, ... }
 <
   {.y empty? if, .result then} .then,
   <
@@ -102,21 +98,21 @@ _times = ${bits result, bits _x, bits y}
     {{._x x, .result |0 y, c0 c} _plus result, ._x _x, .y /1 y}
   > _times
 >;
-times_bits = ${bits x, bits y} {0 result, .x inv _x, .y y} _times inv nat;
+times_bits = {0 result, .x inv _x, .y y} _times inv nat;
 
-unat_to_zeros = $unat < /_ 0b, /1 unat_to_zeros |0 > $bits;
-unat_to_double_zeros = $unat
-  < /_ 0b, /1 unat_to_double_zeros |0 |0 > $bits;
+unat_to_zeros = ?< {} _, X 1 >=X < /_ 0b, /1 unat_to_zeros |0 > ?< {} _, Z 0, Z 1 >=Z;
+unat_to_double_zeros = ?< {} _, X 1 >=X
+  < /_ 0b, /1 unat_to_double_zeros |0 |0 > ?< {} _, Z 0, Z 1 >=Z;
 
 _peel2 = < </0,/1> </0,/1>, </0,/1>, () >;
-_half_unat = ${bits x, bits y, unat m}
+_half_unat = ?{ <X 0, X 1, {} _>=X x, ... }
 <
   {.x empty? if, .y empty? and, .m then} .then,
   {.x _peel2 x, .y _peel2 y, .m |1 m} _half_unat
 >;
 half_unat = {.x x, .y y, 0u m} _half_unat;
 
-_split_rev_u = ${bits x_rev, unat m, bits low}
+_split_rev_u = ?{ <X 0, X 1, {} _>=X x_rev, <M 1, {} _>=M m, ... }
 <
   {.m /_ if, {.low nat low, .x_rev inv nat high} then} .then,
   {.x_rev empty? if, {.low nat low, 0 high} then} .then,
@@ -147,19 +143,19 @@ at_least_256_u? = <
   yes, no
 >;
 
-shift_bits_u = ${bits val, unat m}
+shift_bits_u =
 <
   {.val empty? if, 0b then} .then,
   {.val x, .m unat_to_zeros y} concat
 >;
 
-shift2_bits_u = ${bits val, unat m}
+shift2_bits_u =
 <
   {.val empty? if, 0b then} .then,
   {.val x, .m unat_to_double_zeros y} concat
 >;
 
-_karatsuba = ${bits x, bits y}
+_karatsuba = ?{ <X 0, X 1, {} _>=X x, <Y 0, Y 1, {} _>=Y y }
 <
   -- Base case: if m < 256 (< 512 bits), fall back to times_bits
   {{.x x, .y y} half_unat m, .x x, .y y}
@@ -198,7 +194,7 @@ _karatsuba = ${bits x, bits y}
   >
 >;
 
-karatsuba = ${int x, int y}
+karatsuba =
 {
   <
     {.x/'+' if, .y /'+' and} sign_plus,

package/Examples/nat.k

@@ -1,10 +1,9 @@
-$ nat = < {} 0, nat +1 >;
 0 = {} | 0 ;
-0? = $ nat { / 0 if, () then} .then;
-succ = | +1 $ nat ;
-pred = $nat / +1 ;
-add = ?{ $nat x, ... } = X <{.x pred x, .y succ y} ?X add, .y> ;
-mult = <
+0? = { / 0 if, () then} .then;
+succ = | +1 ;
+pred = / +1 ;
+add = ?{ < {} 0, N +1 > = N x, ... } = X <{.x pred x, .y succ y} ?X add, .y> ;
+mult = ?{ < {} 0, M +1 > = M x, ... } <
     {{.x pred x, .y y} mult x, .y y} add,
     0
 > ;

package/README.md

@@ -1,15 +1,15 @@
 # k
 
-**k is a small language for typed data transformations.**
+**k is a small language for content-addressable schemas and data transformations.**
 
-It describes data as algebraic shapes, programs as first-order partial
-functions, and runtime values as a binary `pattern + value` stream
-that can be parsed, transformed, printed, compiled, and inspected.
+It describes data as algebraic schemas, programs as first-order partial
+relations, and runtime values as a self-describing binary `schema + payload`
+stream that can be parsed, transformed, printed, compiled, and inspected.
 
-Data descriptions and transformations share one syntax, so a k file can
-define both the shapes of values and the relations that move between them.
+Schema definitions and transformations share one syntax, so a k file can
+define both data schemas and the relations that transform between them.
 
-k is experimental, but it already has a working parser, type-derivation
+k is experimental, but it already has a working parser, contract-derivation
 engine, REPL, binary codec pipeline, object/library format, Node.js API,
 and test suite.
 
@@ -17,23 +17,23 @@ and test suite.
 
 Many systems need to answer the same questions:
 
-- What shape does this data have?
-- Which transformations are valid for that shape?
-- What does a program accept, produce, or reject?
-- Can this transformation be serialized, tested, reused, or inspected?
+- What schema does this data have?
+- Which transformations are valid for that schema?
+- What does a program accept, produce, or preserve?
+- Can this transformation be serialized, tested, reused, or verified?
 
-k explores a compact answer: define algebraic data shapes, compose
-partial transformations over them, derive input/output patterns
-automatically, and move values across process boundaries with a canonical
-binary representation.
+k explores a compact answer: define algebraic schemas, compose
+partial relations over them, derive input/output contracts
+automatically, and move values across process boundaries with a canonical,
+content-addressable binary representation.
 
 That makes k interesting as a foundation for:
 
-- schema definitions and schema-to-schema transformations
+- content-addressable schema registries and schema-to-schema pipelines
 - binary codecs and canonical serialization
 - protocol, hardware, or test-vector transformation pipelines
-- teaching algebraic data types and compositional programming
-- research into partial functions, finite tree automata, and typed IRs
+- teaching algebraic data types and compositional relational programming
+- research into partial relations, finite tree automata, and typed IRs
 
 ## A Small Example
 
@@ -41,11 +41,10 @@ k can define recursive data and transformations in the same file. Peano
 natural numbers are either `0` or one more than another natural number:
 
 ```k
-$ nat = < {} 0, nat +1 >;
-0 = {} | 0 $ nat ;
-inc = | +1 $ nat ;
-dec = $ nat / +1 ;       # undefined for '0'
-add = $ { nat x, nat y } <
+0 = {} | 0;
+inc = | +1;
+dec = / +1;       # undefined for '0'
+add = ?{ < {} 0, N +1 > = N x, ... } <
   { . x dec x, . y inc y } add,    # defined if 'x > 0'
   . y                              # else, return 'y'
 >;
@@ -53,7 +52,8 @@ add = $ { nat x, nat y } <
 
 `add` takes a product `{ x, y }`. If `x` has a `+1`, it moves that
 successor from `x` to `y` and recurses. When that no longer applies, it
-returns `y`.
+returns `y`. The inductive filter `?{ < {} 0, N +1 > = N x, ... }`
+explicitly witnesses that recursive calls shrink `x`.
 
 In the REPL:
 
@@ -118,12 +118,13 @@ Every installed command supports `-h` and `--help`.
 
 **Algebraic data shapes**
 
-Types, called *codes*, are built from products and tagged unions:
+All data structures in k are built from products and tagged unions (variants).
+Relations and pattern filters describe their domains:
 
 ```k
-$ bit  = < {} 0, {} 1 >;
-$ byte = { bit 0, bit 1, bit 2, bit 3, bit 4, bit 5, bit 6, bit 7 };
-$ bits = < {} _, bits 0, bits 1 >;
+bit  = ?< {} 0, {} 1 >;
+byte = ?{ Bit 0, Bit 1, Bit 2, Bit 3, Bit 4, Bit 5, Bit 6, Bit 7 };
+bits = ?< {} _, bits 0, bits 1 > = bits;
 ```
 
 There are no built-in primitive values. The empty product `{}` is the
@@ -137,34 +138,38 @@ Core expressions are deliberately small:
 | --- | --- |
 | `.field` | project a product field |
 | `/tag` | project a tagged-union branch |
-| `\|tag` | introduce a tagged-union branch |
+| `\|tag` | introduce a variant (tagged union) |
 | `(f g)` | compose transformations |
 | `<f, g>` | try `f`, then `g` if `f` is undefined |
 | `{f a, g b}` | build a product from parallel transformations |
+| `?filter` | schema filter / inductive termination witness |
 | `()` | identity |
 | `<>` | always undefined |
 | `{}` | constant empty product |
 
-**Derived input/output patterns**
+**Derived relational contracts**
 
-k derives structural constraints for expressions. Those patterns become
-useful for diagnostics, REPL output, binary encoding, and object
-metadata.
+k derives structural contracts for relations. A contract is a connected
+$(input, output)$ schema graph that specifies accepted input schemas,
+guaranteed output schemas, and preserved data structures ($=X$). Those
+contracts guide diagnostics, REPL output, binary serialization, and
+optimizations.
 
-**Binary-friendly runtime values**
+**Self-describing binary streams**
 
 The command-line pipeline uses a self-describing binary stream:
 
 ```text
-encoded pattern, followed by value encoded under that pattern
+encoded schema, followed by payload encoded under that schema
 ```
 
 The boundary tools are:
 
 ```bash
-k-parse   # textual k value -> binary pattern+value stream
+k-parse   # textual k value -> binary schema+payload stream
 k         # apply a k expression or .k/.ko program to the stream
-k-print   # binary pattern+value stream -> textual value
+k-print   # binary schema+payload stream -> textual value
+k-show    # inspect decoded schema and payload value
 ```
 
 **Inspectable objects and libraries**
@@ -172,21 +177,21 @@ k-print   # binary pattern+value stream -> textual value
 `k` programs can be authored, compiled, and linked across four main
 file formats:
 
-- `.k`: human-readable source code defining algebraic types and relations.
-- `.klib`: ahead-of-time (AOT) type-checked library objects (`main: null`)
-  storing canonical relation definitions, type codes, and local aliases.
-- `.ko`: ahead-of-time (AOT) type-checked executable containers (`KOBJ\n`
-  magic header) with entrypoint `main: "__main__"`, skipping parsing and
-  type derivation at runtime.
+- `.k`: human-readable source code defining algebraic schemas and relations.
+- `.klib`: ahead-of-time (AOT) library objects (`main: null`) storing
+  canonical relation definitions, schemas, and local aliases.
+- `.ko`: ahead-of-time (AOT) executable containers (`KOBJ\n` magic header)
+  with entrypoint `main: "__main__"`, skipping parsing and contract
+  derivation at runtime.
 - `.kvm`: polymorphic register-IR template artifacts (`layer: "KVM-P"`)
-  carrying principal pattern graphs for instant runtime specialization
+  carrying principal schema contracts for instant runtime specialization
   (`specializeKVM`).
 
-In `k`, all relations and types are identified canonically by immutable
+In `k`, all relations and derived schemas are identified canonically by immutable
 content-addressed hashes (`@hash`). There is no global symbol namespace;
 friendly names (such as `plus`, `int`, or `5`) are local aliases stored
 in metadata. Similarly, there are no primitive numbers: numerical
-identifiers like `5` or `10` are nullary relations mapping `${} -> $bits`.
+identifiers like `5` or `10` are nullary relations mapping `{}` to `bits`.
 
 For a detailed guide to all four formats, commands, and workflows, see
 [DOCS/FILE_FORMATS.md](DOCS/FILE_FORMATS.md).
@@ -204,9 +209,9 @@ For a detailed guide to all four formats, commands, and workflows, see
 
 | Command | Purpose |
 | --- | --- |
-| `k-parse` | Convert textual k values to binary pattern+value streams |
-| `k-print` | Convert binary pattern+value streams back to textual values |
-| `k-show` | Pass a stream through while showing the decoded value/filter |
+| `k-parse` | Convert textual k values to binary schema+payload streams |
+| `k-print` | Convert binary schema+payload streams back to textual values |
+| `k-show` | Pass a stream through while showing the decoded payload and schema |
 
 **Built-in codecs**
 

package/TODO.md

@@ -17,37 +17,32 @@ This document details the issues, conceptual improvements, and completed enhance
 ## 2. Help Modal (`? Help` / `:help`) Overhaul
 
 ### Language Overview & Grammar Categorization
-- [x] **Language Overview**: Short, positive, accessible description: `k` is a concise language of types and relations (functions) over tree-like (JSON-like) documents.
-- [x] **Content-Addressed Identity**: Functions and types are identified by their canonical content hash (`@...`) derived directly from their structure; local names are just temporary aliases used for recursion and readability.
-- [x] **Three Clean Grammar Categories**:
+- [x] **Language Overview**: Short, positive, accessible description: `k` is a concise language of relations (functions) over tree-like (JSON-like) documents.
+- [x] **Content-Addressed Identity**: Relations are identified by their canonical content hash (`@...`) derived directly from their structure; local names are just temporary aliases used for recursion and readability.
+- [x] **Grammar Categories**:
    1. **Definitions (Local Aliases)**:
      - `name = relExpr;` — Relation alias (e.g. `swap = { . y x, . x y };`).
-     - `$ name = typeExpr;` &mdash; Type alias (e.g. `$ bool = < {} true, {} false >;`).
-  2. **Type Expressions (`typeExpr`)**: Schemas describing tree-like documents:
-     - `{ Type_1 label_1, ..., Type_k label_k }` &mdash; Product type of arity $k$ (labeled records, e.g. `{float64 x, string n}`; special case: `{}` is the 0-ary product).
-     - `< Type_1 tag_1, ..., Type_k tag_k >` &mdash; Union type of arity $k$ (tagged sum of variants, e.g. `<int ok, string err>`).
-     - `name` / `@hash` &mdash; Type reference.
-  3. **Relation Expressions (`relExpr`)**: Functions transforming an input document to an output document:
+   2. **Relation Expressions (`relExpr`)**: Functions transforming an input document to an output document:
      - `{ rel_1 label_1, ..., rel_k label_k }` &mdash; Product of arity $k$ (evaluates relations into record fields; special case: `{}` evaluates 0 relations, producing empty record `{}`).
      - `< rel_1, ..., rel_k >` &mdash; Union / ordered choice of arity $k$ (evaluates relations in order until one succeeds).
      - `( rel_1 ... rel_k )` &mdash; Composition of arity $k$ (sequentially composes relations; special case: `()` is the 0-ary composition denoting identity; parentheses can be omitted when non-empty: `f g`).
      - `. label` &mdash; Field projection (extracts field `label`).
      - `/ tag` &mdash; Variant branch projection (extracts payload of variant `tag`).
      - `| tag` &mdash; Variant constructor (wraps document into variant `tag`).
-     - `$ typeExpr` &mdash; Type constraint (asserts input matches schema; compile-time Type Error on mismatch).
+     - `? filterExpr` &mdash; Pattern filter (asserts input matches pattern; serves as inductive termination witness).
      - `name` / `@hash` &mdash; Relation reference.
 - [x] **Simplified Intro**:
   - Made arbitrary arity explicit across products `{...}`, unions `<...>`, and compositions `(...)`; explained `{}` and `()` as the natural 0-ary special cases; omitted the pattern/filter expressions table from the introductory reference.
 - [x] **Replaced Misleading Expressions & Snippets**:
   - Removed phantom concepts (`10` as literal, "bit-path", `{10 int x, 5 int y} plus` in default state).
-  - Added self-contained snippets (`{} | ok`, `not = < / true | false, / false | true >;`, `$ bool = < {} true, {} false >;`, `not = $ bool < / true | false, {} | true > $ bool;`, `swap = { . y x, . x y };`).
+  - Added self-contained snippets (`{} | ok`, `not = < / true | false, / false | true >;`, `bool = ?< {} true, {} false >;`, `not = bool ?X < / true | false, {} | true > ?X;`, `swap = { . y x, . x y };`).
 - [x] **Command Reference Table**:
   - Added `:time <expr>`.
   - Removed obsolete commands: `:rel <name> = expr`, `:val`, `:timing [on|off]`, `:codec define n t b`.
-  - Updated `:type <name>` to purely inspect and display type definitions (type definition is native via `$ name = typeExpr;`).
+  - Removed obsolete commands: `:type`, `:types`, `:code`, `:codes`.
   - Timing is now always enabled by default across all evaluations.
   - Updated `:input` documentation to note the interactive browser dialog.
-  - Clarified `:codes` (type aliases/hashes) and `:rels` (relation aliases).
+  - Clarified `:rels` (relation aliases).
 
 ---
 
@@ -56,15 +51,15 @@ This document details the issues, conceptual improvements, and completed enhance
 ### Concept Correction: External Format Adapters
 - [x] Reframed codecs as format adapters translating external text to/from $k$ values defined as pairs `(filter, tree)`.
 - [x] **Type-Specific Codecs**:
-  - `int`: Converts decimal integers to/from `$ int = < bits '+', bits '-' >`.
-  - `ieee`: Converts decimal floats to/from `$ float64` records (`sign`, `exponent`, `fraction`).
-  - `utf8`: Converts text to/from `$ string` (aliased to `$ utf8`), a list of Unicode scalar values (`$ unicode`) partitioned by Unicode planes.
+  - `int`: Converts decimal integers to/from `int = ?< bits '+', bits '-' >`.
+  - `ieee`: Converts decimal floats to/from `float64` records (`sign`, `exponent`, `fraction`).
+  - `utf8`: Converts text to/from `string` (aliased to `utf8`), a list of Unicode scalar values (`unicode`) partitioned by Unicode planes.
   - `unit`: Converts to/from `{}`.
 - [x] **Parameterized Codecs**:
   - `json`: JSON text is untyped; deserializing JSON requires a target $k$ type schema parameter (e.g. `:input {float64 x, string n} json`).
 - [x] **Custom Codec Studio**:
   - Updated explanation to emphasize pairs `(filter, tree)`.
-  - Fixed `yn` preset to provide self-contained type definition `$ bool = < {} true, {} false >;`.
+  - Fixed `yn` preset to provide self-contained relation definition `bool = ?< {} true, {} false >;`.
   - Fixed `blank` preset with proper Value payload formatting.
 
 ---
@@ -105,7 +100,7 @@ This document details the issues, conceptual improvements, and completed enhance
   - Verified via headless Chromium CDP automated tests that `#btn-help` is completely visible and interactable at narrow viewport widths (e.g. 600px).
 - [x] **Removed Obsolete Commands**:
   - Removed `:rel <name> = expr` and `:def` (relations are defined using native syntax `name = expr;`).
-  - Removed `:type <name> = <...>` definition syntax from `:type` (types are defined using native syntax `$ name = typeExpr;`; `:type <name>` remains for inspecting type definitions).
+  - Removed `:type`, `:types`, `:code`, `:codes` commands completely on `no-codes`.
   - Removed `:val` completely.
   - Removed `:timing [on|off]` (timing reporting is now permanently enabled by default for all evaluations; `:time <expr>` remains for explicit timing).
   - Removed `:codec define n t b` (custom codecs are created using the browser Custom Codec Studio UI or loaded from modules via `:codec load`).

package/browser/repl-browser.mjs

@@ -477,7 +477,7 @@ function showVfsFilePreview(filename) {
 function loadPreviewedFile() {
   if (!currentPreviewFile) return;
   closeVfsModal();
-  if (currentPreviewFile.endsWith(".mjs") || currentPreviewFile.startsWith("codecs/")) {
+  if (currentPreviewFile.endsWith(".mjs") || currentPreviewFile.endsWith(".js") || currentPreviewFile.startsWith("codecs/")) {
     executeCommand(`:codec load ${currentPreviewFile}`);
   } else {
     executeCommand(`:load ${currentPreviewFile}`);
@@ -498,32 +498,49 @@ function downloadPreviewedFile() {
   URL.revokeObjectURL(url);
 }
 
-// File Upload Handler
+// File Upload Handler (adds file to VFS without auto-loading)
 function handleFileUpload(file) {
-  const reader = new FileReader();
-  const isBinary = file.name.endsWith(".klib") || file.name.endsWith(".ko") || file.name.endsWith(".wasm");
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    const isBinary = file.name.endsWith(".klib") ||
+      file.name.endsWith(".ko") ||
+      file.name.endsWith(".wasm");
+
+    reader.onload = (e) => {
+      let data;
+      if (isBinary) {
+        data = new Uint8Array(e.target.result);
+      } else {
+        data = e.target.result;
+      }
+      setVfsFile(file.name, data);
+      appendSystemMessage(
+        `📁 Uploaded <b>${escapeHtml(file.name)}</b> into VFS (` +
+        `${(data.length / 1024).toFixed(1)} KB).`,
+        false,
+        true
+      );
+      if (vfsModal && vfsModal.classList.contains("open")) {
+        renderVfsFileList();
+        showVfsFilePreview(file.name);
+      }
+      resolve();
+    };
+
+    reader.onerror = () => {
+      appendSystemMessage(
+        `❌ Error reading file: ${file.name}`,
+        true
+      );
+      reject(reader.error || new Error("Failed to read file"));
+    };
 
-  reader.onload = (e) => {
-    let data;
     if (isBinary) {
-      data = new Uint8Array(e.target.result);
+      reader.readAsArrayBuffer(file);
     } else {
-      data = e.target.result;
+      reader.readAsText(file);
     }
-    setVfsFile(file.name, data);
-    appendSystemMessage(`📁 Uploaded <b>${escapeHtml(file.name)}</b> into VFS (${(data.length / 1024).toFixed(1)} KB).`);
-    if (file.name.endsWith("-codec.mjs") || file.name.endsWith("-codec.js") || file.name.includes("codec")) {
-      executeCommand(`:codec load ${file.name}`);
-    } else {
-      executeCommand(`:load ${file.name}`);
-    }
-  };
-
-  if (isBinary) {
-    reader.readAsArrayBuffer(file);
-  } else {
-    reader.readAsText(file);
-  }
+  });
 }
 
 // Export State as .klib
@@ -993,6 +1010,7 @@ if (typeof window !== "undefined") {
     getVfsFile,
     setVfsFile,
     getAllVfsFiles,
+    handleFileUpload,
     openCodecsModal,
     registerCodec,
     unregisterCodec

package/browser/shims/fs.mjs

@@ -25,10 +25,7 @@ function cleanPath(p) {
 }
 
 export function setVfsFile(path, content) {
-  let cleaned = cleanPath(path);
-  if (cleaned.endsWith(".mjs") && !cleaned.startsWith("codecs/")) {
-    cleaned = `codecs/${cleaned}`;
-  }
+  const cleaned = cleanPath(path);
   vfs.set(cleaned, content);
 }
 
@@ -58,11 +55,11 @@ const CURATED_VFS_FILES = [
   "ieee.k",
   "poly.k",
   "karatsuba-mult.k",
-  "codecs/json.mjs",
-  "codecs/utf8.mjs",
-  "codecs/int.mjs",
-  "codecs/unit.mjs",
-  "codecs/ieee.mjs"
+  "json.mjs",
+  "utf8.mjs",
+  "int.mjs",
+  "unit.mjs",
+  "ieee.mjs"
 ];
 
 export function getAllVfsFiles() {
@@ -74,7 +71,7 @@ export function getAllVfsFiles() {
   }
   for (const key of vfs.keys()) {
     if (key.endsWith("runtime.wat") || key.startsWith("backends/")) continue;
-    if (key.startsWith("Examples/")) continue;
+    if (key.startsWith("Examples/") || key.startsWith("codecs/")) continue;
     result.add(key);
   }
   return Array.from(result);