category_set( ) → void

Build a set of registered asset-type names so we can recognise a `<name>.<type>/` boundary. `asset.categories` answers from a cache keyed on the asset index's revision, and a miss walks every registered claim in the world, so one dispatch reads it once and hands the set to each resolver below rather than asking again per question.

enclosing_types(path: string, cats: { [string]: boolean }) → void

Every registered type whose asset ENCLOSES `path`, innermost last. `resolve_enclosing_asset` keeps only the innermost, which is the asset whose `onChange` owns the write. Containment is what makes that too narrow for anything keyed on an OUTER asset's content: a write to `Shop.dialogue/greeting.dialogueLine/init.luau` is a change to the LINE and equally a change to the DIALOGUE that contains it, and only the outer one knows it now has a different set of children.

is_directory(path: string) → boolean

Whether `path` is a DIRECTORY on the VFS. Discriminates a typed-asset FOLDER from a loose FILE whose extension happens to collide with a registered category name (a loose `foo.glb` when `glb` is a registered category, a loose `notes.json` against the `json` category) — the suffix match alone cannot tell them apart. One dispatch runs per applied source write, on every session bound to the world, so this asks about the ONE path written and costs what that write is rather than what the folder it landed in holds.

dispatch_loose(path: string, origin: string?) → void

Loose-file seam. When a written path has NO enclosing typed-asset folder (a bare `/source/foo.glb`), there's no per-type `onChange` to fire — but a write still happened, and some system may want to claim the orphan. This is the generic "a path owned by no asset type was written" hook. The importer SYSTEM is its first consumer: the importer assetType's shared module exposes `onLooseWrite(path, origin)` and decides whether a registered `.importer/` claims the file. The engine stays generic — it never names importers; this dispatcher only forwards the orphan write to the importer type's shared layer (resolved by name, exactly like `onChange` resolves a type's behavior).

dispatch(path: string, kind: string?, origin: string?) → void

Dispatch the asset-type change hook for a VFS path. Called by the engine for two orthogonal axes: - `kind`: a per-file EDIT (`"edited"`, `path` is the written file) vs an asset COMPLETION (`"seeded"`, `path` is the typed-asset folder, now fully present from a world seed). The type inspects `kind` to decide whether to filter by which file changed or act on the whole asset. - `origin`: `"local"` for a write made on this client, `"remote"` for a peer-synced write — forwarded so hooks can gate on it (importers run on the originator only). Resolves the typed asset, loads its `behavior.luau`, and invokes `onChange(ref, change)` (`change = { path, asset, type, kind, origin }`). When the path has no enclosing typed asset, forwards to the loose-file seam (`dispatch_loose`) so the importer system can claim orphan writes.

__zero_dispatch_asset_change("/zero/source/Goblin.dynamicAsset/prompt.json", "edited", "local")

dispatchDelete(path: string) → void

Dispatch the asset-type DELETE hook for a removed typed-asset FOLDER — the teardown counterpart of `dispatch`. `path` is the folder that was removed; this resolves its `<name>.<type>` identity, loads the type's `behavior.luau`, and invokes `onDelete(ref)` if defined (a `.component` unregisters its type). No-op when the path isn't a registered typed asset or the type defines no `onDelete`. The engine calls this via `ffi_callbacks::fire_asset_delete_dispatch` once per typed-asset folder removal.

__zero_dispatch_asset_delete("/zero/source/Spinner.component")