@get-enlace/nest 0.0.1 → 0.0.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BugDiver Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,63 @@
+# @get-enlace/nest
+
+NestJS adapter for [Enlace](https://github.com/get-enlace/enlace-ui) — a visual,
+chained-execution canvas for any OpenAPI-documented API. This adapter's job is intentionally
+small: it serves the OpenAPI document and the `@get-enlace/ui` static bundle. Everything else
+(wiring up a chain, running it, credentials) happens client-side, in the browser.
+
+## Install
+
+```bash
+npm install @get-enlace/nest
+```
+
+## Usage
+
+### With `@nestjs/swagger` (generated spec)
+
+```ts
+// app.module.ts — just import, no config needed
+import { EnlaceModule } from '@get-enlace/nest';
+
+@Module({ imports: [EnlaceModule] })
+export class AppModule {}
+
+// main.ts — one line after the app is built
+const app = await NestFactory.create(AppModule);
+const doc = SwaggerModule.createDocument(app, config);
+EnlaceModule.setSpec(app, doc);
+```
+
+### With a static spec (file path or pre-parsed object)
+
+```ts
+@Module({ imports: [EnlaceModule.forRoot({ spec: './openapi.json' })] })
+export class AppModule {}
+```
+
+`spec` accepts a file path, a URL, or an already-parsed OpenAPI 3.x object.
+
+### What Enlace needs from your spec
+
+Whatever produces it, `servers[0].url` needs to be your API's real, reachable base URL — Enlace
+sends every request in a chain straight there from the browser. `operationId` is optional (Enlace
+falls back to a synthetic `METHOD /path` label without one) but is what shows on the node and in
+the operation search — `@nestjs/swagger` sets one per route by default (`ControllerName_methodName`).
+
+Already serving `@nestjs/swagger`'s own Swagger UI from that same document? Handing it to Enlace
+too doesn't change how that keeps working — they're independent consumers of the same object.
+
+### Custom mount path
+
+By default the canvas is at `/enlace`. To change it:
+
+```ts
+@Module({ imports: [EnlaceModule.forRoot({ path: 'canvas' })] })
+export class AppModule {}
+```
+
+## Learn more
+
+See the [`enlace-js` repo](https://github.com/get-enlace/enlace-js) for the other adapters in
+this family, and the [`enlace-ui` repo](https://github.com/get-enlace/enlace-ui) for how Enlace
+itself works.

package/dist/constants.d.ts

@@ -1,2 +1,4 @@
-/** DI token for injecting a module instance's {@link EnlaceOptions} into its controller. */
+/** DI token for injecting a module instance's {@link EnlaceOptions} into its spec route. */
 export declare const ENLACE_OPTIONS: unique symbol;
+/** DI token for the mount path this instance serves at (e.g. `'enlace'`, `'canvas'`). */
+export declare const ENLACE_MOUNT_PATH: unique symbol;

package/dist/constants.js

@@ -1,2 +1,4 @@
-/** DI token for injecting a module instance's {@link EnlaceOptions} into its controller. */
+/** DI token for injecting a module instance's {@link EnlaceOptions} into its spec route. */
 export const ENLACE_OPTIONS = Symbol('ENLACE_OPTIONS');
+/** DI token for the mount path this instance serves at (e.g. `'enlace'`, `'canvas'`). */
+export const ENLACE_MOUNT_PATH = Symbol('ENLACE_MOUNT_PATH');

package/dist/enlace.module.d.ts

@@ -1,36 +1,68 @@
-import { DynamicModule } from '@nestjs/common';
+import { DynamicModule, type INestApplication } from '@nestjs/common';
 import type { SpecSource } from './specLoader.js';
 export interface EnlaceOptions {
-    /** A file/URL path or an already-parsed object — the only input this needs is a valid OpenAPI 3.x document, however it's produced or served. */
-    spec: SpecSource;
     /**
-     * Mount path for the canvas, e.g. `'enlace'` serves the UI at `/enlace`
-     * and the spec at `/enlace/api/spec`. Defaults to `'enlace'`.
+     * A file/URL path or an already-parsed object — the only input this needs
+     * is a valid OpenAPI 3.x document, however it's produced or served.
      *
-     * Nest controller prefixes are fixed at decorator time, so this can't
-     * vary per `forRoot()` call the way the express adapter's `app.use(path,
-     * enlace(...))` does — it's applied via `RouterModule.register()` instead,
-     * the standard Nest pattern for a dynamic module with a configurable
-     * route prefix.
+     * Can be omitted at module-definition time and set later via
+     * `EnlaceModule.setSpec(app, spec)` in `main.ts` — useful when the spec
+     * is generated by `@nestjs/swagger` (which needs the app instance to exist
+     * before it can build the document, later than module imports are evaluated).
+     */
+    spec?: SpecSource;
+    /**
+     * Mount path for the canvas, e.g. `'canvas'` serves the UI at `/canvas`
+     * and the spec at `/canvas/api/spec`. Defaults to `'enlace'`.
+     *
+     * Only available via `forRoot({ path })` — a plain `imports: [EnlaceModule]`
+     * always mounts at `/enlace`.
      */
     path?: string;
 }
 /**
- * Mounts the Enlace canvas.
+ * Mounts the Enlace canvas.  Import directly for zero-config defaults
+ * (mounts at `/enlace`), or call `forRoot()` to customise the mount path:
  *
- *   @Module({ imports: [EnlaceModule.forRoot({ spec })] })
- *   export class AppModule {}
+ *   // Zero-config — mounts at /enlace, use setSpec() in main.ts:
+ *   @Module({ imports: [EnlaceModule] })
+ *
+ *   // With a static spec file:
+ *   @Module({ imports: [EnlaceModule.forRoot({ spec: './openapi.json' })] })
+ *
+ *   // Custom mount path:
+ *   @Module({ imports: [EnlaceModule.forRoot({ path: 'canvas' })] })
  *
  * This adapter's job is deliberately small — per ARCHITECTURE.md's MVP
  * model, execution runs entirely client-side in @get-enlace/ui, so there's
  * no `/api/run` or `/api/credentials` here at all. All this does is:
- *   - serve the raw OpenAPI document (parsed into an Operation[] list
- *     client-side, not here — see @get-enlace/ui's engine/specParser.ts),
- *     via EnlaceController
- *   - serve the built UI bundle, via @nestjs/serve-static (platform-
- *     agnostic — works whether the host app runs Nest's Express or Fastify
- *     adapter, unlike @get-enlace/express's direct `express.static` use)
+ *   - serve the raw OpenAPI document at `<mount>/api/spec`, registered
+ *     directly on the underlying HTTP adapter (see specRoute.ts) rather
+ *     than as a Nest controller, so it isn't gated behind whatever global
+ *     guards/interceptors the host app has registered — true zero-config,
+ *     no exception needed on the host app's side
+ *   - serve the built UI bundle via @nestjs/serve-static
  */
 export declare class EnlaceModule {
-    static forRoot(options: EnlaceOptions): DynamicModule;
+    /**
+     * Set the OpenAPI spec after the app is built — the one-liner for
+     * `@nestjs/swagger` users:
+     *
+     *   EnlaceModule.setSpec(app, SwaggerModule.createDocument(app, config));
+     *
+     * Works because SpecRouteRegistrar reads `options.spec` fresh on every
+     * request (via `loadSpec`), not a snapshot taken at module-definition
+     * time — so whatever's assigned here is what gets served.
+     */
+    static setSpec(app: INestApplication, spec: SpecSource): void;
+    /**
+     * Optional explicit configuration — only needed when passing a static
+     * spec at module-definition time or customising the mount path. For
+     * `@nestjs/swagger` users, prefer the zero-config direct import +
+     * `setSpec()`.
+     */
+    static forRoot(options?: {
+        spec?: SpecSource;
+        path?: string;
+    }): DynamicModule;
 }

package/dist/enlace.module.js

@@ -4,67 +4,113 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var EnlaceModule_1;
 import { Module } from '@nestjs/common';
-import { RouterModule } from '@nestjs/core';
 import { ServeStaticModule } from '@nestjs/serve-static';
 import path from 'node:path';
 import { createRequire } from 'node:module';
-import { ENLACE_OPTIONS } from './constants.js';
-import { EnlaceController } from './enlace.controller.js';
+import { ENLACE_MOUNT_PATH, ENLACE_OPTIONS } from './constants.js';
+import { SpecRouteRegistrar } from './specRoute.js';
 const require = createRequire(import.meta.url);
+// Resolved once at module load — Node's own module resolution against the
+// installed `@get-enlace/ui` package (a real dependency, see package.json),
+// not a relative path into this monorepo. Works identically whether
+// `@get-enlace/ui` got here via an npm workspace symlink (local dev) or a
+// real `node_modules` install.
+const uiPackageJson = require.resolve('@get-enlace/ui/package.json');
+const uiDist = path.join(path.dirname(uiPackageJson), 'dist');
 /**
- * Mounts the Enlace canvas.
+ * Internal module class used by `forRoot()` — keeps its DynamicModule
+ * metadata isolated from EnlaceModule's own @Module() defaults so
+ * providers aren't double-registered.
+ * @internal
+ */
+let EnlaceConfiguredModule = class EnlaceConfiguredModule {
+};
+EnlaceConfiguredModule = __decorate([
+    Module({})
+], EnlaceConfiguredModule);
+/**
+ * Mounts the Enlace canvas.  Import directly for zero-config defaults
+ * (mounts at `/enlace`), or call `forRoot()` to customise the mount path:
+ *
+ *   // Zero-config — mounts at /enlace, use setSpec() in main.ts:
+ *   @Module({ imports: [EnlaceModule] })
  *
- *   @Module({ imports: [EnlaceModule.forRoot({ spec })] })
- *   export class AppModule {}
+ *   // With a static spec file:
+ *   @Module({ imports: [EnlaceModule.forRoot({ spec: './openapi.json' })] })
+ *
+ *   // Custom mount path:
+ *   @Module({ imports: [EnlaceModule.forRoot({ path: 'canvas' })] })
  *
  * This adapter's job is deliberately small — per ARCHITECTURE.md's MVP
  * model, execution runs entirely client-side in @get-enlace/ui, so there's
  * no `/api/run` or `/api/credentials` here at all. All this does is:
- *   - serve the raw OpenAPI document (parsed into an Operation[] list
- *     client-side, not here — see @get-enlace/ui's engine/specParser.ts),
- *     via EnlaceController
- *   - serve the built UI bundle, via @nestjs/serve-static (platform-
- *     agnostic — works whether the host app runs Nest's Express or Fastify
- *     adapter, unlike @get-enlace/express's direct `express.static` use)
+ *   - serve the raw OpenAPI document at `<mount>/api/spec`, registered
+ *     directly on the underlying HTTP adapter (see specRoute.ts) rather
+ *     than as a Nest controller, so it isn't gated behind whatever global
+ *     guards/interceptors the host app has registered — true zero-config,
+ *     no exception needed on the host app's side
+ *   - serve the built UI bundle via @nestjs/serve-static
  */
-let EnlaceModule = EnlaceModule_1 = class EnlaceModule {
+let EnlaceModule = class EnlaceModule {
+    /**
+     * Set the OpenAPI spec after the app is built — the one-liner for
+     * `@nestjs/swagger` users:
+     *
+     *   EnlaceModule.setSpec(app, SwaggerModule.createDocument(app, config));
+     *
+     * Works because SpecRouteRegistrar reads `options.spec` fresh on every
+     * request (via `loadSpec`), not a snapshot taken at module-definition
+     * time — so whatever's assigned here is what gets served.
+     */
+    static setSpec(app, spec) {
+        const options = app.get(ENLACE_OPTIONS);
+        options.spec = spec;
+    }
+    /**
+     * Optional explicit configuration — only needed when passing a static
+     * spec at module-definition time or customising the mount path. For
+     * `@nestjs/swagger` users, prefer the zero-config direct import +
+     * `setSpec()`.
+     */
     static forRoot(options) {
-        const mountPath = options.path ?? 'enlace';
-        // Resolved via Node's own module resolution against the installed
-        // `@get-enlace/ui` package (a real dependency, see package.json) — not a
-        // relative path into this monorepo — so this works identically whether
-        // `@get-enlace/ui` got here via an npm workspace symlink (local dev) or
-        // a real `node_modules` install (anyone who installs @get-enlace/nest on
-        // its own). There's nothing to copy or build into this package itself;
-        // the bundle lives wherever @get-enlace/ui's own "files" field ships it
-        // (dist/), and it must already be built (`npm run build --workspace
-        // @get-enlace/ui`) before this resolves.
-        const uiPackageJson = require.resolve('@get-enlace/ui/package.json');
-        const uiDist = path.join(path.dirname(uiPackageJson), 'dist');
+        const opts = { spec: options?.spec, path: options?.path };
+        const mountPath = opts.path ?? 'enlace';
         return {
-            module: EnlaceModule_1,
+            // EnlaceConfiguredModule (not EnlaceModule) so the DynamicModule
+            // metadata doesn't merge with EnlaceModule's own @Module() defaults.
+            module: EnlaceConfiguredModule,
             imports: [
                 ServeStaticModule.forRoot({
                     rootPath: uiDist,
                     serveRoot: `/${mountPath}`,
-                    // Keeps the static middleware from shadowing EnlaceController's
-                    // `/api/spec` route. `{*splat}` is path-to-regexp v8's wildcard
-                    // syntax (the version @nestjs/serve-static v5 bundles) — the
-                    // older unnamed `(.*)` capture group it replaces silently 500s
-                    // instead of matching, since it's now invalid syntax rather than
-                    // just non-matching.
                     exclude: [`/${mountPath}/api/{*splat}`],
                 }),
-                RouterModule.register([{ path: mountPath, module: EnlaceModule_1 }]),
             ],
-            controllers: [EnlaceController],
-            providers: [{ provide: ENLACE_OPTIONS, useValue: options }],
+            providers: [
+                { provide: ENLACE_OPTIONS, useValue: opts },
+                { provide: ENLACE_MOUNT_PATH, useValue: mountPath },
+                SpecRouteRegistrar,
+            ],
         };
     }
 };
-EnlaceModule = EnlaceModule_1 = __decorate([
-    Module({})
+EnlaceModule = __decorate([
+    Module({
+        imports: [
+            ServeStaticModule.forRoot({
+                rootPath: uiDist,
+                serveRoot: '/enlace',
+                exclude: ['/enlace/api/{*splat}'],
+            }),
+        ],
+        // useFactory (not useValue) so each NestFactory.create() gets its own
+        // options object — otherwise setSpec() on one app would leak into another.
+        providers: [
+            { provide: ENLACE_OPTIONS, useFactory: () => ({ spec: undefined }) },
+            { provide: ENLACE_MOUNT_PATH, useValue: 'enlace' },
+            SpecRouteRegistrar,
+        ],
+    })
 ], EnlaceModule);
 export { EnlaceModule };

package/dist/specRoute.d.ts

@@ -0,0 +1,27 @@
+import { type OnModuleInit } from '@nestjs/common';
+import { HttpAdapterHost } from '@nestjs/core';
+import type { EnlaceOptions } from './enlace.module.js';
+/**
+ * Registers `<mount>/api/spec` directly on the underlying HTTP adapter —
+ * the same technique `@nestjs/swagger` uses for its own `/docs-json` route
+ * — instead of as a Nest `@Controller`.
+ *
+ * A `@Controller` route is resolved through Nest's full request pipeline,
+ * which includes any global guards/interceptors the host app has
+ * registered (e.g. an app-wide `APP_GUARD` auth guard). That would gate
+ * this adapter's spec endpoint behind the host app's own auth policy,
+ * breaking zero-config installs the same way it'd break `@nestjs/swagger`
+ * if swagger-ui-express routes went through Nest's router instead of being
+ * registered on the raw adapter. Registering here the same way — like
+ * `ServeStaticModule` already does for the UI bundle (see
+ * enlace.module.test.ts) — keeps this endpoint outside the host app's
+ * guard/interceptor pipeline entirely, matching ARCHITECTURE.md's "adapter
+ * is thin and never entangled with app policy" model.
+ */
+export declare class SpecRouteRegistrar implements OnModuleInit {
+    private readonly adapterHost;
+    private readonly options;
+    private readonly mountPath;
+    constructor(adapterHost: HttpAdapterHost, options: EnlaceOptions, mountPath: string);
+    onModuleInit(): void;
+}

package/dist/specRoute.js

@@ -0,0 +1,67 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from '@nestjs/common';
+import { HttpAdapterHost } from '@nestjs/core';
+import { ENLACE_MOUNT_PATH, ENLACE_OPTIONS } from './constants.js';
+import { loadSpec } from './specLoader.js';
+const NO_SPEC_MESSAGE = 'No OpenAPI spec configured — call EnlaceModule.setSpec(app, spec) in main.ts, '
+    + 'or pass { spec } to EnlaceModule.forRoot().';
+/**
+ * Registers `<mount>/api/spec` directly on the underlying HTTP adapter —
+ * the same technique `@nestjs/swagger` uses for its own `/docs-json` route
+ * — instead of as a Nest `@Controller`.
+ *
+ * A `@Controller` route is resolved through Nest's full request pipeline,
+ * which includes any global guards/interceptors the host app has
+ * registered (e.g. an app-wide `APP_GUARD` auth guard). That would gate
+ * this adapter's spec endpoint behind the host app's own auth policy,
+ * breaking zero-config installs the same way it'd break `@nestjs/swagger`
+ * if swagger-ui-express routes went through Nest's router instead of being
+ * registered on the raw adapter. Registering here the same way — like
+ * `ServeStaticModule` already does for the UI bundle (see
+ * enlace.module.test.ts) — keeps this endpoint outside the host app's
+ * guard/interceptor pipeline entirely, matching ARCHITECTURE.md's "adapter
+ * is thin and never entangled with app policy" model.
+ */
+let SpecRouteRegistrar = class SpecRouteRegistrar {
+    constructor(adapterHost, options, mountPath) {
+        this.adapterHost = adapterHost;
+        this.options = options;
+        this.mountPath = mountPath;
+    }
+    onModuleInit() {
+        const httpAdapter = this.adapterHost.httpAdapter;
+        // `httpAdapter.reply(res, body, statusCode)` — not `res.status().json()`
+        // — is the deliberately adapter-agnostic primitive Nest itself uses to
+        // send a response from inside its own controller pipeline. It's
+        // implemented identically by ExpressAdapter and FastifyAdapter (JSON
+        // body + status code, on whichever platform is actually running), so
+        // this route works the same whether the host app is Express- or
+        // Fastify-based — unlike Express-specific chaining (`res.status(x).json(y)`),
+        // which would throw under Fastify (`FastifyReply` has no `.json()`).
+        httpAdapter.get(`/${this.mountPath}/api/spec`, (_req, res) => {
+            if (this.options.spec == null) {
+                httpAdapter.reply(res, { statusCode: 503, message: NO_SPEC_MESSAGE }, 503);
+                return;
+            }
+            httpAdapter.reply(res, loadSpec(this.options.spec), 200);
+        });
+    }
+};
+SpecRouteRegistrar = __decorate([
+    Injectable(),
+    __param(1, Inject(ENLACE_OPTIONS)),
+    __param(2, Inject(ENLACE_MOUNT_PATH)),
+    __metadata("design:paramtypes", [HttpAdapterHost, Object, String])
+], SpecRouteRegistrar);
+export { SpecRouteRegistrar };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@get-enlace/nest",
   "private": false,
-  "version": "0.0.1",
+  "version": "0.0.4",
   "description": "Simple NestJS adapter for @get-enlace/ui. Early dev preview: no persistence yet (serves the spec + UI bundle only), install via the `dev` dist-tag on GitHub Packages.",
   "license": "MIT",
   "repository": {
@@ -36,7 +36,7 @@
     "reflect-metadata": "^0.1.13 || ^0.2.0"
   },
   "dependencies": {
-    "@get-enlace/ui": "0.0.1",
+    "@get-enlace/ui": "0.0.4",
     "js-yaml": "^4.1.0"
   },
   "devDependencies": {

package/dist/enlace.controller.d.ts

@@ -1,15 +0,0 @@
-import type { EnlaceOptions } from './enlace.module.js';
-/**
- * Serves the raw OpenAPI document at `<mount>/api/spec`. Read fresh on each
- * request, not cached — matches the "not stored, read fresh each load" rule
- * from ARCHITECTURE.md §4, same as the express adapter's `/api/spec` route.
- *
- * This is the only route this adapter defines — per ARCHITECTURE.md's MVP
- * model, execution runs entirely client-side in @get-enlace/ui, so there's
- * no `/api/run` or `/api/credentials` here at all.
- */
-export declare class EnlaceController {
-    private readonly options;
-    constructor(options: EnlaceOptions);
-    getSpec(): Record<string, any>;
-}

package/dist/enlace.controller.js

@@ -1,44 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-import { Controller, Get, Inject } from '@nestjs/common';
-import { ENLACE_OPTIONS } from './constants.js';
-import { loadSpec } from './specLoader.js';
-/**
- * Serves the raw OpenAPI document at `<mount>/api/spec`. Read fresh on each
- * request, not cached — matches the "not stored, read fresh each load" rule
- * from ARCHITECTURE.md §4, same as the express adapter's `/api/spec` route.
- *
- * This is the only route this adapter defines — per ARCHITECTURE.md's MVP
- * model, execution runs entirely client-side in @get-enlace/ui, so there's
- * no `/api/run` or `/api/credentials` here at all.
- */
-let EnlaceController = class EnlaceController {
-    constructor(options) {
-        this.options = options;
-    }
-    getSpec() {
-        return loadSpec(this.options.spec);
-    }
-};
-__decorate([
-    Get('spec'),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
-], EnlaceController.prototype, "getSpec", null);
-EnlaceController = __decorate([
-    Controller('api'),
-    __param(0, Inject(ENLACE_OPTIONS)),
-    __metadata("design:paramtypes", [Object])
-], EnlaceController);
-export { EnlaceController };