@pb33f/cowboy-components 0.7.17 → 0.8.0

package/dist/services/mermaid-config-service.js

@@ -0,0 +1,519 @@
+// Copyright 2023-2025 Princess Beef Heavy Industries, LLC / Dave Shanley
+// https://pb33f.io
+export class MermaidConfigService {
+    constructor() {
+        this.currentTheme = 'light';
+        this.customThemeVariables = {};
+        this.layoutOptions = {
+            layout: 'elk',
+            rankDir: 'TB',
+            curve: 'linear'
+        };
+        this.colorCache = new Map();
+        this.cacheValid = false;
+        this.themeObserver = null;
+        this.detectTheme();
+        this.observeThemeChanges();
+    }
+    extractCSSColor(cssVar, fallback = '#00ff00') {
+        const cacheKey = `${cssVar}-${this.currentTheme}`;
+        if (this.cacheValid && this.colorCache.has(cacheKey)) {
+            return this.colorCache.get(cacheKey);
+        }
+        const computed = getComputedStyle(document.documentElement)
+            .getPropertyValue(cssVar)
+            .trim();
+        const result = this.parseColorValue(computed, fallback);
+        this.colorCache.set(cacheKey, result);
+        return result;
+    }
+    parseColorValue(value, fallback) {
+        if (!value)
+            return fallback;
+        if (value.startsWith('rgba') || value.startsWith('rgb')) {
+            return this.rgbaToHex(value);
+        }
+        return value.startsWith('#') ? value : fallback;
+    }
+    rgbaToHex(rgba) {
+        const match = rgba.match(MermaidConfigService.RGBA_REGEX);
+        if (!match)
+            return '#000000';
+        const [, r, g, b] = match.map(Number);
+        return '#' + [r, g, b].map(x => x.toString(16).padStart(2, '0')).join('');
+    }
+    invalidateCache() {
+        this.cacheValid = false;
+        this.colorCache.clear();
+    }
+    extractCSSValue(cssVar, fallback = '') {
+        const computed = getComputedStyle(document.documentElement)
+            .getPropertyValue(cssVar)
+            .trim();
+        return computed || fallback;
+    }
+    static getInstance() {
+        if (!MermaidConfigService.instance) {
+            MermaidConfigService.instance = new MermaidConfigService();
+        }
+        return MermaidConfigService.instance;
+    }
+    detectTheme() {
+        const htmlElement = document.querySelector('html');
+        const theme = htmlElement?.getAttribute('theme');
+        const newTheme = theme === 'dark' ? 'dark' : 'light';
+        if (newTheme !== this.currentTheme) {
+            this.currentTheme = newTheme;
+            this.invalidateCache();
+        }
+    }
+    observeThemeChanges() {
+        this.themeObserver = new MutationObserver((mutations) => {
+            mutations.forEach((mutation) => {
+                if (mutation.type === 'attributes' && mutation.attributeName === 'theme') {
+                    this.detectTheme();
+                    window.dispatchEvent(new CustomEvent('mermaid-theme-change', {
+                        detail: { theme: this.currentTheme }
+                    }));
+                }
+            });
+        });
+        const htmlElement = document.querySelector('html');
+        if (htmlElement) {
+            this.themeObserver.observe(htmlElement, { attributes: true });
+        }
+    }
+    cleanup() {
+        if (this.themeObserver) {
+            this.themeObserver.disconnect();
+            this.themeObserver = null;
+        }
+        this.colorCache.clear();
+    }
+    getTheme() {
+        return this.currentTheme;
+    }
+    setCustomThemeVariables(variables) {
+        this.customThemeVariables = { ...this.customThemeVariables, ...variables };
+        this.invalidateCache();
+    }
+    getThemeVariables() {
+        this.cacheValid = true;
+        const isDark = this.currentTheme === 'dark';
+        const baseVariables = isDark ? this.getDarkThemeVariables() : this.getLightThemeVariables();
+        return { ...baseVariables, ...this.customThemeVariables };
+    }
+    getDarkThemeVariables() {
+        const vars = MermaidConfigService.CSS_VARS;
+        const terminalGreen = this.extractCSSColor(vars.TERMINAL_TEXT, '#00FF00');
+        const primaryBlue = this.extractCSSColor(vars.PRIMARY_COLOR, '#62c4ff');
+        const secondaryMagenta = this.extractCSSColor(vars.SECONDARY_COLOR, '#f83aff');
+        const tertiaryGray = this.extractCSSColor(vars.TERTIARY_COLOR, '#a3abba');
+        const backgroundDark = this.extractCSSColor(vars.BACKGROUND_COLOR, '#0d1117');
+        const terminalYellow = this.extractCSSColor(vars.TERMINAL_YELLOW, '#fddb00');
+        const fontColor = this.extractCSSColor(vars.FONT_COLOR, '#e8e9ed');
+        const fontStack = this.extractCSSValue(vars.FONT_STACK, 'monospace');
+        return {
+            primaryColor: backgroundDark,
+            primaryTextColor: primaryBlue,
+            primaryBorderColor: secondaryMagenta,
+            lineColor: secondaryMagenta,
+            secondaryColor: backgroundDark,
+            tertiaryColor: backgroundDark,
+            background: backgroundDark,
+            mainBkg: backgroundDark,
+            secondBkg: backgroundDark,
+            tertiaryBkg: backgroundDark,
+            secondaryBorderColor: primaryBlue,
+            tertiaryBorderColor: terminalGreen,
+            secondaryTextColor: primaryBlue,
+            tertiaryTextColor: tertiaryGray,
+            textColor: primaryBlue,
+            nodeTextColor: primaryBlue,
+            fontFamily: fontStack,
+            fontSize: '14px',
+            darkMode: true,
+            classText: fontColor,
+            nodeBkg: backgroundDark,
+            nodeBorder: secondaryMagenta,
+            clusterBkg: backgroundDark,
+            clusterBorder: terminalYellow,
+            defaultLinkColor: secondaryMagenta,
+            titleColor: primaryBlue,
+            edgeLabelBackground: backgroundDark,
+            actorBkg: backgroundDark,
+            actorBorder: secondaryMagenta,
+            actorTextColor: primaryBlue,
+            actorLineColor: secondaryMagenta,
+            signalColor: secondaryMagenta,
+            signalTextColor: primaryBlue,
+            labelBoxBkgColor: backgroundDark,
+            labelBoxBorderColor: secondaryMagenta,
+            labelTextColor: primaryBlue,
+            loopTextColor: primaryBlue,
+            noteBorderColor: terminalYellow,
+            noteBkgColor: backgroundDark,
+            noteTextColor: primaryBlue,
+            activationBorderColor: secondaryMagenta,
+            activationBkgColor: backgroundDark,
+            sequenceNumberColor: backgroundDark,
+            labelColor: primaryBlue,
+            altBackground: backgroundDark,
+            gitBranchLabel0: primaryBlue,
+            gitBranchLabel1: secondaryMagenta,
+            gitBranchLabel2: terminalGreen,
+            gitBranchLabel3: terminalYellow,
+            gitBranchLabel4: tertiaryGray,
+            gitBranchLabel5: primaryBlue,
+            gitBranchLabel6: secondaryMagenta,
+            gitBranchLabel7: terminalGreen,
+            git0: primaryBlue,
+            git1: secondaryMagenta,
+            git2: terminalGreen,
+            git3: terminalYellow,
+            git4: tertiaryGray,
+            git5: primaryBlue,
+            git6: secondaryMagenta,
+            git7: terminalGreen,
+            pie1: primaryBlue,
+            pie2: secondaryMagenta,
+            pie3: terminalGreen,
+            pie4: terminalYellow,
+            pie5: tertiaryGray,
+            pie6: primaryBlue,
+            pie7: secondaryMagenta,
+            pie8: terminalGreen,
+            pie9: terminalYellow,
+            pie10: tertiaryGray,
+            pie11: primaryBlue,
+            pie12: secondaryMagenta,
+            pieTitleTextSize: '16px',
+            pieTitleTextColor: primaryBlue,
+            pieSectionTextSize: '14px',
+            pieSectionTextColor: primaryBlue,
+            pieLegendTextSize: '14px',
+            pieLegendTextColor: primaryBlue,
+            pieStrokeColor: secondaryMagenta,
+            pieStrokeWidth: '2px',
+            pieOpacity: '1',
+            fillType0: backgroundDark,
+            fillType1: backgroundDark,
+            fillType2: backgroundDark,
+            fillType3: backgroundDark,
+            fillType4: backgroundDark,
+            fillType5: backgroundDark,
+            fillType6: backgroundDark,
+            fillType7: backgroundDark,
+        };
+    }
+    getLightThemeVariables() {
+        const vars = MermaidConfigService.CSS_VARS;
+        const terminalText = this.extractCSSColor(vars.TERMINAL_TEXT, '#000000');
+        const primaryBlue = this.extractCSSColor(vars.PRIMARY_COLOR, '#2f8efb');
+        const secondaryPurple = this.extractCSSColor(vars.SECONDARY_COLOR, '#c201c8');
+        const tertiaryGray = this.extractCSSColor(vars.TERTIARY_COLOR, '#4c4c4c');
+        const backgroundLight = this.extractCSSColor(vars.BACKGROUND_COLOR, '#ffffff');
+        const warnOrange = this.extractCSSColor(vars.WARN_300, '#ff9900');
+        const fontColor = this.extractCSSColor(vars.FONT_COLOR, '#000000');
+        const fontStack = this.extractCSSValue(vars.FONT_STACK, 'monospace');
+        return {
+            primaryColor: backgroundLight,
+            primaryTextColor: primaryBlue,
+            primaryBorderColor: secondaryPurple,
+            lineColor: secondaryPurple,
+            secondaryColor: '#f8fafc',
+            tertiaryColor: '#e2e8f0',
+            background: backgroundLight,
+            mainBkg: backgroundLight,
+            secondBkg: '#f8fafc',
+            tertiaryBkg: '#e2e8f0',
+            secondaryBorderColor: primaryBlue,
+            tertiaryBorderColor: tertiaryGray,
+            secondaryTextColor: primaryBlue,
+            tertiaryTextColor: tertiaryGray,
+            textColor: primaryBlue,
+            nodeTextColor: primaryBlue,
+            fontFamily: fontStack,
+            fontSize: '14px',
+            darkMode: false,
+            classText: fontColor,
+            nodeBkg: backgroundLight,
+            nodeBorder: secondaryPurple,
+            clusterBkg: '#f8fafc',
+            clusterBorder: warnOrange,
+            defaultLinkColor: secondaryPurple,
+            titleColor: primaryBlue,
+            edgeLabelBackground: backgroundLight,
+            actorBkg: backgroundLight,
+            actorBorder: secondaryPurple,
+            actorTextColor: primaryBlue,
+            actorLineColor: secondaryPurple,
+            signalColor: secondaryPurple,
+            signalTextColor: primaryBlue,
+            labelBoxBkgColor: backgroundLight,
+            labelBoxBorderColor: secondaryPurple,
+            labelTextColor: primaryBlue,
+            loopTextColor: primaryBlue,
+            noteBorderColor: warnOrange,
+            noteBkgColor: '#f8fafc',
+            noteTextColor: primaryBlue,
+            activationBorderColor: secondaryPurple,
+            activationBkgColor: backgroundLight,
+            sequenceNumberColor: backgroundLight,
+            labelColor: primaryBlue,
+            altBackground: '#f8fafc',
+            gitBranchLabel0: primaryBlue,
+            gitBranchLabel1: secondaryPurple,
+            gitBranchLabel2: tertiaryGray,
+            gitBranchLabel3: warnOrange,
+            gitBranchLabel4: primaryBlue,
+            gitBranchLabel5: secondaryPurple,
+            gitBranchLabel6: tertiaryGray,
+            gitBranchLabel7: warnOrange,
+            git0: primaryBlue,
+            git1: secondaryPurple,
+            git2: tertiaryGray,
+            git3: warnOrange,
+            git4: primaryBlue,
+            git5: secondaryPurple,
+            git6: tertiaryGray,
+            git7: warnOrange,
+            pie1: secondaryPurple,
+            pie2: primaryBlue,
+            pie3: warnOrange,
+            pie4: tertiaryGray,
+            pie5: secondaryPurple,
+            pie6: primaryBlue,
+            pie7: warnOrange,
+            pie8: tertiaryGray,
+            pie9: secondaryPurple,
+            pie10: primaryBlue,
+            pie11: warnOrange,
+            pie12: tertiaryGray,
+            pieTitleTextSize: '16px',
+            pieTitleTextColor: terminalText,
+            pieSectionTextSize: '14px',
+            pieSectionTextColor: terminalText,
+            pieLegendTextSize: '14px',
+            pieLegendTextColor: terminalText,
+            pieStrokeColor: secondaryPurple,
+            pieStrokeWidth: '2px',
+            pieOpacity: '0.9',
+            fillType0: backgroundLight,
+            fillType1: '#f8fafc',
+            fillType2: '#e2e8f0',
+            fillType3: backgroundLight,
+            fillType4: '#f8fafc',
+            fillType5: '#e2e8f0',
+            fillType6: backgroundLight,
+            fillType7: '#f8fafc',
+        };
+    }
+    setLayoutOptions(options) {
+        this.layoutOptions = { ...this.layoutOptions, ...options };
+    }
+    getLayoutOptions() {
+        return this.layoutOptions;
+    }
+    getMermaidConfig(overrides = {}) {
+        const themeVariables = this.getThemeVariables();
+        const layoutOptions = this.getLayoutOptions();
+        const fontStack = this.extractCSSValue(MermaidConfigService.CSS_VARS.FONT_STACK, 'monospace');
+        return {
+            startOnLoad: false,
+            securityLevel: 'loose',
+            theme: 'base',
+            themeVariables,
+            elk: {
+                mergeEdges: false,
+                nodePlacementStrategy: 'BRANDES_KOEPF',
+                cycleBreakingStrategy: 'DEPTH_FIRST',
+                forceNodeModelOrder: false,
+                considerModelOrder: 'NODES_AND_EDGES'
+            },
+            flowchart: {
+                useMaxWidth: true,
+                htmlLabels: true,
+                curve: layoutOptions.curve || 'linear',
+                padding: 15,
+                nodeSpacing: layoutOptions.nodeSpacing || 50,
+                rankSpacing: layoutOptions.rankSpacing || 50,
+                defaultRenderer: layoutOptions.layout,
+            },
+            sequence: {
+                diagramMarginX: 50,
+                diagramMarginY: 10,
+                actorMargin: 50,
+                width: 150,
+                height: 65,
+                boxMargin: 10,
+                boxTextMargin: 5,
+                noteMargin: 10,
+                messageMargin: 35,
+                mirrorActors: true,
+                bottomMarginAdj: 1,
+                useMaxWidth: true,
+                rightAngles: false,
+                showSequenceNumbers: false,
+            },
+            gantt: {
+                numberSectionStyles: 4,
+                axisFormat: '%Y-%m-%d',
+                tickInterval: undefined,
+                topAxis: false,
+                displayMode: '',
+            },
+            journey: {
+                diagramMarginX: 300,
+                diagramMarginY: 30,
+                leftMargin: 150,
+                width: 150,
+                height: 50,
+                boxMargin: 10,
+                boxTextMargin: 5,
+                noteMargin: 10,
+                messageMargin: 35,
+                messageAlign: 'center',
+                bottomMarginAdj: 1,
+                useMaxWidth: true,
+                rightAngles: false,
+            },
+            class: {
+                arrowMarkerAbsolute: false,
+                dividerMargin: 10,
+                padding: 5,
+                textHeight: 10,
+                defaultRenderer: layoutOptions.layout,
+                useMaxWidth: true,
+                hideEmptyMembersBox: true,
+            },
+            state: {
+                dividerMargin: 10,
+                sizeUnit: 5,
+                padding: 5,
+                textHeight: 10,
+                titleShift: -15,
+                noteMargin: 10,
+                forkWidth: 70,
+                forkHeight: 7,
+                miniPadding: 2,
+                fontSizeFactor: 5.02,
+                labelHeight: 16,
+                edgeLengthFactor: '20',
+                compositTitleSize: 35,
+                radius: 0, // No rounded corners
+                defaultRenderer: layoutOptions.layout,
+                useMaxWidth: true,
+            },
+            er: {
+                entityPadding: 15,
+                minEntityWidth: 100,
+                minEntityHeight: 75,
+                stroke: 'gray',
+                fill: 'honeydew',
+                fontSize: 12,
+                useMaxWidth: true,
+            },
+            pie: {
+                useMaxWidth: true,
+                textPosition: 0.75,
+            },
+            requirement: {
+                useMaxWidth: true,
+            },
+            gitGraph: {
+                diagramPadding: 8,
+                nodeLabel: {
+                    width: 75,
+                    height: 100,
+                    x: -25,
+                    y: 0,
+                },
+                mainBranchName: 'main',
+                mainBranchOrder: 0,
+                showCommitLabel: true,
+                showBranches: true,
+                rotateCommitLabel: true,
+            },
+            c4: {
+                useMaxWidth: true,
+                diagramMarginX: 50,
+                diagramMarginY: 10,
+                c4ShapeMargin: 50,
+                c4ShapePadding: 20,
+                c4ShapeInRow: 4,
+                nextLinePaddingX: 0,
+                c4BoundaryInRow: 2,
+                personFontSize: 14,
+                personFontFamily: fontStack,
+                personFontWeight: 'normal',
+                messageFontSize: 12,
+                messageFontFamily: fontStack,
+                messageFontWeight: 'normal',
+                width: 200,
+                height: 60,
+                boxMargin: 10,
+                wrapPadding: 10,
+            },
+            ...overrides,
+        };
+    }
+    getClassDiagramConfig() {
+        return {
+            class: {
+                arrowMarkerAbsolute: false,
+                dividerMargin: 10,
+                padding: 5,
+                textHeight: 10,
+                defaultRenderer: this.layoutOptions.layout,
+                useMaxWidth: true,
+            },
+        };
+    }
+    getFlowchartConfig() {
+        return {
+            flowchart: {
+                useMaxWidth: true,
+                htmlLabels: true,
+                curve: this.layoutOptions.curve || 'linear',
+                padding: 15,
+                nodeSpacing: this.layoutOptions.nodeSpacing || 50,
+                rankSpacing: this.layoutOptions.rankSpacing || 50,
+                defaultRenderer: this.layoutOptions.layout,
+            },
+        };
+    }
+    getSequenceDiagramConfig() {
+        return {
+            sequence: {
+                diagramMarginX: 50,
+                diagramMarginY: 10,
+                actorMargin: 50,
+                width: 150,
+                height: 65,
+                boxMargin: 10,
+                boxTextMargin: 5,
+                noteMargin: 10,
+                messageMargin: 35,
+                mirrorActors: true,
+                bottomMarginAdj: 1,
+                useMaxWidth: true,
+                rightAngles: false,
+                showSequenceNumbers: false,
+            },
+        };
+    }
+}
+MermaidConfigService.CSS_VARS = {
+    TERMINAL_TEXT: '--terminal-text',
+    PRIMARY_COLOR: '--primary-color',
+    SECONDARY_COLOR: '--secondary-color',
+    TERTIARY_COLOR: '--tertiary-color',
+    BACKGROUND_COLOR: '--background-color',
+    TERMINAL_YELLOW: '--terminal-yellow',
+    WARN_COLOR: '--warn-color',
+    WARN_300: '--warn-300',
+    FONT_COLOR: '--font-color',
+    FONT_STACK: '--font-stack'
+};
+MermaidConfigService.RGBA_REGEX = /rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*[\d.]+)?\)/;

package/dist/services/model-service.d.ts

@@ -1,17 +1,22 @@
-import { GraphResponse, Reference } from "../model/graph";
-import { ExampleContainer } from "../model/example";
-import { Node } from "../model/graph";
-import { ArchiveFileResponse, RolodexResponse } from "../model/rolodex";
+import { GraphResponse, Reference } from "../model/graph.js";
+import { ExampleContainer } from "../model/example.js";
+import { Node } from "../model/graph.js";
+import { ArchiveFileResponse, RolodexResponse } from "../model/rolodex.js";
+import { BundleResponse } from "../model/bundle.js";
 export declare class ModelService {
     static doctorEndpoint: string;
-    static fetchLatestGraph(): Promise<GraphResponse>;
+    static fetchLatestGraph(limit?: number): Promise<GraphResponse>;
     static fetchReferenceMap(currentPath?: string): Promise<Reference[]>;
     static uploadArchive(formData: FormData): Promise<ArchiveFileResponse>;
     static selectRootPath(path: string): Promise<Node>;
     static queryRolodex(id?: string, path?: string): Promise<RolodexResponse>;
-    static generateMock(spec?: string): Promise<any>;
-    static generateExample(example: ExampleContainer): Promise<ExampleContainer>;
+    static generateMock(spec?: string, brokerId?: string): Promise<any>;
+    static generateExample(example: ExampleContainer, brokerId?: string): Promise<ExampleContainer>;
     static convertJSONToYAML(json?: string): Promise<any>;
     static resetWorkspace(): Promise<boolean>;
     static getCurrentSpec(): Promise<string>;
+    static refreshGraph(limit?: number): Promise<GraphResponse>;
+    static refreshReferenceMap(currentPath?: string): Promise<Reference[]>;
+    static refreshRolodex(path?: string): Promise<RolodexResponse>;
+    static bundleSpec(brokerId?: string): Promise<BundleResponse>;
 }

package/dist/services/model-service.js

@@ -1,5 +1,6 @@
+import { HeaderService } from "./header-service.js";
 export class ModelService {
-    static async fetchLatestGraph() {
+    static async fetchLatestGraph(limit) {
         return new Promise(async (resolve, reject) => {
             try {
                 const graph = await fetch(ModelService.doctorEndpoint + '/model/graph', {
@@ -22,7 +23,8 @@ export class ModelService {
                 if (graphRevisions) {
                     // first is latest, grab the id
                     const gId = graphRevisions[0].graphId;
-                    const graphFile = await fetch(ModelService.doctorEndpoint + '/model/graph/' + gId, {
+                    const queryParams = limit ? `?limit=${limit}` : '';
+                    const graphFile = await fetch(ModelService.doctorEndpoint + '/model/graph/' + gId + queryParams, {
                         method: 'GET',
                         credentials: 'include',
                         headers: {
@@ -172,18 +174,26 @@ export class ModelService {
             }
         });
     }
-    static async generateMock(spec = '') {
+    static async generateMock(spec = '', brokerId) {
         return new Promise(async (resolve, reject) => {
             try {
+                const headers = HeaderService.buildDefaultHeaders(brokerId);
                 const graph = await fetch(ModelService.doctorEndpoint + '/model/mock', {
                     method: 'POST',
                     credentials: 'include',
-                    headers: {
-                        'Content-Type': 'application/json'
-                    },
+                    headers: headers,
                     body: spec,
                 });
                 if (!graph.ok) {
+                    if (graph.status == 401) {
+                        reject({ detail: 'authentication is required to generate mocks' });
+                        return;
+                    }
+                    if (graph.status == 402) {
+                        const error = await graph.json();
+                        reject(error);
+                        return;
+                    }
                     const error = await graph.json();
                     reject(error);
                     return;
@@ -196,19 +206,18 @@ export class ModelService {
                 resolve(mockData);
             }
             catch (e) {
-                reject({ detail: 'unable fetch model mock: ' + e });
+                reject({ detail: 'mock generation failed: authentication is required, partner!' });
             }
         });
     }
-    static async generateExample(example) {
+    static async generateExample(example, brokerId) {
         return new Promise(async (resolve, reject) => {
             try {
+                const headers = HeaderService.buildDefaultHeaders(brokerId);
                 const exampleBuild = await fetch(ModelService.doctorEndpoint + '/model/generate-example', {
                     method: 'POST',
                     credentials: 'include',
-                    headers: {
-                        'Content-Type': 'application/json'
-                    },
+                    headers: headers,
                     body: example,
                 });
                 if (!exampleBuild.ok) {
@@ -290,5 +299,49 @@ export class ModelService {
             }
         });
     }
+    static async refreshGraph(limit) {
+        return ModelService.fetchLatestGraph(limit);
+    }
+    static async refreshReferenceMap(currentPath = '') {
+        return ModelService.fetchReferenceMap(currentPath);
+    }
+    static async refreshRolodex(path = '') {
+        return ModelService.queryRolodex(undefined, path);
+    }
+    static async bundleSpec(brokerId) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const headers = HeaderService.buildDefaultHeaders(brokerId);
+                const response = await fetch(ModelService.doctorEndpoint + '/model/bundle', {
+                    method: 'POST',
+                    credentials: 'include',
+                    headers: headers,
+                });
+                if (!response.ok) {
+                    if (response.status === 401) {
+                        reject({ detail: 'authentication is required to bundle specifications' });
+                        return;
+                    }
+                    if (response.status === 402) {
+                        const error = await response.json();
+                        reject(error);
+                        return;
+                    }
+                    const error = await response.json();
+                    reject(error);
+                    return;
+                }
+                const bundleData = await response.json();
+                if (!bundleData) {
+                    reject({ detail: 'unable to fetch bundled specification' });
+                    return;
+                }
+                resolve(bundleData);
+            }
+            catch (e) {
+                reject({ detail: 'bundle operation failed: ' + e });
+            }
+        });
+    }
 }
 ModelService.doctorEndpoint = 'https://doctor.pb33f.io';