@overdeck/desktop 0.45.16 → 0.45.19

package/server/{multipart-parser-Csn8U-K9.js → multipart-parser-9DhuAkPd.js}

@@ -1,5 +1,5 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { a as File, i as init_esm_min, n as FormData, t as init_from } from "./from-NSJypkI8.js";
+import { a as File, i as init_esm_min, n as FormData, t as init_from } from "./from-B2tOYhYV.js";
 //#region ../../../node_modules/.bun/node-fetch@3.3.2/node_modules/node-fetch/src/utils/multipart-parser.js
 function _fileName(headerValue) {
 	const m = headerValue.match(/\bfilename=("(.*?)"|([^()<>@,;:\\"/[\]?={}\s\t]+))($|;\s)/i);
@@ -293,4 +293,4 @@ __esmMin((() => {
 }))();
 export { toFormData };
 
-//# sourceMappingURL=multipart-parser-Csn8U-K9.js.map
+//# sourceMappingURL=multipart-parser-9DhuAkPd.js.map

package/server/node_modules/.package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@overdeck/desktop-server",
-  "version": "0.45.16",
+  "version": "0.45.19",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
@@ -23,9 +23,9 @@
       }
     },
     "node_modules/@effect/platform-node/node_modules/@effect/platform-node-shared": {
-      "version": "4.0.0-beta.97",
-      "resolved": "https://registry.npmjs.org/@effect/platform-node-shared/-/platform-node-shared-4.0.0-beta.97.tgz",
-      "integrity": "sha512-sAlygOlDLLERk7fC24f7Aa4G3wkEbGyyMEileHTHU2fThiPYSGMqNRK1LLnNr17m2+JR7BHbycwXkJkM18BAQw==",
+      "version": "4.0.0-beta.98",
+      "resolved": "https://registry.npmjs.org/@effect/platform-node-shared/-/platform-node-shared-4.0.0-beta.98.tgz",
+      "integrity": "sha512-iySXaffnCJX1sNAIp79ghhIeui9E5qwUQyqd1VLPkB9UNO4vdpd9B5fTEXwe7S/GusL4jsk9vSvX38XJgRFG1w==",
       "license": "MIT",
       "dependencies": {
         "@types/ws": "^8.18.1",
@@ -35,7 +35,7 @@
         "node": ">=18.0.0"
       },
       "peerDependencies": {
-        "effect": "^4.0.0-beta.97"
+        "effect": "^4.0.0-beta.98"
       }
     },
     "node_modules/@google-cloud/common": {
@@ -2042,9 +2042,9 @@
       }
     },
     "node_modules/toml": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/toml/-/toml-4.1.2.tgz",
-      "integrity": "sha512-m0vXfHODcw3gk+KONAOlVQ5yNHc3yS3B1ybM3HS1vqDoS0RWTDDVBVVTYi8hH0k+2OM1vmo9fb1WX9EVqjqfHA==",
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/toml/-/toml-4.3.0.tgz",
+      "integrity": "sha512-lVb8X9BsPVuH0M4BKeS91tXAmJvCjQ5UIyAbQFaxkKGyUFK2RPkhwaFSQH8vbpl1d23eu/IBH+dwVMHWaq9A5A==",
       "license": "MIT",
       "engines": {
         "node": ">=20"
@@ -2218,9 +2218,9 @@
       "license": "ISC"
     },
     "node_modules/ws": {
-      "version": "8.21.0",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.0.tgz",
-      "integrity": "sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g==",
+      "version": "8.21.1",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.1.tgz",
+      "integrity": "sha512-+0NTnW77fFN/DjQi6k/Sq/Yvk4Sgajw7urW8V+asjXnRgDs9gyGkdb7EzgfhA4goXsRIZKE28fzIXBHEzhuiWw==",
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"

package/server/node_modules/@effect/platform-node/node_modules/@effect/platform-node-shared/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@effect/platform-node-shared",
   "type": "module",
-  "version": "4.0.0-beta.97",
+  "version": "4.0.0-beta.98",
   "license": "MIT",
   "description": "Unified interfaces for common platform-specific services",
   "homepage": "https://effect.website",
@@ -46,12 +46,12 @@
     "provenance": true
   },
   "peerDependencies": {
-    "effect": "^4.0.0-beta.97"
+    "effect": "^4.0.0-beta.98"
   },
   "devDependencies": {
     "@types/node": "^26.1.1",
     "tar": "^7.5.19",
-    "effect": "^4.0.0-beta.97"
+    "effect": "^4.0.0-beta.98"
   },
   "dependencies": {
     "@types/ws": "^8.18.1",

package/server/node_modules/toml/README.md

@@ -60,6 +60,14 @@ try {
 }
 ```
 
+### Nesting Depth Limit
+
+To guard against stack overflow on maliciously deep input, arrays and inline tables may nest at most 500 levels deep by default; input past the limit throws a normal parse error. Adjust the limit with the `maxDepth` option:
+
+```javascript
+toml.parse(someTomlString, { maxDepth: 100 });
+```
+
 ### Date/Time Values
 
 Offset date-times are returned as JavaScript `Date` objects. Local date-times, local dates, and local times are returned as strings since they have no timezone information and can't be losslessly represented as `Date`:
@@ -78,6 +86,52 @@ typeof data.ld             // "string"
 typeof data.lt             // "string"
 ```
 
+#### Temporal Support
+
+Pass `useTemporal: true` to have date/time values returned as
+[Temporal](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Temporal)
+objects instead:
+
+| TOML type        | Returned as               |
+| ---------------- | ------------------------- |
+| Offset date-time | `Temporal.ZonedDateTime`  |
+| Local date-time  | `Temporal.PlainDateTime`  |
+| Local date       | `Temporal.PlainDate`      |
+| Local time       | `Temporal.PlainTime`      |
+
+```javascript
+const data = toml.parse(`
+odt = 1979-05-27T00:32:00-07:00
+ldt = 1979-05-27T07:32:00
+ld  = 1979-05-27
+lt  = 07:32:00
+`, { useTemporal: true });
+
+data.odt.toString()  // "1979-05-27T00:32:00-07:00[-07:00]"
+data.ldt.toString()  // "1979-05-27T07:32:00"
+data.ld.toString()   // "1979-05-27"
+data.lt.toString()   // "07:32:00"
+```
+
+Offset date-times become `Temporal.ZonedDateTime` values whose time zone is
+the original UTC offset (`Z` maps to the `UTC` time zone), so the offset
+written in the TOML document is preserved — unlike the default `Date`
+representation, which loses it. Fractional seconds beyond nanosecond
+precision are truncated, as permitted by the TOML spec.
+
+`useTemporal` requires a runtime with the `Temporal` global. On runtimes
+that don't provide it yet, pass an implementation such as
+[`@js-temporal/polyfill`](https://www.npmjs.com/package/@js-temporal/polyfill)
+via the `temporal` option:
+
+```javascript
+const { Temporal } = require('@js-temporal/polyfill');
+const data = toml.parse(someTomlString, { useTemporal: true, temporal: Temporal });
+```
+
+Once `Temporal` is broadly available, Temporal output is expected to become
+the default behavior in a future major version.
+
 ### Special Float Values
 
 `inf` and `nan` are returned as JavaScript `Infinity` and `NaN`:

package/server/node_modules/toml/index.d.ts

@@ -1,3 +1,44 @@
 declare module 'toml' {
-  export function parse(input: string): any;
+  /**
+   * A minimal structural subset of the `Temporal` global, used to supply an
+   * alternate implementation (e.g. from `@js-temporal/polyfill`) on runtimes
+   * without native Temporal support.
+   */
+  export interface TemporalLike {
+    ZonedDateTime: { from(item: string): any };
+    PlainDateTime: { from(item: string): any };
+    PlainDate: { from(item: string): any };
+    PlainTime: { from(item: string): any };
+  }
+
+  export interface ParseOptions {
+    /**
+     * Maximum nesting depth for arrays and inline tables. Parsing input nested
+     * deeper than this throws a parse error rather than overflowing the stack.
+     * Defaults to 500.
+     */
+    maxDepth?: number;
+
+    /**
+     * When true, date/time values are returned as Temporal objects instead of
+     * the default representations:
+     *
+     * - Offset date-time: `Temporal.ZonedDateTime` (instead of `Date`)
+     * - Local date-time:  `Temporal.PlainDateTime` (instead of `string`)
+     * - Local date:       `Temporal.PlainDate` (instead of `string`)
+     * - Local time:       `Temporal.PlainTime` (instead of `string`)
+     *
+     * Requires a global `Temporal` object, or an implementation passed via
+     * the `temporal` option.
+     */
+    useTemporal?: boolean;
+
+    /**
+     * The Temporal implementation to use when `useTemporal` is set. Defaults
+     * to the global `Temporal` object if one is available.
+     */
+    temporal?: TemporalLike;
+  }
+
+  export function parse(input: string, options?: ParseOptions): any;
 }

package/server/node_modules/toml/index.js

@@ -2,9 +2,9 @@ var parser = require('./lib/parser');
 var compiler = require('./lib/compiler');
 
 module.exports = {
-  parse: function(input) {
+  parse: function(input, options) {
     var str = input.toString();
-    var nodes = parser.parse(str);
-    return compiler.compile(nodes, str);
+    var nodes = parser.parse(str, options);
+    return compiler.compile(nodes, str, options);
   }
 };

package/server/node_modules/toml/lib/compiler.js

@@ -1,5 +1,18 @@
 "use strict";
-function compile(nodes, inputText) {
+function compile(nodes, inputText, options) {
+  options = options || {};
+  var temporal = null;
+  if (options.useTemporal) {
+    temporal = options.temporal || (typeof Temporal !== "undefined" ? Temporal : null);
+    if (!temporal) {
+      throw new Error(
+        "The `useTemporal` option was set, but no Temporal implementation is available. " +
+        "Use a runtime with global `Temporal` support, or provide an implementation " +
+        "(e.g. from the `@js-temporal/polyfill` package) via the `temporal` option."
+      );
+    }
+  }
+
   var assignedPaths = new Set();
   var valueAssignments = new Set();
   var explicitTablePaths = new Set();
@@ -93,9 +106,28 @@ function compile(nodes, inputText) {
       return reduceArray(node.value);
     } else if (node.type === "InlineTable") {
       return reduceInlineTableNode(node.value);
-    } else {
-      return node.value;
+    } else if (temporal) {
+      switch (node.type) {
+      case "Date":
+        return temporal.ZonedDateTime.from(
+          truncateFractionalSeconds(node.raw) + node.tz +
+          "[" + (node.tz === "Z" ? "UTC" : node.tz) + "]"
+        );
+      case "LocalDateTime":
+        return temporal.PlainDateTime.from(truncateFractionalSeconds(node.value));
+      case "LocalDate":
+        return temporal.PlainDate.from(node.value);
+      case "LocalTime":
+        return temporal.PlainTime.from(truncateFractionalSeconds(node.value));
+      }
     }
+    return node.value;
+  }
+
+  // TOML allows arbitrary fractional-second precision (implementations may
+  // truncate); Temporal rejects more than 9 digits (nanoseconds).
+  function truncateFractionalSeconds(str) {
+    return str.replace(/\.(\d{9})\d+/, ".$1");
   }
 
   function reduceInlineTableNode(values) {