funicular 0.3.0 → 0.5.0

data/sig/component.rbs

@@ -17,6 +17,8 @@ module Funicular
       def error: (Symbol key) -> untyped
     end
 
+    include Tags
+
     attr_accessor props: Hash[Symbol, untyped]
     attr_accessor vdom: VDOM::VNode | VDOM::Text | nil
     attr_accessor dom_element: JS::Element
@@ -29,8 +31,13 @@ module Funicular
     type suspense_definition = { loader: untyped, on_resolve: untyped, min_delay: Integer? }
 
     def initialize: (?Hash[Symbol, untyped] props) -> void
+    def self.allow_dsl_override: (*Symbol names) -> void
+    def self.dsl_overrides: () -> Array[Symbol]
+    def self.method_added: (Symbol name) -> void
+    def self.validate_dsl_conflicts!: () -> void
     def self.styles: () { (StyleBuilder) -> void } -> void
     def self.styles_definitions: () -> Hash[Symbol, Hash[Symbol, untyped]]
+    def self.style_accessor_class: () -> singleton(StyleAccessor)
     def self.use_suspense: (Symbol name, untyped loader, ?on_resolve: untyped, ?min_delay: Integer) -> void
     def self.suspense_definitions: () -> Hash[Symbol, suspense_definition]
 
@@ -40,28 +47,42 @@ module Funicular
     def initialize_state: () -> Hash[Symbol, untyped]
     def seed_state: (Hash[untyped, untyped]? state_hash) -> self
 
+    @__watches: Hash[Symbol, Integer]?
+    def watch: (Symbol key) { () -> untyped } -> nil
+    def evaluate_watch: (Symbol key, untyped block) -> nil
+    def cleanup_watches: () -> nil
+
     def load_suspense_data: () -> void
     def load_single_suspense: (Symbol name, ?suspense_definition? definition) -> void
     def reload_suspense: (Symbol name) -> void
     def suspense_loading?: (*Symbol names) -> bool
     def suspense_error?: (Symbol name) -> bool
     def suspense_error: (Symbol name) -> untyped
-    def render_suspense: (ViewContext h, Symbol name, fallback: untyped, ?error: untyped) { (ViewContext, ResourceAccessor) -> untyped } -> untyped
+    def render_suspense: (Symbol name, fallback: untyped, ?error: untyped) { (ResourceAccessor) -> untyped } -> untyped
 
+    def navigation_guard: () -> String?
     def patch: (Hash[Symbol, untyped] new_state) -> void
     def mount: (JS::Element container) -> void
     def hydrate: (JS::Element dom_element) -> void
     def unmount: () -> void
-    def render: (ViewContext h) -> (VDOM::VNode | String | Integer | Float | Array[untyped] | nil)
+    def render: () -> (VDOM::VNode | String | Integer | Float | Array[untyped] | nil)
     def build_vdom: () -> (VDOM::VNode | VDOM::Text | nil)
 
     def bind_events: (JS::Element dom_element, VDOM::VNode | VDOM::Text | nil vnode) -> void
+    def report_handler_error: (String event_name, String handler, StandardError error) -> void
     def collect_refs: (JS::Element dom_element, VDOM::VNode | VDOM::Text | nil vnode, ?Hash[Symbol, JS::Element] refs_map) -> Hash[Symbol, JS::Element]
     def normalize_vnode_for_view: (untyped value) -> (VDOM::Element | VDOM::Text | VDOM::Component | nil)
+    def __view__: () -> ViewContext
+    def routes: () -> untyped
+    def component: (singleton(Component) component_class, ?Hash[Symbol, untyped] props) ?{ () -> untyped } -> VDOM::Component
+    def form_for: (Symbol model_key, ?Hash[Symbol, untyped] options) { (FormBuilder) -> void } -> VDOM::Element
+    def link_to: (String path, **untyped options) ?{ -> untyped } -> VDOM::Element
+    def button_to: (String path, ?method: Symbol, **untyped options) ?{ -> untyped } -> VDOM::Element
+    def suspense: (Symbol name, fallback: untyped, ?error: untyped) { (ResourceAccessor) -> untyped } -> untyped
     def add_child_from_view: (untyped child) -> void
     def build_form_for: (ViewContext h, Symbol model_key, ?Hash[Symbol, untyped] options) { (FormBuilder) -> void } -> VDOM::Element
-    def build_link_to: (ViewContext h, String path, **untyped options) { (ViewContext) -> untyped } -> VDOM::Element
-    def build_button_to: (ViewContext h, String path, ?method: Symbol, **untyped options) { (ViewContext) -> untyped } -> VDOM::Element
+    def build_link_to: (ViewContext h, String path, **untyped options) ?{ () -> untyped } -> VDOM::Element
+    def build_button_to: (ViewContext h, String path, ?method: Symbol, **untyped options) ?{ () -> untyped } -> VDOM::Element
 
     def component_will_mount: () -> void
     def component_mounted: () -> void

data/sig/db.rbs

@@ -0,0 +1,328 @@
+module Funicular
+  class RecordNotFound < StandardError
+  end
+
+  module DB
+    class Error < StandardError
+    end
+
+    class NoTableError < Error
+    end
+
+    class ReadOnlyTabError < Error
+    end
+
+    class ReplicaWriteError < Error
+    end
+
+    class SchemaTooNewError < Error
+    end
+
+    class UnavailableError < Error
+    end
+
+    class ConfigError < Error
+    end
+
+    self.@subscriptions: Hash[Integer, [Symbol, String, Proc]]?
+    self.@subscription_serial: Integer?
+    self.@deferral_depths: Hash[Symbol, Integer]?
+    self.@pending_seen: Hash[Symbol, Hash[String, bool]]?
+    self.@pending_orders: Hash[Symbol, Array[[Symbol, String]]]?
+    self.@tick_events: Hash[String, bool]?
+    self.@tick_order: Array[[Symbol, String]]?
+    self.@tick_generation: Integer?
+    self.@drain_scheduled: bool?
+    self.@tick_scheduler: Proc?
+
+    def self.subscribe: (Symbol role, untyped table) { (Symbol role, String table) -> void } -> Integer
+    def self.unsubscribe: (Integer id) -> nil
+    def self.notify_changed: (untyped target, ?untyped table) -> nil
+    def self.validate_role: (untyped role) -> Symbol
+    private def self.deferral_depth: (Symbol role) -> Integer
+    private def self.pending_seen: (Symbol role) -> Hash[String, bool]
+    private def self.pending_order: (Symbol role) -> Array[[Symbol, String]]
+    def self.__begin_deferral: (Symbol role) -> void
+    def self.__commit_deferral: (Symbol role) -> void
+    def self.__rollback_deferral: (Symbol role) -> void
+    private def self.clear_pending: (Symbol role) -> nil
+    private def self.enqueue_delivery: (Symbol role, String table) -> nil
+    def self.__set_tick_scheduler: (Proc? scheduler) -> Proc?
+    private def self.schedule_drain: () -> nil
+    def self.__drain_events: () -> nil
+    private def self.deliver_event: (Symbol role, String table, ?Integer? generation) -> void
+
+    class GuardedStatement
+      @stmt: untyped
+      @guard: GuardedDatabase
+
+      def initialize: (untyped stmt, GuardedDatabase guard) -> void
+      def bind_params: (*untyped bind_vars) -> untyped
+      def readonly?: () -> bool
+      def columns: () -> untyped
+      def close: () -> untyped
+      def closed?: () -> bool
+      def execute: (*untyped bind_vars) -> Array[untyped]
+      def step: () -> untyped
+
+      private def check_writable: () -> void
+    end
+
+    class GuardedResultSet
+      @rs: untyped
+      @stmt: untyped
+      @guard: GuardedDatabase
+
+      def initialize: (untyped rs, untyped stmt, GuardedDatabase guard) -> void
+      def next: () -> untyped
+      def each: () { (untyped row) -> void } -> GuardedResultSet
+      def to_a: () -> Array[untyped]
+      def reset: (*untyped bind_params) -> untyped
+      def eof?: () -> bool
+      def close: () -> untyped
+      def closed?: () -> bool
+      def columns: () -> untyped
+      def types: () -> untyped
+
+      private def check_writable: () -> void
+    end
+
+    def self.enforce_read_only: (bool read_only, untyped raw_stmt) -> void
+
+    class GuardedDatabase
+      @db: untyped
+      @role: Symbol
+      @read_only: bool
+
+      def initialize: (untyped db, ?Symbol role, ?bool read_only) -> void
+      def role: () -> Symbol
+      def read_only?: () -> bool
+      def __become_read_only: () -> void
+      def execute: (String sql, ?Array[untyped] bind_vars) ?{ (untyped row) -> void } -> untyped
+      def prepare: (String sql) ?{ (GuardedStatement stmt) -> untyped } -> untyped
+      def query: (String sql, ?Array[untyped] bind_vars) ?{ (GuardedResultSet result) -> untyped } -> untyped
+      def get_first_row: (String sql, ?Array[untyped] bind_vars) -> untyped
+      def get_first_value: (String sql, ?Array[untyped] bind_vars) -> untyped
+      def transaction: (?Symbol mode) ?{ (GuardedDatabase proxy) -> untyped } -> untyped
+      def commit: () -> bool
+      def rollback: () -> bool
+      private def __execute_control: (String sql) -> nil
+    end
+
+    TRANSACTION_CONTROL_WORDS: Array[String]
+    def self.guard_statement_sql: (untyped sql) -> void
+    private def self.statement_head: (untyped sql) -> String
+    private def self.pragma_name: (String s, Integer pos) -> String
+    private def self.skip_sql_blanks: (String s, Integer i) -> Integer
+    private def self.read_sql_word: (String s, Integer i) -> [String, Integer]
+    private def self.read_sql_token: (String s, Integer i) -> [String, Integer]
+    LOCK_SHIM_JS: String
+    self.@durability: Symbol?
+    self.@writer_lock_name: String?
+    self.@lock_shim_installed: bool?
+
+    def self.durability: () -> Symbol
+    def self.__set_durability: (Symbol state) -> Symbol
+    def self.elect_writer: (String lock_name) -> Symbol
+    private def self.install_lock_shim: () -> void
+    def self.release_writer_lock: () -> bool
+
+    class Config
+      @replica_debounce_ms: Integer
+      @local_debounce_ms: Integer
+      @request_persistent_storage: bool
+      @on_persist_error: Proc?
+      @on_boot_error: Proc?
+      @on_session_change: Proc?
+
+      attr_accessor replica_debounce_ms: Integer
+      attr_accessor local_debounce_ms: Integer
+      attr_accessor request_persistent_storage: bool
+      attr_accessor on_persist_error: Proc?
+      attr_accessor on_boot_error: Proc?
+      attr_accessor on_session_change: Proc?
+
+      def initialize: () -> void
+    end
+
+    self.@config: Config?
+    self.@databases: Hash[Symbol, [untyped, Array[untyped]]]?
+    self.@snapshot_identity: String?
+    self.@snapshot_store: untyped
+    self.@snapshot_store_unavailable: bool?
+    self.@persist_timers: Hash[Symbol, untyped]?
+    self.@persist_timer_tokens: Hash[Symbol, Integer]?
+    self.@persist_deferred: Hash[Symbol, bool]?
+    self.@persist_inflight: Integer?
+    self.@mutation_generation: Integer?
+    self.@visibility_hook_installed: bool?
+
+    SNAPSHOT_DB_NAME: String
+    STORAGE_PERSIST_JS: String
+
+    def self.config: () -> Config
+    def self.configure: () { () -> void } -> nil
+    def self.__reset_config: () -> nil
+    def self.__register_database: (Symbol role, untyped raw_db, Array[untyped] models) -> nil
+    def self.__registered_database: (Symbol role) -> untyped
+    def self.__set_snapshot_identity: (String? identity) -> String?
+    def self.__set_snapshot_store: (untyped store) -> untyped
+    def self.snapshot_store: () -> untyped
+    def self.open_snapshot_store: () -> untyped
+    private def self.__become_volatile: (untyped error) -> nil
+    private def self.report_persist_error: (untyped error) -> nil
+    private def self.invoke_persist_error_hook: (untyped error) -> nil
+    def self.mutation_generation: () -> Integer
+    def self.persist_snapshot: (Symbol role) -> bool
+    def self.restore_snapshot: (Symbol role) -> bool
+    private def self.schedule_persist: (Symbol role) -> nil
+    def self.__persist_timer_fired: (Symbol role, Integer? token) -> nil
+    def self.__persist_timer_token: (Symbol role) -> Integer?
+    private def self.resume_deferred_persist: (Symbol role) -> nil
+    def self.cancel_persist_timers: () -> nil
+    private def self.persist_inflight: () -> Integer
+    private def self.await_inflight_persists: () -> nil
+    def self.flush: () -> bool
+    def self.__install_visibility_hook: () -> bool
+    def self.__visibility_flush: () -> nil
+    def self.request_persistent_storage: () -> Symbol
+    def self.stale_generation?: (Integer token) -> bool
+    def self.stale_response_error: () -> Error
+
+    self.@boot_state: Symbol?
+    self.@session_epoch: untyped
+    self.@page_metadata: Hash[Symbol, untyped]?
+    self.@page_metadata_latched: bool?
+    self.@local_database_enabled: bool?
+    self.@local_database_latched: bool?
+    self.@local_handle: GuardedDatabase?
+    self.@replica_handle: GuardedDatabase?
+    self.@schema_lockdown: untyped
+
+    def self.boot_state: () -> Symbol
+    def self.__set_boot_state: (Symbol state) -> Symbol
+    def self.session_epoch: () -> untyped
+    PAGE_METADATA_JS: String
+
+    def self.boot: (?models: Array[untyped]?, ?metadata: Hash[Symbol, untyped]?) -> bool
+    def self.__fail_boot: (Array[untyped] errors) -> bool
+    def self.__report_boot_errors: (Array[untyped] errors) -> bool
+    def self.read_page_metadata: () -> Hash[Symbol, untyped]
+    def self.__page_metadata: () -> Hash[Symbol, untyped]
+    def self.local_database_enabled?: () -> bool
+    def self.__set_local_database_enabled: (untyped value) -> bool
+    def self.__ensure_local_database_enabled: (untyped operation) -> bool
+
+    self.@session_terminated: bool?
+    self.@page_epoch_latched: bool?
+
+    def self.__set_session_epoch: (untyped value) -> untyped
+    def self.__latch_page_epoch: () -> untyped
+    def self.session_terminated?: () -> bool
+    def self.__session_epoch_ok?: (String? header) -> bool
+    def self.__terminate_session: (String? header) -> nil
+    private def self.__boot_steps: (Array[untyped] models, Hash[Symbol, untyped] metadata) -> nil
+    private def self.ensure_boot_not_terminated: () -> nil
+    private def self.metadata_value: (Hash[Symbol, untyped]? metadata, Symbol key, untyped default) -> untyped
+    private def self.report_boot_error: (Array[untyped] errors) -> nil
+    private def self.__install_handles: (untyped local_db, untyped replica_db) -> nil
+    def self.local: () -> GuardedDatabase
+    def self.replica: () -> GuardedDatabase
+    def self.__model_local_db: (untyped model) -> GuardedDatabase
+    def self.__model_replica_db: () -> GuardedDatabase?
+    private def self.engage_schema_lockdown: (untyped db, untyped error) -> nil
+    def self.schema_lockdown: () -> untyped
+    private def self.__check_schema_lockdown: (String context) -> nil
+    def self.reset_local_table: (untyped model) -> bool
+    private def self.revalidate_schema_lockdown: (untyped db) -> nil
+    def self.__reset_boot: () -> nil
+    def self.wipe: () -> bool
+    private def self.tick_generation: () -> Integer
+    private def self.clear_tick_events: () -> nil
+    private def self.ensure_session_not_terminated: (Symbol operation) -> nil
+    private def self.ensure_not_in_transaction: (Symbol role) -> nil
+    private def self.wipe_role: (Symbol role) -> nil
+    private def self.notify_wiped: (Symbol role) -> nil
+    private def self.drop_all_tables: (untyped db) -> nil
+
+    def self.namespace_identity: (untyped application_id, untyped user_key, bool anonymous) -> String
+    def self.resolve_namespace: (application_id: untyped, user_key: untyped, user_key_configured: bool, anonymous_only: bool) -> String
+    def self.snapshot_key: (String identity, Symbol role) -> String
+    def self.lock_name: (String identity) -> String
+
+    module Codec
+      def self.encode: (Symbol? `type`, untyped value) -> untyped
+      def self.decode: (Symbol? `type`, untyped value) -> untyped
+      def self.encode_bind: (untyped value) -> untyped
+      def self.time_to_iso: (Time time) -> String
+      def self.iso_to_time: (String str) -> Time
+      def self.civil_from_days: (Integer days) -> Array[Integer]
+      def self.days_from_civil: (Integer y, Integer m, Integer d) -> Integer
+      def self.days_in_month: (Integer year, Integer mon) -> Integer
+      def self.zone_offset: (String str, Integer pos) -> Integer
+      def self.digits_at: (String str, Integer pos, Integer len) -> Integer
+      def self.sep_at: (String str, Integer pos, Integer code) -> void
+      def self.zpad: (Integer n, Integer width) -> String
+    end
+
+    class TableBuilder
+      @ops: Array[untyped]
+
+      attr_reader ops: Array[untyped]
+
+      def initialize: () -> void
+      def string: (untyped name, ?default: untyped, ?null: bool) -> void
+      def text: (untyped name, ?default: untyped, ?null: bool) -> void
+      def integer: (untyped name, ?default: untyped, ?null: bool) -> void
+      def float: (untyped name, ?default: untyped, ?null: bool) -> void
+      def boolean: (untyped name, ?default: untyped, ?null: bool) -> void
+      def datetime: (untyped name, ?default: untyped, ?null: bool) -> void
+      def timestamps: () -> void
+      def index: (*untyped columns) -> void
+      def remove_index: (*untyped columns) -> void
+      def rename: (untyped old_name, untyped new_name) -> void
+      def remove: (untyped name) -> void
+      def execute: (String sql) -> void
+
+      private def add_column: (Symbol `type`, untyped name, untyped default, bool null) -> void
+      private def identifier_list: (Array[untyped] columns) -> Array[String]
+    end
+
+    SQL_TYPES: Hash[Symbol, String]
+    META_TABLE: String
+    REPLICA_FINGERPRINT_KEY: String
+    self.@reserved_column_names: Array[Symbol]?
+
+    def self.validate_identifier: (untyped name) -> String
+    private def self.guard_reserved_table: (String table) -> String
+    private def self.baseline_index: (untyped migrations) -> Integer
+    def self.fold_local_columns: (untyped model) -> Hash[String, Symbol]
+    private def self.fold_builders: (Array[TableBuilder] builders, untyped migrations, untyped model) -> Hash[String, Symbol]
+    def self.apply_local_migrations: (untyped db, untyped model) -> Integer
+    def self.rebuild_local_table: (untyped db, untyped model, ?Array[TableBuilder]? builders) -> Integer
+    def self.stored_table_version: (untyped db, String table) -> Integer
+    def self.store_table_version: (untyped db, String table, Integer version) -> void
+    def self.read_meta: (untyped db, String key) -> String?
+    def self.store_meta: (untyped db, String key, String value) -> void
+    private def self.ensure_meta_table: (untyped db) -> void
+    def self.replica_table_ddl: (untyped model) -> String
+    def self.canonical_replica_schema: (Array[untyped] models) -> String
+    def self.build_replica_tables: (untyped db, Array[untyped] models) -> bool
+    private def self.stale_replica_tables: (String? stored) -> Array[String]
+    def self.replica_upsert: (untyped db, untyped model, Hash[untyped, untyped] attrs) -> bool
+    def self.replica_upsert_all: (untyped db, untyped model, Array[untyped] rows) -> bool
+    private def self.replica_upsert_row: (untyped db, untyped model, Hash[untyped, untyped] attrs) -> void
+    def self.replica_delete: (untyped db, untyped model, untyped id) -> bool
+    private def self.collect_builders: (untyped model) -> Array[TableBuilder]
+    private def self.fold_ops: (Hash[String, Symbol] columns, Array[untyped] ops, untyped model) -> void
+    private def self.guard_id: (String name, untyped model) -> void
+    private def self.guard_reserved_column: (String name, untyped model) -> void
+    private def self.apply_blocks: (untyped db, untyped model, Integer from_version, Array[TableBuilder] builders) -> void
+    private def self.run_block: (untyped db, String table, TableBuilder builder, bool create_mode) -> void
+    private def self.run_alter_op: (untyped db, String table, Array[untyped] op) -> void
+    private def self.column_ddl: (Array[untyped] op) -> String
+    private def self.default_literal: (Symbol `type`, untyped value) -> String
+    private def self.index_name: (String table, Array[String] columns) -> String
+    private def self.quoted_list: (Array[String] columns) -> String
+  end
+end

data/sig/error_boundary.rbs

@@ -5,10 +5,10 @@ module Funicular
     def initialize_state: () -> Hash[Symbol, untyped]
     def catch_error: (Exception error, ?Hash[Symbol, untyped]? error_info) -> bool
     def reset: () -> void
-    def render: (ViewContext h) -> (VDOM::VNode | String | Integer | Float | Array[untyped] | nil)
+    def render: () -> (VDOM::VNode | String | Integer | Float | Array[untyped] | nil)
 
-    private def render_fallback: (ViewContext h) -> (VDOM::VNode | String)
-    private def default_fallback: (ViewContext h) -> VDOM::VNode
-    private def render_children: (ViewContext h) -> VDOM::VNode
+    private def render_fallback: () -> (VDOM::VNode | String)
+    private def default_fallback: () -> VDOM::VNode
+    private def render_children: () -> VDOM::VNode
   end
 end

data/sig/funicular.rbs

@@ -8,6 +8,8 @@ module Funicular
   def self.env: () -> EnvironmentInquirer
   def self.env=: (EnvironmentInquirer | String environment) -> EnvironmentInquirer?
   def self.router: () -> Router?
+  def self.confirm_handler=: ((^(String) -> boolish)? handler) -> (^(String) -> boolish)?
+  def self.confirm: (String message) -> bool
 
   # SSR / hydration support
   def self.server?: () -> bool
@@ -17,6 +19,9 @@ module Funicular
   def self.first_element_child: (JS::Element container_element) -> JS::Element?
 
   def self.load_schemas: (Hash[singleton(Model), String] models) ?{ () -> void } -> void
+  def self.__request_schema: (untyped model_class, String schema_name, Array[untyped] errors, Proc settle) -> nil
+  def self.__settle_boot_barrier: (Array[untyped] errors) ?{ () -> void } -> nil
+  def self.__boot_for_start: () -> bool
   def self.start: (?singleton(Component)? component_class, ?container: String | JS::Element, ?props: Hash[Symbol, untyped], ?hydrate: bool) ?{ (Router router) -> void } -> (Component | Router | nil)
   def self.configure_forms: () ?{ (Hash[Symbol, String]) -> void } -> void
   def self.form_builder_config: () -> Hash[Symbol, String]?

data/sig/http.rbs

@@ -1,10 +1,5 @@
 module Funicular
   module HTTP
-    CACHE_DB_NAME: String
-    CACHE_STORE: String
-
-    self.@cache: IndexedDB::KVS?
-
     class Response
       attr_reader data: untyped
       attr_reader status: Integer
@@ -15,24 +10,16 @@ module Funicular
       def error_message: () -> String?
     end
 
-    def self.cache_init!: () -> IndexedDB::KVS
-    def self.cache_purge: (String url) -> nil
-    def self.cache_clear: () -> nil
-    def self.cache_lookup: (String url) -> untyped
-    def self.cache_write: (String url, Hash[String, untyped] entry) -> nil
-
-    def self.get: (String url, ?cache: Integer?) { (Response) -> void } -> void
-    def self.post: (String url, ?Hash[untyped, untyped]? body, ?cache: Integer?) { (Response) -> void } -> void
-    def self.patch: (String url, ?Hash[untyped, untyped]? body, ?cache: Integer?) { (Response) -> void } -> void
-    def self.delete: (String url, ?cache: Integer?) { (Response) -> void } -> void
-    def self.put: (String url, ?Hash[untyped, untyped]? body, ?cache: Integer?) { (Response) -> void } -> void
+    def self.get: (String url) { (Response) -> void } -> void
+    def self.post: (String url, ?Hash[untyped, untyped]? body) { (Response) -> void } -> void
+    def self.patch: (String url, ?Hash[untyped, untyped]? body) { (Response) -> void } -> void
+    def self.delete: (String url) { (Response) -> void } -> void
+    def self.put: (String url, ?Hash[untyped, untyped]? body) { (Response) -> void } -> void
     def self.csrf_token: () -> String?
 
-    private def self.warn_unsupported_cache: (String verb) -> void
-    private def self.now_seconds: () -> Integer
-    private def self.cache_hit?: (untyped entry, Integer ttl) -> bool
-    private def self.serve_from_cache: (Hash[String, untyped] entry) { (Response) -> void } -> void
     private def self.parse_response_body: (untyped text) -> untyped
-    private def self.request: (String method, String url, Hash[untyped, untyped]? body, ?cache: Integer?) { (Response) -> void } -> void
+    private def self.request: (String method, String url, Hash[untyped, untyped]? body) { (Response) -> void } -> void
+    private def self.session_changed_response: () -> Response
+    private def self.response_epoch: (untyped response) -> String?
   end
 end

data/sig/model.rbs

@@ -5,24 +5,118 @@ module Funicular
 
     attr_reader id: untyped
     @changed_attributes: Hash[String, untyped]
+    @local_baseline: Hash[String, untyped]?
+    @provided_attributes: Hash[String, bool]?
+
+    self.@registered_models: Array[untyped]?
+    self.@storage_kind: Symbol?
+    self.@local_migrations: Array[Hash[Symbol, untyped]]?
+    self.@collecting_migrations: bool?
+    self.@refresh_mode: Symbol?
+    self.@table_name: String?
+    self.@associations: Hash[Symbol, Hash[Symbol, untyped]]?
+    self.@local_columns: Hash[String, Symbol]?
 
     def self.schema: () -> Hash[String, Hash[String, untyped]]
     def self.schema=: (Hash[String, Hash[String, untyped]] schema) -> Hash[String, Hash[String, untyped]]
     def self.endpoints: () -> Hash[String, Hash[String, String]]
     def self.endpoints=: (Hash[String, Hash[String, String]] endpoints) -> Hash[String, Hash[String, String]]
 
+    def self.inherited: (untyped subclass) -> void
+    def self.__register_model: (untyped subclass) -> nil
+    def self.__registered_models: () -> Array[untyped]
+
     def initialize: (?Hash[untyped, untyped] attributes) -> void
     def self.load_schema: (Hash[String, untyped] schema_data) -> void
     def self.register_schema_validations: (untyped validations) -> void
     def self.normalize_validation_options: (Symbol | String kind, untyped opts) -> untyped
 
-    def self.all: (?Hash[untyped, untyped] params) ?{ (Array[Model]? instances, String? error) -> void } -> void
-    def self.find: (?untyped id, ?endpoint_name: String, ?model_class: singleton(Model)) ?{ (Model? instance, String? error) -> void } -> void
-    def self.create: (Hash[untyped, untyped] attrs, ?model_class: singleton(Model)) ?{ (Model? instance, untyped error) -> void } -> void
-    def self.destroy: (?untyped id) ?{ (bool success, untyped result) -> void } -> void
+    # Local-database declaration DSL (docs/local_database.md). Migrate
+    # blocks are recorded at class eval and executed at DB boot.
+    def self.storage: (Symbol kind) ?{ () -> void } -> Symbol
+    def self.storage_kind: () -> Symbol
+    def self.replica?: () -> bool
+    def self.ephemeral?: () -> bool
+    def self.local?: () -> bool
+    def self.migrate: (Integer version, ?reset: bool) { (untyped t) -> void } -> void
+    def self.local_migrations: () -> Array[Hash[Symbol, untyped]]?
+    def self.validate_local_migrations: () -> void
+    def self.refresh: (Symbol mode) -> Symbol
+    def self.refresh_mode: () -> Symbol
+
+    # Associations: declaration-time metadata plus lazily resolved
+    # targets. The generated readers are dynamic, like the accessors.
+    def self.belongs_to: (Symbol | String name, ?class_name: (String | Symbol)?, ?foreign_key: (String | Symbol)?, **untyped rest) -> nil
+    def self.has_many: (Symbol | String name, ?class_name: (String | Symbol)?, ?foreign_key: (String | Symbol)?, **untyped rest) -> nil
+    def self.__reject_association_options: (Symbol kind, Symbol | String name, Hash[Symbol, untyped] rest) -> nil
+    def self.__register_association: (Symbol key) -> nil
+    def self.__assert_association_name_free: (Symbol key) -> nil
+    def self.__associations: () -> Hash[Symbol, Hash[Symbol, untyped]]
+    def self.__association_target: (Symbol key, String class_name) -> untyped
+    def self.__resolve_association_constant: (Symbol key, String class_name) -> untyped
+    def self.__unresolvable_association: (Symbol key, String class_name) -> String
+    def self.__assert_no_association_conflict: (Array[String] names) -> nil
+
+    def self.table_name: (?(String | Symbol)? explicit) -> String
+    def self.derive_table_name: () -> String
+    def self.demodulized_snake_name: () -> String
+    def self.__pluralize: (String name) -> String
+    def self.__singularize: (String name) -> String
+    def self.__camelize: (String name) -> String
+    def self.local: () -> Relation
+
+    # Relation protocol (mrblib/relation.rb)
+    def self.local_columns: () -> Hash[String, Symbol]
+    def self.derive_replica_columns: () -> Hash[String, Symbol]
+    def self.local_db: () -> untyped
+    def self.replica_db: () -> untyped
+    def self.build_from_local: (Hash[untyped, untyped] attrs) -> Model
+    def self.local_table_changed: () -> void
+    def self.on_change: () { (Symbol role, String table) -> void } -> Integer
+    def self.off_change: (Integer subscription) -> nil
+    def self.rest_attribute_type: (String name) -> Symbol?
+    def self.__write_through_upsert: (untyped attrs) -> void
+    def self.__write_through_upsert_all: (untyped rows) -> void
+    def self.__write_through_delete: (untyped id) -> void
+
+    # Unified callback contract (0.5.0): every REST callback is
+    # (result, error). On success `result` is the payload and `error` is
+    # nil; on failure `result` is nil. destroy's success payload is `true`.
+    # On storage :local models these methods are synchronous instead
+    # (bare-class alias): no blocks, direct return values.
+    def self.all: (?Hash[untyped, untyped] params) ?{ (Array[Model]? instances, untyped error) -> void } -> untyped
+    def self.find: (?untyped id, ?endpoint_name: String, ?model_class: singleton(Model)) ?{ (Model? instance, untyped error) -> void } -> untyped
+    def self.create: (?Hash[untyped, untyped] attrs, **untyped kw) ?{ (Model? instance, untyped error) -> void } -> untyped
+    def self.destroy: (?untyped id) ?{ (bool? success, untyped error) -> void } -> untyped
+
+    def update: (?Hash[untyped, untyped]? attrs) ?{ (Model? instance, untyped error) -> void } -> untyped
+    def destroy: () ?{ (bool? success, untyped error) -> void } -> untyped
+    def reload: () ?{ (Model? instance, untyped error) -> void } -> untyped
+
+    # storage :local CRUD and the bare-class alias
+    def self.define_local_accessors: (Hash[String, Symbol] columns) -> void
+    def self.define_local_accessor: (String name, Array[Symbol] existing) -> void
+    def self.merge_keyword_attrs: (Hash[untyped, untyped] attrs, Hash[Symbol, untyped] kw) -> Hash[untyped, untyped]
+    def self.local_create: (?Hash[untyped, untyped] attrs) -> Model
+    def self.reset_local: () -> bool
+    def self.local_query: (String method_name) -> Relation
+    def self.where: (?Hash[untyped, untyped] | String | nil conditions, *untyped binds) -> Relation
+    def self.order: (*untyped args) -> Relation
+    def self.limit: (Integer? n) -> Relation
+    def self.offset: (Integer? n) -> Relation
+    def self.count: () -> Integer
+    def self.first: () -> untyped
+    def self.exists?: () -> bool
+    def self.find_by: (Hash[untyped, untyped] conditions) -> untyped
+    def self.delete_all: () -> Integer
 
-    def update: (?Hash[untyped, untyped]? attrs) ?{ (bool success, untyped result) -> void } -> void
-    def destroy: () ?{ (bool success, untyped result) -> void } -> void
-    def reload: () ?{ (Model? instance, String? error) -> void } -> void
+    def new_record?: () -> bool
+    def __track_local_change: (String name, untyped value, untyped old) -> void
+    def __local_insert: () -> Model
+    def __local_update: (Hash[untyped, untyped]? attrs) -> bool
+    def __local_destroy: () -> bool
+    def __sync_from_row: () -> void
+    def __hydrate_local: (Hash[untyped, untyped] attrs) -> void
+    def __set_local_baseline: (Hash[untyped, untyped] attrs) -> void
   end
 end

data/sig/relation.rbs

@@ -0,0 +1,44 @@
+module Funicular
+  class Relation
+    @model: untyped
+    @where_sql: Array[String]
+    @where_binds: Array[untyped]
+    @order_sql: Array[String]
+    @limit: Integer?
+    @offset: Integer?
+
+    def initialize: (untyped model, ?Array[String] where_sql,
+                     ?Array[untyped] where_binds, ?Array[String] order_sql,
+                     ?Integer? limit, ?Integer? offset) -> void
+
+    def where: (?Hash[untyped, untyped] | String | nil conditions, *untyped binds) -> Relation
+    def order: (*untyped args) -> Relation
+    def limit: (Integer? n) -> Relation
+    def offset: (Integer? n) -> Relation
+
+    def to_a: () -> Array[untyped]
+    def each: () { (untyped record) -> void } -> Array[untyped]
+    def first: () -> untyped
+    def count: () -> Integer
+    def exists?: () -> bool
+    def find: (untyped id) -> untyped
+    def find_by: (Hash[untyped, untyped] conditions) -> untyped
+    def delete_all: () -> Integer
+    def to_sql: () -> String
+    def __event_source: () -> [Symbol, String]
+
+    private def append_condition: (Array[String] w, Array[untyped] b, untyped col, untyped value) -> void
+    private def order_term: (untyped col, untyped dir) -> String
+    private def validate_column: (untyped col) -> String
+    private def quote: (String name) -> String
+    private def quoted_table: () -> String
+    private def select_sql: () -> String
+    private def where_clause: () -> String
+    private def order_clause: () -> String
+    private def slice_clause: () -> String
+    private def slice_arg: (Integer? n, String label) -> Integer?
+    private def decode_row: (Array[String] cols, untyped row) -> Hash[String, untyped]
+    private def single_value: (String sql) -> untyped
+    private def model_label: () -> untyped
+  end
+end

data/sig/router.rbs

@@ -21,6 +21,7 @@ module Funicular
     def start: (?hydrate: bool) -> void
     def stop: () -> void
     def navigate: (String path) -> void
+    def leave_allowed?: () -> bool
     def current_location_path: () -> String
 
     private def add_route_with_method: (Symbol method, String path, singleton(Component) component_class, String? name, ?route_constraints_t? constraints) -> void