rename: affinescript.ownership → typedwasm.ownership (producer-neutral) (#65)

## Summary
- Renames the wasm custom section `affinescript.ownership` →
`typedwasm.ownership` in `OWNERSHIP_SECTION_NAME`.
- Producer-neutral name: removes the brand coupling that embedded one of
typed-wasm's producers' names in the verifier's wire format.
- Updates all comments, docs, integration tests, and the aspect-test
assertion that checks the constant against doc claims.

## Sibling PRs (coordinated hard-flip)
- **typed-wasm** (this PR): source-of-truth constant +
comments/docs/tests.
- **affinescript**: codegen, `tw_verify`, `tw_interface`, `affine-js`
loader, tea bridges, CLI output.
- **ephapax**: bump the `typed-wasm-verify` rev pin to this PR's merge
SHA + 6 comment updates.

Producer PRs land after this one merges (they need the new constant
value).

## Test plan
- [x] `cargo test -p typed-wasm-verify` → 43 unit + 10 cross_compat
passing.
- [x] `node tests/aspect/claim-envelope.mjs` → 57 assertions passing.
- [ ] No `.wasm` fixtures tracked in this repo — nothing to regenerate.

Refs: estate disentangling — AffineScript and Ephapax must be
independent; typed-wasm must be removable from either with no impact.
Removing the producer brand from the wire format is the first concrete
step.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Author: hyperpolymath

LEVEL-STATUS.md

@@ -115,7 +115,7 @@ codegen actually obeys the discipline.
 
 `crates/typed-wasm-verify/` (added 2026-05-15) closes that loop on the
 **post-codegen** side. Given a wasm module plus an
-`affinescript.ownership` custom section, the crate runs a per-path
+`typedwasm.ownership` custom section, the crate runs a per-path
 `(min, max)` use-range analysis over every function body and reports
 L7 (aliasing) + L10 (linearity) violations. It's a second line of
 defence: the source-level checker enforces the rules during compilation;
@@ -138,6 +138,6 @@ L1-L6, L13-L16 enforcement on emitted wasm is future work.
 **Consumers** (live as of 2026-05-15):
 
 - `hyperpolymath/ephapax:src/ephapax-wasm/` — emits the
-  `affinescript.ownership` section on every compile
+  `typedwasm.ownership` section on every compile
 - `hyperpolymath/ephapax:src/ephapax-cli/` — exposes the verifier via
   `ephapax compile --verify-ownership`

crates/typed-wasm-verify/README.md

@@ -5,7 +5,7 @@ Post-codegen verifier for typed-wasm **L7 (aliasing safety)** and **L10 (lineari
 
 ## What it does
 
-Given a wasm module that carries an `affinescript.ownership` custom section, this crate:
+Given a wasm module that carries an `typedwasm.ownership` custom section, this crate:
 
 1. **Intra-function check** — walks every function body and computes per-path `(min_uses, max_uses)` for each parameter. Linear params must be `(1, 1)` on every path; ExclBorrow params must have `max_uses ≤ 1`.
 2. **Cross-module check** — given a callee's exported ownership interface plus a caller module that imports those functions, verifies that Linear-param imports are invoked exactly once per execution path.

crates/typed-wasm-verify/src/cross.rs

@@ -205,7 +205,7 @@ mod tests {
     };
 
     /// Build a callee module with one exported function `name` whose
-    /// param kinds are recorded in an `affinescript.ownership` section.
+    /// param kinds are recorded in an `typedwasm.ownership` section.
     /// The function body is trivial (just returns).
     fn callee_module(export_name: &str, param_kinds: Vec<OwnershipKind>) -> Vec<u8> {
         let n_params = param_kinds.len() as u32;

crates/typed-wasm-verify/src/lib.rs

@@ -3,7 +3,7 @@
 // typed-wasm post-codegen verifier.
 //
 // Statically verifies typed-wasm L7 (aliasing safety) and L10 (linearity)
-// on emitted wasm modules. Reads the `affinescript.ownership` custom
+// on emitted wasm modules. Reads the `typedwasm.ownership` custom
 // section, then runs per-path min/max use-range analysis on every
 // function body in the module.
 //
@@ -26,7 +26,7 @@ pub use section::{
 pub use verify::{count_uses_range, verify_function};
 
 /// Ownership kinds matching the OCaml `Codegen.ownership_kind` enum.
-/// Wire encoding in the `affinescript.ownership` custom section: a single
+/// Wire encoding in the `typedwasm.ownership` custom section: a single
 /// u8 per kind, values 0/1/2/3 as below.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum OwnershipKind {
@@ -121,16 +121,17 @@ pub enum VerifyError {
     Cross(Vec<CrossError>),
 }
 
-/// Custom-section name carrying ownership annotations. Matches the OCaml
-/// emitter (`Codegen.build_ownership_section`) and reader.
-pub const OWNERSHIP_SECTION_NAME: &str = "affinescript.ownership";
+/// Custom-section name carrying ownership annotations. Producer-neutral as
+/// of the 2026-05-26 rename; both AffineScript (`Codegen.build_ownership_section`)
+/// and Ephapax (`ephapax-wasm`) emit and read this name.
+pub const OWNERSHIP_SECTION_NAME: &str = "typedwasm.ownership";
 
 // ----------------------------------------------------------------------
 // Public entry points (stubbed in C1; implementations land in C2-C4).
 // ----------------------------------------------------------------------
 
 /// Verify the L7+L10 ownership constraints on a wasm module by reading its
-/// embedded `affinescript.ownership` custom section. Returns `Ok(())` when
+/// embedded `typedwasm.ownership` custom section. Returns `Ok(())` when
 /// no violations are found; modules without the section verify trivially.
 ///
 /// Rust port of OCaml `Tw_verify.verify_from_module`.

crates/typed-wasm-verify/src/section.rs

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MPL-2.0
 //
-// `affinescript.ownership` custom-section codec.
+// `typedwasm.ownership` custom-section codec.
 //
 // Wire format (little-endian, byte-aligned):
 //
@@ -30,7 +30,7 @@ pub struct OwnershipEntry {
     pub ret_kind: OwnershipKind,
 }
 
-/// Parse the `affinescript.ownership` custom-section payload into
+/// Parse the `typedwasm.ownership` custom-section payload into
 /// structured entries.
 ///
 /// Matches OCaml `Tw_verify.parse_ownership_section_payload` exactly,
@@ -58,7 +58,7 @@ pub fn parse_ownership_section_payload(payload: &[u8]) -> Vec<OwnershipEntry> {
         .collect()
 }
 
-/// Encode entries to the `affinescript.ownership` custom-section
+/// Encode entries to the `typedwasm.ownership` custom-section
 /// payload format. The inverse of `parse_ownership_section_payload` for
 /// any input that doesn't truncate.
 ///

crates/typed-wasm-verify/src/verify.rs

@@ -268,7 +268,7 @@ pub fn verify_function(
 // ----------------------------------------------------------------------
 
 /// Verify the L7+L10 ownership constraints across an entire wasm
-/// module by reading its embedded `affinescript.ownership` custom
+/// module by reading its embedded `typedwasm.ownership` custom
 /// section. Modules without the section verify trivially.
 ///
 /// Rust port of OCaml `Tw_verify.verify_from_module`.
@@ -396,7 +396,7 @@ mod tests {
     /// — `wasm_encoder::Function` adds it automatically). The function
     /// has `n_params` i32 params, no return value.
     ///
-    /// Optionally embeds an `affinescript.ownership` custom section
+    /// Optionally embeds an `typedwasm.ownership` custom section
     /// claiming the function (at global index 0, since there are no
     /// imports) has the given param kinds.
     fn module_with_body(

crates/typed-wasm-verify/tests/cross_compat.rs

@@ -21,7 +21,7 @@
 //      The Rust verdict asserted here must match the OCaml one;
 //      divergence either side is a parity bug.
 //   3. **Anchor the wire format** — the fixtures emit the exact same
-//      `affinescript.ownership` custom-section bytes that
+//      `typedwasm.ownership` custom-section bytes that
 //      `Codegen.build_ownership_section` would emit, exercising the C2
 //      codec end-to-end.
 //
@@ -56,7 +56,7 @@ use wasm_encoder::{
 // ----------------------------------------------------------------------
 
 /// Builder for an `affinescript`-shaped module with multiple functions
-/// and an `affinescript.ownership` custom section.
+/// and an `typedwasm.ownership` custom section.
 struct ModuleBuilder {
     types: TypeSection,
     funcs: FunctionSection,

docs/arxiv/typed-wasm.tex

@@ -1135,7 +1135,7 @@ \subsection{AffineScript TEA: Navigation History as a Linear Type}
 where $\multimap$ is the linear function arrow from QTT
 (Section~\ref{sec:formal}).  Every \texttt{update} call consumes the old
 model and the incoming message exactly once, producing a fresh model.  The
-\texttt{affinescript.ownership} custom section records the linearity kind
+\texttt{typedwasm.ownership} custom section records the linearity kind
 (0 = Unrestricted, 1 = Linear) for each function parameter, enabling the
 typed-wasm verifier to enforce the invariant statically.
 
@@ -1164,7 +1164,7 @@ \subsection{AffineScript TEA: Navigation History as a Linear Type}
 \texttt{PresentPopup}, \texttt{DismissPopup}, and \texttt{Resize}.
 The \texttt{screen\_tag} parameter of \texttt{Push}, the \texttt{popup\_tag}
 of \texttt{PresentPopup}, and both dimension arguments of \texttt{Resize}
-are annotated \textbf{Linear} in the \texttt{affinescript.ownership}
+are annotated \textbf{Linear} in the \texttt{typedwasm.ownership}
 custom section.  This means each message is consumed exactly once per
 navigation event.  The typed-wasm verifier rejects any module that attempts
 to re-send the same tag value without an intervening update.
@@ -1184,7 +1184,7 @@ \subsection{AffineScript TEA: Navigation History as a Linear Type}
 
 \paragraph{Verification result.}
 The router module passes \texttt{WebAssembly.validate}.  The
-\texttt{affinescript.ownership} section is checked by the AffineScript
+\texttt{typedwasm.ownership} section is checked by the AffineScript
 toolchain at code-generation time; the typed-wasm Level~10 checker
 additionally verifies at load time that no function parameter marked
 \texttt{kind=1} (Linear) is reachable via two distinct call paths within

tests/aspect/claim-envelope.mjs

@@ -177,10 +177,10 @@ for (const [name, byte] of expectedWire) {
 }
 
 // Section name constant
-if (/OWNERSHIP_SECTION_NAME:\s*&str\s*=\s*"affinescript\.ownership"/.test(libRs)) {
-  ok("OWNERSHIP_SECTION_NAME = \"affinescript.ownership\" (matches doc claims)");
+if (/OWNERSHIP_SECTION_NAME:\s*&str\s*=\s*"typedwasm\.ownership"/.test(libRs)) {
+  ok("OWNERSHIP_SECTION_NAME = \"typedwasm.ownership\" (matches doc claims)");
 } else {
-  bad("OWNERSHIP_SECTION_NAME constant drifted from \"affinescript.ownership\"");
+  bad("OWNERSHIP_SECTION_NAME constant drifted from \"typedwasm.ownership\"");
 }
 
 // ----------------------------------------------------------------------