@raclettejs/core 0.1.26 → 0.1.27

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.27] - 2026-04-27 <a href="https://gitlab.com/raclettejs/core-dev/-/compare/v0.1.26...v0.1.27" target="_blank" rel="noopener"><b>Overview of all changes</b></a>
+
+### Fixed
+
+- Build: added missing publish folder `templates`
+
 ## [0.1.26] - 2026-04-27 <a href="https://gitlab.com/raclettejs/core-dev/-/compare/v0.1.25...v0.1.26" target="_blank" rel="noopener"><b>Overview of all changes</b></a>
 
 ### Updated

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raclettejs/core",
-  "version": "0.1.26",
+  "version": "0.1.27",
   "description": "racletteJS core package",
   "repository": "https://gitlab.com/raclettejs/core",
   "author": "Pacifico Digital Explorations GmbH <info@raclettejs.com>",
@@ -37,7 +37,8 @@
     "src/types.ts",
     "LICENSE.md",
     "CONTRIBUTING.md",
-    "raclette.default.config.yaml"
+    "raclette.default.config.yaml",
+    "templates"
   ],
   "exports": {
     ".": {
@@ -78,7 +79,7 @@
     "@emnapi/core": "1.9.2",
     "@emnapi/runtime": "1.9.2",
     "@eslint/js": "9.35.0",
-    "@raclettejs/types": "^0.1.26",
+    "@raclettejs/types": "^0.1.27",
     "@types/fs-extra": "11.0.4",
     "@types/js-yaml": "4.0.9",
     "@types/node": "25.5.0",

package/templates/backend.Dockerfile

@@ -0,0 +1,31 @@
+FROM node:24.4-alpine3.21
+WORKDIR /app
+
+# add bash since alpine doesn't come with a shell
+RUN apk update && apk add bash curl {{config.services.backend.installPackages}} {{.}} {{/config.services.backend.installPackages}}
+
+COPY backend/package.json backend/yarn.lock ./
+COPY backend/raclette.config.js ./
+
+ARG NODE_ENV={{environment}}
+
+
+# make sure our raclette packages are being resolved by adding a symlink to handle nodes module resolution
+RUN mkdir -p /app/node_modules/@raclettejs/core
+RUN ln -sf /app/src /app/node_modules/@raclettejs/core/backend
+
+COPY ./dist/check-dependencies.sh /app/
+RUN chmod +x /app/check-dependencies.sh
+
+# copy everything else that is not ignored (see .dockerignore)
+COPY ./virtual/backend ./
+
+# set default values
+ENV PORT 3000
+
+# set port
+EXPOSE 3000
+EXPOSE 9229
+
+# default command
+CMD ["yarn", "run", "{{#environment}}build{{/environment}} {{^environment}}dev{{/environment}} "]

package/templates/build.yml

@@ -0,0 +1,34 @@
+entryPoints:
+  - ./src/cli.ts
+  - ./src/index.ts
+bundle: true
+platform: node
+target: node20
+outdir: ./dist
+format: esm
+banner:
+  js: "import { createRequire } from 'module'; const require = createRequire(import.meta.url);"
+external:
+  # External packages that shouldn't be bundled
+  - fastify
+  - mongodb
+  - mongoose
+  - redis
+  - chokidar
+  - fs-extra
+  # Node.js built-ins
+  - fs
+  - path
+  - child_process
+  - os
+  - url
+  - util
+  - events
+  - stream
+  - crypto
+  # Add any native modules you're using
+  - fsevents
+loader: 
+  .node: file
+sourcemap: true
+minify: false

package/templates/docker-compose.yml

@@ -0,0 +1,161 @@
+services:
+  mongodb:
+    container_name: ${RACLETTE_MONGODB_CONTAINERNAME:-raclette-mongodb}
+    image: mongo:8.2
+    restart: unless-stopped
+    ports:
+      - 127.0.0.1:${RACLETTE_MONGODB_PORT:-27017}:27017
+    volumes:
+      - ${RACLETTE_MONGODB_VOLUME:-raclette-mongodb}:/data/db
+      - >-
+        ${RACLETTE_MONGODB_CONFIG_VOLUME:-playground-mongodb-config}:/data/config
+    networks:
+      - raclette_shared
+    healthcheck:
+      test:
+        - CMD
+        - mongosh
+        - '--eval'
+        - db.adminCommand('ping')
+      interval: 10s
+      timeout: 30s
+      retries: 20
+  cache:
+    container_name: ${RACLETTE_CACHE_CONTAINERNAME:-raclette-cache}
+    image: valkey/valkey:9.0-alpine
+    ports:
+      - 127.0.0.1:${RACLETTE_CACHE_PORT:-6379}:6379
+    volumes:
+      - ${RACLETTE_CACHE_VOLUME:-raclette-cache}:/data
+    networks:
+      - raclette_shared
+    healthcheck:
+      test:
+        - CMD
+        - valkey-cli
+        - ping
+      interval: 10s
+      timeout: 5s
+      retries: 3
+    command: valkey-server --save ""
+  backend:
+    container_name: ${RACLETTE_SERVER_CONTAINERNAME:-playground-backend}
+    build:
+      context: .
+      dockerfile: ./backend.Dockerfile
+      args:
+        NODE_ENV: development
+    command: yarn run dev:inspect
+    environment:
+      - NODE_ENV=${NODE_ENV:-development}
+      - DISABLE_PLUGIN_LOGS=${RACLETTE_DISABLE_PLUGIN_LOGS:-false}
+      - >-
+        SERVER_TOKEN_SECRET=${RACLETTE_SERVER_TOKEN_SECRET:-thisshouldbesetforproduction}
+      - RACLETTE_FRONTEND_URLS=${RACLETTE_FRONTEND_URLS:-}
+      - >-
+        MONGO_HOST=${RACLETTE_MONGODB_HOST:-mongodb://mongodb:${RACLETTE_MONGODB_PORT:-27017}/${RACLETTE_MONGODB_DATABASE:-raclette}}
+      - >-
+        CACHE_URL=${RACLETTE_CACHE_URL:-redis://cache:${RACLETTE_CACHE_PORT:-6379}}
+      - RACLETTE_DEBUG_MODE=true
+      - RACLETTE_APP_PATH=/home/shookie/core-dev/@raclettejs/playground
+    volumes:
+      - yarn-cache:/usr/local/share/.cache/yarn
+      - playground-backend_node_modules:/app/node_modules
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/.raclette/virtual/backend/src:/app/src
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/plugins:/app/src/appPlugins
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/.raclette/backend/raclette.config.js:/app/raclette.config.js
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/backend.yarn.lock:/app/yarn.lock
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/.raclette/dist/check-dependencies.sh:/app/check-dependencies.sh
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/.raclette/backend/package.json:/app/package.json
+    ports:
+      - ${RACLETTE_SERVER_PORT:-8082}:3000
+      - '9229:9229'
+    networks:
+      - raclette_shared
+    depends_on:
+      mongodb:
+        condition: service_started
+      cache:
+        condition: service_healthy
+    healthcheck:
+      test:
+        - CMD
+        - curl
+        - '-f'
+        - http://0.0.0.0:3000/health
+      interval: 10s
+      timeout: 30s
+      retries: 10
+    entrypoint:
+      - /app/check-dependencies.sh
+  frontend:
+    container_name: ${RACLETTE_CLIENT_CONTAINERNAME:-playground-frontend}
+    build:
+      context: .
+      dockerfile: ./frontend.Dockerfile
+      args:
+        NODE_ENV: ${NODE_ENV:-development}
+      target: ${NODE_ENV:-development}
+    command: yarn dev
+    depends_on:
+      backend:
+        condition: service_healthy
+    environment:
+      - NODE_ENV=${NODE_ENV:-development}
+      - RACLETTE_DEBUG_MODE=${RACLETTE_DEBUG_MODE:-true}
+      - >-
+        RACLETTE_SERVER_BASE_URL=${RACLETTE_SERVER_BASE_URL:-http://localhost:${RACLETTE_SERVER_PORT:-8082}}
+      - >-
+        RACLETTE_SOCKET_URL=${RACLETTE_SOCKET_URL:-http://localhost:${RACLETTE_SERVER_PORT:-8082}}
+      - RACLETTE_DEBUG_MODE=true
+      - RACLETTE_APP_PATH=/home/shookie/core-dev/@raclettejs/playground
+    volumes:
+      - yarn-cache:/usr/local/share/.cache/yarn
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/.raclette/virtual/frontend/src:/app/src
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/.raclette/virtual/backend/src/shared:/app/src/shared
+      - playground-frontend_node_modules:/app/node_modules
+      - /home/shookie/core-dev/@raclettejs/playground/plugins:/app/src/plugins
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/.raclette/virtual/backend/src/corePlugins:/app/src/corePlugins
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/.raclette/frontend/raclette.config.js:/app/raclette.config.js
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/frontend.yarn.lock:/app/yarn.lock
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/.raclette/dist/check-dependencies.sh:/app/check-dependencies.sh
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/.raclette/frontend/package.json:/app/package.json
+    ports:
+      - ${RACLETTE_CLIENT_PORT:-8081}:8081
+    networks:
+      - raclette_shared
+    healthcheck:
+      test:
+        - CMD
+        - curl
+        - '-f'
+        - http://0.0.0.0:8081/
+      interval: 10s
+      timeout: 30s
+      retries: 10
+    entrypoint:
+      - /app/check-dependencies.sh
+volumes:
+  yarn-cache:
+    driver: local
+  raclette-public-shared: null
+  {{#volumes}}
+    {{entry}}
+  {{/volumes}}
+networks:
+  raclette_shared:
+    external: true
+    name: raclette_shared

package/templates/frontend.Dockerfile

@@ -0,0 +1,49 @@
+FROM node:24-alpine3.21 AS build
+WORKDIR /app
+
+RUN apk update && apk add bash curl {{#config.services.frontend.installPackages}} {{.}} {{/config.services.frontend.installPackages}}
+
+# Copy package files first for better caching
+COPY frontend/package.json frontend/yarn.lock ./
+COPY frontend/raclette.config.js ./
+
+ARG NODE_ENV={{environment}}
+
+# Copy source files - we'll handle development overrides through volumes
+COPY ./virtual/frontend/ ./
+
+COPY ./dist/check-dependencies.sh /app/
+RUN chmod +x /app/check-dependencies.sh
+
+RUN rm -rf ./src/shared
+
+# Now copy the actual shared folder - be explicit with the path
+COPY virtual/backend/src/shared/ ./src/shared/
+
+# Ports
+ENV PORT {{config.services.frontend.port}}
+EXPOSE {{config.services.frontend.port}}
+
+# Add development target
+FROM build AS development
+CMD ["yarn", "run", "dev"]
+
+# ----------------------------------------------------------------
+# 2. production stage
+# Here we will use a new docker image, which is only the web server
+FROM nginx:stable-alpine AS production
+WORKDIR /app
+
+# Copy nginx config as a template
+COPY frontend/provision/nginx.conf /etc/nginx/conf.d/default.conf.template
+
+COPY --from=build app/dist /usr/share/nginx/html
+COPY frontend/provision/entrypoint.sh /docker-entrypoint.d/entrypoint.sh
+
+# Make sure the entrypoint is executable
+RUN chmod +x /docker-entrypoint.d/entrypoint.sh
+
+ENV PORT 80
+EXPOSE 80
+
+CMD ["nginx", "-g", "daemon off;"]

package/templates/fs.yml

@@ -0,0 +1,73 @@
+# this defines the contents of the raclette app directory named by config.root (usually .raclette)
+# the files in there are either generated at build time or linked from the sources
+# these settings rarely if ever change, so they are outside the general raclette.config.yaml
+# during development almost everything in there is mounted as volumes to the different running containers
+# in production builds the contents become part of the image
+
+# almost the only reason this exists is so the development docker containers can do hot-reload
+# without messing up the workspaces and git repo
+# the hot-reload itself is of course handled by node, vite or tsx
+# but the changes in the repo need to be passed on to the volumes
+# this is done by creating hardlinks on startup
+# and watching the repo itself for relevant additions and deletions
+
+
+patterns:
+  # can be used in vfs mappings, but mainly is used in watcher file selection
+  ext:     ["**/*.vue", "**/*.ts", "**/*.js", "**/*.json", "**/*.css", "**/*.scss"]
+  pkg:     ["**/package.json", "**/yarn.lock"] # changes here require new install anyway
+  # always added when globbing, config.root is also always added
+  ignore:  ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/.prettierrc", "**/eslint.config.js"]
+
+
+mappings:
+# this defines how files are processed, whether they are watched or not
+# remember, all watched files are hard linked, this just defines where from and where to
+# the mappings are processed in order, and when a later mapping tries to link to the same location, that file will be ignored
+# 
+# src: files can come from different source paths, the most common being
+#      1. generated files from the raclette root directory, paths starting with "/"
+#         generated files are not watched
+#      2. the raclette core package, paths starting with ".", this is the default
+#      3. paths defined in environment variables, starting with "$", the default being "RACLETTE_APP_PATH"
+#      4. any other relative path is from the current application directory, the default is ""
+# get: this selects the files relative to the source that need to be gotten
+#      - you use globby syntax here for pattern matching
+#      - a string that matches a key in patterns above will splice the pattern into the glob list
+#      - default is [ '**' ], i.e. recursivly everything
+# for dst:
+#    - always relative to vfs root, i.e. "." is the default, which is "$config.root/virtual/"
+#    - the final link target is always the join of dst / selected-file
+#    - can be a list for multiple destinations
+#    - when the get list is a single file, and dst is not "." and does not end in "/", the file will be renamed
+  - src: services/
+  - get: src/types.ts
+    dst: [backend/types/index.ts, frontend/types/index.ts]
+  - src: ./services/
+  - src: /
+    get: [ frontend/*, backend/* ]
+  - get: bin/check-dependencies.sh           # copies from core/bin into $config.root/dist/
+    dst: ../dist/check-dependencies.sh
+  - src: i18n
+    dst: frontend/src/orchestrator/i18n/app/
+  - src: workbench/i18n
+    dst: frontend/src/orchestrator/i18n/workbench/
+  - src: shared
+    dst: [ frontend/src/shared/app/, backend/src/shared/app/ ]
+  - src: $/shared/
+    dst: [ backend/src/shared/app/,  backend/src/shared/app/ ]
+
+# these are the chokidar watcher options that get passed along as is (ignored string compiled as RegExp)
+watcher:
+  followSymlinks: false
+  ignoreInitial: true
+  ignored: ^node_modules|/node_modules$|^dist|/dist$|^\\.git|/\\.git$
+
+volumes:
+# these are added to the volumes of the respective services in the compose files
+# since later volumes override earlier volumes, the order here is important
+# for production builds this also defines the order of COPY operations for image creation
+# volume sources can be the same as mapping sources, with one exception:
+# there can't be any direct mounting of core based paths, instead there are vfs based paths
+# i.e. paths starting with "." are relative to "$config.root/virtual"
+- 

package/templates/raclette.config.workbench.yaml

@@ -0,0 +1,61 @@
+defineRacletteConfig:
+  name: "raclette-dev"
+
+  # Configure services
+  services:
+    frontend:
+      enabled: true
+      port: 8081
+
+    backend:
+      enabled: true
+      port: 8082
+      enableDebug:  {{process.env.ENABLE_DEBUG}}
+      installPackages: ["imagemagick", "font-overpass", "font-dejavu"]
+  
+    mongodb:
+      name: "raclette-mongodb"
+      enabled: true
+      port: 27017
+      volume: "raclette-mongodb"
+      databaseName: "raclette"
+
+    cache:
+      name: "raclette-cache"
+      volume: "raclette-cache"
+      enabled: true
+      port: 6379
+
+    workbench:
+      enabled: true
+      debugPort: 9228
+      frontendPort: 8083
+      backendPort: 8084
+      withLogs: false
+      
+  # list your installed plugins
+  # make sure they are listed in your package.json
+  # Environment-specific configuration
+  env:
+    development:
+      RACLETTE_DEBUG_MODE: true
+    production:
+      NODE_ENV: "production"
+
+  # Frontend framework configuration
+  frontend:
+    meta:
+      title: "Dev-Setup"
+    i18n:
+      locales: ["tl-TL", "en-EU", "de-DE"]
+    framework: "vue"
+    vue:
+      plugins: ["vue-router"]
+  workbench:
+    frontend:
+      i18n:
+        # explicitly set enabled languages for the workbench
+        locales: ["tl-TL", "en-EU", "de-DE"]
+  eslint:
+    useRecommended: false
+

package/templates/raclette.config.yaml

@@ -0,0 +1,59 @@
+name: "raclette-dev"
+root: ".raclette"
+
+services:
+  frontend:
+    enabled: true
+    port: 8081
+
+  backend:
+    enabled: true
+    port: 8082
+    enableDebug:  {{process.env.ENABLE_DEBUG}}
+    installPackages: []
+
+  mongodb:
+    name: "raclette-mongodb"
+    enabled: true
+    port: 27017
+    volume: "raclette-mongodb"
+    databaseName: "raclette"
+
+  cache:
+    name: "raclette-cache"
+    volume: "raclette-cache"
+    enabled: true
+    port: 6379
+
+  workbench:
+    enabled: true
+    debugPort: 9228
+    frontendPort: 8083
+    backendPort: 8084
+    withLogs: false
+
+# list your installed plugins
+# make sure they are listed in your package.json
+# Environment-specific configuration
+env:
+  development:
+    RACLETTE_DEBUG_MODE: true
+  production:
+    NODE_ENV: "production"
+
+# Frontend framework configuration
+frontend:
+  meta:
+    title: "Dev-Setup"
+  i18n:
+    locales: ["tl-TL", "en-EU", "de-DE"]
+  framework: "vue"
+  vue:
+    plugins: ["vue-router"]
+workbench:
+  frontend:
+    i18n:
+      # explicitly set enabled languages for the workbench
+      locales: ["tl-TL", "en-EU", "de-DE"]
+eslint:
+  useRecommended: false

package/templates/shims.vue.d.ts

@@ -0,0 +1,5 @@
+declare module "*.vue" {
+  import { DefineComponent } from "vue"
+  const component: DefineComponent<{}, {}, any>
+  export default component
+}

package/templates/types.yaml

@@ -0,0 +1,316 @@
+RacletteAppMode: [ "workbench" , "product-view" ]
+
+RacletteConfig:
+  name: string
+  root: string
+
+  services:
+    frontend?: ServiceFrontendConfig
+    backend?: ServiceBackendConfig
+
+    mongodb?:
+      enabled: boolean
+      port: number
+      name?: string
+      volume?: string
+      databaseName?: string
+      volumes?: VolumeDefinition[] // Add custom volumes property
+    cache?: {
+      enabled: boolean
+      port: number
+      name?: string
+      volume?: string
+      db?: number
+      volumes?: VolumeDefinition[]
+
+#    workbench?: {
+#      enabled: boolean
+#      debugPort?: number
+#      withLogs?: boolean
+#      frontendPort: number
+#      backendPort: number
+#    }
+#    [key: string]: any
+#  }
+#  plugins: Array<string | [string, any]>
+#  modules: Array<string | [string, any]>
+#  env: {
+#    development?: EnvironmentVariables
+#    production?: EnvironmentVariables
+#    [key: string]: EnvironmentVariables | undefined
+#  }
+#  global: {
+#    requireAuthentication: boolean
+#    appMode?: RacletteAppMode
+#  }
+#  frontend: {
+#    additonalPluginPaths?: string[]
+#    framework: "vue" | "react"
+#    pleaseLetUsAdvertiseOurselfs?: boolean
+#    advertiseYourself?: string
+#    preventNotifications?: boolean
+#    i18n?: {
+#      locales?: string[]
+#      priorities?: Record<string, number>
+#    }
+#    vue?: {
+#      plugins: string[]
+#    }
+#    react?: {
+#      plugins: string[]
+#    }
+#    custom?: {
+#      [key: string]: any
+#    }
+#  }
+#  backend: {
+#    additonalPluginPaths?: string[]
+#    sockets?: SocketConfig
+#    custom?: {
+#      [key: string]: any
+#    }
+#    cache?: CacheConfig
+#  }
+#  workbench?: WorkbenchConfig
+#  typescript?: {
+#    compilerOptions?: {
+#      // Allow for any compiler option to be overridden
+#      [key: string]: any
+#    }
+#  }
+#  eslint?: {
+#    rules?: Record<string, any>
+#    plugins?: string[]
+#    extends?: string[]
+#    ignores?: string[]
+#    // Whether to use recommended rules
+#    useRecommended?: boolean
+#    // For environment-specific configurations
+#    env?: Record<string, any>
+#  }
+#  // Multi-App Workspace feature - configurable source directories
+#  sourceDirectories?: Array<{
+#    name: string
+#    path: string // Supports env variables like process.env.SOME_PATH || "../fallback"
+#    priority: number
+#    servicePathMap?: {
+#      [service: string]: string
+#    }
+#    folderMappings?: {
+#      [targetPath: string]: string
+#    }
+#  }>
+#  // Generic package merging configuration
+#  packageMerging?: {
+#    frontend?: PackageSourceConfig[]
+#    backend?: PackageSourceConfig[]
+#    [service: string]: PackageSourceConfig[] | undefined
+#  }
+#  // Configurable lock file paths
+#  lockFiles?: {
+#    frontend?: string
+#    backend?: string
+#    [service: string]: string | undefined
+#  }
+#}
+#
+#export type WorkbenchConfig = {
+#  frontend: {
+#    i18n?: {
+#      locales?: string[]
+#    }
+#  }
+#}
+#
+#export type ServiceFrontendConfig = {
+#  enabled: boolean
+#  port: number
+#  name?: string
+#  nodeModulesVolume?: string
+#  installPackages?: string[]
+#  volumes?: VolumeDefinition[] // Add custom volumes property
+#}
+#
+#export type ServiceBackendConfig = {
+#  enabled: boolean
+#  port: number
+#  name?: string
+#  nodeModulesVolume?: string
+#  enableDebug?: boolean
+#  installPackages?: string[]
+#  volumes?: VolumeDefinition[] // Add custom volumes property
+#}
+#
+#export type EnvironmentVariables = {
+#  RACLETTE_CORE_ABSOLUTE_PATH?: string
+#  RACLETTE_DEBUG_MODE?: boolean
+#  RACLETTE_SOCKET_URL?: string
+#  RACLETTE_SERVER_BASE_URL?: string
+#  RACLETTE_INERHIT_NPMRC?: boolean
+#  RACLETTE_DISABLE_PLUGIN_LOGS?: boolean
+#  // overrides for service config
+#  RACLETTE_SERVER_CONTAINERNAME?: string
+#  RACLETTE_SERVER_PORT?: number
+#  RACLETTE_SERVER_TOKEN_SECRET?: string
+#  RACLETTE_CLIENT_CONTAINERNAME?: string
+#  RACLETTE_CLIENT_PORT?: number
+#  RACLETTE_MONGODB_HOST?: string
+#  RACLETTE_MONGODB_CONTAINERNAME?: string
+#  RACLETTE_MONGODB_PORT?: number
+#  RACLETTE_MONGODB_VOLUME?: string
+#  RACLETTE_MONGODB_CONFIG_VOLUME?: string
+#  RACLETTE_CACHE_URL?: string
+#  RACLETTE_CACHE_CONTAINERNAME?: string
+#  RACLETTE_CACHE_PORT?: number
+#  RACLETTE_CACHE_VOLUME?: string
+#
+#  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+#  [key: string]: any // Allow additional vars
+#}
+#
+#/**
+# * Volume Definition for Docker Compose
+# */
+#export type VolumeDefinition = {
+#  // Source can be a named volume, host path, or volume specification
+#  source: string
+#  // Target is the path inside the container
+#  target: string
+#  // Optional volume type (bind, volume, tmpfs)
+#  type?: "bind" | "volume" | "tmpfs"
+#  // Optional read-only flag
+#  readonly?: boolean
+#  // Skip this volume if source path doesn't exist
+#  mustExist?: boolean
+#  // Optional volume driver-specific options
+#  volumeOptions?: {
+#    // Populate on service creation when volume doesn't exist
+#    nocopy?: boolean
+#    // Any other driver-specific options
+#    [key: string]: any
+#  }
+#  // Optional bind-specific options
+#  bindOptions?: {
+#    // Propagation mode for bind mounts
+#    propagation?:
+#      | "private"
+#      | "rprivate"
+#      | "shared"
+#      | "rshared"
+#      | "slave"
+#      | "rslave"
+#    // Create host path if it doesn't exist
+#    createHostPath?: boolean
+#    // Any other bind-specific options
+#    [key: string]: any
+#  }
+#  // Optional tmpfs-specific options
+#  tmpfsOptions?: {
+#    // Size of the tmpfs mount in bytes
+#    size?: number
+#    // File mode of the tmpfs in octal
+#    mode?: number
+#  }
+#}
+#/**
+# * Cache Configuration
+# */
+#export type CacheConfig = {
+#  persistence?: "none" | "rdb" | "aof" | "rdb+aof"
+#  RDB_OPTIONS?: string
+#}
+#/**
+# * Socket Configuration
+# */
+#export type SocketConfig = {
+#  /** Configure what data is automatically sent when a frontend joins */
+#  autoSend: {
+#    /** Send compositions data on join */
+#    compositions: boolean
+#    /** Send interaction links data on join */
+#    interactionLinks: boolean
+#    /** Send project configuration on join */
+#    projectConfig: boolean
+#    /** Additional custom data types to send (must be in the DB and registered via stream) */
+#    additionalDatatypes?: {
+#      [key: string]: boolean | undefined
+#    }
+#    customData?: {
+#      /** Key is the property name in the response, value is the static data */
+#      [key: string]: any
+#    }
+#  }
+#
+#  /** Socket security configuration */
+#  security: {
+#    /** Whether authentication is required for socket connections */
+#    requireAuth: boolean
+#    /** Token validation method */
+#    tokenValidation: "jwt"
+#    /** Custom validation handler path */
+#    customValidator?: string
+#  }
+#
+#  /** Advanced socket options */
+#  options: {
+#    /** Socket.io adapter configuration */
+#    adapter: "memory" | "cache" | "mongodb"
+#    /** Connection timeout in milliseconds */
+#    connectionTimeout: number
+#    /** Ping interval in milliseconds */
+#    pingInterval: number
+#    /** Ping timeout in milliseconds */
+#    pingTimeout: number
+#  }
+#}
+#
+#/**
+# * Raclette Module Definition
+# */
+#export type RacletteModule = {
+#  name: string
+#  services?: Record<string, any>
+#  extendConfig?: (config: RacletteConfig, options: any) => RacletteConfig
+#  backendExtensions?: {
+#    plugins?: string[]
+#    routes?: string[]
+#  }
+#  frontendExtensions?: {
+#    components?: string[]
+#    plugins?: string[]
+#  }
+#  hooks?: Record<string, (...args: any[]) => Promise<void>>
+#}
+#
+#export type PluginMetadata = {
+#  name: string
+#  author: string
+#  version: string
+#  description?: string
+#  repository?: string
+#  license?: string
+#  hooks?: {
+#    beforeMount?: (app: any) => Promise<void>
+#    mounted?: (app: any) => Promise<void>
+#    beforeUnmount?: (app: any) => Promise<void>
+#  }
+#  pluginKey?: string
+#  dependencies?: string[]
+#  options?: Record<string, any>
+#  frontendDir?: string // default: "./frontend"
+#  backendDir?: string // default: "./backend"
+#}
+#
+#export type PackageSourceConfig = {
+#  // Path to the packages.json file (supports env variables)
+#  file: string
+#  // Key within the file to extract (e.g., "frontend", "workbench.frontend")
+#  key: string
+#}
+#
+#export type PackageTarget =
+#  | "frontend"
+#  | "backend"
+#  | "workbench.frontend"
+#  | "workbench.backend"
+#