@ms-cloudpack/cli 0.76.15 → 0.77.0

package/schema/AppConfig.json

@@ -0,0 +1,1242 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "extends": {
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      ],
+      "description": "Extend the configuration from another file: either an import path or a relative path (resolved from the config file's location). Relative paths or deep imports into another package (without an exports map) must include the file extension.\n\nIf an array, later files will take precedence when merging. (The current file's config always takes precedence over any extended config.)\n\nConfig merging approach:\n- Objects will be deeply merged.\n- Primitive values will be overwritten.\n- Arrays will be overwritten, EXCEPT for `packageSettings`, which will be concatenated."
+    },
+    "devServer": {
+      "$ref": "#/definitions/ServerConfig",
+      "deprecated": "- use \"server\" instead."
+    },
+    "server": {
+      "$ref": "#/definitions/ServerConfig",
+      "description": "Configuration for the dev server."
+    },
+    "telemetry": {
+      "$ref": "#/definitions/TelemetryConfig",
+      "description": "Configuration for telemetry."
+    },
+    "features": {
+      "$ref": "#/definitions/Features",
+      "description": "Enable additional Cloudpack features."
+    },
+    "helpMessage": {
+      "type": "string",
+      "description": "Help message to display when Cloudpack starts up."
+    },
+    "packageSettings": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/PackageSettings"
+      },
+      "description": "Settings to customize how packages are bundled. Later settings in the array take precedence over earlier ones."
+    },
+    "dependsOn": {
+      "type": "array",
+      "items": {
+        "type": "array",
+        "minItems": 2,
+        "items": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          }
+        ],
+        "maxItems": 2
+      },
+      "description": "Commands to execute prior to Cloudpack bundling. Each entry has a command and an array of arguments: `['command', ['arg1', 'arg2']]`."
+    },
+    "patchFilesGlobPattern": {
+      "type": "string",
+      "description": "Glob pattern to match `patch-package` patch files, relative to the project root (usually the same as the repository root).\n\nNote that if you're using `yarn patch` (v2+), those patches will be handled automatically (not by this glob pattern).",
+      "default": "patches/*.patch"
+    },
+    "remoteCache": {
+      "$ref": "#/definitions/RemoteCacheConfig",
+      "description": "Azure Blob Storage configuration for remote cache - uploading and downloading packages via `cloudpack sync`. If this is not provided, the remote cache will not be used."
+    },
+    "routes": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/ShorthandRoute"
+      },
+      "description": "Defines what routes to support from the app server, and which scripts will be loaded for each."
+    },
+    "neverExcludeDependencies": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "Ignore these package names when calculating included and excluded dependencies. This is mainly intended for helper packages such as `tslib`.\n\nInclude `...` to merge with the default list (`tslib` and `@babel/runtime` as of writing)."
+    },
+    "bundlerCapabilitiesRegistry": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "string"
+      },
+      "description": "Key value pairs of external bundler capabilities that can be enabled in the package settings.\n- Key is the name of the capability, which will be used in `PackageSettings.bundlerCapabilities`.\n- Value is the import specifier (local path or package name) for the capability module."
+    },
+    "define": {
+      "$ref": "#/definitions/DefineFlags",
+      "description": "Key value pairs that will be used to define global variables in the runtime."
+    },
+    "defaultBundler": {
+      "type": "string",
+      "description": "Advanced use only: Override the bundler that's used by default (if a package's source type doesn't indicate that a specific bundler should be used, and there are no applicable package settings). This will **significantly** decrease performance and should only be modified if `ori` is incompatible with your repo/build for some reason.\n\nIn most cases, you should use `packageSettings` to change the bundler instead: for example, if your repo's packages must be built with rspack/webpack to support some custom config, use `packageSettings: [{ match: [\"@yourscope/*\", \"your-unscoped-package\"], bundler: \"rspack\" }]`.",
+      "default": "ori"
+    },
+    "$schema": {
+      "type": "string"
+    }
+  },
+  "additionalProperties": false,
+  "description": "Per-application user-provided configuration for Cloudpack.",
+  "definitions": {
+    "ServerConfig": {
+      "type": "object",
+      "properties": {
+        "domain": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            }
+          ],
+          "description": "The domain name of the server. If multiple domains are specified, the first one will be used as the primary domain used when opening the browser."
+        },
+        "requestHeaders": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string"
+          },
+          "description": "Additional header key/value pairs to be added to every response.\n\nNOTE: The following header values from Cloudpack will \"win\" against by a user's config:\n- `'Cache-Control': 'no-cache'`\n- `'Access-Control-Allow-Origin': '*'`"
+        },
+        "port": {
+          "anyOf": [
+            {
+              "type": "number"
+            },
+            {
+              "type": "array",
+              "items": {
+                "type": "number"
+              }
+            }
+          ],
+          "description": "Port(s) to try when starting the server. If provided, an error will be thrown if none of the ports are available.\n\nIf no ports are provided, the server will attempt to find an available port."
+        },
+        "defaultPath": {
+          "type": "string",
+          "description": "The default path to use when opening the browser."
+        },
+        "https": {
+          "anyOf": [
+            {
+              "type": "boolean",
+              "const": true
+            },
+            {
+              "$ref": "#/definitions/HttpsConfig"
+            }
+          ],
+          "description": "The config settings for the https server. Paths to files are accepted for 'ca', 'cert', 'key', and 'pfx' settings. Everything else is passed directly to the https.createServer() method. If not provided, the server will use http."
+        },
+        "routes": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/ShorthandRoute"
+          },
+          "deprecated": "Moved to the root of the config."
+        }
+      },
+      "additionalProperties": false
+    },
+    "HttpsConfig": {
+      "type": "object",
+      "properties": {
+        "ALPNCallback": {
+          "not": {},
+          "description": "If set, this will be called when a client opens a connection using the ALPN extension. One argument will be passed to the callback: an object containing `servername` and `protocols` fields, respectively containing the server name from the SNI extension (if any) and an array of ALPN protocol name strings. The callback must return either one of the strings listed in `protocols`, which will be returned to the client as the selected ALPN protocol, or `undefined`, to reject the connection with a fatal alert. If a string is returned that does not match one of the client's ALPN protocols, an error will be thrown. This option cannot be used with the `ALPNProtocols` option, and setting both options will throw an error."
+        },
+        "allowPartialTrustChain": {
+          "type": "boolean",
+          "description": "Treat intermediate (non-self-signed) certificates in the trust CA certificate list as trusted."
+        },
+        "ca": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            }
+          ],
+          "description": "Optionally override the trusted CA certificates. Default is to trust the well-known CAs curated by Mozilla. Mozilla's CAs are completely replaced when CAs are explicitly specified using this option."
+        },
+        "cert": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            }
+          ],
+          "description": "Cert chains in PEM format. One cert chain should be provided per private key. Each cert chain should consist of the PEM formatted certificate for a provided private key, followed by the PEM formatted intermediate certificates (if any), in order, and not including the root CA (the root CA must be pre-known to the peer, see ca). When providing multiple cert chains, they do not have to be in the same order as their private keys in key. If the intermediate certificates are not provided, the peer will not be able to validate the certificate, and the handshake will fail."
+        },
+        "sigalgs": {
+          "type": "string",
+          "description": "Colon-separated list of supported signature algorithms. The list can contain digest algorithms (SHA256, MD5 etc.), public key algorithms (RSA-PSS, ECDSA etc.), combination of both (e.g 'RSA+SHA384') or TLS v1.3 scheme names (e.g. rsa_pss_pss_sha512)."
+        },
+        "ciphers": {
+          "type": "string",
+          "description": "Cipher suite specification, replacing the default. For more information, see modifying the default cipher suite. Permitted ciphers can be obtained via tls.getCiphers(). Cipher names must be uppercased in order for OpenSSL to accept them."
+        },
+        "clientCertEngine": {
+          "type": "string",
+          "description": "Name of an OpenSSL engine which can provide the client certificate."
+        },
+        "crl": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            }
+          ],
+          "description": "PEM formatted CRLs (Certificate Revocation Lists)."
+        },
+        "dhparam": {
+          "type": "string",
+          "description": "`'auto'` or custom Diffie-Hellman parameters, required for non-ECDHE perfect forward secrecy. If omitted or invalid, the parameters are silently discarded and DHE ciphers will not be available. ECDHE-based perfect forward secrecy will still be available."
+        },
+        "ecdhCurve": {
+          "type": "string",
+          "description": "A string describing a named curve or a colon separated list of curve NIDs or names, for example P-521:P-384:P-256, to use for ECDH key agreement. Set to auto to select the curve automatically. Use crypto.getCurves() to obtain a list of available curve names. On recent releases, openssl ecparam -list_curves will also display the name and description of each available elliptic curve. Default: tls.DEFAULT_ECDH_CURVE."
+        },
+        "honorCipherOrder": {
+          "type": "boolean",
+          "description": "Attempt to use the server's cipher suite preferences instead of the client's. When true, causes SSL_OP_CIPHER_SERVER_PREFERENCE to be set in secureOptions"
+        },
+        "key": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "array",
+              "items": {
+                "anyOf": [
+                  {
+                    "type": "string"
+                  },
+                  {
+                    "$ref": "#/definitions/KeyObject"
+                  }
+                ]
+              }
+            }
+          ],
+          "description": "Private keys in PEM format. PEM allows the option of private keys being encrypted. Encrypted keys will be decrypted with options.passphrase. Multiple keys using different algorithms can be provided either as an array of unencrypted key strings or buffers, or an array of objects in the form {pem: <string|buffer>[, passphrase: <string>]}. The object form can only occur in an array. object.passphrase is optional. Encrypted keys will be decrypted with object.passphrase if provided, or options.passphrase if it is not."
+        },
+        "privateKeyEngine": {
+          "type": "string",
+          "description": "Name of an OpenSSL engine to get private key from. Should be used together with privateKeyIdentifier."
+        },
+        "privateKeyIdentifier": {
+          "type": "string",
+          "description": "Identifier of a private key managed by an OpenSSL engine. Should be used together with privateKeyEngine. Should not be set together with key, because both options define a private key in different ways."
+        },
+        "maxVersion": {
+          "$ref": "#/definitions/SecureVersion",
+          "description": "Optionally set the maximum TLS version to allow. One of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the `secureProtocol` option, use one or the other.\n**Default:** `'TLSv1.3'`, unless changed using CLI options. Using `--tls-max-v1.2` sets the default to `'TLSv1.2'`. Using `--tls-max-v1.3` sets the default to `'TLSv1.3'`. If multiple of the options are provided, the highest maximum is used."
+        },
+        "minVersion": {
+          "$ref": "#/definitions/SecureVersion",
+          "description": "Optionally set the minimum TLS version to allow. One of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the `secureProtocol` option, use one or the other.  It is not recommended to use less than TLSv1.2, but it may be required for interoperability.\n**Default:** `'TLSv1.2'`, unless changed using CLI options. Using `--tls-v1.0` sets the default to `'TLSv1'`. Using `--tls-v1.1` sets the default to `'TLSv1.1'`. Using `--tls-min-v1.3` sets the default to 'TLSv1.3'. If multiple of the options are provided, the lowest minimum is used."
+        },
+        "passphrase": {
+          "type": "string",
+          "description": "Shared passphrase used for a single private key and/or a PFX."
+        },
+        "pfx": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "array",
+              "items": {
+                "anyOf": [
+                  {
+                    "type": "string"
+                  },
+                  {
+                    "$ref": "#/definitions/PxfObject"
+                  }
+                ]
+              }
+            }
+          ],
+          "description": "PFX or PKCS12 encoded private key and certificate chain. pfx is an alternative to providing key and cert individually. PFX is usually encrypted, if it is, passphrase will be used to decrypt it. Multiple PFX can be provided either as an array of unencrypted PFX buffers, or an array of objects in the form {buf: <string|buffer>[, passphrase: <string>]}. The object form can only occur in an array. object.passphrase is optional. Encrypted PFX will be decrypted with object.passphrase if provided, or options.passphrase if it is not."
+        },
+        "secureOptions": {
+          "type": "number",
+          "description": "Optionally affect the OpenSSL protocol behavior, which is not usually necessary. This should be used carefully if at all! Value is a numeric bitmask of the SSL_OP_* options from OpenSSL Options"
+        },
+        "secureProtocol": {
+          "type": "string",
+          "description": "Legacy mechanism to select the TLS protocol version to use, it does not support independent control of the minimum and maximum version, and does not support limiting the protocol to TLSv1.3. Use minVersion and maxVersion instead. The possible values are listed as SSL_METHODS, use the function names as strings. For example, use 'TLSv1_1_method' to force TLS version 1.1, or 'TLS_method' to allow any TLS protocol version up to TLSv1.3. It is not recommended to use TLS versions less than 1.2, but it may be required for interoperability. Default: none, see minVersion."
+        },
+        "sessionIdContext": {
+          "type": "string",
+          "description": "Opaque identifier used by servers to ensure session state is not shared between applications. Unused by clients."
+        },
+        "ticketKeys": {
+          "not": {},
+          "description": "48-bytes of cryptographically strong pseudo-random data. See Session Resumption for more information."
+        },
+        "sessionTimeout": {
+          "type": "number",
+          "description": "The number of seconds after which a TLS session created by the server will no longer be resumable. See Session Resumption for more information. Default: 300."
+        },
+        "handshakeTimeout": {
+          "type": "number",
+          "description": "Abort the connection if the SSL/TLS handshake does not finish in the specified number of milliseconds. A 'tlsClientError' is emitted on the tls.Server object whenever a handshake times out. Default: 120000 (120 seconds)."
+        },
+        "pskIdentityHint": {
+          "type": "string",
+          "description": "hint to send to a client to help with selecting the identity during TLS-PSK negotiation. Will be ignored in TLS 1.3. Upon failing to set pskIdentityHint `tlsClientError` will be emitted with `ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED` code."
+        },
+        "secureContext": {
+          "$ref": "#/definitions/SecureContext",
+          "description": "An optional TLS context object from tls.createSecureContext()"
+        },
+        "enableTrace": {
+          "type": "boolean",
+          "description": "When enabled, TLS packet trace information is written to `stderr`. This can be used to debug TLS connection problems.",
+          "default": false
+        },
+        "requestCert": {
+          "type": "boolean",
+          "description": "If true the server will request a certificate from clients that connect and attempt to verify that certificate. Defaults to false."
+        },
+        "ALPNProtocols": {
+          "anyOf": [
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            {
+              "type": "array",
+              "items": {
+                "not": {}
+              }
+            }
+          ],
+          "description": "An array of strings or a Buffer naming possible ALPN protocols. (Protocols should be ordered by their priority.)"
+        },
+        "SNICallback": {
+          "not": {},
+          "description": "SNICallback(servername, cb) <Function> A function that will be called if the client supports SNI TLS extension. Two arguments will be passed when called: servername and cb. SNICallback should invoke cb(null, ctx), where ctx is a SecureContext instance. (tls.createSecureContext(...) can be used to get a proper SecureContext.) If SNICallback wasn't provided the default callback with high-level API will be used (see below)."
+        },
+        "rejectUnauthorized": {
+          "type": "boolean",
+          "description": "If true the server will reject any connection which is not authorized with the list of supplied CAs. This option only has an effect if requestCert is true.",
+          "default": true
+        },
+        "allowHalfOpen": {
+          "type": "boolean",
+          "description": "Indicates whether half-opened TCP connections are allowed.",
+          "default": false
+        },
+        "pauseOnConnect": {
+          "type": "boolean",
+          "description": "Indicates whether the socket should be paused on incoming connections.",
+          "default": false
+        },
+        "noDelay": {
+          "type": "boolean",
+          "description": "If set to `true`, it disables the use of Nagle's algorithm immediately after a new incoming connection is received.",
+          "default": false
+        },
+        "keepAlive": {
+          "type": "boolean",
+          "description": "If set to `true`, it enables keep-alive functionality on the socket immediately after a new incoming connection is received, similarly on what is done in `socket.setKeepAlive([enable][, initialDelay])`.",
+          "default": false
+        },
+        "keepAliveInitialDelay": {
+          "type": "number",
+          "description": "If set to a positive number, it sets the initial delay before the first keepalive probe is sent on an idle socket.",
+          "default": 0
+        },
+        "highWaterMark": {
+          "type": "number",
+          "description": "Optionally overrides all `net.Socket`s' `readableHighWaterMark` and `writableHighWaterMark`.",
+          "default": "See [stream.getDefaultHighWaterMark()](https://nodejs.org/docs/latest-v20.x/api/stream.html#streamgetdefaulthighwatermarkobjectmode)."
+        },
+        "requestTimeout": {
+          "type": "number",
+          "description": "Sets the timeout value in milliseconds for receiving the entire request from the client.",
+          "default": 300000
+        },
+        "joinDuplicateHeaders": {
+          "type": "boolean",
+          "description": "It joins the field line values of multiple headers in a request with `, ` instead of discarding the duplicates.",
+          "default": false
+        },
+        "keepAliveTimeout": {
+          "type": "number",
+          "description": "The number of milliseconds of inactivity a server needs to wait for additional incoming data, after it has finished writing the last response, before a socket will be destroyed.",
+          "default": 5000
+        },
+        "connectionsCheckingInterval": {
+          "type": "number",
+          "description": "Sets the interval value in milliseconds to check for request and headers timeout in incomplete requests.",
+          "default": 30000
+        },
+        "headersTimeout": {
+          "type": "number",
+          "description": "Sets the timeout value in milliseconds for receiving the complete HTTP headers from the client. See  {@link  Server.headersTimeout }  for more information.",
+          "default": 60000
+        },
+        "insecureHTTPParser": {
+          "type": "boolean",
+          "description": "Use an insecure HTTP parser that accepts invalid HTTP headers when `true`. Using the insecure parser should be avoided. See --insecure-http-parser for more information.",
+          "default": false
+        },
+        "maxHeaderSize": {
+          "type": "number",
+          "description": "Optionally overrides the value of `--max-http-header-size` for requests received by this server, i.e. the maximum length of request headers in bytes.",
+          "default": 16384
+        },
+        "requireHostHeader": {
+          "type": "boolean",
+          "description": "If set to `true`, it forces the server to respond with a 400 (Bad Request) status code to any HTTP/1.1 request message that lacks a Host header (as mandated by the specification).",
+          "default": true
+        },
+        "uniqueHeaders": {
+          "type": "array",
+          "items": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              }
+            ]
+          },
+          "description": "A list of response headers that should be sent only once. If the header's value is an array, the items will be joined using `; `."
+        },
+        "rejectNonStandardBodyWrites": {
+          "type": "boolean",
+          "description": "If set to `true`, an error is thrown when writing to an HTTP response which does not have a body.",
+          "default": false
+        }
+      },
+      "additionalProperties": false,
+      "description": "HTTPS server configuration settings."
+    },
+    "KeyObject": {
+      "type": "object",
+      "properties": {
+        "pem": {
+          "type": "string",
+          "description": "Private keys in PEM format."
+        },
+        "passphrase": {
+          "type": "string",
+          "description": "Optional passphrase."
+        }
+      },
+      "required": [
+        "pem"
+      ],
+      "additionalProperties": false
+    },
+    "SecureVersion": {
+      "type": "string",
+      "enum": [
+        "TLSv1.3",
+        "TLSv1.2",
+        "TLSv1.1",
+        "TLSv1"
+      ]
+    },
+    "PxfObject": {
+      "type": "object",
+      "properties": {
+        "buf": {
+          "type": "string",
+          "description": "PFX or PKCS12 encoded private key and certificate chain."
+        },
+        "passphrase": {
+          "type": "string",
+          "description": "Optional passphrase."
+        }
+      },
+      "required": [
+        "buf"
+      ],
+      "additionalProperties": false
+    },
+    "SecureContext": {
+      "type": "object",
+      "properties": {
+        "context": {}
+      },
+      "required": [
+        "context"
+      ],
+      "additionalProperties": false
+    },
+    "ShorthandRoute": {
+      "anyOf": [
+        {
+          "$ref": "#/definitions/ShorthandRenderedRoute"
+        },
+        {
+          "$ref": "#/definitions/ShorthandBootstrapRoute"
+        },
+        {
+          "$ref": "#/definitions/StaticRoute"
+        },
+        {
+          "$ref": "#/definitions/RedirectRoute"
+        },
+        {
+          "$ref": "#/definitions/ProxyRoute"
+        }
+      ],
+      "description": "Route as specified in `AppConfig` (`cloudpack.config.json`)."
+    },
+    "ShorthandRenderedRoute": {
+      "type": "object",
+      "properties": {
+        "match": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RouteMatch"
+            },
+            {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/RouteMatch"
+              }
+            }
+          ],
+          "description": "The URL path to match. Paths should usually start with a slash, e.g. `'/my-route'`. You can also use wildcards (`*`), e.g. `'/my-route/*'` to match all paths starting with `'/my-route'`.\n\nSee the [Express docs](https://expressjs.com/en/guide/routing.html#route-paths) for the full supported routing syntax.\n\nIf you need a route to match on a specific domain, you can pass an object (path, domain) in where the domain is a string which can have wildcards (`*`). e.g. `'word.*'` will match `word.com`, `word.net`, etc.\n\nUse an array to handle multiple paths with the same route handler."
+        },
+        "renderScript": {
+          "type": "string",
+          "description": "Path to a .js or .html file (relative to the app path) for rendering the route.\n\nIf a .js file, it must export a default function implementing `RenderFunction` from `@ms-cloudpack/common-types`.",
+          "deprecated": "Use `serverEntry` instead. (Please talk to the team if you have a scenario where\nbundling the script causes a problem.)"
+        },
+        "exportEntry": {
+          "type": "string",
+          "description": "The key in the exports map which represents the entry point app script for this route.",
+          "deprecated": "Use `entry` instead."
+        },
+        "entry": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            }
+          ],
+          "description": "Additional source file path(s) to bundle and include in the HTML. This **overwrites** any original exports map for the package.\n\nUsually this should be an actual source path, though it could also be an exports map key if necessary."
+        },
+        "serverEntry": {
+          "type": "string",
+          "description": "Path to a TS, JS, or HTML file (relative to the app path) for rendering the route on the server. (Also supports export map keys.) If a JS or TS file, it will be bundled before rendering.\n\nIf JS or TS, it must export a default function implementing `RenderRouteFunction` defined in `@ms-cloudpack/app-server`."
+        }
+      },
+      "additionalProperties": false,
+      "required": [
+        "match"
+      ],
+      "description": "A server-rendered route with optional shorthand `entry` info (as specified in `AppConfig`/`cloudpack.config.json`). The route is rendered by a custom server script in Cloudpack."
+    },
+    "RouteMatch": {
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "path": {
+              "type": "string"
+            },
+            "domain": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "path"
+          ],
+          "additionalProperties": false
+        }
+      ],
+      "description": "A route match can be a string path or an object with a path and domain."
+    },
+    "ShorthandBootstrapRoute": {
+      "type": "object",
+      "properties": {
+        "entry": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            }
+          ],
+          "description": "Additional source file path(s) to bundle and include in the HTML. This **overwrites** any original exports map for the package.\n\nUsually this should be an actual source path, though it could also be an exports map key if necessary."
+        },
+        "serverEntry": {
+          "type": "string",
+          "description": "Path to a TS, JS, or HTML file (relative to the app path) for rendering the route on the server. (Also supports export map keys.) If a JS or TS file, it will be bundled before rendering.\n\nIf JS or TS, it must export a default function implementing `RenderRouteFunction` defined in `@ms-cloudpack/app-server`."
+        },
+        "exportEntry": {
+          "type": "string",
+          "description": "The key in the exports map which represents the entry point app script for this route.",
+          "deprecated": "Use `entry` instead."
+        },
+        "match": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RouteMatch"
+            },
+            {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/RouteMatch"
+              }
+            }
+          ],
+          "description": "The URL path to match. Paths should usually start with a slash, e.g. `'/my-route'`. You can also use wildcards (`*`), e.g. `'/my-route/*'` to match all paths starting with `'/my-route'`.\n\nSee the [Express docs](https://expressjs.com/en/guide/routing.html#route-paths) for the full supported routing syntax.\n\nIf you need a route to match on a specific domain, you can pass an object (path, domain) in where the domain is a string which can have wildcards (`*`). e.g. `'word.*'` will match `word.com`, `word.net`, etc.\n\nUse an array to handle multiple paths with the same route handler."
+        },
+        "type": {
+          "type": "string",
+          "const": "bootstrap"
+        }
+      },
+      "required": [
+        "match",
+        "type"
+      ],
+      "additionalProperties": false,
+      "description": "A route that serves a bootstrap script."
+    },
+    "StaticRoute": {
+      "type": "object",
+      "properties": {
+        "match": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RouteMatch"
+            },
+            {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/RouteMatch"
+              }
+            }
+          ],
+          "description": "The URL path to match. Paths should usually start with a slash, e.g. `'/my-route'`. You can also use wildcards (`*`), e.g. `'/my-route/*'` to match all paths starting with `'/my-route'`.\n\nSee the [Express docs](https://expressjs.com/en/guide/routing.html#route-paths) for the full supported routing syntax.\n\nIf you need a route to match on a specific domain, you can pass an object (path, domain) in where the domain is a string which can have wildcards (`*`). e.g. `'word.*'` will match `word.com`, `word.net`, etc.\n\nUse an array to handle multiple paths with the same route handler."
+        },
+        "staticPath": {
+          "type": "string",
+          "description": "The path relative to the app root to static assets."
+        }
+      },
+      "required": [
+        "match",
+        "staticPath"
+      ],
+      "additionalProperties": false,
+      "description": "A route with a staticPath property serves static files from the specified path."
+    },
+    "RedirectRoute": {
+      "type": "object",
+      "properties": {
+        "match": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RouteMatch"
+            },
+            {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/RouteMatch"
+              }
+            }
+          ],
+          "description": "The URL path to match. Paths should usually start with a slash, e.g. `'/my-route'`. You can also use wildcards (`*`), e.g. `'/my-route/*'` to match all paths starting with `'/my-route'`.\n\nSee the [Express docs](https://expressjs.com/en/guide/routing.html#route-paths) for the full supported routing syntax.\n\nIf you need a route to match on a specific domain, you can pass an object (path, domain) in where the domain is a string which can have wildcards (`*`). e.g. `'word.*'` will match `word.com`, `word.net`, etc.\n\nUse an array to handle multiple paths with the same route handler."
+        },
+        "redirectTo": {
+          "type": "string",
+          "description": "The url to redirect to."
+        }
+      },
+      "required": [
+        "match",
+        "redirectTo"
+      ],
+      "additionalProperties": false,
+      "description": "A route that redirects to another url."
+    },
+    "ProxyRoute": {
+      "type": "object",
+      "properties": {
+        "match": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RouteMatch"
+            },
+            {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/RouteMatch"
+              }
+            }
+          ],
+          "description": "The URL path to match. Paths should usually start with a slash, e.g. `'/my-route'`. You can also use wildcards (`*`), e.g. `'/my-route/*'` to match all paths starting with `'/my-route'`.\n\nSee the [Express docs](https://expressjs.com/en/guide/routing.html#route-paths) for the full supported routing syntax.\n\nIf you need a route to match on a specific domain, you can pass an object (path, domain) in where the domain is a string which can have wildcards (`*`). e.g. `'word.*'` will match `word.com`, `word.net`, etc.\n\nUse an array to handle multiple paths with the same route handler."
+        },
+        "proxyTo": {
+          "type": "string",
+          "description": "The target host to proxy to. (protocol + host)."
+        },
+        "changeOrigin": {
+          "type": "boolean",
+          "description": "For virtual hosted sites."
+        },
+        "pathRewrite": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string"
+          },
+          "description": "Rewrite target's url path. Object-keys will be used as RegExp to match paths."
+        }
+      },
+      "required": [
+        "match",
+        "proxyTo"
+      ],
+      "additionalProperties": false,
+      "description": "A route that proxies requests to another server. This is handled by https://github.com/chimurai/http-proxy-middleware."
+    },
+    "TelemetryConfig": {
+      "type": "object",
+      "properties": {
+        "connectionString": {
+          "type": "string",
+          "description": "Application Insights connection string."
+        },
+        "pageLoadTimePerformanceEntry": {
+          "$ref": "#/definitions/PageLoadTimePerformanceEntry",
+          "description": "Cloudpack will query this performance entry to determine the page load time."
+        }
+      },
+      "additionalProperties": false
+    },
+    "PageLoadTimePerformanceEntry": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "The name of the performance mark/measure to query."
+        },
+        "type": {
+          "type": "string",
+          "enum": [
+            "mark",
+            "measure"
+          ],
+          "description": "The type of performance entry to query.",
+          "default": "mark"
+        },
+        "timeout": {
+          "type": "number",
+          "description": "The maximum time in milliseconds to wait for the performance mark to be set.",
+          "default": "5 mins"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "additionalProperties": false,
+      "description": "Client and server side object for Cloudpack to detect app-specific page load time entry"
+    },
+    "Features": {
+      "type": "object",
+      "properties": {
+        "autoUpdateEntries": {
+          "type": "boolean"
+        },
+        "disableSourceMaps": {
+          "type": "boolean"
+        },
+        "enableCloudHosted": {
+          "type": "boolean"
+        },
+        "enableModuleWorkers": {
+          "type": "boolean"
+        },
+        "enableParcelWatcher": {
+          "type": "boolean"
+        },
+        "enableRemoteCacheDownloads": {
+          "type": "boolean"
+        },
+        "enableSSR": {
+          "type": "boolean"
+        },
+        "enableWatcherInFork": {
+          "type": "boolean"
+        },
+        "enqueueDependencies": {
+          "type": "boolean"
+        },
+        "evaluateDynamicImports": {
+          "type": "boolean"
+        },
+        "optimizeDependencies": {
+          "type": "boolean"
+        },
+        "relativeImportMapPaths": {
+          "type": "boolean"
+        },
+        "removeUnusedExports": {
+          "type": "boolean"
+        },
+        "resolveWebExtensions": {
+          "type": "boolean"
+        },
+        "syncBundles": {
+          "type": "boolean"
+        },
+        "syncInternalPackages": {
+          "type": "boolean"
+        },
+        "useSingleWebServer": {
+          "type": "boolean"
+        },
+        "verifyExports": {
+          "type": "boolean"
+        }
+      },
+      "additionalProperties": false,
+      "description": "Represents all features that can be enabled or disabled for Cloudpack."
+    },
+    "PackageSettings": {
+      "type": "object",
+      "properties": {
+        "match": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/PackageSettingsMatch"
+            },
+            {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/PackageSettingsMatch"
+              }
+            }
+          ],
+          "description": "Which package(s) the settings should be applied to. A string is a shorthand for matching the name with any version (`*` to match any name). An array allows multiple matches to be specified."
+        },
+        "includedDependencies": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "The dependencies which should be included when computing the import map. This is primarily used when devDependencies are needed by the app. This often happens when a library has a demo app which relies on devDependencies.\n\nAccepts `$devDependencies` as a special value to include all devDependencies."
+        },
+        "excludedDependencies": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "The dependencies which should be ignored by Cloudpack verbs. For example, if \"react-native\" is a dependency which should not be included in the import map or evaluated during `init`, it can be listed here to ignore it.\n\nAccepts `$peerDependencies` as a special value to exclude all peerDependencies."
+        },
+        "inlinedDependencies": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Dependencies which should be inlined in the library bundled by Cloudpack. This is useful for libraries which are small and don't need to be loaded separately, have issues being resolved by the browser, or provide reusable scss files."
+        },
+        "exports": {
+          "$ref": "#/definitions/PackageJsonExports",
+          "description": "Use this exports map instead of the original entry points from package.json. (Any Cloudpack- generated exports will be merged.) This is useful if a library's exports map is missing or broken, or to skip bundling entries which aren't needed at runtime.\n\nGenerally, keys should be relative import paths starting with ./ (use . for the top-level import). Other standard exports map syntax (such as conditions) is also supported. For example: ```json {   \".\": \"./lib/index.js\",   \"./foo\": \"./lib/foo.js\", } ```"
+        },
+        "unsafeCjsExportNames": {
+          "anyOf": [
+            {
+              "type": "object",
+              "additionalProperties": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              }
+            },
+            {
+              "type": "string",
+              "const": "types"
+            }
+          ],
+          "description": "If specified, Cloudpack will not attempt to auto-generate ESM stubs for the package, but will instead use the array of named exports you provide (per entry key). Any keys not included will have a default export, but no named exports (so `{}` means that all entries should have only a default export). An entry key is the output file path, relative to `outputPath` (with forward slashes and leading `./`) and *without* the extension (unless it's non-JS).\n\nYou can also use the special value `'types'` to generate stubs based on the TypeScript declaration file if it exists. This will generate named exports for all types in the declaration file and relative imported files.\n\nNote: This is an escape hatch and should be used with caution, as it can lead to unexpected behavior."
+        },
+        "bundler": {
+          "type": "string",
+          "description": "Forces the package to be bundled using a specific bundler."
+        },
+        "bundlerType": {
+          "type": "string",
+          "deprecated": "Use `bundler`.\n\nThis should be removed once repo configs are updated to use `bundler`."
+        },
+        "bundlerOptions": {
+          "type": "object",
+          "additionalProperties": {},
+          "description": "Any bundler-specific options to be merged with the calculated bundler options. `bundler` is also required if this is specified.\n\nThis is an escape hatch which is generally not recommended, since it locks the package to a specific bundler implementation. It's better to use built-in or custom bundler capabilities.\n\nWARNING: When merging package settings, `bundlerOptions` will be **overwritten** with the last specified value."
+        },
+        "inputPaths": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Paths used for file monitoring and input hashing. Supports glob matching. Defaults are under `@ms-cloudpack/path-utilities` in `sourceFilesGlobs`. Use `...` to include the default paths.\n\nFor input hashing, both positive and negative globs are considered. For file watching, behavior depends on the watcher backend:\n- Parcel watcher (default): only negative globs are respected for ignoring files\n- Chokidar watcher: both positive and negative globs are supported"
+        },
+        "ignoreMissingExports": {
+          "anyOf": [
+            {
+              "type": "boolean"
+            },
+            {
+              "type": "object",
+              "additionalProperties": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              }
+            }
+          ],
+          "description": "Controls the behavior of the `verifyExports` feature when checking consumed exports from this package:\n- If true, don't check this package's exports at all.\n- If an object, this is a mapping from package import paths to export names to ignore. Examples:   - To ignore top-level exports: `{ \".\": [\"badName\"] }`   - To ignore exports from another path: `{ \"./lib/foo\": [\"badName\"] }`"
+        },
+        "dynamicImports": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Only relevant for packages bundled with rollup: globs of files that include dynamic (async) imports with non-literal paths, to be processed by `@rollup/plugin-dynamic-import-vars` (subject to that plugin's [limitations](https://www.npmjs.com/package/\\@rollup/plugin-dynamic-import-vars#limitations)). Files matching `*.dynamic.*` are automatically included.\n\nThis is not needed for ori/esbuild and webpack because they should handle these types of imports automatically."
+        },
+        "ignoredBundlerWarnings": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Ignore these warning messages from the bundler (partial string matches). This is intended for non-actionable messages from external dependencies which can't easily be fixed, to avoid confusing users."
+        },
+        "link": {
+          "$ref": "#/definitions/LinkOptions",
+          "description": "Settings to control how the package is linked in the resolve map."
+        },
+        "bundlerCapabilities": {
+          "$ref": "#/definitions/BundlerCapabilitiesOptions",
+          "description": "Setting to control the bundler capabilities for this package. This is used to enable or disable specific bundler capabilities."
+        }
+      },
+      "required": [
+        "match"
+      ],
+      "additionalProperties": false,
+      "description": "Settings overrides for bundling a package (or multiple packages, depending on `match`)."
+    },
+    "PackageSettingsMatch": {
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "$ref": "#/definitions/PackageSettingsMatchObject"
+        }
+      ],
+      "description": "Which package(s) the settings should be applied to. A string is a shorthand for matching the name with any version (`*` to match any name)."
+    },
+    "PackageSettingsMatchObject": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "Name of the package. Can use a trailing wildcard (e.g. `@scope/*`). `*` to match any name.\n\nTo negate a match, use `!` as the first character (e.g. `!@scope/foo` or `!@scope/*`)."
+        },
+        "version": {
+          "type": "string",
+          "description": "Version of the package. Unspecified matches any version.\n\nNote that if the package version is a prerelease, it will only match `*` or ranges that explicitly include prereleases. For example, `^1.0.0` will not match `1.0.1-beta.0`."
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "additionalProperties": false
+    },
+    "PackageJsonExports": {
+      "anyOf": [
+        {
+          "$ref": "#/definitions/PackageJsonExportsValue"
+        },
+        {
+          "$ref": "#/definitions/PackageJsonExportsObject"
+        },
+        {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/PackageJsonExports"
+          }
+        }
+      ],
+      "description": "Entry points of a package, optionally with conditions and subpath exports. Used as `PackageJson.exports`."
+    },
+    "PackageJsonExportsValue": {
+      "anyOf": [
+        {
+          "type": "null"
+        },
+        {
+          "type": "string"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "browser": {
+              "$ref": "#/definitions/PackageJsonExportsValue"
+            },
+            "default": {
+              "$ref": "#/definitions/PackageJsonExportsValue"
+            },
+            "deno": {
+              "$ref": "#/definitions/PackageJsonExportsValue"
+            },
+            "electron": {
+              "$ref": "#/definitions/PackageJsonExportsValue"
+            },
+            "import": {
+              "$ref": "#/definitions/PackageJsonExportsValue"
+            },
+            "module": {
+              "$ref": "#/definitions/PackageJsonExportsValue"
+            },
+            "node-addons": {
+              "$ref": "#/definitions/PackageJsonExportsValue"
+            },
+            "node": {
+              "$ref": "#/definitions/PackageJsonExportsValue"
+            },
+            "react-native": {
+              "$ref": "#/definitions/PackageJsonExportsValue"
+            },
+            "require": {
+              "$ref": "#/definitions/PackageJsonExportsValue"
+            }
+          },
+          "additionalProperties": {
+            "$ref": "#/definitions/PackageJsonExportsValue"
+          }
+        },
+        {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/PackageJsonExportsValue"
+          }
+        }
+      ],
+      "description": "The value of an `PackageJson.exports` object key. Note at the root of the object, keys can be represented either by a condition, or a `string` to provide import paths (such as \"./foo\"). At subsequent levels within the object, only conditions (string which don't start with \".\") can be used as keys."
+    },
+    "PackageJsonExportsObject": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/definitions/PackageJsonExportsValue"
+      },
+      "description": "Definition of the root exports object. Keys can be either conditions or import paths."
+    },
+    "LinkOptions": {
+      "type": "object",
+      "properties": {
+        "duplicatedDependencyBehavior": {
+          "type": "string",
+          "enum": [
+            "force-host-version",
+            "allow-duplication",
+            "force-remote-version"
+          ],
+          "description": "Controls the behavior of duplicated dependencies in the resolve map when running `cloudpack link`.\n\n- `allow-duplication` (default): allow multiple versions of the same package to exist in the   resolve map to satisfy semver.\n- `force-host-version`: the package will be deduplicated to the version of the host package,   ignoring semver requirements.\n- `force-remote-version`: the package will be deduplicated to the version of the remote package,   ignoring semver requirements.\n\nNote: These settings only apply when the resolve strategy is set to the default `dedupe`."
+        }
+      },
+      "additionalProperties": false,
+      "description": "Options for when a package is linked in the resolve map."
+    },
+    "BundlerCapabilitiesOptions": {
+      "type": "object",
+      "additionalProperties": {
+        "type": [
+          "object",
+          "boolean"
+        ]
+      },
+      "properties": {
+        "asset-inline": {
+          "anyOf": [
+            {
+              "type": "object",
+              "properties": {
+                "extensions": {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                }
+              },
+              "required": [
+                "extensions"
+              ],
+              "additionalProperties": false,
+              "description": "Inlines assets into the bundle. Options: List of file extensions to inline. Do not include the leading dot."
+            },
+            {
+              "type": "boolean"
+            }
+          ]
+        },
+        "density": {
+          "type": "boolean"
+        },
+        "alias": {
+          "anyOf": [
+            {
+              "type": "object",
+              "additionalProperties": {
+                "type": "string"
+              },
+              "description": "Adds aliases to externalized packages."
+            },
+            {
+              "type": "boolean"
+            }
+          ]
+        },
+        "resolve-web-extensions": {
+          "anyOf": [
+            {
+              "type": "boolean",
+              "description": "Enables React Native type resolution of .web.ts extensions. Options: object is empty because it's just an indicator. No options are needed."
+            },
+            {
+              "type": "boolean"
+            }
+          ]
+        }
+      },
+      "description": "Options used in `PackageSettings` to configure or disable bundler capabilities.\n- Key: capability name, either internal (Cloudpack-provided) or external (as specified in   `AppConfig.bundlerCapabilitiesRegistry`)\n- Value: options object to configure the capability, or false to disable it."
+    },
+    "RemoteCacheConfig": {
+      "type": "object",
+      "properties": {
+        "storageAccount": {
+          "type": "string",
+          "description": "The name of the Azure Blob Storage account."
+        },
+        "container": {
+          "type": "string",
+          "description": "The name of the container to use for the remote cache. Container must already exist."
+        },
+        "tenantId": {
+          "type": "string",
+          "description": "The Microsoft Entra tenant (directory) ID. This will ensure that only users from this tenant can access the remote cache."
+        }
+      },
+      "required": [
+        "storageAccount",
+        "container"
+      ],
+      "additionalProperties": false,
+      "description": "Azure Blob Storage configuration for remote cache - uploading and downloading packages via `cloudpack sync`."
+    },
+    "DefineFlags": {
+      "type": "object",
+      "additionalProperties": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "number"
+          },
+          {
+            "type": "boolean"
+          },
+          {
+            "type": "array",
+            "items": {
+              "type": [
+                "string",
+                "number",
+                "boolean"
+              ]
+            }
+          }
+        ]
+      },
+      "description": "DefineFlags is an interface that represents a collection of global variables that will be defined on the window object. Each define flag is represented by a key-value pair"
+    }
+  }
+}