Address review comments on submodule support

Submodule tables were stored under the wrong name
-------------------------------------------------
`create_table_from_def_with_prefix` set a submodule table's canonical name from
its *accessor* name and then dropped the alias entirely. Accessor names exist
for client codegen; the host must never key on them. This made the host resolve
submodule tables by a codegen-only name and left `st_table_accessor` with no row
to recover the real accessor from.

The view path already did this correctly and said so in a comment, so the two
disagreed with each other; codegen had the same split, emitting
`prefix + accessor_name` as a table's wire name but `prefix + name` for views.
It was invisible only because accessor == canonical in the test fixture.

Submodule tables are now stored as `prefix + canonical name`, with the accessor
name kept as a namespaced alias, matching root tables. `check_compatible` goes
back to an exact name match rather than accepting either name.
`submodule_table_is_stored_under_canonical_name` covers this with a
case-converted name, where the two actually differ.

Local names were recovered by splitting on the last `.`
-------------------------------------------------------
`check_compatible` recovered an index, constraint, sequence or schedule function's
local name with `rsplit('.')`. A V9 sub-object name may itself contain dots -- the
`wacky_names` test builds `"wacky.index()"` -- so the last segment is not the local
name, and republishing such a module failed with "Index 0 not found in definition".
Master compared the stored name to `def.name` outright and was unaffected.

Now that every def records the namespace it is mounted under, the local name is
recovered by stripping exactly that prefix, via `NamespacePath::strip_from`, which
borrows rather than allocating. `wacky_names` covers the round-trip.

The table-name check was loose in the same place: it compared only the last segment,
so a table stored as `lib.my_table` validated against a root def named `my_table`.
It now checks the whole name, and `check_compatible_submodule_table_name` covers a
def actually mounted in `lib`.

The related *panic* is gone too: `auto_migrate_indexes` and friends built keys with
`Identifier::new(name).expect("names in a validated ModuleDef are valid identifiers")`,
which aborts outright on `"wacky.index()"`. Keying by `(namespace, name)` removes the
need to parse the name at all.

`ModuleDefLookup::key()` restored
---------------------------------
That naming split is why `key()` had to go: a table had two candidate keys.
With it fixed, each def records the `NamespacePath` its module is mounted under
(stamped by `ModuleDef::apply_namespace` once the module tree is assembled) and
its key is `(namespace, name)` -- a `Copy` pair, so `AutoMigrateStep` and
`AutoMigratePrecheck` go back to borrowing `Key<'def>` as they do on master.

The local name is stored once; the qualified form is built where it is actually
needed, which is the few places that hand a name to the database. That is 19
`format!`s at the same migration and table-creation sites this PR already had
them. They are per migration step and per table, never per row, and
`table_id_from_name` already allocates an owned `AlgebraicValue::String` to probe
the index, so the marginal cost is one short string on top of one that was
unavoidable.

Sub-objects (indexes, sequences, constraints) key on `(namespace, local name)`
rather than a dot-joined name, because a V9 sub-object name may itself contain
dots -- `wacky_names` covers exactly that -- and `stored_in_table_def` already
maps a sub-object to its table, so the key does not need to name the table.
Schedules are 1:1 with tables, so a table's key identifies its schedule.

`ModuleDef` now knows the path it is mounted under, so a namespaced key resolves
relative to whichever module it is looked up in -- from the root, or from the
submodule that owns the def.

This replaces the `find_*_by_full_name(&str)` helpers, which scanned every table
in the tree and `format!`ed each candidate, with `find_table`, `find_view` and
`find_storing_table`, which take keys and walk the submodule tree by segment.
`ensure_same_schema` filtered submodule steps with `name.contains('.')`; it now
asks whether the namespace is empty.

Type safety for namespaced names
--------------------------------
`RawIdentifier` was used for dot-delimited names, which is wrong: a name
containing `.` can never be validated into one `Identifier`. Add
`RawNamespacedIdentifier` and use it where a name may carry a namespace:
`TableName`, `SqlIdent`, index/constraint/sequence names and their `st_*` rows,
and query-planner relvar names. `ScheduleSchema::function_name` becomes a
`NamespacedIdentifier`.

`ReducerName` becomes fully qualified, so `local()` gives the name within its own
module and the `Deref<str>` gives the wire name. Previously it held a single
`Identifier`, so converting it to a `NamespacedIdentifier` yielded a one-segment
name -- `verify_token`, not `myauth.verify_token`.

The v1/v2 websocket message types are deliberately left as `RawIdentifier`.
They have always carried the table name as an opaque string and this feature
does not change that, so the narrowing happens at the boundary in `core` rather
than churning a published protocol crate.

This removes the `rsplit('.')` "bare name" hacks in `schema.rs` in favour of
`local_name()`, and namespace prefixing now goes through typed
`NamespacePath::{join, join_raw, join_namespaced}` instead of `format!` into a
`RawIdentifier`.

`Identifier::new_assume_valid` is renamed to `new_unsafe_assume_valid` so it
reads as the escape hatch it is; the schedule-name call site that used it to
smuggle a dotted name into an `Identifier` is gone.

Note this makes `TxDataTableEntry` and `MutTxId` grow, which the static size
assertions record. `TableName` and `ReducerName` wrap a `NamespacedIdentifier`,
which stores both the segments and their joined rendering. Those names genuinely
are qualified -- they are the database and wire identities -- so shrinking them
would mean changing how `NamespacedIdentifier` itself is represented.

Host boundary
-------------
`InstanceOp::name()` returned an owned `NamespacedIdentifier`, so every call
cloned; it returns a reference again. `ProcedureOp`/`HttpHandlerOp` build theirs
once at construction and `ReducerOp` borrows its `ReducerName`. Only
`start_funcall`, which takes the name by value, still clones. `start_funcall`
itself took `&str`/`RawIdentifier` and now takes a `NamespacedIdentifier` in v8,
wasmtime and `wasm_instance_env`.

A submodule reducer is now named by its qualified name in logs and metrics
rather than its bare local name.

Also fixes stale-view backing-table recreation, which iterated only root views
and looked them up in `st_view` by local name, so submodule views were never
repaired.

TypeScript
----------
- camelCase throughout `lib_submodule.ts`, `index.ts` and the submodules doc
- drop the `Anonymous extends true ? ... : ...` generic on `registerView` and
  split it into `registerView` / `registerAnonymousView`, removing the
  `as unknown as ViewFn<any, any, any>` cast; what remains is a single
  documented schema-erasure assertion per flavour
- generated internals use `__`-prefixed names (`__qb`, `__reducerAccessors`,
  `__procedureAccessors`), matching the rest of the emitted code
- the docs' subscription example used `addQuery`, which this branch removed

The camelCase rename is to the TypeScript *exports*; the wire name is the
canonical snake_case form and does not change. The docs now spell that out,
since the HTTP and CLI paths take the canonical name while the generated
bindings expose the camelCase accessor.
`submodule_reducer_wire_name_is_qualified_once` pins the codegen side, as no
snapshot fixture mounts a submodule.

Other
-----
- restore the step-ordering note inside `AutoMigrateStep` where it was
- restore the named bindings in `successful_auto_migration` to shrink the diff
- drop an unrelated `sender` -> `s` rename in the view-call path
- `RawNamespacedIdentifier::segments` collected a `Vec` per call to be an
  `ExactSizeIterator`; no caller reads the size, so it just yields the `split`
- the docs said a submodule view is reachable as `<namespace>.<viewName>` in SQL.
  SQL takes the canonical snake_case name; only the generated bindings expose the
  camelCase accessor

Author: cloutiertyler

crates/bench/src/spacetime_raw.rs

@@ -69,7 +69,7 @@ impl BenchDatabase for SpacetimeRaw {
                             IndexSchema {
                                 index_id: IndexId::SENTINEL,
                                 table_id,
-                                index_name: column.name.clone().unwrap(),
+                                index_name: column.name.clone().unwrap().into(),
                                 index_algorithm: IndexAlgorithm::BTree(BTreeAlgorithm {
                                     columns: ColId(i as _).into(),
                                 }),

crates/bindings-typescript/src/server/views.ts

@@ -51,7 +51,7 @@ export function makeViewExport<
     fn.bind() as ViewExport<F>;
   viewExport[exportContext] = ctx;
   viewExport[registerExport] = (ctx, exportName) => {
-    registerView(ctx, opts, exportName, false, params, ret, fn);
+    registerView(ctx, opts, exportName, params, ret, fn);
   };
   return viewExport;
 }
@@ -73,7 +73,7 @@ export function makeAnonViewExport<
     fn.bind() as ViewExport<F>;
   viewExport[exportContext] = ctx;
   viewExport[registerExport] = (ctx, exportName) => {
-    registerView(ctx, opts, exportName, true, params, ret, fn);
+    registerAnonymousView(ctx, opts, exportName, params, ret, fn);
   };
   return viewExport;
 }
@@ -194,28 +194,64 @@ export type ViewReturnTypeBuilder =
 
 export function registerView<
   S extends UntypedSchemaDef,
-  const Anonymous extends boolean,
   Params extends ParamsObj,
   Ret extends ViewReturnTypeBuilder,
 >(
   ctx: SchemaInner,
   opts: ViewOpts,
   exportName: string,
-  anon: Anonymous,
   params: Params,
   ret: Ret,
-  fn: Anonymous extends true
-    ? AnonymousViewFn<S, Params, Ret>
-    : ViewFn<S, Params, Ret>
+  fn: ViewFn<S, Params, Ret>
+) {
+  const described = describeView(ctx, opts, exportName, false, params, ret);
+  // `ctx.views` is schema-erased. `ViewCtx<S>` and `ViewCtx<any>` describe the same
+  // shape, but TypeScript cannot relate two instantiations of the mapped type
+  // `ReadonlyDbView` while the schema is still a type parameter, so erasing `S` here
+  // needs an assertion. It is sound because the runtime builds the context it passes
+  // back in from this very schema.
+  ctx.views.push(buildViewInfo(ctx, described, fn as AnyViewFn));
+}
+
+export function registerAnonymousView<
+  S extends UntypedSchemaDef,
+  Params extends ParamsObj,
+  Ret extends ViewReturnTypeBuilder,
+>(
+  ctx: SchemaInner,
+  opts: ViewOpts,
+  exportName: string,
+  params: Params,
+  ret: Ret,
+  fn: AnonymousViewFn<S, Params, Ret>
+) {
+  const described = describeView(ctx, opts, exportName, true, params, ret);
+  // Schema-erased for the same reason as `registerView` above.
+  ctx.anonViews.push(buildViewInfo(ctx, described, fn as AnyAnonymousViewFn));
+}
+
+/**
+ * The flavor-independent part of registering a view: register its types, record
+ * it in the module def, and validate its primary key. Everything here is the
+ * same for regular and anonymous views, so it is factored out of both.
+ */
+function describeView<
+  Params extends ParamsObj,
+  Ret extends ViewReturnTypeBuilder,
+>(
+  ctx: SchemaInner,
+  opts: ViewOpts,
+  exportName: string,
+  anon: boolean,
+  params: Params,
+  ret: Ret
 ) {
   ctx.defineFunction(exportName);
   const paramsBuilder = new RowBuilder(params, toPascalCase(exportName));
 
   // Register return types if they are product types
   let returnType = ctx.registerTypesRecursively(ret).algebraicType;
 
-  const { typespace } = ctx;
-
   const { value: paramType } = ctx.resolveType(
     ctx.registerTypesRecursively(paramsBuilder)
   );
@@ -255,24 +291,39 @@ export function registerView<
     });
   }
 
-  // If it is an option, we wrap the function to make the return look like an array.
+  // An option-returning view is presented to the host as an array of zero or one
+  // rows, so its function needs wrapping and its return type rewriting.
+  const wrapOption = returnType.tag == 'Sum';
+  // Tested directly rather than via `wrapOption` so that TypeScript narrows `returnType`.
   if (returnType.tag == 'Sum') {
-    const originalFn = fn;
-    fn = ((ctx: ViewCtx<S>, args: InferTypeOfRow<Params>) => {
-      const ret = originalFn(ctx, args);
-      return ret == null ? [] : [ret];
-    }) as any;
     returnType = AlgebraicType.Array(
       returnType.value.variants[0].algebraicType
     );
   }
 
-  (anon ? ctx.anonViews : ctx.views).push({
-    fn: fn as unknown as ViewFn<any, any, any>,
+  return { paramType, returnType, wrapOption };
+}
+
+// Build the stored `ViewInfo` for `fn`. Generic over the stored function type so
+// the regular and anonymous cases each keep their own context shape here, instead
+// of being collapsed into one type by a cast.
+function buildViewInfo<F extends (viewCtx: any, params: any) => any>(
+  ctx: SchemaInner,
+  { paramType, returnType, wrapOption }: ReturnType<typeof describeView>,
+  fn: F
+): ViewInfo<F> {
+  const { typespace } = ctx;
+  return {
+    fn: wrapOption
+      ? (((viewCtx, args) => {
+          const ret = fn(viewCtx, args);
+          return ret == null ? [] : [ret];
+        }) as F)
+      : fn,
     deserializeParams: ProductType.makeDeserializer(paramType, typespace),
     serializeReturn: AlgebraicType.makeSerializer(returnType, typespace),
     returnTypeBaseSize: bsatnBaseSize(typespace, returnType),
-  });
+  };
 }
 
 // Inspect the returned row builder and collect the column property names marked

crates/cli/src/subcommands/call.rs

@@ -285,7 +285,7 @@ fn add_reducer_procedure_ctx_to_err(error: &mut String, module_def: &ModuleDef,
         .all_reducers_with_prefix()
         .into_iter()
         .filter(|(_, _, r)| r.lifecycle.is_none())
-        .map(|(prefix, _, r)| format!("{prefix}{}", &*r.name))
+        .map(|(_, _, r)| r.name.to_string())
         .collect::<Vec<_>>();
     let reducers = reducer_names.iter().map(String::as_str).collect::<Vec<_>>();
 

crates/codegen/src/typescript.rs

@@ -320,7 +320,7 @@ impl Lang for TypeScript {
         }
         // Namespace tables from submodules
         for (prefix, owning_def, table) in &ns_tables {
-            let source_name = submodule_source_name(prefix, table.accessor_name.deref());
+            let source_name = submodule_source_name(prefix, table.name.deref());
             let row_type = submodule_row_type_name(prefix, table.accessor_name.deref());
             let type_ref = table.product_type_ref;
             writeln!(out, "\"{source_name}\": __table({{");
@@ -377,7 +377,8 @@ impl Lang for TypeScript {
             if !is_reducer_invokable(reducer) {
                 continue;
             }
-            let wire_name = format!("{}{}", prefix, reducer.name);
+            // `reducer.name` is already qualified; do not prefix it again.
+            let wire_name = reducer.name.to_string();
             let args_type = submodule_reducer_args_type_name(prefix, &reducer.accessor_name);
             writeln!(out, "__reducerSchema(\"{wire_name}\", {args_type}),");
         }
@@ -593,18 +594,18 @@ impl Lang for TypeScript {
                 );
             }
         } else {
-            writeln!(out, "const _qb = __makeQueryBuilder(tablesSchema.schemaType);");
+            writeln!(out, "const __qb = __makeQueryBuilder(tablesSchema.schemaType);");
             writeln!(out, "export const tables = {{");
             out.indent(1);
             // Root tables (use camelCase accessor, matching tablesSchema keys)
             for table in iter_tables(module, options.visibility) {
                 let key = table.accessor_name.deref().to_case(Case::Camel);
-                writeln!(out, "{key}: _qb.{key},");
+                writeln!(out, "{key}: __qb.{key},");
             }
             // Root views
             for view in iter_views(module) {
                 let key = view.accessor_name.deref().to_case(Case::Camel);
-                writeln!(out, "{key}: _qb.{key},");
+                writeln!(out, "{key}: __qb.{key},");
             }
             // Build and emit namespace tree
             let tree = build_ns_tree(&ns_tables, &ns_views);
@@ -622,7 +623,7 @@ impl Lang for TypeScript {
         } else {
             writeln!(
                 out,
-                "const _reducers = __convertToAccessorMap(reducersSchema.reducersType.reducers);"
+                "const __reducerAccessors = __convertToAccessorMap(reducersSchema.reducersType.reducers);"
             );
             writeln!(out, "export const reducers = {{");
             out.indent(1);
@@ -631,10 +632,10 @@ impl Lang for TypeScript {
                     continue;
                 }
                 let key = reducer.accessor_name.deref().to_case(Case::Camel);
-                writeln!(out, "{key}: _reducers.{key},");
+                writeln!(out, "{key}: __reducerAccessors.{key},");
             }
             let tree = build_reducer_ns_tree(&ns_reducers);
-            emit_fn_ns_tree(out, "_reducers", &tree);
+            emit_fn_ns_tree(out, "__reducerAccessors", &tree);
             out.dedent(1);
             writeln!(out, "}} as const;");
         }
@@ -652,16 +653,16 @@ impl Lang for TypeScript {
         } else {
             writeln!(
                 out,
-                "const _procedures = __convertToAccessorMap(proceduresSchema.procedures);"
+                "const __procedureAccessors = __convertToAccessorMap(proceduresSchema.procedures);"
             );
             writeln!(out, "export const procedures = {{");
             out.indent(1);
             for procedure in iter_procedures(module, options.visibility) {
                 let key = procedure.accessor_name.deref().to_case(Case::Camel);
-                writeln!(out, "{key}: _procedures.{key},");
+                writeln!(out, "{key}: __procedureAccessors.{key},");
             }
             let tree = build_procedure_ns_tree(&ns_procedures);
-            emit_fn_ns_tree(out, "_procedures", &tree);
+            emit_fn_ns_tree(out, "__procedureAccessors", &tree);
             out.dedent(1);
             writeln!(out, "}} as const;");
         }
@@ -1328,9 +1329,11 @@ fn table_module_name(table_name: &Identifier) -> String {
 }
 
 /// Source name (wire name) for a submodule namespace table/view.
-/// E.g. namespace="alias.", accessor_name="tableName" → "alias.tableName"
-fn submodule_source_name(namespace: &NamespacePath, accessor_name: &str) -> String {
-    format!("{}{}", namespace, accessor_name)
+///
+/// This is the *canonical* name, not the accessor name: it is what the host stores and
+/// what appears on the wire. E.g. namespace="lib.", name="fruit_basket" → "lib.fruit_basket".
+fn submodule_source_name(namespace: &NamespacePath, canonical_name: &str) -> String {
+    format!("{}{}", namespace, canonical_name)
 }
 
 /// TypeScript import symbol for a submodule namespace table/view row type.
@@ -1413,7 +1416,7 @@ fn build_ns_tree<'a>(
 ) -> BTreeMap<String, NsTree> {
     let mut tree: BTreeMap<String, NsTree> = BTreeMap::new();
     for (prefix, _, table) in ns_tables {
-        let source_name = submodule_source_name(prefix, table.accessor_name.deref());
+        let source_name = submodule_source_name(prefix, table.name.deref());
         let local = table.accessor_name.deref().to_case(Case::Camel);
         let segs: Vec<&str> = prefix.segments().iter().map(|s| &**s).collect();
         if let Some((first, rest)) = segs.split_first() {
@@ -1442,7 +1445,7 @@ fn emit_ns_tree(out: &mut Indenter, tree: &BTreeMap<String, NsTree>) {
         writeln!(out, "{ns}: {{");
         out.indent(1);
         for (qb_key, local_key) in &node.entries {
-            writeln!(out, "{local_key}: _qb[\"{qb_key}\"],");
+            writeln!(out, "{local_key}: __qb[\"{qb_key}\"],");
         }
         emit_ns_tree(out, &node.children);
         out.dedent(1);

crates/codegen/tests/codegen.rs

@@ -60,3 +60,29 @@ fn test_typescript_table_handles_are_camel_case() {
         r#"/** @deprecated Use `loggedOutPlayer` instead. This alias will be removed in the next major version. */"#
     ));
 }
+
+/// A submodule reducer's wire name must be qualified exactly once.
+///
+/// `ReducerDef::name` is fully qualified, so any code that also prepends the namespace
+/// path would emit `lib.lib.libInsert`. Nothing in the snapshot fixtures mounts a
+/// submodule, so this checks the TypeScript output of one that does.
+#[test]
+fn submodule_reducer_wire_name_is_qualified_once() {
+    let module = CompiledModule::compile("module-test-ts", CompilationMode::Debug).extract_schema_blocking();
+    let code = generate(&module, &TypeScript, &CodegenOptions::default())
+        .into_iter()
+        .map(|f| f.code)
+        .collect::<Vec<_>>()
+        .join("\n");
+
+    let reducer_lines: Vec<_> = code.lines().filter(|l| l.contains("__reducerSchema(")).collect();
+    assert!(
+        code.contains(r#"__reducerSchema("lib.lib_insert""#),
+        "expected a singly-qualified wire name for the submodule reducer; got:\n{}",
+        reducer_lines.join("\n")
+    );
+    assert!(
+        !code.contains("lib.lib."),
+        "namespace was applied twice somewhere in the generated bindings"
+    );
+}

crates/core/src/client/messages.rs

@@ -17,6 +17,7 @@ use spacetimedb_lib::ser::serde::SerializeWrapper;
 use spacetimedb_lib::{AlgebraicValue, ConnectionId, TimeDuration, Timestamp};
 use spacetimedb_primitives::TableId;
 use spacetimedb_sats::bsatn;
+use spacetimedb_sats::raw_identifier::RawIdentifier;
 use spacetimedb_schema::table_name::TableName;
 use std::sync::Arc;
 use std::time::Instant;
@@ -608,7 +609,7 @@ impl ToProtocol for SubscriptionMessage {
                             query_id,
                             rows: ws_v1::SubscribeRows {
                                 table_id: result.table_id,
-                                table_name: result.table_name.into(),
+                                table_name: RawIdentifier::new(&*result.table_name),
                                 table_rows,
                             },
                         }
@@ -621,7 +622,7 @@ impl ToProtocol for SubscriptionMessage {
                             query_id,
                             rows: ws_v1::SubscribeRows {
                                 table_id: result.table_id,
-                                table_name: result.table_name.into(),
+                                table_name: RawIdentifier::new(&*result.table_name),
                                 table_rows,
                             },
                         }
@@ -639,7 +640,7 @@ impl ToProtocol for SubscriptionMessage {
                             query_id,
                             rows: ws_v1::SubscribeRows {
                                 table_id: result.table_id,
-                                table_name: result.table_name.into(),
+                                table_name: RawIdentifier::new(&*result.table_name),
                                 table_rows,
                             },
                         }
@@ -652,7 +653,7 @@ impl ToProtocol for SubscriptionMessage {
                             query_id,
                             rows: ws_v1::SubscribeRows {
                                 table_id: result.table_id,
-                                table_name: result.table_name.into(),
+                                table_name: RawIdentifier::new(&*result.table_name),
                                 table_rows,
                             },
                         }

crates/core/src/host/instance_env.rs

@@ -21,12 +21,12 @@ use spacetimedb_datastore::locking_tx_datastore::{FuncCallType, IndexScanPointOr
 use spacetimedb_datastore::traits::IsolationLevel;
 use spacetimedb_lib::{http as st_http, ConnectionId, Identity, Timestamp};
 use spacetimedb_primitives::{ColId, ColList, IndexId, TableId};
-use spacetimedb_sats::raw_identifier::RawIdentifier;
 use spacetimedb_sats::{
     bsatn::{self, ToBsatn},
     buffer::CountWriter,
     AlgebraicValue, ProductValue,
 };
+use spacetimedb_schema::identifier::NamespacedIdentifier;
 use spacetimedb_table::indexes::RowPointer;
 use spacetimedb_table::table::RowRef;
 use std::fmt::Display;
@@ -48,7 +48,7 @@ pub struct InstanceEnv {
     /// The type of the last, including current, function to be executed by this environment.
     pub func_type: FuncCallType,
     /// The name of the last, including current, function to be executed by this environment.
-    pub func_name: Option<RawIdentifier>,
+    pub func_name: Option<NamespacedIdentifier>,
     /// Are we in an anonymous tx context?
     in_anon_tx: bool,
     /// A procedure's last known transaction offset.
@@ -246,7 +246,7 @@ impl InstanceEnv {
     }
 
     /// Signal to this `InstanceEnv` that a function call is beginning.
-    pub fn start_funcall(&mut self, name: RawIdentifier, ts: Timestamp, func_type: FuncCallType) {
+    pub fn start_funcall(&mut self, name: NamespacedIdentifier, ts: Timestamp, func_type: FuncCallType) {
         self.start_time = ts;
         self.start_instant = Instant::now();
         self.func_type = func_type;