@skmtc/core 0.0.983 → 0.16.1

package/script/context/CoreContext.d.ts

@@ -1,7 +1,6 @@
 import { GenerateContext } from './GenerateContext.js';
 import { RenderContext } from './RenderContext.js';
 import { ParseContext } from './ParseContext.js';
-import type { PrettierConfigType } from '../types/PrettierConfig.js';
 import type { OasDocument } from '../oas/document/Document.js';
 import type { ClientSettings } from '../types/Settings.js';
 import type { ResultType } from '../types/Results.js';
@@ -9,7 +8,12 @@ import type { Logger } from '../types/Logger.js';
 import type { StackTrail } from './StackTrail.js';
 import type { GeneratorsMapContainer } from '../types/GeneratorType.js';
 import type { OpenAPIV3 } from 'openapi-types';
-import type { RenderResult } from './generateTypes.js';
+import type { ToArtifactsResult } from './generateTypes.js';
+import type { SkmtcDocumentInput } from '../types/SkmtcDocument.js';
+import type { AttributionState } from '../types/AttributionState.js';
+import type { SupportedSubjects } from '../types/SupportedSubjects.js';
+import type { EnrichmentDefaults } from '../types/EnrichmentDefaults.js';
+import type { ParseIssue } from './ParseIssue.js';
 /**
  * Represents the parse phase of the SKMTC pipeline.
  *
@@ -19,7 +23,8 @@ import type { RenderResult } from './generateTypes.js';
 export type ParsePhase = {
     /** Identifies this as the parse phase */
     type: 'parse';
-    /** The parse context containing parsed document and utilities */
+    /** The unified parse context — handles both OAS and GQL via its
+     * internal protocol-discriminated state. */
     context: ParseContext;
 };
 /**
@@ -61,22 +66,39 @@ type CoreContextArgs = {
 /**
  * Arguments for the `toArtifacts` method of CoreContext.
  *
- * Contains all the necessary configuration for transforming an OpenAPI document
- * into code artifacts through the SKMTC pipeline.
+ * Contains all the necessary configuration for transforming a
+ * source document into code artifacts through the SKMTC parse +
+ * generate + render phases.
+ *
+ * On the OAS side `document.value` is the *raw* OpenAPI v3 document —
+ * `CoreContext.toArtifacts` runs the parse phase itself. On the GQL
+ * side `document.value` is a pre-parsed {@link GqlDocument}, since SDL
+ * parsing lives in the `parsers/graphql` sub-export to keep the
+ * `graphql` npm dependency optional for consumers.
  */
 export type ToArtifactsArgs = {
     /** Stack trail for distributed tracing */
     stackTrail: StackTrail;
-    /** The OpenAPI v3 document to process */
-    documentObject: OpenAPIV3.Document;
+    /**
+     * Source document. OAS variant carries the raw OpenAPI v3 JSON; GQL
+     * variant carries a pre-parsed {@link GqlDocument}. The generate
+     * phase reads the post-parse {@link SkmtcDocument}; both model and
+     * operation generators dispatch on `document.type`.
+     */
+    document: SkmtcDocumentInput;
     /** Client settings for customization (optional) */
     settings: ClientSettings | undefined;
     /** Function that returns the generator configuration map */
     toGeneratorConfigMap: <EnrichmentType = undefined>() => GeneratorsMapContainer<EnrichmentType>;
-    /** Prettier configuration for code formatting (optional) */
-    prettier?: PrettierConfigType;
     /** Whether to suppress console output */
     silent: boolean;
+    /**
+     * Optional attribution (gen-maps) **emission** config. Capture is
+     * always on; when `postPass` is set, the pipeline emits sidecars + a
+     * generation map alongside the usual artifacts. See
+     * {@link AttributionState}.
+     */
+    attribution?: AttributionState;
 };
 /**
  * The main orchestration class for the SKMTC transformation pipeline.
@@ -102,11 +124,11 @@ export type ToArtifactsArgs = {
  * });
  *
  * const result = await context.toArtifacts({
- *   documentObject: openApiDoc,
+ *   document: { type: 'oas', value: openApiDoc },
  *   settings: clientSettings,
  *   toGeneratorConfigMap: () => generators,
- *   prettier: prettierConfig,
- *   silent: false
+ *   silent: false,
+ *   stackTrail: new StackTrail(['gen'])
  * });
  * ```
  *
@@ -202,48 +224,41 @@ export declare class CoreContext {
      * about the generation process, including file mappings, previews, and results.
      *
      * @param args - Configuration for the artifact generation
-     * @param args.documentObject - The OpenAPI v3 document to process
+     * @param args.document - The source document, discriminated by protocol
+     *   (`{ type: 'oas', value: OpenAPIV3.Document }` or
+     *   `{ type: 'gql', value: GqlDocument }`)
      * @param args.settings - Client settings for customization
      * @param args.toGeneratorConfigMap - Function returning generator configuration
-     * @param args.prettier - Optional Prettier configuration for code formatting
      * @param args.silent - Whether to suppress console output during generation
+     * @param args.stackTrail - Stack trail for distributed tracing
      * @returns Promise resolving to rendered artifacts and metadata
      *
      * @example Complete pipeline
      * ```typescript
+     * import { CoreContext, StackTrail, toModelEntry, toOasOperationEntry } from '@skmtc/core';
+     *
      * const context = new CoreContext({
      *   spanId: 'api-client-gen',
      *   silent: false
      * });
      *
-     * const result = await context.toArtifacts({
-     *   documentObject: openApiDoc,
+     * const result = context.toArtifacts({
+     *   document: { type: 'oas', value: openApiDoc },
      *   settings: {
-     *     basePath: './src/api',
-     *     skip: {
-     *       models: ['Internal*'],
-     *       operations: {
-     *         '/health': ['get'],
-     *         '/debug/**': ['*']
-     *       }
-     *     }
+     *     basePath: './src/api'
      *   },
      *   toGeneratorConfigMap: () => ({
-     *     models: {
-     *       generator: MyModelGenerator,
-     *       settings: { includeValidation: true }
-     *     },
-     *     operations: {
-     *       generator: MyOperationGenerator,
-     *       settings: { generateTypes: true }
-     *     }
+     *     'typescript-models': toModelEntry({
+     *       id: 'typescript-models',
+     *       transform: ({ context, refName }) => {}
+     *     }),
+     *     'api-client': toOasOperationEntry({
+     *       id: 'api-client',
+     *       transform: ({ context, operation }) => {}
+     *     })
      *   }),
-     *   prettier: {
-     *     semi: false,
-     *     singleQuote: true,
-     *     trailingComma: 'all'
-     *   },
-     *   silent: false
+     *   silent: false,
+     *   stackTrail: new StackTrail(['gen'])
      * });
      *
      * // Access generated artifacts
@@ -261,7 +276,28 @@ export declare class CoreContext {
      *
      * @throws Will throw an error if any phase of the pipeline fails
      */
-    toArtifacts({ documentObject, settings, toGeneratorConfigMap, stackTrail, prettier }: ToArtifactsArgs): RenderResult;
+    toArtifacts({ document, settings, toGeneratorConfigMap, stackTrail, attribution }: ToArtifactsArgs): ToArtifactsResult;
+    /**
+     * Capability-only sibling of {@link toArtifacts}: parse the document, then
+     * evaluate each generator's `isSupported` over its subjects — no transform,
+     * no render. Returns the subjects each generator supports, plus parse issues.
+     */
+    toSupportedSubjects({ document, settings, toGeneratorConfigMap, stackTrail }: Pick<ToArtifactsArgs, 'document' | 'settings' | 'toGeneratorConfigMap' | 'stackTrail'>): {
+        subjects: SupportedSubjects;
+        parseIssues: ParseIssue[];
+    };
+    /**
+     * Seed-values sibling of {@link toSupportedSubjects}: parse the document, then
+     * call each generator's `toEnrichmentDefaults` over its supported subjects —
+     * no transform, no render. Returns the default enrichment values keyed by the
+     * `client.json#settings.enrichments` routing, plus parse issues. Fails open
+     * like {@link toArtifacts}: a bad schema surfaces as a `parseIssue` and the
+     * defaults map is returned empty.
+     */
+    toEnrichmentDefaults({ document, settings, toGeneratorConfigMap, stackTrail }: Pick<ToArtifactsArgs, 'document' | 'settings' | 'toGeneratorConfigMap' | 'stackTrail'>): {
+        enrichmentDefaults: EnrichmentDefaults;
+        parseIssues: ParseIssue[];
+    };
     /**
      * Captures a result at the current execution position in the stack trail.
      *

package/script/context/CoreContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CoreContext.d.ts","sourceRoot":"","sources":["../../src/context/CoreContext.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"CoreContext.d.ts","sourceRoot":"","sources":["../../src/context/CoreContext.ts"],"names":[],"mappings":"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"}

package/script/context/CoreContext.js

@@ -54,8 +54,8 @@ const ParseContext_js_1 = require("./ParseContext.js");
 const log = __importStar(require("../deps/jsr.io/@std/log/0.224.14/mod.js"));
 const ResultsHandler_js_1 = require("./ResultsHandler.js");
 const ResultsLog_js_1 = require("../helpers/ResultsLog.js");
-const join_js_1 = require("../deps/jsr.io/@std/path/1.1.3/join.js");
-const colors_js_1 = require("../deps/jsr.io/@std/fmt/1.0.8/colors.js");
+const join_js_1 = require("../deps/jsr.io/@std/path/1.1.4/join.js");
+const colors_js_1 = require("../deps/jsr.io/@std/fmt/1.0.10/colors.js");
 /**
  * The main orchestration class for the SKMTC transformation pipeline.
  *
@@ -80,11 +80,11 @@ const colors_js_1 = require("../deps/jsr.io/@std/fmt/1.0.8/colors.js");
  * });
  *
  * const result = await context.toArtifacts({
- *   documentObject: openApiDoc,
+ *   document: { type: 'oas', value: openApiDoc },
  *   settings: clientSettings,
  *   toGeneratorConfigMap: () => generators,
- *   prettier: prettierConfig,
- *   silent: false
+ *   silent: false,
+ *   stackTrail: new StackTrail(['gen'])
  * });
  * ```
  *
@@ -184,10 +184,14 @@ class CoreContext {
      * ```
      */
     parse(documentObject, stackTrail) {
-        __classPrivateFieldSet(this, _CoreContext_phase, __classPrivateFieldGet(this, _CoreContext_instances, "m", _CoreContext_setupParsePhase).call(this, documentObject), "f");
-        const oasDocument = __classPrivateFieldGet(this, _CoreContext_phase, "f").context.parse(stackTrail);
+        __classPrivateFieldSet(this, _CoreContext_phase, __classPrivateFieldGet(this, _CoreContext_instances, "m", _CoreContext_setupParsePhase).call(this, { type: 'oas', value: documentObject }), "f");
+        const parsed = __classPrivateFieldGet(this, _CoreContext_phase, "f").context.parse(stackTrail);
+        if (parsed.type !== 'oas') {
+            // Unreachable: input was tagged 'oas' so the parsed branch must match.
+            throw new Error('CoreContext.parse: expected OAS parsed document');
+        }
         return {
-            oasDocument
+            oasDocument: parsed.value
         };
     }
     /**
@@ -202,48 +206,41 @@ class CoreContext {
      * about the generation process, including file mappings, previews, and results.
      *
      * @param args - Configuration for the artifact generation
-     * @param args.documentObject - The OpenAPI v3 document to process
+     * @param args.document - The source document, discriminated by protocol
+     *   (`{ type: 'oas', value: OpenAPIV3.Document }` or
+     *   `{ type: 'gql', value: GqlDocument }`)
      * @param args.settings - Client settings for customization
      * @param args.toGeneratorConfigMap - Function returning generator configuration
-     * @param args.prettier - Optional Prettier configuration for code formatting
      * @param args.silent - Whether to suppress console output during generation
+     * @param args.stackTrail - Stack trail for distributed tracing
      * @returns Promise resolving to rendered artifacts and metadata
      *
      * @example Complete pipeline
      * ```typescript
+     * import { CoreContext, StackTrail, toModelEntry, toOasOperationEntry } from '@skmtc/core';
+     *
      * const context = new CoreContext({
      *   spanId: 'api-client-gen',
      *   silent: false
      * });
      *
-     * const result = await context.toArtifacts({
-     *   documentObject: openApiDoc,
+     * const result = context.toArtifacts({
+     *   document: { type: 'oas', value: openApiDoc },
      *   settings: {
-     *     basePath: './src/api',
-     *     skip: {
-     *       models: ['Internal*'],
-     *       operations: {
-     *         '/health': ['get'],
-     *         '/debug/**': ['*']
-     *       }
-     *     }
+     *     basePath: './src/api'
      *   },
      *   toGeneratorConfigMap: () => ({
-     *     models: {
-     *       generator: MyModelGenerator,
-     *       settings: { includeValidation: true }
-     *     },
-     *     operations: {
-     *       generator: MyOperationGenerator,
-     *       settings: { generateTypes: true }
-     *     }
+     *     'typescript-models': toModelEntry({
+     *       id: 'typescript-models',
+     *       transform: ({ context, refName }) => {}
+     *     }),
+     *     'api-client': toOasOperationEntry({
+     *       id: 'api-client',
+     *       transform: ({ context, operation }) => {}
+     *     })
      *   }),
-     *   prettier: {
-     *     semi: false,
-     *     singleQuote: true,
-     *     trailingComma: 'all'
-     *   },
-     *   silent: false
+     *   silent: false,
+     *   stackTrail: new StackTrail(['gen'])
      * });
      *
      * // Access generated artifacts
@@ -261,44 +258,85 @@ class CoreContext {
      *
      * @throws Will throw an error if any phase of the pipeline fails
      */
-    toArtifacts({ documentObject, settings, toGeneratorConfigMap, stackTrail, prettier }) {
+    toArtifacts({ document, settings, toGeneratorConfigMap, stackTrail, attribution }) {
         try {
-            const oasDocument = stackTrail.trace('parse', st => {
-                __classPrivateFieldSet(this, _CoreContext_phase, __classPrivateFieldGet(this, _CoreContext_instances, "m", _CoreContext_setupParsePhase).call(this, documentObject), "f");
-                return __classPrivateFieldGet(this, _CoreContext_phase, "f").context.parse(st);
-            });
+            // Parse phase: one unified ParseContext handles both protocols
+            // via its internal protocol-discriminated state. `parse()` returns
+            // a SkmtcParsedDocument; we collect issues from `context.issues`.
+            const phase = __classPrivateFieldGet(this, _CoreContext_instances, "m", _CoreContext_setupParsePhase).call(this, document);
+            __classPrivateFieldSet(this, _CoreContext_phase, phase, "f");
+            const parsedDocument = stackTrail.trace('parse', st => phase.context.parse(st));
+            // The shared attribution capture channel: snippets constructed
+            // during generate hold the GenerateContext, whose `captureSink`
+            // reads this slot; RenderContext flips it around the one capturing
+            // render. One object per run wires the two phases together.
+            const captureChannel = { sink: undefined };
             const { files, previews, mappings } = stackTrail.trace('generate', st => {
                 __classPrivateFieldSet(this, _CoreContext_phase, __classPrivateFieldGet(this, _CoreContext_instances, "m", _CoreContext_setupGeneratePhase).call(this, {
                     toGeneratorConfigMap,
-                    oasDocument,
-                    settings
+                    document: parsedDocument,
+                    settings,
+                    captureChannel
                 }), "f");
                 return __classPrivateFieldGet(this, _CoreContext_phase, "f").context.toArtifacts(st);
             });
+            // Render is a single capture pass: it renders each File once and,
+            // when `attribution.postPass` is configured, simultaneously captures
+            // the producer occurrence tree and emits sidecars + the generation
+            // map (folded into `RenderContext.render`). No separate pre-render
+            // post-pass, no re-render — the old `_rendered` cache that faked
+            // "render once" across two passes is gone.
             const renderOutput = stackTrail.trace('render', st => {
                 __classPrivateFieldSet(this, _CoreContext_phase, __classPrivateFieldGet(this, _CoreContext_instances, "m", _CoreContext_setupRenderPhase).call(this, {
                     files,
                     previews,
                     mappings,
-                    prettier,
-                    basePath: settings?.basePath
+                    basePath: settings?.basePath,
+                    attribution,
+                    captureChannel
                 }), "f");
                 return __classPrivateFieldGet(this, _CoreContext_phase, "f").context.render(st);
             });
             return {
                 ...renderOutput,
-                results: __classPrivateFieldGet(this, _CoreContext_results, "f").toTree()
+                results: __classPrivateFieldGet(this, _CoreContext_results, "f").toTree(),
+                parseIssues: phase.context.issues
             };
         }
         catch (error) {
             console.error(error);
             this.logger.error(error);
+            // Surface the fatal error as a synthesized parse-issue so
+            // downstream consumers (CLI `generate`, the manifest writer)
+            // can tell a successful 0-file run apart from a crashed run.
+            // Before this, the catch returned `parseIssues: []` and an
+            // empty `artifacts`, which read on the CLI side as "everything
+            // generated, just nothing emitted" — silent failure.
+            //
+            // We pull whatever parse-phase issues were already recorded
+            // before the throw, so any incremental diagnostics aren't lost,
+            // and append the top-level failure on the end. Protocol is
+            // hardcoded to 'oas' because the synthesized issue is
+            // post-protocol-dispatch and we don't have a discriminator at
+            // this catch site; OAS is the more common case and the
+            // location format ('toArtifacts') is unambiguous regardless.
+            const priorIssues = __classPrivateFieldGet(this, _CoreContext_phase, "f")?.type === 'parse' ? __classPrivateFieldGet(this, _CoreContext_phase, "f").context.issues : [];
+            const message = error instanceof Error ? error.message : String(error);
+            const fatalIssue = {
+                protocol: 'oas',
+                level: 'error',
+                type: 'INVALID_SCHEMA',
+                location: 'toArtifacts',
+                message: `Top-level toArtifacts failure: ${message}`,
+                cause: error
+            };
             return {
                 artifacts: {},
                 files: {},
                 previews: {},
                 mappings: {},
-                results: __classPrivateFieldGet(this, _CoreContext_results, "f").toTree()
+                results: __classPrivateFieldGet(this, _CoreContext_results, "f").toTree(),
+                parseIssues: [...priorIssues, fatalIssue]
             };
         }
         finally {
@@ -309,6 +347,97 @@ class CoreContext {
             });
         }
     }
+    /**
+     * Capability-only sibling of {@link toArtifacts}: parse the document, then
+     * evaluate each generator's `isSupported` over its subjects — no transform,
+     * no render. Returns the subjects each generator supports, plus parse issues.
+     */
+    toSupportedSubjects({ document, settings, toGeneratorConfigMap, stackTrail }) {
+        try {
+            const phase = __classPrivateFieldGet(this, _CoreContext_instances, "m", _CoreContext_setupParsePhase).call(this, document);
+            __classPrivateFieldSet(this, _CoreContext_phase, phase, "f");
+            const parsedDocument = stackTrail.trace('parse', st => phase.context.parse(st));
+            const subjects = stackTrail.trace('generate', () => {
+                // Capability probing never renders, so the capture interval never
+                // opens — a throwaway channel satisfies the wiring.
+                const generatePhase = __classPrivateFieldGet(this, _CoreContext_instances, "m", _CoreContext_setupGeneratePhase).call(this, {
+                    toGeneratorConfigMap,
+                    document: parsedDocument,
+                    settings,
+                    captureChannel: { sink: undefined }
+                });
+                __classPrivateFieldSet(this, _CoreContext_phase, generatePhase, "f");
+                return generatePhase.context.toSupportedSubjects();
+            });
+            return { subjects, parseIssues: phase.context.issues };
+        }
+        catch (error) {
+            this.logger.error(error);
+            const priorIssues = __classPrivateFieldGet(this, _CoreContext_phase, "f")?.type === 'parse' ? __classPrivateFieldGet(this, _CoreContext_phase, "f").context.issues : [];
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                subjects: {},
+                parseIssues: [
+                    ...priorIssues,
+                    {
+                        protocol: 'oas',
+                        level: 'error',
+                        type: 'INVALID_SCHEMA',
+                        location: 'toSupportedSubjects',
+                        message: `Top-level toSupportedSubjects failure: ${message}`,
+                        cause: error
+                    }
+                ]
+            };
+        }
+    }
+    /**
+     * Seed-values sibling of {@link toSupportedSubjects}: parse the document, then
+     * call each generator's `toEnrichmentDefaults` over its supported subjects —
+     * no transform, no render. Returns the default enrichment values keyed by the
+     * `client.json#settings.enrichments` routing, plus parse issues. Fails open
+     * like {@link toArtifacts}: a bad schema surfaces as a `parseIssue` and the
+     * defaults map is returned empty.
+     */
+    toEnrichmentDefaults({ document, settings, toGeneratorConfigMap, stackTrail }) {
+        try {
+            const phase = __classPrivateFieldGet(this, _CoreContext_instances, "m", _CoreContext_setupParsePhase).call(this, document);
+            __classPrivateFieldSet(this, _CoreContext_phase, phase, "f");
+            const parsedDocument = stackTrail.trace('parse', st => phase.context.parse(st));
+            const enrichmentDefaults = stackTrail.trace('generate', () => {
+                // Seeding never renders, so the capture interval never opens — a
+                // throwaway channel satisfies the wiring.
+                const generatePhase = __classPrivateFieldGet(this, _CoreContext_instances, "m", _CoreContext_setupGeneratePhase).call(this, {
+                    toGeneratorConfigMap,
+                    document: parsedDocument,
+                    settings,
+                    captureChannel: { sink: undefined }
+                });
+                __classPrivateFieldSet(this, _CoreContext_phase, generatePhase, "f");
+                return generatePhase.context.toEnrichmentDefaults();
+            });
+            return { enrichmentDefaults, parseIssues: phase.context.issues };
+        }
+        catch (error) {
+            this.logger.error(error);
+            const priorIssues = __classPrivateFieldGet(this, _CoreContext_phase, "f")?.type === 'parse' ? __classPrivateFieldGet(this, _CoreContext_phase, "f").context.issues : [];
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                enrichmentDefaults: {},
+                parseIssues: [
+                    ...priorIssues,
+                    {
+                        protocol: 'oas',
+                        level: 'error',
+                        type: 'INVALID_SCHEMA',
+                        location: 'toEnrichmentDefaults',
+                        message: `Top-level toEnrichmentDefaults failure: ${message}`,
+                        cause: error
+                    }
+                ]
+            };
+        }
+    }
     /**
      * Captures a result at the current execution position in the stack trail.
      *
@@ -378,31 +507,33 @@ _CoreContext_phase = new WeakMap(), _CoreContext_results = new WeakMap(), _CoreC
         }
     });
     return log.getLogger(spanId);
-}, _CoreContext_setupParsePhase = function _CoreContext_setupParsePhase(documentObject) {
+}, _CoreContext_setupParsePhase = function _CoreContext_setupParsePhase(input) {
     const parseContext = new ParseContext_js_1.ParseContext({
-        documentObject,
+        input,
         logger: this.logger,
         silent: this.silent
     });
     return { type: 'parse', context: parseContext };
-}, _CoreContext_setupGeneratePhase = function _CoreContext_setupGeneratePhase({ oasDocument, settings, toGeneratorConfigMap }) {
+}, _CoreContext_setupGeneratePhase = function _CoreContext_setupGeneratePhase({ document, settings, toGeneratorConfigMap, captureChannel }) {
     const generateContext = new GenerateContext_js_1.GenerateContext({
-        oasDocument,
+        document,
         settings,
         logger: this.logger,
         captureCurrentResult: this.captureCurrentResult.bind(this),
-        toGeneratorConfigMap
+        toGeneratorConfigMap,
+        captureChannel
     });
     return { type: 'generate', context: generateContext };
-}, _CoreContext_setupRenderPhase = function _CoreContext_setupRenderPhase({ files, previews, mappings, prettier, basePath }) {
+}, _CoreContext_setupRenderPhase = function _CoreContext_setupRenderPhase({ files, previews, mappings, basePath, attribution, captureChannel }) {
     const renderContext = new RenderContext_js_1.RenderContext({
         files,
         previews,
         mappings,
-        prettierConfig: prettier,
         basePath,
         logger: this.logger,
-        captureCurrentResult: this.captureCurrentResult.bind(this)
+        captureCurrentResult: this.captureCurrentResult.bind(this),
+        attribution,
+        captureChannel
     });
     return { type: 'render', context: renderContext };
 };