mikoshi-construct 0.1.0

package/templates/harness/package.json.eta

@@ -0,0 +1,29 @@
+{
+  "name": "{{projectName}}",
+  "type": "module",
+  "version": "0.1.0",
+  "private": true,
+{{#if pnpmVersion}}
+  "packageManager": "pnpm@{{pnpmVersion}}",
+{{/if}}
+  "scripts": {
+    "composition:render": "tsx scripts/composition/sync-docs.ts",
+    "composition:check": "tsx scripts/composition/check.ts",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "quality": "pnpm composition:check && pnpm lint && pnpm typecheck && pnpm test",
+    "ci": "pnpm run quality"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^9.5.1",
+    "@types/node": "^{{nodeMajor}}.0.0",
+    "eslint": "^10.10.0",
+    "tsx": "^4.23.13",
+    "typescript": "^5.9.3",
+    "vitest": "^5.0.0",
+    "yaml": "^2.9.1"
+  }
+}

package/templates/harness/pnpm-workspace.yaml

@@ -0,0 +1,11 @@
+minimumReleaseAgeExcludePrune: true
+
+trustPolicy: no-downgrade
+trustPolicyExclude:
+  - chokidar@4.0.3
+  - undici-types@6.21.0
+
+shellEmulator: true
+
+allowBuilds:
+  esbuild: true

package/templates/harness/scripts/composition/check.ts

@@ -0,0 +1,19 @@
+import { readFileSync } from 'node:fs'
+import process from 'node:process'
+import { loadCompositionModels, missingPaths } from './files.js'
+import { extractEmbedded, renderEmbedded } from './render.js'
+
+const problems: string[] = []
+
+for (const { model, file, docPath } of loadCompositionModels()) {
+  for (const missing of missingPaths(model))
+    problems.push(`${file}: path "${missing}" does not exist`)
+  const doc = readFileSync(docPath, 'utf8')
+  if (extractEmbedded(doc, model, model.doc) !== renderEmbedded(model))
+    problems.push(`${model.doc}: the ${model.id} diagram is out of date with ${file}; run pnpm composition:render`)
+}
+
+if (problems.length > 0) {
+  console.error(problems.join('\n'))
+  process.exit(1)
+}

package/templates/harness/scripts/composition/files.ts

@@ -0,0 +1,34 @@
+import type { CompositionModel } from './model.js'
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { parseCompositionModel } from './model.js'
+
+export const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..')
+export const COMPOSITION_DIR = path.join(REPO_ROOT, 'architecture/composition')
+
+export interface LoadedModel {
+  model: CompositionModel
+  file: string
+  docPath: string
+}
+
+export function loadCompositionModels(dir = COMPOSITION_DIR): LoadedModel[] {
+  if (!existsSync(dir))
+    return []
+  return readdirSync(dir)
+    .filter(file => file.endsWith('.yaml'))
+    .sort()
+    .map((file) => {
+      const model = parseCompositionModel(readFileSync(path.join(dir, file), 'utf8'), file)
+      if (`${model.id}.yaml` !== file)
+        throw new Error(`${file}: the file must be named after its id "${model.id}"`)
+      return { model, file, docPath: path.join(REPO_ROOT, model.doc) }
+    })
+}
+
+export function missingPaths(model: CompositionModel, root = REPO_ROOT): string[] {
+  return model.nodes
+    .flatMap(node => (node.path == null ? [] : [node.path]))
+    .filter(candidate => !existsSync(path.join(root, candidate)))
+}

package/templates/harness/scripts/composition/model.ts

@@ -0,0 +1,137 @@
+import { parse } from 'yaml'
+
+export const EDGE_KINDS = ['sequence', 'parallel', 'route', 'fan-out', 'fan-in', 'wires'] as const
+export type EdgeKind = (typeof EDGE_KINDS)[number]
+
+export interface Boundary {
+  id: string
+  label: string
+}
+
+export interface CompositionNode {
+  id: string
+  label: string
+  path?: string
+  boundary?: string
+}
+
+export interface CompositionEdge {
+  from: string
+  to: string
+  kind: EdgeKind
+  label?: string
+}
+
+export interface CompositionModel {
+  id: string
+  title: string
+  description?: string
+  doc: string
+  boundaries: Boundary[]
+  nodes: CompositionNode[]
+  edges: CompositionEdge[]
+}
+
+const IDENTIFIER = /^[A-Z]\w*$/i
+
+function fail(name: string, message: string): never {
+  throw new Error(`${name}: ${message}`)
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value != null && !Array.isArray(value)
+}
+
+function text(name: string, record: Record<string, unknown>, key: string, where: string): string {
+  const value = record[key]
+  if (typeof value !== 'string' || value.trim() === '')
+    fail(name, `${where} needs a non-empty "${key}"`)
+  return value
+}
+
+function optionalText(name: string, record: Record<string, unknown>, key: string, where: string): string | undefined {
+  if (record[key] === undefined)
+    return undefined
+  return text(name, record, key, where)
+}
+
+function identifier(name: string, value: string, where: string): string {
+  if (!IDENTIFIER.test(value))
+    fail(name, `${where} id "${value}" must match ${IDENTIFIER}`)
+  return value
+}
+
+function list(name: string, record: Record<string, unknown>, key: string): Record<string, unknown>[] {
+  const value = record[key] ?? []
+  if (!Array.isArray(value) || !value.every(isRecord))
+    fail(name, `"${key}" must be a list of objects`)
+  return value
+}
+
+export function parseCompositionModel(source: string, name: string): CompositionModel {
+  const raw: unknown = parse(source)
+  if (!isRecord(raw))
+    fail(name, 'the document must be a mapping')
+
+  const boundaries = list(name, raw, 'boundaries').map((entry, index) => ({
+    id: identifier(name, text(name, entry, 'id', `boundaries[${index}]`), `boundaries[${index}]`),
+    label: text(name, entry, 'label', `boundaries[${index}]`),
+  }))
+  const boundaryIds = new Set(boundaries.map(boundary => boundary.id))
+  if (boundaryIds.size !== boundaries.length)
+    fail(name, 'boundary ids must be unique')
+
+  const nodes = list(name, raw, 'nodes').map((entry, index) => {
+    const where = `nodes[${index}]`
+    const node: CompositionNode = {
+      id: identifier(name, text(name, entry, 'id', where), where),
+      label: text(name, entry, 'label', where),
+    }
+    const path = optionalText(name, entry, 'path', where)
+    if (path != null)
+      node.path = path
+    const boundary = optionalText(name, entry, 'boundary', where)
+    if (boundary != null) {
+      if (!boundaryIds.has(boundary))
+        fail(name, `${where} refers to unknown boundary "${boundary}"`)
+      node.boundary = boundary
+    }
+    return node
+  })
+  const nodeIds = new Set(nodes.map(node => node.id))
+  if (nodeIds.size !== nodes.length)
+    fail(name, 'node ids must be unique')
+  if (nodes.length === 0)
+    fail(name, 'at least one node is required')
+
+  const edges = list(name, raw, 'edges').map((entry, index) => {
+    const where = `edges[${index}]`
+    const from = text(name, entry, 'from', where)
+    const to = text(name, entry, 'to', where)
+    for (const endpoint of [from, to]) {
+      if (!nodeIds.has(endpoint))
+        fail(name, `${where} refers to unknown node "${endpoint}"`)
+    }
+    const kind = text(name, entry, 'kind', where)
+    if (!(EDGE_KINDS as readonly string[]).includes(kind))
+      fail(name, `${where} kind "${kind}" is not one of ${EDGE_KINDS.join(', ')}`)
+    const edge: CompositionEdge = { from, to, kind: kind as EdgeKind }
+    const label = optionalText(name, entry, 'label', where)
+    if (label != null)
+      edge.label = label
+    return edge
+  })
+
+  const model: CompositionModel = {
+    id: identifier(name, text(name, raw, 'id', 'the document'), 'the document'),
+    title: text(name, raw, 'title', 'the document'),
+    doc: text(name, raw, 'doc', 'the document'),
+    boundaries,
+    nodes,
+    edges,
+  }
+  const description = optionalText(name, raw, 'description', 'the document')
+  if (description != null)
+    model.description = description
+  return model
+}

package/templates/harness/scripts/composition/render.ts

@@ -0,0 +1,72 @@
+import type { CompositionEdge, CompositionModel } from './model.js'
+
+const ARROWS: Record<CompositionEdge['kind'], string> = {
+  'sequence': '-->',
+  'parallel': '==>',
+  'route': '-->',
+  'fan-out': '-->',
+  'fan-in': '-->',
+  'wires': '-.->',
+}
+
+const IMPLICIT_LABELS: Partial<Record<CompositionEdge['kind'], string>> = {
+  'parallel': 'parallel',
+  'fan-out': 'fan-out',
+  'fan-in': 'fan-in',
+}
+
+function quoted(label: string): string {
+  return `"${label.replaceAll('"', '#quot;')}"`
+}
+
+function edgeLine(edge: CompositionEdge): string {
+  const label = edge.label ?? IMPLICIT_LABELS[edge.kind]
+  const link = label == null ? ARROWS[edge.kind] : `${ARROWS[edge.kind]}|${quoted(label)}|`
+  return `  ${edge.from} ${link} ${edge.to}`
+}
+
+export function renderMermaid(model: CompositionModel): string {
+  const lines = ['flowchart LR']
+  for (const boundary of model.boundaries) {
+    lines.push(`  subgraph b_${boundary.id}[${quoted(boundary.label)}]`)
+    for (const node of model.nodes.filter(candidate => candidate.boundary === boundary.id))
+      lines.push(`    ${node.id}[${quoted(node.label)}]`)
+    lines.push('  end')
+  }
+  for (const node of model.nodes.filter(candidate => candidate.boundary == null))
+    lines.push(`  ${node.id}[${quoted(node.label)}]`)
+  for (const edge of model.edges)
+    lines.push(edgeLine(edge))
+  return `${lines.join('\n')}\n`
+}
+
+export function openingMarker(id: string): string {
+  return `<!-- composition:${id} -->`
+}
+
+export function closingMarker(id: string): string {
+  return `<!-- /composition:${id} -->`
+}
+
+function markerBounds(doc: string, id: string, docName: string): { start: number, end: number } {
+  const start = doc.indexOf(openingMarker(id))
+  const end = doc.indexOf(closingMarker(id))
+  if (start === -1 || end === -1 || end < start)
+    throw new Error(`${docName} is missing the ${openingMarker(id)} … ${closingMarker(id)} block`)
+  return { start: start + openingMarker(id).length, end }
+}
+
+export function renderEmbedded(model: CompositionModel): string {
+  const description = model.description == null ? '' : `${model.description}\n\n`
+  return `\n${description}\`\`\`mermaid\n${renderMermaid(model)}\`\`\`\n`
+}
+
+export function embed(doc: string, model: CompositionModel, docName: string): string {
+  const { start, end } = markerBounds(doc, model.id, docName)
+  return doc.slice(0, start) + renderEmbedded(model) + doc.slice(end)
+}
+
+export function extractEmbedded(doc: string, model: CompositionModel, docName: string): string {
+  const { start, end } = markerBounds(doc, model.id, docName)
+  return doc.slice(start, end)
+}

package/templates/harness/scripts/composition/sync-docs.ts

@@ -0,0 +1,11 @@
+import { readFileSync, writeFileSync } from 'node:fs'
+import { loadCompositionModels } from './files.js'
+import { embed } from './render.js'
+
+for (const { model, docPath } of loadCompositionModels()) {
+  const doc = readFileSync(docPath, 'utf8')
+  const next = embed(doc, model, model.doc)
+  if (next !== doc)
+    writeFileSync(docPath, next)
+  console.warn(`[composition] ${model.id} → ${model.doc}`)
+}

package/templates/harness/scripts/tests/composition/files.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest'
+import { COMPOSITION_DIR, loadCompositionModels, missingPaths, REPO_ROOT } from '../../composition/files.js'
+
+describe('composition models on disk', () => {
+  it('are named after their id and point only at files that exist', () => {
+    for (const { model, file } of loadCompositionModels(COMPOSITION_DIR)) {
+      expect(file).toBe(`${model.id}.yaml`)
+      expect(missingPaths(model, REPO_ROOT)).toEqual([])
+    }
+  })
+
+  it('reports a node path that does not exist', () => {
+    const broken = { id: 'x', title: 'x', doc: 'architecture/x.md', boundaries: [], edges: [], nodes: [{ id: 'x', label: 'x', path: 'src/nowhere/file.ts' }] }
+    expect(missingPaths(broken, REPO_ROOT)).toEqual(['src/nowhere/file.ts'])
+  })
+})

package/templates/harness/scripts/tests/composition/model.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest'
+import { parseCompositionModel } from '../../composition/model.js'
+
+const valid = `
+id: demo
+title: Demo flow
+doc: docs/demo.md
+boundaries:
+  - { id: api, label: API }
+nodes:
+  - { id: a, label: Start, path: package.json, boundary: api }
+  - { id: b, label: End }
+edges:
+  - { from: a, to: b, kind: sequence, label: next }
+`
+
+describe('parseCompositionModel', () => {
+  it('reads a valid model', () => {
+    const model = parseCompositionModel(valid, 'demo.yaml')
+    expect(model.id).toBe('demo')
+    expect(model.nodes.map(node => node.id)).toEqual(['a', 'b'])
+    expect(model.edges[0]).toEqual({ from: 'a', to: 'b', kind: 'sequence', label: 'next' })
+  })
+
+  it('rejects an edge that points at an unknown node', () => {
+    expect(() => parseCompositionModel(valid.replace('to: b', 'to: ghost'), 'demo.yaml'))
+      .toThrow('edges[0] refers to unknown node "ghost"')
+  })
+
+  it('rejects an edge kind outside the vocabulary', () => {
+    expect(() => parseCompositionModel(valid.replace('kind: sequence', 'kind: maybe'), 'demo.yaml'))
+      .toThrow('kind "maybe" is not one of')
+  })
+
+  it('rejects a node in an undeclared boundary and an id Mermaid cannot render', () => {
+    expect(() => parseCompositionModel(valid.replace('boundary: api', 'boundary: web'), 'demo.yaml'))
+      .toThrow('unknown boundary "web"')
+    expect(() => parseCompositionModel(valid.replace('id: a,', 'id: 1a,'), 'demo.yaml'))
+      .toThrow('must match')
+  })
+})

package/templates/harness/scripts/tests/composition/render.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest'
+import { parseCompositionModel } from '../../composition/model.js'
+import { closingMarker, embed, extractEmbedded, openingMarker, renderEmbedded, renderMermaid } from '../../composition/render.js'
+
+const model = parseCompositionModel(`
+id: demo
+title: Demo flow
+description: Two steps.
+doc: docs/demo.md
+boundaries:
+  - { id: api, label: "API \\"edge\\"" }
+nodes:
+  - { id: a, label: Start, boundary: api }
+  - { id: b, label: End }
+  - { id: c, label: Side }
+edges:
+  - { from: a, to: b, kind: sequence }
+  - { from: a, to: c, kind: fan-out }
+  - { from: c, to: b, kind: wires, label: provides }
+`, 'demo.yaml')
+
+describe('renderMermaid', () => {
+  it('groups nodes by boundary, escapes quotes and styles edges by kind', () => {
+    expect(renderMermaid(model)).toBe([
+      'flowchart LR',
+      '  subgraph b_api["API #quot;edge#quot;"]',
+      '    a["Start"]',
+      '  end',
+      '  b["End"]',
+      '  c["Side"]',
+      '  a --> b',
+      '  a -->|"fan-out"| c',
+      '  c -.->|"provides"| b',
+      '',
+    ].join('\n'))
+  })
+})
+
+describe('embed and extractEmbedded', () => {
+  const doc = `# Doc\n\n${openingMarker('demo')}\nstale\n${closingMarker('demo')}\n\nTail\n`
+
+  it('replaces only the marked block and reads it back unchanged', () => {
+    const next = embed(doc, model, 'docs/demo.md')
+    expect(next.startsWith('# Doc\n\n')).toBe(true)
+    expect(next.endsWith('\n\nTail\n')).toBe(true)
+    expect(next).toContain('Two steps.\n\n```mermaid\nflowchart LR')
+    expect(extractEmbedded(next, model, 'docs/demo.md')).toBe(renderEmbedded(model))
+    expect(extractEmbedded(doc, model, 'docs/demo.md')).not.toBe(renderEmbedded(model))
+  })
+
+  it('refuses a document without the markers', () => {
+    expect(() => embed('# Doc\n', model, 'docs/demo.md')).toThrow('missing the <!-- composition:demo -->')
+  })
+})

package/templates/harness/tsconfig.base.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "resolveJsonModule": true,
+    "types": ["node"],
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  }
+}

package/templates/harness/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "./tsconfig.base.json",
+  "include": ["src/**/*.ts", "tests/**/*.ts", "scripts/**/*.ts", "vitest.config.ts"],
+  "exclude": ["**/node_modules/**", "**/dist/**"]
+}

package/templates/harness/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    include: ['tests/**/*.test.ts', 'scripts/tests/**/*.test.ts'],
+    environment: 'node',
+  },
+})

package/templates/presets/monorepo/baseline/eslint.config.mjs.eta

@@ -0,0 +1,100 @@
+import antfu from '@antfu/eslint-config'
+
+const WORKSPACE_PACKAGES = {{workspacePackages}}
+
+const ALLOWED_WORKSPACE_IMPORTS = {{allowedWorkspaceImports}}
+
+const PROCESS_ENV = 'MemberExpression[object.name="process"][property.name="env"]'
+const PROCESS_MEMBER = 'MemberExpression[object.name="process"]'
+const RAW_REQUEST_DATA = 'MemberExpression[object.name="req"][property.name=/^(body|query|params)$/]'
+const RAW_SQL = 'CallExpression[callee.object.name="sql"][callee.property.name="raw"]'
+const SHARED_IMPORT = ':matches(ImportDeclaration, ExportNamedDeclaration, ExportAllDeclaration)[source.value=/^{{scope}}\\/shared(\\/|$)/]'
+
+function dependencyBoundary([directory, allowed]) {
+  const forbidden = WORKSPACE_PACKAGES.filter(name => !allowed.includes(name))
+  return {
+    files: [`${directory}/**`],
+    rules: {
+      'no-restricted-imports': ['error', {
+        patterns: [{
+          group: forbidden.flatMap(name => [name, `${name}/*`]),
+          message: allowed.length === 0
+            ? `${directory} imports no other workspace package`
+            : `${directory} may import only ${allowed.join(', ')}`,
+        }],
+      }],
+    },
+  }
+}
+
+const dependencyBoundaries = Object.entries(ALLOWED_WORKSPACE_IMPORTS)
+  .filter(([, allowed]) => allowed.length < WORKSPACE_PACKAGES.length)
+  .map(dependencyBoundary)
+
+const NO_PROCESS_OUTSIDE_CONFIG = {
+  selector: PROCESS_MEMBER,
+  message: 'An app touches process only in config.ts: read configuration through readConfig() and pass the value on',
+}
+const NO_PROCESS_ENV_IN_PACKAGE = {
+  selector: PROCESS_ENV,
+  message: 'A package reads the environment only in its *.config.ts',
+}
+const NO_RAW_REQUEST_DATA = {
+  selector: RAW_REQUEST_DATA,
+  message: 'External input is validated at the HTTP boundary: read req.body, req.query and req.params in a controller or middleware and pass values on',
+}
+const NO_RAW_SQL = {
+  selector: RAW_SQL,
+  message: 'SQL is never built from raw strings: interpolate tables and columns into the sql template instead of sql.raw',
+}
+const NO_SHARED_OUTSIDE_CONTRACTS = {
+  selector: SHARED_IMPORT,
+  message: 'Contract types enter an app only through src/contracts/types.ts: import them from there',
+}
+
+function restrictSyntax(files, restrictions) {
+  return { files, rules: { 'no-restricted-syntax': ['error', ...restrictions] } }
+}
+
+const APP_ENVIRONMENT_READERS = ['apps/*/src/config.ts', 'apps/*/src/server.ts', 'apps/*/src/scripts/**']
+const HTTP_BOUNDARY = ['apps/*/src/**/*.controller.ts', 'apps/*/src/**/*.middleware.ts', 'apps/*/src/http/**']
+const CONTRACT_TYPES_GATEWAY = ['apps/*/src/contracts/**']
+const PACKAGE_ENVIRONMENT_READERS = ['packages/*/src/*.config.ts']
+
+const restrictedSyntax = [
+  restrictSyntax(['apps/*/src/**'], [NO_RAW_SQL, NO_PROCESS_OUTSIDE_CONFIG, NO_RAW_REQUEST_DATA, NO_SHARED_OUTSIDE_CONTRACTS]),
+  restrictSyntax(CONTRACT_TYPES_GATEWAY, [NO_RAW_SQL, NO_PROCESS_OUTSIDE_CONFIG, NO_RAW_REQUEST_DATA]),
+  restrictSyntax(HTTP_BOUNDARY, [NO_RAW_SQL, NO_PROCESS_OUTSIDE_CONFIG, NO_SHARED_OUTSIDE_CONTRACTS]),
+  restrictSyntax(APP_ENVIRONMENT_READERS, [NO_RAW_SQL, NO_SHARED_OUTSIDE_CONTRACTS]),
+  restrictSyntax(['packages/*/src/**'], [NO_RAW_SQL, NO_PROCESS_ENV_IN_PACKAGE]),
+  restrictSyntax(PACKAGE_ENVIRONMENT_READERS, [NO_RAW_SQL]),
+]
+
+export default antfu(
+  {
+    isInEditor: false,
+    typescript: {
+      tsconfigPath: './tsconfig.json',
+    },
+  },
+  {
+    ignores: ['**/dist/**', '**/node_modules/**', 'pnpm-lock.yaml', 'scripts/construct/*.workflow.mjs', '{{contractTypesOutput}}'],
+  },
+  ...dependencyBoundaries,
+  ...restrictedSyntax,
+  {
+    files: ['apps/*/src/server.ts', 'apps/*/src/scripts/**'],
+    rules: {
+      'no-console': 'off',
+    },
+  },
+  {
+    files: ['**/*.test.ts'],
+    rules: {
+      'ts/no-unsafe-assignment': 'off',
+      'ts/no-unsafe-call': 'off',
+      'ts/no-unsafe-member-access': 'off',
+      'ts/no-floating-promises': 'off',
+    },
+  },
+)

package/templates/presets/monorepo/baseline/package.json.eta

@@ -0,0 +1,18 @@
+{
+  "name": "{{projectName}}",
+  "scripts": {
+    "dev": "pnpm --filter {{scope}}/api dev",
+    "build": "pnpm -r build"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "catalog:",
+    "@redocly/cli": "catalog:",
+    "@types/node": "catalog:",
+    "eslint": "catalog:",
+    "openapi-typescript": "catalog:",
+    "tsx": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:",
+    "yaml": "catalog:"
+  }
+}

package/templates/presets/monorepo/baseline/packages/shared/package.json.eta

@@ -0,0 +1,22 @@
+{
+  "name": "{{scope}}/shared",
+  "type": "module",
+  "version": "0.1.0",
+  "private": true,
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "types": "./src/index.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json"
+  },
+  "devDependencies": {
+    "typescript": "catalog:"
+  }
+}