@researchdatabox/redbox-dev-tools 0.0.1-beta.8936

package/skills/redbox-web-verification/redbox-controllers/SKILL.md

@@ -0,0 +1,56 @@
+# Skill: Redbox Controllers
+
+## Context
+
+ReDBox controllers live in `@researchdatabox/redbox-core` and are surfaced to Sails.js through generated shims.
+
+## Locations
+
+- API controllers: `packages/redbox-core/src/controllers/`
+- Webservice controllers: `packages/redbox-core/src/controllers/webservice/`
+
+## Patterns
+
+- Extend `Controllers.Core.Controller`.
+- Implement `init()` for sails-dependent setup (avoid using `sails` in constructors).
+- Use `_exportedMethods` to define which methods are exposed.
+- Actions are usually `async index(req, res)`.
+- **Response Handling:** Use `this.sendResp(data, req, res)` instead of direct `res.json()` or `res.send()`. This ensures consistent response formatting.
+
+## Generating Controllers
+
+Use the `redbox-dev-tools` CLI generator `generate controller`:
+
+- `name`: Controller name (e.g., `MyRecord`) as an argument.
+- `--actions <list>`: Comma-separated actions (e.g., `index,get,save`).
+- `--webservice`: If it's a webservice controller.
+- `--routes <routes>`: Action-to-route mappings: `action:verb:path[:role1:role2],...` (e.g., `list:get:/api/items:Admin:Researcher`).
+- `--auth <roles>`: Default roles for auth rules (can be overridden per-route).
+
+## Adding Methods
+
+Use `redbox-dev-tools generate method` to add actions to an existing controller:
+
+- `--file <path>`: Path to the controller file.
+- `--method <name>`: Method name.
+- `--route <route>`: Route path (e.g., `/api/new-path`).
+- `--http <verb>`: HTTP verb (GET, POST, etc.).
+- `--auth <roles>`: Auth roles.
+
+## Index Updates
+
+When adding a controller, you must update `packages/redbox-core/src/controllers/index.ts`:
+
+- Import the controller module.
+- Add to `ControllerExports` (or `WebserviceControllerExports`) with a lazy getter.
+- Add to `ControllerNames` (or `WebserviceControllerNames`) array.
+
+## Route Configuration
+
+Routes are defined in `packages/redbox-core/src/config/routes.config.ts`.
+Pattern: `'get /api/my-path': { controller: 'MyController', action: 'index' }`
+
+## Auth Rules
+
+Auth rules are defined in `packages/redbox-core/src/config/auth.config.ts`.
+Pattern: `{ path: '/api/my-path', role: 'admin', can_read: true }`

package/skills/redbox-web-verification/redbox-form-config/SKILL.md

@@ -0,0 +1,29 @@
+# Skill: Redbox Form Config
+
+## Context
+ReDBox uses a JSON-based DSL for configuring record forms, workflows, and record types.
+
+## Locations
+- Form configurations: `config/form.js`
+- Workflow configurations: `config/workflow.js`
+- Record type configurations: `config/recordtype.js`
+
+## Key Concepts
+- **Record Type**: Defines the entity (e.g., `rdmp`) and its search filters.
+- **Workflow**: Defines stages (e.g., `draft`, `review`), transitions, roles, and which form to use at each stage.
+- **Form**: Defines the layout and fields.
+- **Field**: Each field has a `class` (usually `Container`), a `compClass` (the Angular component name, e.g., `TextBlockComponent`), and a `definition`.
+
+## Generating Form Fields
+Use the `redbox-dev-tools` CLI generator `generate_form_field`:
+- `name`: Field name as an argument.
+- `--type <type>`: Record type (e.g., `rdmp`).
+
+## Form Expressions
+Dynamic behavior is handled via `expressions`:
+- Listen to events using JSON Pointer paths (e.g., `/form_tab/source_field::field.value.changed`).
+- Apply conditions and templates (using JSONata).
+- Target model or component properties.
+
+## Language Files
+Labels and messages should use keys (starting with `@`) that map to entries in `assets/locales/<language>/translation.json`.

package/skills/redbox-web-verification/redbox-hook-development/SKILL.md

@@ -0,0 +1,61 @@
+# Skill: Redbox Hook Development
+
+## Context
+
+ReDBox hooks are NPM packages that extend or customize ReDBox functionality. They are loaded during the Sails lift process.
+
+## Project Structure
+
+- `redbox-hook-[project-name]`
+- `typescript/`: TypeScript source code.
+- `assets/`: Custom assets.
+- `views/`: Custom EJS views.
+- `config/`: Configuration overrides.
+- `form-config/`: Form configuration overrides.
+
+## Hook Capabilities
+
+Declared in `package.json` under the `sails` key:
+
+- `hasModels`: Provides Waterline models.
+- `hasPolicies`: Provides Sails policies.
+- `hasServices`: Provides business logic services (can override core).
+- `hasControllers`: Provides internal/app controllers (Sails controllers used by the portal).
+- `hasWebserviceControllers`: Provides HTTP/webservice-facing controllers (API endpoints).
+- `hasBootstrap`: Provides a startup function.
+- `hasConfig`: Provides configuration object to merge.
+
+## Required Exports
+
+The hook's main entry point (usually `index.ts` compiled to `index.js`) must export registration functions **only** for the capabilities enabled in `package.json`:
+
+- `registerRedboxModels()` — required when `hasModels` is `true`.
+- `registerRedboxPolicies()` — required when `hasPolicies` is `true`.
+- `registerRedboxServices()` — required when `hasServices` is `true`.
+- `registerRedboxControllers()` — required when `hasControllers` is `true` (internal/app controllers).
+- `registerRedboxWebserviceControllers()` — required when `hasWebserviceControllers` is `true` (HTTP/webservice controllers).
+- `registerRedboxBootstrap()` — required when `hasBootstrap` is `true`.
+- `registerRedboxConfig()` — required when `hasConfig` is `true`.
+
+If a capability is disabled, its matching export must be omitted.
+
+## Development with Hook Kit
+
+The `redbox-dev-tools` CLI simplifies hook development:
+
+- Use `init` to scaffold a new project.
+- Use generators to add components (controllers, services, etc.).
+- Use `redbox-dev-tools generate model` to add Waterline models.
+
+## Generating Models
+
+Use the `redbox-dev-tools` CLI generator `generate model`:
+
+- `--identity <identity>`: Waterline identity (table name), defaults to lowercase name.
+- `--attrs <attrs>`: Comma-separated list of attributes (e.g. `name:string:required,age:number`).
+- `--belongs-to <associations>`: Comma-separated belongsTo associations (e.g. `owner:user`).
+- `--has-many <associations>`: Comma-separated hasMany associations (e.g. `pets:animal:owner`).
+
+## Overriding Core Components
+
+To override a core service or controller, register a component with the same name as the core one. It is recommended to extend the core class in your implementation.

package/skills/redbox-web-verification/redbox-services/SKILL.md

@@ -0,0 +1,45 @@
+# Skill: Redbox Services
+
+## Context
+
+ReDBox business logic is encapsulated in TypeScript services in `@researchdatabox/redbox-core`.
+
+## Locations
+
+- Services: `packages/redbox-core/src/services/`
+- Index: `packages/redbox-core/src/services/index.ts`
+
+## Patterns
+
+- Extend `Services.Core.Service`.
+- Implement `bootstrap()` for initialization.
+- Use `_exportedMethods` to define exposed methods.
+- Often use RxJS Observables for async operations.
+- Access Waterline models via globals (e.g., `declare var Record: Model;`).
+
+## Generating Services
+
+Use the `redbox-dev-tools` CLI generator `generate_service`:
+
+- `name`: Service name (e.g., `Records`) as an argument.
+- `--methods <list>`: Comma-separated initial methods.
+
+## Adding Methods
+
+Use `redbox-dev-tools generate method` to add methods to an existing service:
+
+- `--file <path>`: Path to the service file.
+- `--method <name>`: Method name.
+
+## Index Updates
+
+When adding a service, update `packages/redbox-core/src/services/index.ts`:
+
+- Import the service module.
+- Re-export the service.
+- Add to `ServiceExports` with a lazy getter.
+
+## Overriding Services in Hooks
+
+Hooks can override core services by registering them in `registerRedboxServices`.
+Override services should extend the core service they are replacing.

package/skills/redbox-web-verification/redbox-testing/SKILL.md

@@ -0,0 +1,53 @@
+# Skill: Redbox Testing
+
+## Context
+ReDBox uses Mocha for integration testing and Bruno for API testing. All integration tests are run within Docker containers managed by docker-compose profiles.
+
+## Mocha Tests
+Mocha tests are located in `packages/*/test`. To run them, they are executed within a Docker environment.
+
+### Commands
+- **Run all Mocha tests (Development):**
+  ```bash
+  npm run test:mocha:mount
+  ```
+  This mounts your local code into the test containers, allowing for faster iteration.
+
+- **Run all Mocha tests (CI):**
+  ```bash
+  npm run test:mocha
+  ```
+  This runs the tests using the `portal` profile without mounting local code.
+
+- **Clean up Mocha test resources:**
+  ```bash
+  npm run test:mocha:clean
+  ```
+
+## Bruno Tests
+Bruno is used for API testing. Tests are located in `test/bruno`.
+
+### Commands
+- **Run Bruno OIDC tests (Development):**
+  ```bash
+  npm run test:bruno:oidc:mount
+  ```
+  This runs tests specifically for OIDC authentication flows with mounted code.
+
+- **Run Bruno General tests (Development):**
+  ```bash
+  npm run test:bruno:general:mount
+  ```
+  This runs a general suite of Bruno tests with mounted code.
+
+- **Run Bruno tests (CI):**
+  The non-mount variants (e.g. `npm run test:bruno:oidc`) are intended for CircleCI builds.
+
+- **Cleanup:**
+  Use the corresponding clean command for the test suite you ran:
+  - `npm run test:bruno:clean`
+  - `npm run test:bruno:oidc:clean`
+  - `npm run test:bruno:general:clean`
+
+## Docker Profiles
+These commands utilize Docker Compose profiles to start the necessary services (e.g., `redboxportal`, `keycloak`, `mongo`, `solr`). The `package.json` scripts define which profiles and compose files are used for each test suite.

package/skills/redbox-web-verification/redbox-web-verification/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: "Web Interface Verification"
+description: "This skill outlines the workflow for verifying the Redbox Portal web interface using the Agent's built-in browser capabilities and natural language test scripts."
+---
+
+# Skill: Web Interface Verification
+
+## Context
+This skill outlines the workflow for verifying the Redbox Portal web interface using the Agent's built-in browser capabilities and natural language test scripts.
+
+## Workflow
+
+### 1. Start the Application
+Start the application in development mode with the mount profile.
+**Important:** Capture the `CommandId` returned by this command to monitor logs later.
+
+```bash
+npm run dev:run
+```
+
+Wait for the application to be ready (look for "Sails lifted").
+
+### 2. Launch Browser
+Use the `browser_subagent` tool to launch a browser session.
+- **TaskName:** Web Verification
+- **Task:** "Open http://localhost:1500 and [Insert Natural Language Script Here]"
+
+### 3. Execute Natural Language Script
+Follow the natural language instructions provided by the user.
+**Example Script:**
+1. "Login to the system."
+2. "Expectation: You are navigated to `/researcher/home`."
+3. "Navigate to 'My Data'."
+4. "Verify the 'Create Record' button is visible."
+
+**Agent Responsibilities:**
+- translate high-level actions (e.g., "Login") into interaction steps (type username, type password, click login).
+- Verify URLs and UI elements match expectations.
+
+### 4. Monitor Logs
+While the browser session is active or after a step fails, check the logs of the running application using the `command_status` tool and the captured `CommandId`.
+- Look for server-side errors (500s, exceptions) that correlate with UI actions.
+
+### 5. Report Findings
+After completing the script or encountering a failure, report the results to the user.
+- **Success:** Confirm all steps passed.
+- **Failure:** Detail which step failed, the observed vs. expected behavior, and any relevant server logs.

package/templates/hook-archetype/standard/.gitignore.hbs

@@ -0,0 +1,4 @@
+dist
+node_modules
+.tmp
+coverage

package/templates/hook-archetype/standard/.npmignore.hbs

@@ -0,0 +1,3 @@
+src
+test
+support

package/templates/hook-archetype/standard/.npmrc.hbs

@@ -0,0 +1,6 @@
+save-exact=true
+save-prefix=
+ignore-scripts=true
+provenance=true
+registry=https://registry.npmjs.org/
+audit-level=moderate

package/templates/hook-archetype/standard/.nvmrc.hbs

@@ -0,0 +1 @@
+24

package/templates/hook-archetype/standard/AGENTS.md.hbs

@@ -0,0 +1,34 @@
+# {{packageName}} Agent Guide
+
+This hook follows the standard ReDBox hook archetype generated by `@researchdatabox/redbox-dev-tools init`.
+
+Keep these rules in place unless the user explicitly asks to change the hook model.
+
+## Dependency Contract
+
+- `@researchdatabox/redbox-core` is the runtime compatibility anchor.
+- `@researchdatabox/redbox-dev-tools` is the shared authoring and test toolchain.
+- Direct hook `dependencies` are reserved for hook-owned runtime packages only.
+
+Do not directly add shared runtime or toolchain packages such as:
+
+- `axios`
+- `rxjs`
+- `lodash`
+- `typescript`
+- `ts-node`
+- `mocha`
+- `chai`
+- `@researchdatabox/sails-ng-common`
+
+## Compile And Test
+
+Use the existing scripts in `package.json`.
+
+Do not replace the custom `run-hook-tsc` or `run-hook-mocha` entrypoints with plain `tsc` or `mocha`.
+
+## Docker Runtime
+
+The docker compose files intentionally set `NODE_PATH` so a mounted hook can resolve host-provided runtime dependencies from the Redbox portal dependency tree.
+
+Do not remove that unless the runtime install model changes deliberately.

package/templates/hook-archetype/standard/Dockerfile.hbs

@@ -0,0 +1,28 @@
+ARG REDBOX_BASE_IMAGE=qcifengineering/redbox-portal:develop-pdfgen
+
+FROM ${REDBOX_BASE_IMAGE} AS builder
+
+USER root
+
+COPY {{packageName}} /opt/{{packageName}}
+COPY redbox-portal/packages/redbox-core /opt/redbox-portal/packages/redbox-core
+COPY redbox-portal/packages/sails-ng-common /opt/redbox-portal/packages/sails-ng-common
+COPY redbox-portal/packages/redbox-dev-tools /opt/redbox-portal/packages/redbox-dev-tools
+
+RUN --mount=type=cache,target=/root/.npm \
+  cd /opt/{{packageName}} \
+  && npm install --include=dev --ignore-scripts --legacy-peer-deps \
+  && npm run compile \
+  && cd /opt/redbox-portal \
+  && npm install --legacy-peer-deps --ignore-scripts /opt/{{packageName}} \
+  && mkdir -p /opt/redbox-portal/views /opt/redbox-portal/assets /opt/redbox-portal/language-defaults \
+  && if [ -d /opt/{{packageName}}/views ]; then cp -a /opt/{{packageName}}/views/. /opt/redbox-portal/views/; fi \
+  && if [ -d /opt/{{packageName}}/assets ]; then cp -a /opt/{{packageName}}/assets/. /opt/redbox-portal/assets/; fi \
+  && if [ -d /opt/{{packageName}}/language-defaults ]; then cp -a /opt/{{packageName}}/language-defaults/. /opt/redbox-portal/language-defaults/; fi
+
+FROM ${REDBOX_BASE_IMAGE} AS {{packageName}}
+USER root
+
+COPY --from=builder --chown=node:node --chmod='u=rwx,g=rx,o=rx' /opt/redbox-portal /opt/redbox-portal
+
+USER node

package/templates/hook-archetype/standard/README.md.hbs

@@ -0,0 +1,39 @@
+# {{packageName}}
+
+A generated ReDBox hook archetype.
+
+This project keeps its dependency declarations intentionally small:
+
+- `@researchdatabox/redbox-core` is the ReDBox runtime compatibility contract
+- `@researchdatabox/redbox-dev-tools` provides the shared compile and unit-test toolchain
+- direct `dependencies` are reserved for hook-owned runtime libraries only
+- the generated package versions assume `redbox-core` and `redbox-dev-tools` are installed from npm, not from a sibling `redbox-portal` checkout
+
+## Development
+
+```bash
+npm install
+npm run compile
+npm run test:unit
+```
+
+Local installs intentionally allow lifecycle scripts so native modules and other postinstall hooks can run. Use `npm install --ignore-scripts` only in controlled CI or container contexts where that trade-off is deliberate.
+
+For the docker-backed portal harness:
+
+```bash
+npm run dev:run:build
+npm run dev:run
+```
+
+The development compose stack expects a locally trusted CA certificate at `support/development/certs/dev-ca.pem` and mounts it with `NODE_EXTRA_CA_CERTS`. Generate that certificate with your local CA tooling, for example `mkcert -CAROOT`, before starting the stack.
+
+## Structure
+
+- `src/index.ts`: hook entrypoint using `defineRedboxHook()`
+- `src/api/controllers`: hook controllers
+- `src/api/services`: hook services
+- `src/config`: configuration and reusable form definition helpers
+- `src/form-config`: form config exports
+- `test/unit`: fast hook-local TypeScript tests
+- `test/integration`: portal integration tests

package/templates/hook-archetype/standard/assets/fonts/.gitkeep

@@ -0,0 +1 @@
+

package/templates/hook-archetype/standard/language-defaults/.gitkeep

@@ -0,0 +1 @@
+

package/templates/hook-archetype/standard/package.json.hbs

@@ -0,0 +1,40 @@
+{
+  "name": {{json packageName}},
+  "version": "1.0.0",
+  "description": {{json description}},
+  "main": "dist/index.js",
+  "sails": {
+    "isHook": true,
+    "hookName": {{json packageName}},
+    "hasControllers": true,
+    "hasServices": true,
+    "hasConfig": true,
+    "hasFormConfigs": true
+  },
+  "scripts": {
+    "compile": "node ./node_modules/@researchdatabox/redbox-dev-tools/bin/run-hook-tsc.js -p tsconfig.json",
+    "test": "npm run test:unit && npm run test:integration:mocha",
+    "test:unit": "TS_NODE_PROJECT=./test/tsconfig.json npm run compile && node ./node_modules/@researchdatabox/redbox-dev-tools/bin/run-hook-mocha.js --config ./test/unit/.mocharc.cjs ./test/unit",
+    "test:integration:mocha": "npm run compile &&docker compose -f ./support/integration-testing/docker-compose.mocha.yml up --build --menu=false --abort-on-container-exit --exit-code-from redboxportal",
+    "test:integration:mocha:clean": "docker compose -f ./support/integration-testing/docker-compose.mocha.yml down -v --remove-orphans --timeout 180",
+    "dev:run": "docker compose -f ./support/development/docker-compose.yml up --menu=false --abort-on-container-exit --exit-code-from rbportal",
+    "dev:run:build": "docker compose -f ./support/development/docker-compose.yml build",
+    "dev:run:clean": "docker compose -f ./support/development/docker-compose.yml down -v --remove-orphans --timeout 180",
+    "dev:run:prepare": "mkdir -p ./support/development/.tmp/attachments/staging"
+  },
+  "keywords": [
+    "sails",
+    "hook",
+    "redbox"
+  ],
+  "license": "GPL-3.0",
+  "dependencies": {},
+  "peerDependencies": {
+    "@researchdatabox/redbox-core": {{json redboxCoreVersion}}
+  },
+  "devDependencies": {
+    "@researchdatabox/redbox-core": {{json redboxCoreVersion}},
+    "@researchdatabox/redbox-dev-tools": {{json redboxDevToolsVersion}},
+    "@types/node": "24.12.2"
+  }
+}

package/templates/hook-archetype/standard/src/api/controllers/ExampleController.ts.hbs

@@ -0,0 +1,21 @@
+import { Controllers as CoreControllers } from '@researchdatabox/redbox-core';
+
+export namespace Controllers {
+  export class Example extends CoreControllers.Core.Controller {
+    protected _exportedMethods: string[] = [
+      'index'
+    ];
+
+    public async index(_req: Sails.Req, res: Sails.Res): Promise<unknown> {
+      return res.json({
+        hook: '{{packageName}}',
+        status: 'ok'
+      });
+    }
+  }
+}
+
+export type ExampleController = ReturnType<Controllers.Example['exports']>;
+export const ExampleController: ExampleController = new Controllers.Example().exports() as ExampleController;
+
+module.exports = ExampleController;

package/templates/hook-archetype/standard/src/api/controllers/index.ts.hbs

@@ -0,0 +1,23 @@
+import type { ExampleController as ExampleControllerExports } from './ExampleController';
+
+export type HookRedboxControllers = {
+  ExampleController: ExampleControllerExports;
+};
+
+const controllerCache: Partial<HookRedboxControllers> = {};
+
+function getOrCreateController<K extends keyof HookRedboxControllers>(
+  name: K,
+  factory: () => HookRedboxControllers[K]
+): HookRedboxControllers[K] {
+  if (!controllerCache[name]) {
+    controllerCache[name] = factory();
+  }
+  return controllerCache[name] as HookRedboxControllers[K];
+}
+
+export const ControllerExports = {
+  get ExampleController(): ExampleControllerExports {
+    return getOrCreateController('ExampleController', () => require('./ExampleController') as ExampleControllerExports);
+  }
+};

package/templates/hook-archetype/standard/src/api/services/ExampleService.ts.hbs

@@ -0,0 +1,22 @@
+import { Services as CoreServices } from '@researchdatabox/redbox-core';
+import { of } from 'rxjs';
+
+export namespace Services {
+  export class Example extends CoreServices.Core.Service {
+    protected _exportedMethods: string[] = [
+      'describe'
+    ];
+
+    public describe() {
+      return of({
+        hook: '{{packageName}}',
+        status: 'ready'
+      });
+    }
+  }
+}
+
+export type ExampleService = ReturnType<Services.Example['exports']>;
+export const ExampleService: ExampleService = new Services.Example().exports() as ExampleService;
+
+module.exports = ExampleService;

package/templates/hook-archetype/standard/src/api/services/index.ts.hbs

@@ -0,0 +1,23 @@
+import type { ExampleService as ExampleServiceExports } from './ExampleService';
+
+export type HookRedboxServices = {
+  ExampleService: ExampleServiceExports;
+};
+
+const serviceCache: Partial<HookRedboxServices> = {};
+
+function getOrCreateService<K extends keyof HookRedboxServices>(
+  name: K,
+  factory: () => HookRedboxServices[K]
+): HookRedboxServices[K] {
+  if (!(name in serviceCache)) {
+    serviceCache[name] = factory();
+  }
+  return serviceCache[name] as HookRedboxServices[K];
+}
+
+export const ServiceExports = {
+  get ExampleService(): ExampleServiceExports {
+    return getOrCreateService('ExampleService', () => require('./ExampleService') as ExampleServiceExports);
+  }
+};

package/templates/hook-archetype/standard/src/config/brandingConfigurationDefaults.ts.hbs

@@ -0,0 +1,9 @@
+export const brandingConfigurationDefaults = {
+  menu: {
+    items: [],
+    showSearch: true
+  },
+  homePanels: {
+    panels: []
+  }
+};

package/templates/hook-archetype/standard/src/config/reusableFormDefinitions.ts.hbs

@@ -0,0 +1,6 @@
+import type { ReusableFormDefinitions } from '@researchdatabox/sails-ng-common';
+import { reusableFormDefinitions as coreReusableFormDefinitions } from '@researchdatabox/redbox-core';
+
+export const reusableFormDefinitions: ReusableFormDefinitions = {
+  ...coreReusableFormDefinitions
+};

package/templates/hook-archetype/standard/src/form-config/default-1.0-draft.ts.hbs

@@ -0,0 +1,20 @@
+import type { FormConfigFrame } from '@researchdatabox/sails-ng-common';
+import { FormConfigExports as CoreFormConfigExports } from '@researchdatabox/redbox-core';
+
+function isFormConfigFrame(value: unknown): value is FormConfigFrame {
+	return typeof value === 'object' && value !== null;
+}
+
+if (!('generated-view-only' in CoreFormConfigExports)) {
+	throw new Error("CoreFormConfigExports is missing the 'generated-view-only' form config.");
+}
+
+const generatedViewOnly = CoreFormConfigExports['generated-view-only'];
+
+if (!isFormConfigFrame(generatedViewOnly)) {
+	throw new Error("CoreFormConfigExports['generated-view-only'] is not a valid FormConfigFrame.");
+}
+
+const defaultDraft: FormConfigFrame = generatedViewOnly;
+
+export default defaultDraft;

package/templates/hook-archetype/standard/src/form-config/index.ts.hbs

@@ -0,0 +1,8 @@
+import type { FormConfigFrame } from '@researchdatabox/sails-ng-common';
+import { FormConfigExports as CoreFormConfigExports } from '@researchdatabox/redbox-core';
+import defaultDraft from './default-1.0-draft';
+
+export const FormConfigExports: Record<string, FormConfigFrame> = {
+  'default-1.0-draft': defaultDraft,
+  'generated-view-only': CoreFormConfigExports['generated-view-only']
+};