> For the complete documentation index, see [llms.txt](https://host2host.onibonje.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://host2host.onibonje.com/docs/20-universal-library-extensibility.md).

# Universal Library Extensibility

## 1. Overview

Every library in the H2H platform — **security**, **file management**, **observability**, **context**, **Camel core**, **Finacle wrapper**, **transforms**, **jobs**, **scripts**, and **admin** — follows the **same extensibility contract**. Customizations defined once for a partner or country **propagate across the entire solution** without per-library silos.

**Core modules:**

| Module                 | Role                                                           |
| ---------------------- | -------------------------------------------------------------- |
| `h2h-extension-api`    | SPI interfaces shared by all libraries                         |
| `h2h-extension-kernel` | Central registry, customization resolution, publish validation |
| `h2h-config-runtime`   | Loads and caches customization profiles                        |

```mermaid
flowchart TB
  subgraph admin [Admin Portal]
    CustomUI[Customization Designer]
    Publish[Publish Workflow]
  end

  subgraph kernel [h2h-extension-kernel]
    Registry[ExtensionRegistry]
    Resolver[CustomizationResolver]
    Validator[ExtensionValidator]
  end

  subgraph libs [All Platform Libraries]
    Security[h2h-security]
    FileMgmt[h2h-file-management]
    Observability[h2h-observability]
    Context[h2h-context]
    Camel[h2h-camel-core]
    CBSApi[h2h-core-banking-api]
    Finacle[h2h-finacle-wrapper]
    Transform[h2h-transform-core]
    Jobs[h2h-job-scheduler]
    Script[h2h-script-engine]
  end

  subgraph runtime [Shared Runtime State]
    H2hCtx[H2hContext]
    Profile[CustomizationProfile]
  end

  admin --> kernel
  kernel --> libs
  Resolver --> Profile
  Profile --> H2hCtx
  H2hCtx --> libs
```

**Design mandate:** No library may implement private, ad-hoc extension mechanisms. All extensions register through `h2h-extension-kernel`.

***

## 2. Extensibility Principles (All Libraries)

| #  | Principle                          | Meaning                                                                       |
| -- | ---------------------------------- | ----------------------------------------------------------------------------- |
| 1  | **Extend, don't fork**             | Customize via SPI, config, scripts, hooks — never copy library source         |
| 2  | **One customization profile**      | Partner/country customizations bundled in a single `CustomizationProfile`     |
| 3  | **Context carries all**            | `H2hContext` holds resolved customizations — every library reads from context |
| 4  | **Scope inheritance**              | Global → organization → country → partner → product → environment             |
| 5  | **Publish once, apply everywhere** | Single publish invalidates caches across all libraries                        |
| 6  | **Validate at publish**            | Kernel validates all extension references before go-live                      |
| 7  | **Same approval workflow**         | Draft → test → approve → publish for every customization type                 |
| 8  | **Discoverable catalog**           | Admin UI lists all extension points per library from `ExtensionRegistry`      |
| 9  | **Versioned customizations**       | Every customization has version, effective dates, audit trail                 |
| 10 | **Safe defaults**                  | Libraries work with zero customization; extensions are additive               |

***

## 3. The Customization Profile

### 3.1 Single Profile, All Libraries

A **CustomizationProfile** is the unified bundle of all partner/country-specific overrides. Resolved once at transaction start and attached to `H2hContext`.

```java
public record CustomizationProfile(
    String profileId,
    String scopeType,           // GLOBAL, COUNTRY, PARTNER, PRODUCT
    String scopeId,
    int version,

  // Per-library customization blocks (all optional)
    SecurityCustomization security,
    FileManagementCustomization fileManagement,
    ObservabilityCustomization observability,
    CamelCustomization camel,
    TransformCustomization transform,
    FinacleCustomization finacle,
    JobCustomization jobs,
    ScriptCustomization scripts,
    List<HookDef> hooks,
    Map<String, String> customAttributes,
    Map<String, Object> extensionEntities
) {}
```

### 3.2 Database Storage

**Table: `customization_profile`**

| Column                            | Description                                     |
| --------------------------------- | ----------------------------------------------- |
| `profile_id`                      | UUID                                            |
| `scope_type`                      | GLOBAL, COUNTRY, PARTNER, PRODUCT               |
| `scope_id`                        | e.g. `NG`, `ACME_NG`                            |
| `environment`                     | sandbox, production                             |
| `version`                         | Incrementing                                    |
| `status`                          | DRAFT, PENDING\_APPROVAL, PUBLISHED, SUPERSEDED |
| `security_config`                 | JSON                                            |
| `file_mgmt_config`                | JSON                                            |
| `observability_config`            | JSON                                            |
| `camel_config`                    | JSON                                            |
| `transform_config`                | JSON                                            |
| `finacle_config`                  | JSON                                            |
| `job_config`                      | JSON                                            |
| `script_config`                   | JSON                                            |
| `hooks`                           | JSON array                                      |
| `effective_from` / `effective_to` | Validity                                        |

**Resolution order** (most specific wins):

```
PRODUCT + PARTNER + environment
  → PARTNER + environment
    → COUNTRY + environment
      → GLOBAL defaults
```

Merged by `CustomizationResolver` into one effective profile per transaction.

### 3.3 Resolution Flow

```mermaid
sequenceDiagram
  participant Route as Camel Route
  participant Ctx as H2hContextBuilder
  participant CR as CustomizationResolver
  participant Cache as CustomizationCache
  participant Lib as Any Library

  Route->>Ctx: build(partnerId, country, product)
  Ctx->>CR: resolve(ResolveScope)
  CR->>Cache: get(scopeKey)
  alt cache miss
    CR->>CR: Merge GLOBAL → COUNTRY → PARTNER → PRODUCT
    CR->>Cache: put(mergedProfile)
  end
  CR-->>Ctx: CustomizationProfile
  Ctx-->>Route: H2hContext with profile
  Route->>Lib: process(context)
  Lib->>Lib: apply library-specific customization from context
```

***

## 4. Universal SPI Contract

### 4.1 ExtensionProvider (base interface)

Every library implements this to register its extension points:

```java
public interface ExtensionProvider {
    String libraryId();                          // e.g. "h2h-security"
    String libraryVersion();
    List<ExtensionPointDescriptor> extensionPoints();
    void validate(CustomizationBlock block);     // throws on invalid config
    void contributeDefaults(CustomizationProfileBuilder builder);
}
```

### 4.2 ExtensionPointDescriptor

Describes what can be customized — drives admin UI catalog:

```java
public record ExtensionPointDescriptor(
    String pointId,              // e.g. "security.pgp.algorithm"
    String displayName,
    String description,
    ExtensionType type,          // CONFIG, SPI_PLUGIN, SCRIPT, HOOK
    JsonSchema configSchema,     // JSON Schema for admin form
    List<String> requiredPermissions
) {}
```

### 4.3 ExtensionRegistry

Central catalog populated at startup from all `ExtensionProvider` beans:

```java
public interface ExtensionRegistry {
    List<ExtensionProvider> providers();
    ExtensionPointDescriptor getPoint(String pointId);
    Set<String> allPointIds();
    void validateProfile(CustomizationProfile profile);
}
```

**Module:** `h2h-extension-kernel`

***

## 5. Per-Library Extension Points

### 5.1 Extension Matrix

| Library                 | Config extensions (L1–L2)                                        | SPI plugins (L4)                                             | Hooks / scripts                   |
| ----------------------- | ---------------------------------------------------------------- | ------------------------------------------------------------ | --------------------------------- |
| **h2h-security**        | PGP algo, signing method, masking level, replay window           | `CryptoProvider`, `SignatureProvider`, `MaskingRuleProvider` | `PRE_DECRYPT`, `POST_ENCRYPT`     |
| **h2h-file-management** | Store backends, signed URL TTL, delivery retries, archive policy | `FileStore` implementation, `DeliveryStrategy`               | `PRE_STORE`, `POST_DELIVER`       |
| **h2h-observability**   | Log fields, metric tags, SLA thresholds, sample rate             | `MetricContributor`, `LogEnricher`, `SlaRuleProvider`        | `ON_SLA_BREACH`                   |
| **h2h-context**         | Custom attribute bindings, header mappings                       | `ContextEnricher`                                            | `ON_CONTEXT_CREATE`               |
| **h2h-camel-core**      | Retry policy, idempotency window, DLQ routing                    | `StepTypeProvider`, `ErrorHandlerProvider`                   | All pipeline `hook_point`s        |
| **h2h-finacle-wrapper** | Service endpoints, timeout, pool size, operation mapping         | `CoreBankingOperationProvider` / `FinacleOperationProvider`  | `PRE_FINACLE`, `POST_FINACLE`     |
| **h2h-transform-core**  | Engine selection, spec overrides                                 | `TransformEngineProvider`                                    | `PRE_TRANSFORM`, `POST_TRANSFORM` |
| **h2h-script-engine**   | Language, timeout, sandbox profile                               | `ScriptEngine` SPI                                           | N/A (scripts are the extension)   |
| **h2h-job-scheduler**   | Schedule expression, job type, retry, delay backbone             | `JobExecutorProvider`                                        | `ON_JOB_FAILURE`                  |
| **h2h-config-runtime**  | Cache TTL, resolver rules                                        | `ConfigSourceProvider` (Git, external)                       | N/A                               |
| **h2h-persistence-spi** | Dialect, pagination strategy                                     | `JsonColumnMapper`, `SqlTaskDialect`                         | N/A                               |
| **h2h-admin-api**       | UI field visibility, approval rules                              | `AdminModuleProvider`                                        | N/A                               |
| **h2h-reconciliation**  | Matching keys, tolerances                                        | `ReconMatcherProvider`                                       | `ON_MATCH`, `ON_EXCEPTION`        |
| **h2h-ack-nack**        | ACK format, filename pattern                                     | `AckFormatProvider`                                          | `PRE_ACK_GENERATE`                |

### 5.2 Library-Specific Customization Blocks

#### Security (`SecurityCustomization`)

```json
{
  "pgpAlgorithm": "AES-256",
  "pgpInboundRequired": true,
  "signingAlgorithm": "HmacSHA256",
  "replayWindowMinutes": 5,
  "maskingLevel": "FULL",
  "customValidators": ["vault:plugins/security/acme-validator"]
}
```

#### File Management (`FileManagementCustomization`)

```json
{
  "inboundStore": "SFTP",
  "outboundStore": "SFTP",
  "archiveStore": "S3",
  "deliveryMethod": "SIGNED_URL",
  "signedUrlUploadTtlMinutes": 15,
  "signedUrlDownloadTtlHours": 24,
  "maxDeliveryAttempts": 5,
  "integrityAlgorithm": "SHA-256"
}
```

#### Observability (`ObservabilityCustomization`)

```json
{
  "additionalLogFields": ["custom.NG_CBN_REF"],
  "metricTags": { "businessUnit": "CORPORATE" },
  "slaMaxProcessingMs": 300000,
  "traceSampleRate": 0.2,
  "alertOnSlaBreach": true
}
```

#### Camel (`CamelCustomization`)

```json
{
  "maxRetries": 3,
  "retryDelayMs": 5000,
  "idempotencyWindowHours": 72,
  "parallelProcessingThreads": 8,
  "dlqEventCode": "DLQ_MESSAGE"
}
```

#### Finacle (`FinacleCustomization`)

```json
{
  "serviceVariant": "FCUBS",
  "connectionPoolSize": 20,
  "timeoutMs": 30000,
  "operationOverrides": {
    "postPayment": "FCUBS_PAYMENT_V2"
  }
}
```

***

## 6. Cross-Library Customization Propagation

### 6.1 The Problem

Without unified propagation, a custom field defined for payments might not appear in logs, file names, or audit events.

### 6.2 Solution: H2hContext as the Bus

All libraries read customizations from the **same** `H2hContext.customizationProfile()`:

```mermaid
flowchart LR
  CP[CustomizationProfile]
  CTX[H2hContext]

  CP --> CTX

  CTX --> SEC[Security applies masking rules]
  CTX --> FILE[File mgmt applies delivery method]
  CTX --> OBS[Observability adds log fields + SLA]
  CTX --> CAM[Camel applies retry + threads]
  CTX --> FIN[Finacle applies operation overrides]
```

### 6.3 Custom Attributes Flow (end-to-end example)

| Step                 | Library          | Uses custom attribute                                     |
| -------------------- | ---------------- | --------------------------------------------------------- |
| 1. Partner onboarded | Admin            | Define `NG_CBN_REF` in `custom_attribute_def`             |
| 2. Profile published | Extension kernel | Attribute in `CustomizationProfile.customAttributes`      |
| 3. File received     | File management  | Include in `file_registry.metadata_json`                  |
| 4. Transform         | Transform core   | `${custom.NG_CBN_REF}` in JSONata spec                    |
| 5. Finacle post      | Finacle wrapper  | Map to Finacle extension field via config                 |
| 6. Audit             | Observability    | Log field `custom.NG_CBN_REF` (masked per security rules) |
| 7. ACK filename      | File management  | Pattern `ACK_{custom.NG_CBN_REF}_{date}.csv`              |
| 8. Partner portal    | Admin API        | Display in transaction detail                             |

**One definition — used everywhere.**

### 6.4 ContextEnricher SPI

Libraries register enrichers that add library-specific data to context at creation time:

```java
public interface ContextEnricher extends ExtensionProvider {
    void enrich(H2hContextBuilder builder, CustomizationProfile profile);
}
```

Example: `SecurityContextEnricher` adds `maskingLevel` to context attributes; `ObservabilityContextEnricher` adds SLA deadline timestamp.

***

## 7. Customizer Chain Pattern

Each library implements an internal **CustomizerChain** — ordered list of customization appliers:

```java
public interface Customizer<T> {
    int order();                    // lower = earlier
    void apply(T target, CustomizationProfile profile, H2hContext context);
}

// Example in h2h-file-management
@Component
public class SignedUrlCustomizer implements Customizer<FileDeliveryRequest> {
    public void apply(FileDeliveryRequest req, CustomizationProfile profile, H2hContext ctx) {
        var fm = profile.fileManagement();
        if (fm.deliveryMethod() == DeliveryMethod.SIGNED_URL) {
            req.setTtl(fm.signedUrlDownloadTtl());
        }
    }
}
```

**Registration:** Spring collects all `Customizer<T>` beans per library; kernel does not need to know internals.

***

## 8. Plugin JAR Extensions (L4)

### 8.1 Standard Plugin Structure

Every plugin JAR — regardless of target library — follows the same layout:

```
h2h-plugin-{name}/
├── pom.xml
├── src/main/java/.../
│   ├── {Name}ExtensionProvider.java    # implements ExtensionProvider
│   ├── {Name}Customizer.java           # optional Customizer
│   └── config/
│       └── PluginAutoConfiguration.java
└── META-INF/
    ├── spring/...AutoConfiguration.imports
    └── h2h/extension-registration.yaml  # declares library targets
```

**`extension-registration.yaml`:**

```yaml
pluginId: acme-security-pack
version: 1.0.0
targets:
  - libraryId: h2h-security
    provides:
      - CryptoProvider
  - libraryId: h2h-file-management
    provides:
      - DeliveryStrategy
  - libraryId: h2h-observability
    provides:
      - LogEnricher
```

### 8.2 Plugin Enablement

```yaml
h2h:
  plugins:
    enabled:
      - h2h-plugin-acme-security-pack
      - h2h-plugin-ng-regulatory
```

Plugins can be scoped per country via customization profile:

```json
{
  "enabledPlugins": ["h2h-plugin-ng-regulatory"]
}
```

***

## 9. Hooks Across All Libraries

### 9.1 Unified Hook Model

**Table: `hook_def`** (already in extensibility framework — extended here for all libraries)

| Column       | Description                     |
| ------------ | ------------------------------- |
| `hook_point` | Namespaced: `{library}.{phase}` |
| `script_id`  | FK to `script_def`              |
| `scope`      | GLOBAL, COUNTRY, PARTNER        |
| `priority`   | Execution order                 |

### 9.2 Standard Hook Points (catalog)

| Hook point                    | Library         | Phase                     |
| ----------------------------- | --------------- | ------------------------- |
| `security.pre_decrypt`        | security        | Before PGP decrypt        |
| `security.post_encrypt`       | security        | After PGP encrypt         |
| `file.pre_store`              | file-management | Before staging            |
| `file.post_deliver`           | file-management | After delivery confirmed  |
| `context.on_create`           | context         | Context initialization    |
| `camel.pre_step`              | camel-core      | Before each pipeline step |
| `camel.post_step`             | camel-core      | After each pipeline step  |
| `camel.on_error`              | camel-core      | Error classification      |
| `finacle.pre_post`            | finacle-wrapper | Before Finacle call       |
| `finacle.post_post`           | finacle-wrapper | After Finacle response    |
| `transform.pre`               | transform-core  | Before mapping            |
| `transform.post`              | transform-core  | After mapping             |
| `observability.on_sla_breach` | observability   | SLA violation             |
| `recon.on_exception`          | reconciliation  | Unmatched item            |
| `job.on_failure`              | job-scheduler   | Failed job execution      |

Hooks are stored in `CustomizationProfile.hooks` and executed by `HookExecutor` in `h2h-extension-kernel`.

***

## 10. Admin Portal — Unified Customization Designer

### 10.1 Screens

| Screen                           | Capability                                                           |
| -------------------------------- | -------------------------------------------------------------------- |
| **Extension catalog**            | Browse all extension points from `ExtensionRegistry`                 |
| **Customization profile editor** | Tab per library — forms generated from JSON Schema                   |
| **Scope selector**               | GLOBAL / country / partner / product                                 |
| **Inheritance viewer**           | Show merged result: what GLOBAL sets vs what partner overrides       |
| **Cross-library test**           | Run sample transaction — verify all libraries applied customizations |
| **Plugin manager**               | Enable/disable plugin JARs per scope                                 |
| **Hook designer**                | Attach scripts to hook points across libraries                       |
| **Publish center**               | Single publish for entire customization profile                      |

### 10.2 Inheritance Viewer (example)

```
GLOBAL defaults
  security.maskingLevel = FULL
  file.deliveryMethod = SFTP
  camel.maxRetries = 3

COUNTRY (NG) overrides
  file.archiveStore = S3
  observability.slaMaxProcessingMs = 240000

PARTNER (ACME_NG) overrides
  file.deliveryMethod = SIGNED_URL     ← wins for ACME
  security.signingAlgorithm = HmacSHA512
  custom.NG_CBN_REF = "required"

Effective for ACME_NG:
  security.maskingLevel = FULL       (from GLOBAL)
  security.signingAlgorithm = HmacSHA512 (from PARTNER)
  file.deliveryMethod = SIGNED_URL     (from PARTNER)
  file.archiveStore = S3               (from COUNTRY)
  camel.maxRetries = 3                 (from GLOBAL)
```

***

## 11. Publish and Validation

### 11.1 Unified Publish Workflow

Publishing a `customization_profile` triggers:

1. **Schema validation** — each library block validated against JSON Schema
2. **Extension reference check** — plugin IDs, script IDs, sql task IDs exist
3. **Hook validation** — hook points exist in `ExtensionRegistry`
4. **Cross-library consistency** — e.g. if `deliveryMethod=SIGNED_URL`, file store must support signing
5. **Simulation** — optional end-to-end test harness
6. **Approval** — supervisor sign-off
7. **Publish** — status → PUBLISHED, version++
8. **Cache invalidation** — `h2h.customization.published` Kafka event → all libraries refresh

### 11.2 Cross-Library Consistency Rules (examples)

| Rule                                                                         | Libraries involved         |
| ---------------------------------------------------------------------------- | -------------------------- |
| Signed URL delivery requires S3-compatible archive or outbound store         | file-management            |
| Custom log field must exist in `custom_attribute_def`                        | observability + config     |
| Finacle operation override must exist in `FinacleOperationProvider` registry | finacle + extension-kernel |
| Script referenced in hook must be PUBLISHED                                  | script-engine + kernel     |
| Masking level NONE requires auditor role permission                          | security + RBAC            |

***

## 12. Module Architecture

```
h2h-extension-api/              # SPI interfaces (no implementation)
├── ExtensionProvider.java
├── ExtensionRegistry.java
├── CustomizationProfile.java
├── CustomizationResolver.java
├── Customizer.java
├── ContextEnricher.java
├── HookExecutor.java
└── blocks/                     # SecurityCustomization, FileManagementCustomization, etc.

h2h-extension-kernel/           # Implementation
├── DefaultExtensionRegistry.java
├── DefaultCustomizationResolver.java
├── CustomizationCache.java
├── ExtensionValidator.java
├── HookExecutorImpl.java
└── config/
    └── ExtensionKernelAutoConfiguration.java

Each library implements:
├── {Library}ExtensionProvider.java
├── customizer/*Customizer.java
└── (optional) plugin SPI implementations
```

### 12.1 Dependency Graph

```
h2h-extension-api
    ↑
h2h-extension-kernel
    ↑
├── h2h-security          (implements ExtensionProvider)
├── h2h-file-management
├── h2h-observability
├── h2h-context
├── h2h-camel-core
├── h2h-finacle-wrapper
├── h2h-transform-core
├── h2h-job-scheduler
├── h2h-script-engine
└── h2h-*-routes

h2h-context consumes CustomizationProfile (from extension-api)
All libraries consume H2hContext (which carries CustomizationProfile)
```

***

## 13. Implementation Checklist per Library

When building or extending any platform library, verify:

| #  | Requirement                                                                   |
| -- | ----------------------------------------------------------------------------- |
| 1  | Implements `ExtensionProvider` with all extension points documented           |
| 2  | Accepts `CustomizationProfile` + `H2hContext` — no direct partner `if` checks |
| 3  | Registers `Customizer` beans for configurable behavior                        |
| 4  | Contributes defaults via `contributeDefaults()`                               |
| 5  | Validates customization block in `validate()`                                 |
| 6  | Supports hooks at documented hook points                                      |
| 7  | Emits audit/metrics using context fields (including custom attributes)        |
| 8  | ArchUnit test: no hardcoded partner/country literals                          |
| 9  | Integration test: customization override changes behavior                     |
| 10 | Admin JSON Schema published for config block                                  |

***

## 14. Customization Without Redeploy

| Change type                               | Redeploy needed? | Mechanism                                                |
| ----------------------------------------- | ---------------- | -------------------------------------------------------- |
| Partner delivery method SFTP → signed URL | No               | Publish customization profile                            |
| Add custom attribute                      | No               | Admin attribute designer                                 |
| New validation script on hook             | No               | Publish script + hook                                    |
| Adjust SLA threshold                      | No               | Observability block in profile                           |
| New CBS operation type                    | Yes (plugin JAR) | `CoreBankingOperationProvider` in `h2h-core-banking-api` |
| New Finacle operation type                | Yes (plugin JAR) | `FinacleOperationProvider` extends CBS SPI               |
| New file store backend (e.g. GCS)         | Yes (plugin JAR) | `FileStore` SPI plugin                                   |
| New pipeline step type                    | Yes (plugin JAR) | `StepTypeProvider` plugin                                |

***

## 15. Relationship to Other Documents

| Document                                                                             | Relationship                                                          |
| ------------------------------------------------------------------------------------ | --------------------------------------------------------------------- |
| [Extensibility Framework](/docs/14-extensibility-framework.md)                       | Scripts, jobs, custom tables — this doc unifies them across libraries |
| [Database-Driven Configuration](/docs/04-database-driven-configuration.md)           | Integration profiles merge with customization profiles                |
| [Execution Context](/docs/18-execution-context.md)                                   | `H2hContext` carries `CustomizationProfile`                           |
| [Design Patterns](/docs/13-design-patterns.md)                                       | Strategy, Registry, Observer applied per library                      |
| [Modular JAR Architecture](/docs/03-modular-jar-architecture.md)                     | Plugin JAR structure                                                  |
| Per-library docs (15–19)                                                             | Each library's extension points detailed in §5                        |
| [Event-Driven Runtime Extensibility](/docs/21-event-driven-runtime-extensibility.md) | Kafka subscriptions and runtime event handlers                        |

***

## 16. Summary

| Concept                       | Implementation                                                    |
| ----------------------------- | ----------------------------------------------------------------- |
| All libraries extendable      | `ExtensionProvider` SPI per library                               |
| Customization across solution | Single `CustomizationProfile` merged by scope                     |
| Propagation                   | `H2hContext` bus + `ContextEnricher`                              |
| Admin experience              | One designer, inheritance viewer, single publish                  |
| Plugins                       | Standard JAR structure targeting multiple libraries               |
| Hooks                         | Unified `hook_def` catalog namespaced by library                  |
| Validation                    | `ExtensionRegistry` validates entire profile at publish           |
| No silos                      | Kernel orchestrates; libraries never own private extension models |


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://host2host.onibonje.com/docs/20-universal-library-extensibility.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.