Skip to content
Documentation Index
Start Here

Documentation Index

Landing page and reading-order guide for the APIMaster documentation suite; links every other document and explains who each is for.

docs/DOC_INDEX.md
all
Docs revision
0.10.1-rc.3
Runtime
0.10.1-rc.3
Commit
605660ba1d61
Build date
2026-09-09T06:58:02.000Z

APIMaster Integration Workbench — Documentation Index


What is APIMaster Integration Workbench?

**APIMaster is a total integration intelligence workbench built around APIs and integration
contracts.** It covers the entire API lifecycle — **import → design → mock → map → run → govern →
ship-readiness** — inside a single browser app. There is no vendor workspace-sync backend or account
system: application-managed workspace state is browser-local by default. Explicit/configured remote
operations, same-origin asset loads, browser navigation and the APIMaster-owned first-party local
error negative control are recorded in the 11-record Trust manifest. The error boundary has no
remote sink by default.

That architectural choice makes the workspace local-first by default: primary workspace data is
kept in browser storage rather than synchronized to a vendor workspace backend. Explicitly initiated
or configured capabilities can still use the network—for example live REST/GraphQL/realtime calls,
URL imports, the local companion sandbox, schedules, and webhooks. Review the Trust page before
using those capabilities with sensitive data.

An integration is more than its endpoint definitions, and the product is organised accordingly, into
five capability domains:

DomainWhat it is forWhere it lives
Integration landscapeEvery API in the estate with its owner, criticality and the consumers depending on it./catalog, /portfolio, /consumers, /api-inventory
Scenario designCross-system behaviour made explicit: steps, participants, data, validation./scenarios, /scenario-builder, /scenario-catalog, /execution
Definition workspaceImport, author, validate, version, publish and document OpenAPI definitions./swaggermaster (SwaggerMaster), /import, /api-explorer
Contract IntelligenceHow contracts evolve, and what that costs the systems already consuming them./contract-radar, /change-intelligence, /schema-diff, /compatibility-matrix
Event & async contractsAsyncAPI event contracts — register, version, compare and document them./event-intelligence (Event Intelligence), /realtime

Contract Intelligence is one domain, not the product. Its promise — _catch breaking API changes
before they break consumers_ — is precise and belongs to it; APIMaster also designs definitions,
models scenarios, describes event contracts and maps an estate's dependencies. See
NAVIGATION_TREE.md for how these map onto the seven sidebar groups.

Documentation currency (2026-09-03). Several documents in this set were written for revision
v0.9.0 and carry a Coverage note saying so. The capability areas added since —
SwaggerMaster, Event Intelligence, Workspace Blueprints and local multitenancy under
/access — are catalogued in FEATURE_CATALOG.md and
NAVIGATION_TREE.md, which are current.

  • Canonical site: <https://apimaster.dev/>
  • In-app help center: the Documentation Center at /docs renders this same documentation
    • Compatibility identifiers: legacy apibox.* storage keys and useApiBoxStore symbols remain intentionally unchanged.

    New here? Jump to Start here — by persona for the fastest path to
    being productive in your role.


    The documentation set

    The help center combines the core reference set with current security, recovery, legal-draft and
    operations material. Every entry is grounded in the real routes, entities and code of APIMaster
    Integration Workbench; verified facts are kept separate from inferred ones and every legal document
    is visibly marked non-operative. The in-app Documentation Center (/docs) discovers and
    renders these files; the Help Menu masterfile is the machine-readable
    manifest that drives the in-app menu.

    Newest addition (v0.9.1): the Readiness Platform Guide documents the
    now ten-dimension Readiness Scorecard and the four dedicated readiness pages (API Inventory,
    Resilience Lab, Agent Readiness, Compatibility Matrix) added since the v0.9.0 wave.

    #DocumentAudienceSummary
    1Documentation Index (this page)EveryoneThe landing page: what the product is, the full doc table, per-persona start paths, and pointers to /docs and the masterfile.
    2Business System ReferenceProduct, engineering, operations, supportThe big-picture reference: what the product is, the value proposition, the module map, and how the lifecycle stages fit together as one system.
    3User ManualEnd users, support, operationsEnd-to-end, operational walkthrough of the app — the shell (sidebar, command palette Ctrl/Cmd+K, g-key chords, theme, tour), every Workspace/Modeling/Runtime screen, and how to actually do each task.
    4Process FlowsProduct, operations, support, engineeringThe core end-to-end processes (import, design→scenario→run, mapping→review→lock, schema-change→CI gate, spec-watch→notify, readiness→PDF, gateway smoke, scheduled runs, evidence bundle, encrypted export, role/lock denial) as Mermaid flows with prose.
    5Navigation TreeSupport, product, engineeringThe complete route map — every sidebar group, label and path, plus detail and public routes — as a navigable tree.
    6Technical ArchitectureEngineering, architecture, security, devopsTech stack, the offline-first/SSR architecture, the store and persistence model, the src/lib/checks engine contract, and local development.
    7Feature CatalogProduct, support, engineeringOne reference section per route/module (what it is, who it's for, how to use it, what it persists), covering every screen in the navigation — including the Readiness Scorecard and the five check modules.
    8Role Permission MatrixProduct, support, security, engineeringThe four roles (owner/editor/operator/viewer), the persona mapping, impersonation, production locks, mapping reviews, and the append-only audit log.
    9Data Flow & Entity ReferenceEngineering, data, productThe domain entity model (src/domain/types.ts), where state lives (apibox.state.v5 + awp.* keys), the ordered 11-record Trust manifest, runner boundary, and end-to-end data journeys.
    10Change Intelligence AppendixEngineering, product, QA, supportFeature-evolution timeline (0.7.0 → 0.9.0), recurring bug classes, fragile/migration-sensitive areas, and the "do-not-rebreak" knowledge mined from the changelog and lessons file.
    11Help Menu MasterfileFrontend, engineering, docs systemThe machine-readable manifest that drives the in-app help menu: every document with its metadata, plus navigation/feature/process/role/entity indexes.
    12Documentation Generation ReportMaintainers, engineeringProvenance of this documentation set: scope analyzed, documents generated, Mermaid coverage, confidence assessment, evidence gaps, and recommendations.
    13Readiness Platform GuideTech Leads/Owners, designers, engineers, ops, securityDeep-dive on the ten-dimension Readiness Scorecard (how the weighted score and ship/caution/blocked verdict are computed) and the four dedicated readiness pages — API Inventory, Resilience Lab, Agent Readiness, Compatibility Matrix — with per-dimension rules and a step-by-step readiness workflow.

    The Readiness Scorecard (/readiness) — now ten dimensions — and its dedicated check
    surfaces (Governance & Lint, Security Posture, Trace Readiness, Drift Radar, Validation Engine,
    API Inventory, Resilience Lab, Agent Readiness, Compatibility Matrix) are covered end-to-end in the
    Readiness Platform Guide and enumerated in the
    Feature Catalog; their end-to-end flows are in
    Process Flows and their data/engine contract in
    Technical Architecture.

    Pre-existing provenance docs (preserved, cross-linked — not part of the numbered help set):
    ARCHITECTURE.md, GDPR.md,
    trust/security-overview.md,
    trust/DPA-template.md. These are the source-of-truth provenance pages a
    security or procurement reviewer reads; the help-center docs cross-link them and never duplicate
    them.

    Current production-readiness material:
    Security disclosure policy,
    Recovery and restore guide,
    public uptime monitoring,
    incident runbook and
    communication templates. The
    Privacy Notice,
    Terms, Pilot SOW and
    DPA are DRAFT — NOT LEGAL APPROVAL and do not clear any legal gate.


    Start here — by persona

    APIMaster Integration Workbench is role-aware. You set your active role by impersonation in Settings
    (/settings); each persona has a default role (see Role Permission Matrix).
    Below is the fastest productive path for each.

    API Designer (default role: editor)

    You import specs and shape endpoints, schemas and scenarios.

    1. User Manual → the shell + the API Catalog & Import (/catalog, /import)
      • Process Flows Import OpenAPI and _Endpoint design → scenarios →
        • Feature CatalogData Packs (/data-packs), Scenarios
          • Feature Catalog → run a Governance & Lint (/governance) pass on your

            Integration Engineer (default role: editor)

            You wire APIs together with field mappings and run scenario suites.

            1. User ManualAPI Explorer (/api-explorer) and Mapping Studio
              • Process Flows Mapping build → review → production lock and _Schema
                • Feature CatalogMapping Reviews (/mapping-reviews), Prevalidation
                  • Change Intelligence Appendix → understand which modules a spec

                    Ops / SRE (default role: operator)

                    You run, configure browser-open schedules, smoke-test and monitor — but cannot change locked
                    production mappings. Browser close/sleep stops continuous in-app ticking; the local one-shot runner
                    requires a separate explicit invocation.

                    1. Feature CatalogEnvironments (/environments), Gateway Smoke
                      • Process Flows Gateway export → smoke and _Scheduled run tick →
                        • Feature CatalogDrift Radar (/drift-radar) and
                          • Role Permission Matrix → what production locks deny you and why.

                          Tech Lead / Owner (default role: owner)

                          You own production locks, govern reviews, and decide what ships.

                          1. Feature Catalog → the Readiness Scorecard (/readiness) and its
                            • Change Intelligence Appendix → the change-intelligence loop and
                              • Process Flows Mapping → review → lock and Readiness check → PDF.
                              • Role Permission Matrix and GDPR.md → governance model

                                Auditor / Viewer (default role: viewer)

                                You inspect, verify and export evidence — read-only.

                                1. Feature CatalogAudit Log (/audit), Trust Center (/trust).
                                2. Process Flows Evidence bundle export (audit-grade).
                                3. GDPR.md and trust/security-overview.md → the
                                  • Data Flow & Entity Reference → verify browser-local storage

                                    Procurement / Security reviewer

                                    You assess risk before adoption.

                                    1. GDPR.md → GDPR Art. 5 / 25 / 32 mapped to architectural answers.
                                    2. ARCHITECTURE.md → the ordered 11-record Trust manifest, runner boundary and
                                      • trust/security-overview.md and trust/DPA-template.md.
                                      • Data Flow & Entity Reference → the verifiable storage-key
                                        • Security disclosure policy and
                                          • Review the clearly non-operative legal drafts only as

                                            The whole app at a glance

                                            The navigation groups every route. Use this as a map; each module has a full section in the
                                            Feature Catalog, and the complete route tree is in
                                            Navigation Tree.

                                            Diagram (Mermaid) — renders on GitHub
                                            flowchart TD
                                              subgraph WS[Workspace]
                                                O["/ Overview"]
                                                CAT["/catalog · Import"]
                                                EXP["/api-explorer"]
                                                GQL["/graphql"]
                                                RT["/realtime"]
                                                TMF["/tmf"]
                                              end
                                              subgraph MOD[Modeling]
                                                DP["/data-packs"]
                                                SC["/scenarios"]
                                                MAP["/mappings"]
                                                MR["/mapping-reviews"]
                                                ERR["/errors"]
                                                SD["/schema-diff"]
                                              end
                                              subgraph RUN[Runtime]
                                                ENVR["/environments"]
                                                PRE["/prevalidation"]
                                                EXEC["/execution"]
                                                GS["/gateway-smoke"]
                                                CI["/ci-gate"]
                                                SCH["/schedules"]
                                                MF["/mock-forge"]
                                              end
                                              subgraph INTEL[Intelligence]
                                                INS["/insights"]
                                                CHI["/change-intelligence"]
                                                OAI["/openai"]
                                                AEX["/explorer"]
                                              end
                                              subgraph RDY[Readiness]
                                                RScore["/readiness"]
                                                GOV["/governance"]
                                                SECP["/security-posture"]
                                                TR["/trace-readiness"]
                                                DR["/drift-radar"]
                                                VE["/validation-engine"]
                                                INV["/api-inventory"]
                                                RL["/resilience-lab"]
                                                AR["/agent-readiness"]
                                                CM["/compatibility-matrix"]
                                              end
                                              subgraph GOVN[Governance]
                                                AUD["/audit"]
                                                TRUST["/trust"]
                                                ENT["/enterprise"]
                                                SET["/settings"]
                                                HELP["/help · /docs"]
                                              end
                                              WS --> MOD --> RUN --> RDY
                                              RUN --> INTEL
                                              RDY --> GOVN

                                            _Diagram: the navigation groups (Workspace, Modeling, Runtime, Intelligence, Readiness, Governance)
                                            and the rough left-to-right lifecycle flow. Detail routes (/api/$apiId,
                                            /api/$apiId/endpoint/$endpointId, advanced /import) and the public, full-bleed routes
                                            (/welcome, /pricing) sit outside these groups._


                                            Where to read these docs

                                            • In the app: open the Documentation Center at /docs — it renders this exact docs
                                              • In the repo / on GitHub: browse the docs/ folder. Start with this index, then follow
                                                • Programmatically: the Help Menu masterfile lists every document

                                                  To learn how this documentation system is wired and how to extend it, see
                                                  docs/README.md.

                                                  APIMaster Integration Workbench · docs 0.10.1-rc.3 · runtime 0.10.1-rc.3 Back to top