capsium 0.3.0 → 0.6.0

data/sig/capsium/package/bundle.rbs

@@ -0,0 +1,43 @@
+module Capsium
+  class Package
+    # Bundled dependencies of an encapsulated (self-contained) package:
+    # dependency .cap files embedded under packages/ with a
+    # packages/index.json manifest mapping each dependency GUID to its
+    # file, version and SHA-256. Bundled dependencies resolve first at
+    # load time, before the store -> registry chain.
+    class Bundle
+      DIRECTORY: String
+      INDEX_FILE: String
+
+      # One bundled dependency: the absolute .cap path, its version and
+      # the SHA-256 recorded in the manifest.
+      class Entry
+        def self.new: (String file, String version, String sha256) -> void
+
+        def file: () -> String
+        def version: () -> String
+        def sha256: () -> String
+      end
+
+      attr_reader entries: Hash[String, Entry]
+
+      def initialize: (String? package_path, ?Hash[String, Entry]? entries) -> void
+
+      # Embeds the resolved dependency .cap files (guid => .cap path
+      # pairs) into the package directory at package_path and writes the
+      # packages/index.json manifest. Returns the manifest hash.
+      def self.write: (String package_path, Array[[String, String]] resolutions) -> Hash[String, Hash[String, String]]
+
+      # Whether this bundle embeds any dependency.
+      def present?: () -> bool
+
+      # Merges an inherited (ancestor) bundle underneath this one; own
+      # entries win on GUID conflicts.
+      def merged_with: (Bundle? other) -> Bundle
+
+      # The absolute .cap path for a bundled dependency, or nil when the
+      # GUID is not bundled.
+      def resolve_path: (String guid, String range, chain: Array[String] chain) -> String?
+    end
+  end
+end

data/sig/capsium/package/cipher.rbs

@@ -32,6 +32,15 @@ module Capsium
       # encrypted package, i.e. contains package.enc.
       def self.encrypted?: (String | Pathname path) -> bool
 
+      # The keyManagement declared by the encryption envelope of the
+      # path (.cap file or uncompressed directory), or nil when the
+      # envelope is absent or unreadable.
+      def self.key_management: (String | Pathname path) -> String?
+
+      # The cipher instance matching the envelope's keyManagement:
+      # OpenPgpCipher for OpenPGP envelopes, the RSA cipher otherwise.
+      def self.for_encrypted: (String | Pathname path) -> Cipher
+
       # Encrypts the package at source_path (a .cap file, or a package
       # directory which is packed first) for the recipient's RSA public
       # key (or X.509 certificate) and writes the encrypted .cap to
@@ -44,7 +53,9 @@ module Capsium
       def decrypt: (String | Pathname encrypted_path, String private_key_path, String output_path) -> String
 
       # Decrypts an encrypted package into a fresh temporary directory
-      # and returns the directory path.
+      # and returns the directory path. The cipher is selected from the
+      # envelope's keyManagement: OpenPGP envelopes decrypt through
+      # OpenPgpCipher, everything else through the RSA cipher.
       def self.decrypt_to_directory: (String | Pathname source_path, String private_key_path) -> String
     end
   end

data/sig/capsium/package/composition.rbs

@@ -1,12 +1,13 @@
 module Capsium
   class Package
     # Composite-package support (ARCHITECTURE.md section 4a), mixed into
-    # Package: metadata.dependencies resolution against a package store
-    # and load-time validation of dependency resource references.
+    # Package: metadata.dependencies resolution — bundled dependencies
+    # (Capsium::Package::Bundle) first, then the package store — and
+    # load-time validation of dependency resource references.
     module Composition
       private
 
-      def resolve_dependencies: ((Store | String)? store, Array[String] chain) -> Array[ResolvedDependency]
+      def resolve_dependencies: ((Store | String)? store, (Capsium::Registry | String)? registry, Array[String] chain, ?Bundle? bundle) -> Array[ResolvedDependency]
 
       def validate_dependency_references!: () -> void
 

data/sig/capsium/package/dataset.rbs

@@ -19,6 +19,14 @@ module Capsium
 
       def validate: () -> bool
 
+      # The parsed JSON schema for this dataset, or nil when none is
+      # declared or the file is unreadable.
+      def json_schema: () -> Hash[String, untyped]?
+
+      # Schema validation of an arbitrary candidate document (used by
+      # the reactor's writable overlay); empty when valid or schema-less.
+      def schema_errors_for: (untyped data) -> Array[String]
+
       # File-existence and schema validations; empty when valid.
       def validation_errors: () -> Array[String]
 

data/sig/capsium/package/dependency_resolver.rbs

@@ -35,14 +35,18 @@ module Capsium
     end
 
     # Orchestrates metadata.dependencies resolution against a package
-    # store: circularity checks plus store lookup.
+    # store: circularity checks plus store lookup, with a registry as
+    # install fallback for store misses.
     class DependencyResolver
       attr_reader store: Store
+      attr_reader registry: Capsium::Registry?
 
-      def initialize: (Store | String? store) -> void
+      def initialize: (Store | String? store,
+                       ?registry: (Capsium::Registry | String)? registry) -> void
 
-      # The newest store .cap satisfying the dependency, raising typed
-      # errors for circular, missing or unsatisfiable dependencies.
+      # The newest store .cap satisfying the dependency, installing from
+      # the configured registry on a store miss and raising typed errors
+      # for circular, missing or unsatisfiable dependencies.
       def resolve_path: (String guid, String range, chain: Array[String] chain) -> String
     end
   end

data/sig/capsium/package/encryption_config.rbs

@@ -1,18 +1,22 @@
 module Capsium
   class Package
     # The "encryption" object of signature.json in an encrypted package:
-    # the AES-256-GCM envelope with the RSA-OAEP-SHA256 wrapped DEK, all
-    # binary values Base64-encoded.
+    # the AES-256-GCM envelope. keyManagement selects how the DEK is
+    # protected: "RSA-OAEP-SHA256" carries it Base64-wrapped in
+    # encryptedDek; "OpenPGP" carries an armored OpenPGP message
+    # containing the DEK in message. iv/authTag are Base64.
     class EncryptionEnvelope
       attr_accessor algorithm: String?
       attr_accessor key_management: String?
       attr_accessor encrypted_dek: String?
+      attr_accessor message: String?
       attr_accessor iv: String?
       attr_accessor auth_tag: String?
 
       def initialize: (?algorithm: String? algorithm,
                        ?key_management: String? key_management,
                        ?encrypted_dek: String? encrypted_dek,
+                       ?message: String? message,
                        ?iv: String? iv,
                        ?auth_tag: String? auth_tag) -> void
 

data/sig/capsium/package/merged_view.rbs

@@ -29,7 +29,8 @@ module Capsium
       def initialize: (String package_path, storage: Storage storage,
                        manifest: Manifest manifest,
                        ?dependency_views: Array[[String, MergedView]] dependency_views,
-                       ?exported_only: bool exported_only) -> void
+                       ?exported_only: bool exported_only,
+                       ?extra_layers: Array[Layer] extra_layers) -> void
 
       # The absolute filesystem path serving a resource reference: a
       # package-relative content path ("content/app.js"), or a dependency

data/sig/capsium/package/metadata.rbs

@@ -21,6 +21,7 @@ module Capsium
       def license: () -> String?
       def repository: () -> Repository?
       def dependencies: () -> Hash[String, String]
+      def read_only: () -> bool?
     end
   end
 end

data/sig/capsium/package/open_pgp.rbs

@@ -0,0 +1,38 @@
+module Capsium
+  class Package
+    # OpenPGP support (signatures and encryption) through the rnp gem's
+    # binding to librnp. rnp is a soft dependency: it is only required
+    # when an OpenPGP feature is used, and this module is the single
+    # place that loads it.
+    module OpenPgp
+      # The rnp gem or the librnp shared library is not available.
+      class OpenPgpUnavailableError < Capsium::Error
+      end
+
+      # A key file is unreadable or holds no suitable OpenPGP key.
+      class KeyError < Capsium::Error
+      end
+
+      UNAVAILABLE_MESSAGE: String
+
+      # One loaded key file: the Rnp context holding the key material
+      # and the selected key within it.
+      class LoadedKey
+        def self.new: (untyped rnp, untyped key) -> void
+
+        def rnp: () -> untyped
+        def key: () -> untyped
+      end
+
+      # A fresh Rnp context. Raises OpenPgpUnavailableError when the rnp
+      # gem or librnp cannot be loaded.
+      def self.rnp: () -> untyped
+
+      # Loads the OpenPGP key at key_path (armored or binary, public or
+      # secret — the format is auto-detected). With secret: true the
+      # selected key must hold secret key material. Raises KeyError when
+      # the file is unreadable or holds no suitable key.
+      def self.load_key: (String key_path, ?secret: bool secret) -> LoadedKey
+    end
+  end
+end

data/sig/capsium/package/open_pgp_cipher.rbs

@@ -0,0 +1,15 @@
+module Capsium
+  class Package
+    # Encrypts and decrypts whole Capsium packages with OpenPGP key
+    # management (ARCHITECTURE.md section 6b) through librnp: the DEK
+    # travels as an armored OpenPGP message in the signature.json
+    # envelope (keyManagement "OpenPGP"); the AES-256-GCM content
+    # encryption and the encrypted .cap layout are the Cipher's.
+    class OpenPgpCipher < Cipher
+      KEY_MANAGEMENT: String
+
+      # The OpenPGP symmetric cipher protecting the DEK message.
+      CIPHER_NAME: String
+    end
+  end
+end

data/sig/capsium/package/open_pgp_signer.rbs

@@ -0,0 +1,46 @@
+module Capsium
+  class Package
+    # Signs and verifies Capsium packages with OpenPGP detached
+    # signatures (ARCHITECTURE.md section 6a) through librnp. Parallel
+    # to the RSA-SHA256/X.509 Signer with the same construction
+    # semantics and the same error taxonomy.
+    class OpenPgpSigner
+      ALGORITHM: String
+      CERTIFICATE_TYPE: String
+      HASH: String
+
+      # Package-relative name of the embedded armored OpenPGP public key
+      # recorded in security.json digitalSignatures.publicKey.
+      PUBLIC_KEY_FILE: String
+
+      attr_reader package_path: String
+
+      def initialize: (String package_path) -> void
+
+      # Signs a package directory in place, or a .cap file (unpacked,
+      # signed, recompressed), with the OpenPGP secret key at
+      # secret_key_path. Returns the signed path.
+      def self.sign_package: (String path, String secret_key_path) -> String
+
+      # Verifies the declared OpenPGP signature of a package directory
+      # or .cap file (false on mismatch; raises typed
+      # Signer::SignatureError subclasses on structural problems).
+      def self.verify_package: (String path, ?String? public_key_path) -> bool
+
+      # Signs the package directory in place: embeds the armored public
+      # key, regenerates security.json (checksums plus digitalSignatures
+      # with certificateType "OpenPGP") and writes the armored detached
+      # OpenPGP signature to signature.sig. Returns the path of the
+      # written signature file.
+      def sign: (String secret_key_path) -> String
+
+      # True when the declared signature verifies against the payload;
+      # false on mismatch.
+      def verify: (?String? public_key_path) -> bool
+
+      def verify!: (?String? public_key_path) -> bool
+
+      def signed?: () -> bool
+    end
+  end
+end

data/sig/capsium/package/security_config.rbs

@@ -15,13 +15,16 @@ module Capsium
       def to_hash: () -> Hash[String, untyped]
     end
 
-    # The "digitalSignatures" object of security.json (parsed only;
-    # signing is a later phase).
+    # The "digitalSignatures" object of security.json: certificateType
+    # selects the signature scheme (absent = RSA-SHA256/X.509,
+    # "OpenPGP" = OpenPGP).
     class DigitalSignatures
+      attr_accessor certificate_type: String?
       attr_accessor public_key: String?
       attr_accessor signature_file: String?
 
-      def initialize: (?public_key: String? public_key,
+      def initialize: (?certificate_type: String? certificate_type,
+                       ?public_key: String? public_key,
                        ?signature_file: String? signature_file) -> void
 
       def to_json: (*untyped args) -> String

data/sig/capsium/package/signer.rbs

@@ -37,9 +37,16 @@ module Capsium
 
       # Verifies the declared signature of a package directory or .cap
       # file (false on mismatch; raises typed SignatureError subclasses
-      # on structural problems, e.g. an unsigned package).
+      # on structural problems, e.g. an unsigned package). The signer is
+      # selected from the declared digitalSignatures certificateType:
+      # OpenPGP packages verify through OpenPgpSigner.
       def self.verify_package: (String path, ?String? public_key_path) -> bool
 
+      # The signer class matching a package's declared signature scheme:
+      # OpenPgpSigner when security.json declares
+      # digitalSignatures.certificateType "OpenPGP", Signer otherwise.
+      def self.signer_class_for: (String package_path) -> (singleton(Signer) | singleton(OpenPgpSigner))
+
       # Signs the package directory in place: embeds the public key PEM,
       # regenerates security.json (checksums plus digitalSignatures) and
       # writes the raw RSA-SHA256 signature to signature.sig. Returns the

data/sig/capsium/package/store.rbs

@@ -32,6 +32,12 @@ module Capsium
 
       # Every .cap in the store with its metadata identity (memoized).
       def catalog: () -> Array[CatalogEntry]
+
+      # Installs the .cap at source_path into the store as file_name,
+      # records guid -> file_name in index.json (atomically) and returns
+      # the installed path.
+      def install: (String source_path, guid: String guid,
+                    file_name: String file_name) -> String
     end
   end
 end

data/sig/capsium/package/verification.rbs

@@ -13,9 +13,11 @@ module Capsium
       # Whether security.json declares a digital signature for this package.
       def signed?: () -> bool
 
-      # Verifies the declared digital signature (RSA-SHA256) against the
-      # checksum-covered payload. True when the package is unsigned or the
-      # signature verifies; false on mismatch.
+      # Verifies the declared digital signature against the
+      # checksum-covered payload, through the signer matching the
+      # declared certificateType (OpenPgpSigner for OpenPGP, the
+      # RSA-SHA256 Signer otherwise). True when the package is unsigned
+      # or the signature verifies; false on mismatch.
       def verify_signature: () -> bool
 
       def verify_signature!: () -> void

data/sig/capsium/package.rbs

@@ -30,12 +30,16 @@ module Capsium
     # Loads a package directory or .cap file. Composite packages
     # (metadata.dependencies, ARCHITECTURE.md section 4a) resolve against
     # the package store given as `store` (directory path or Store) or via
-    # CAPSIUM_STORE. `dependency_chain` is internal: the ancestor GUIDs
+    # CAPSIUM_STORE, falling back to the registry given as `registry`
+    # or via CAPSIUM_REGISTRY when the store has no package for a
+    # dependency GUID. `dependency_chain` is internal: the ancestor GUIDs
     # used for circular-dependency detection during recursive resolution.
     def initialize: (String | Pathname path, ?load_type: Symbol? load_type,
                      ?decryption_key: String? decryption_key,
                      ?store: (Store | String)? store,
-                     ?dependency_chain: Array[String] dependency_chain) -> void
+                     ?registry: (Capsium::Registry | String)? registry,
+                     ?dependency_chain: Array[String] dependency_chain,
+                     ?bundle: Bundle? bundle) -> void
 
     def solidify: () -> void
 
@@ -50,7 +54,8 @@ module Capsium
     # The merged content view across the storage layers (ARCHITECTURE.md
     # section 5a); exported_only gives the dependent-package view (section 4a).
     # Resolved dependencies act as read-only layers below all own layers.
-    def merged_view: (?exported_only: bool exported_only) -> MergedView
+    # extra_layers stack above everything (the reactor's writable overlay).
+    def merged_view: (?exported_only: bool exported_only, ?extra_layers: Array[MergedView::Layer] extra_layers) -> MergedView
 
     # The .cap file this package was loaded from, or nil when loaded
     # from a directory.

data/sig/capsium/reactor/content_api.rbs

@@ -0,0 +1,19 @@
+module Capsium
+  class Reactor
+    # Content writes over the mount's overlay (ARCHITECTURE.md section
+    # 5a): PUT creates/overwrites a content file, DELETE records a
+    # tombstone. Text bodies only for v1.
+    class ContentApi
+      include Responses
+
+      WRITE_METHODS: Array[String]
+      CONTENT_PREFIX: String
+
+      def self.write_method?: (String method) -> bool
+
+      def initialize: (Mount mount) -> void
+
+      def handle: (String inner_path, untyped request, untyped response) -> untyped
+    end
+  end
+end

data/sig/capsium/reactor/data_api.rbs

@@ -0,0 +1,23 @@
+module Capsium
+  class Reactor
+    # REST CRUD over a mount's datasets (ARCHITECTURE.md sections 5 and
+    # 5a): JSON item append/read/replace/delete against the
+    # overlay-merged collection.
+    class DataApi
+      include Responses
+
+      PREFIX: String
+      COLLECTION_PATTERN: Regexp
+      ITEM_PATTERN: Regexp
+
+      def self.path?: (String inner_path) -> bool
+
+      def initialize: (Mount mount) -> void
+
+      # The declared dataset route a data path addresses, or nil.
+      def route_for: (String inner_path) -> Package::Route?
+
+      def handle: (String inner_path, untyped request, untyped response) -> untyped
+    end
+  end
+end

data/sig/capsium/reactor/endpoints.rbs

@@ -0,0 +1,16 @@
+module Capsium
+  class Reactor
+    # Serving of the reactor-level endpoints (introspection reports,
+    # per-package save), mixed into Reactor.
+    module Endpoints
+      include Responses
+
+      private
+
+      def serve_introspection: (untyped request, untyped response) -> untyped
+
+      # POST /package/<name>/save: folds base plus overlay into a new .cap.
+      def serve_package_save: (untyped request, untyped response) -> untyped
+    end
+  end
+end

data/sig/capsium/reactor/graphql_api.rbs

@@ -0,0 +1,27 @@
+module Capsium
+  class Reactor
+    # GraphQL over a mount's datasets (POST and GET <mount>/graphql):
+    # executes the derived schema and maps typed overlay errors into
+    # the "errors" array.
+    class GraphqlApi
+      include Responses
+
+      PATH: String
+
+      def self.path?: (String inner_path) -> bool
+
+      def initialize: (Mount mount) -> void
+
+      def handle: (untyped request, untyped response) -> untyped
+
+      # Query/mutation resolvers called from the derived schema.
+      def collection: (Package::Dataset dataset, ?id: String? id) -> Array[untyped]
+
+      def create_item: (Package::Dataset dataset, item: untyped item) -> untyped
+
+      def update_item: (Package::Dataset dataset, id: String id, item: untyped item) -> untyped
+
+      def remove_item: (Package::Dataset dataset, id: String id) -> bool
+    end
+  end
+end

data/sig/capsium/reactor/graphql_schema.rbs

@@ -0,0 +1,20 @@
+module Capsium
+  class Reactor
+    # Builds the GraphQL schema for a mounted package: per dataset a
+    # query field "<dataset>" (list, optional "id:") plus
+    # create<Dataset>/update<Dataset>/delete<Dataset> mutations. Item
+    # types are inferred from the dataset's JSON schema when present.
+    class GraphqlSchema
+      # Permissive scalar carrying any JSON value.
+      class JsonScalar < GraphQL::Schema::Scalar
+        def self.coerce_input: (untyped input_value, untyped _context) -> untyped
+
+        def self.coerce_result: (untyped ruby_value, untyped _context) -> untyped
+      end
+
+      def initialize: (Mount mount, GraphqlApi api) -> void
+
+      def build: () -> singleton(GraphQL::Schema)
+    end
+  end
+end

data/sig/capsium/reactor/introspection.rbs

@@ -1,23 +1,36 @@
 module Capsium
   class Reactor
-    # Monitoring HTTP API reports for the package this reactor serves
-    # (ARCHITECTURE.md section 7).
+    # Monitoring HTTP API reports (ARCHITECTURE.md section 7):
+    # /api/v1/introspect/* aggregates every mounted package, plus
+    # reactor-level /introspect/* and per-package /package/:id/*
+    # endpoints resolved by package name.
     class Introspection
       METADATA_PATH: String
       ROUTES_PATH: String
       CONTENT_HASHES_PATH: String
       CONTENT_VALIDITY_PATH: String
       PATHS: Array[String]
+      STATUS_PATH: String
+      CONFIG_PATH: String
+      METRICS_PATH: String
+      REACTOR_PATHS: Array[String]
+      PACKAGE_MOUNT: String
+      PACKAGE_PATH_PATTERN: Regexp
+      DEFAULT_LOG_LINES: Integer
+      MAX_LOG_LINES: Integer
 
-      attr_reader package: Package
+      attr_reader packages: Array[Package]
 
-      def initialize: (Package package) -> void
+      def initialize: (Array[Package] packages, ?reactor: Reactor? reactor) -> void
+
+      # The first mounted package (the single-package view).
+      def package: () -> Package
 
       def endpoint?: (String path) -> bool
 
-      # The report body for an introspection endpoint, or nil when the
-      # path is not an introspection endpoint.
-      def report_for: (String path) -> Hash[Symbol, untyped]?
+      # The report body for an endpoint, or nil when the path is not an
+      # endpoint or the package name does not match (404).
+      def report_for: (String path, ?params: Hash[String, String] params) -> Hash[Symbol, untyped]?
 
       def metadata_report: () -> Hash[Symbol, untyped]
 
@@ -26,6 +39,13 @@ module Capsium
       def content_hashes_report: () -> Hash[Symbol, untyped]
 
       def content_validity_report: () -> Hash[Symbol, untyped]
+
+      def status_report: () -> Hash[Symbol, untyped]
+
+      # Reactor configuration; secrets are never exposed.
+      def config_report: () -> Hash[Symbol, untyped]
+
+      def metrics_report: () -> Hash[Symbol, untyped]
     end
   end
 end

data/sig/capsium/reactor/metrics.rbs

@@ -0,0 +1,13 @@
+module Capsium
+  class Reactor
+    # Minimal in-memory request counters for the /introspect/metrics
+    # endpoint, thread-safe via Mutex.
+    class Metrics
+      def initialize: () -> void
+
+      def record: (Integer status) -> Metrics
+
+      def snapshot: () -> Hash[Symbol, untyped]
+    end
+  end
+end

data/sig/capsium/reactor/mount.rbs

@@ -0,0 +1,83 @@
+module Capsium
+  class Reactor
+    # Raised when two mounts claim the same URL prefix, whether given
+    # explicitly or derived from package names.
+    class MountConflictError < Capsium::Error
+    end
+
+    # One mounted package: the URL prefix it answers under plus its
+    # serving state. The reactor serves a list of mounts resolved by
+    # longest-prefix matching; default mount points are "/" for the
+    # first source and "/<metadata.name>/" for each additional one.
+    class Mount
+      ROOT_PATH: String
+      SPEC_SEPARATOR: String
+
+      # A mount entry as accepted from the CLI or a JSON config file:
+      # "path" may be nil (the default is assigned on build), "source"
+      # is a package directory, .cap file or Package, "store"
+      # optionally overrides the global package store for this mount.
+      class Entry
+        def self.new: (path: String? path, source: (Package | String) source, store: (Package::Store | String)? store) -> void
+
+        def path: () -> String?
+
+        def source: () -> (Package | String)
+
+        def store: () -> (Package::Store | String)?
+
+        def with: (?path: String? path, ?source: (Package | String) source, ?store: (Package::Store | String)? store) -> Entry
+      end
+
+      attr_reader path: String
+      attr_reader package: Package
+      attr_reader overlay: Overlay?
+
+      def self.parse_spec: (String spec) -> Entry
+
+      def self.config_entries: (String config_file) -> Array[Entry]
+
+      def self.build: (Array[Entry] entries, ?store: (Package::Store | String)? store, ?registry: (Capsium::Registry | String)? registry) -> Array[Mount]
+
+      def self.load_package: ((Package | String) source, (Package::Store | String)? store, (Capsium::Registry | String)? registry) -> Package
+
+      def self.normalize_path: (String? path) -> String
+
+      def initialize: (path: String? path, package: (Package | String) package, ?store: (Package::Store | String)? store, ?registry: (Capsium::Registry | String)? registry, ?workdir: String? workdir) -> void
+
+      # Attaches the reactor workdir (creates the writable overlay).
+      def attach_workdir: (String workdir) -> void
+
+      # Writable unless the package declares "readOnly": true.
+      def writable?: () -> bool
+
+      def matches?: (String request_path) -> bool
+
+      def inner_path: (String request_path) -> String
+
+      def routes: () -> Package::Routes
+
+      def merged_view: () -> Package::MergedView
+
+      # The dataset as served: base data merged with overlay mutations.
+      def dataset_data: (Package::Dataset dataset) -> untyped
+
+      def data_api: () -> DataApi
+
+      def content_api: () -> ContentApi
+
+      # Whether this mount exposes a GraphQL API (any file-backed dataset).
+      def graphql?: () -> bool
+
+      def graphql_api: () -> GraphqlApi
+
+      # The one-line "name version" summary used in reactor logs.
+      def summary: () -> String
+
+      # The WEBrick mount points serving this mount.
+      def server_paths: () -> Array[String]
+
+      def reload: () -> Package
+    end
+  end
+end