@inlang/paraglide-js 1.2.2 → 1.2.3

package/dist/index.js

@@ -2146,23 +2146,23 @@ var require_errors = __commonJS({
       }
     };
     exports.ValueErrorIterator = ValueErrorIterator;
-    function Create(type, schema, path3, value) {
-      return { type, schema, path: path3, value, message: system_1.TypeSystemErrorFunction.Get()(schema, type) };
+    function Create(type, schema, path4, value) {
+      return { type, schema, path: path4, value, message: system_1.TypeSystemErrorFunction.Get()(schema, type) };
     }
-    function* TAny(schema, references, path3, value) {
+    function* TAny(schema, references, path4, value) {
     }
-    function* TArray(schema, references, path3, value) {
+    function* TArray(schema, references, path4, value) {
       if (!(0, guard_1.IsArray)(value)) {
-        return yield Create(ValueErrorType2.Array, schema, path3, value);
+        return yield Create(ValueErrorType2.Array, schema, path4, value);
       }
       if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) {
-        yield Create(ValueErrorType2.ArrayMinItems, schema, path3, value);
+        yield Create(ValueErrorType2.ArrayMinItems, schema, path4, value);
       }
       if (IsDefined(schema.maxItems) && !(value.length <= schema.maxItems)) {
-        yield Create(ValueErrorType2.ArrayMaxItems, schema, path3, value);
+        yield Create(ValueErrorType2.ArrayMaxItems, schema, path4, value);
       }
       for (let i2 = 0; i2 < value.length; i2++) {
-        yield* Visit(schema.items, references, `${path3}/${i2}`, value[i2]);
+        yield* Visit(schema.items, references, `${path4}/${i2}`, value[i2]);
       }
       if (schema.uniqueItems === true && !function() {
         const set = /* @__PURE__ */ new Set();
@@ -2176,100 +2176,100 @@ var require_errors = __commonJS({
         }
         return true;
       }()) {
-        yield Create(ValueErrorType2.ArrayUniqueItems, schema, path3, value);
+        yield Create(ValueErrorType2.ArrayUniqueItems, schema, path4, value);
       }
       if (!(IsDefined(schema.contains) || IsDefined(schema.minContains) || IsDefined(schema.maxContains))) {
         return;
       }
       const containsSchema = IsDefined(schema.contains) ? schema.contains : Types.Type.Never();
-      const containsCount = value.reduce((acc, value2, index) => Visit(containsSchema, references, `${path3}${index}`, value2).next().done === true ? acc + 1 : acc, 0);
+      const containsCount = value.reduce((acc, value2, index) => Visit(containsSchema, references, `${path4}${index}`, value2).next().done === true ? acc + 1 : acc, 0);
       if (containsCount === 0) {
-        yield Create(ValueErrorType2.ArrayContains, schema, path3, value);
+        yield Create(ValueErrorType2.ArrayContains, schema, path4, value);
       }
       if ((0, guard_1.IsNumber)(schema.minContains) && containsCount < schema.minContains) {
-        yield Create(ValueErrorType2.ArrayMinContains, schema, path3, value);
+        yield Create(ValueErrorType2.ArrayMinContains, schema, path4, value);
       }
       if ((0, guard_1.IsNumber)(schema.maxContains) && containsCount > schema.maxContains) {
-        yield Create(ValueErrorType2.ArrayMaxContains, schema, path3, value);
+        yield Create(ValueErrorType2.ArrayMaxContains, schema, path4, value);
       }
     }
-    function* TAsyncIterator(schema, references, path3, value) {
+    function* TAsyncIterator(schema, references, path4, value) {
       if (!(0, guard_1.IsAsyncIterator)(value))
-        yield Create(ValueErrorType2.AsyncIterator, schema, path3, value);
+        yield Create(ValueErrorType2.AsyncIterator, schema, path4, value);
     }
-    function* TBigInt(schema, references, path3, value) {
+    function* TBigInt(schema, references, path4, value) {
       if (!(0, guard_1.IsBigInt)(value))
-        return yield Create(ValueErrorType2.BigInt, schema, path3, value);
+        return yield Create(ValueErrorType2.BigInt, schema, path4, value);
       if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-        yield Create(ValueErrorType2.BigIntExclusiveMaximum, schema, path3, value);
+        yield Create(ValueErrorType2.BigIntExclusiveMaximum, schema, path4, value);
       }
       if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-        yield Create(ValueErrorType2.BigIntExclusiveMinimum, schema, path3, value);
+        yield Create(ValueErrorType2.BigIntExclusiveMinimum, schema, path4, value);
       }
       if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
-        yield Create(ValueErrorType2.BigIntMaximum, schema, path3, value);
+        yield Create(ValueErrorType2.BigIntMaximum, schema, path4, value);
       }
       if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
-        yield Create(ValueErrorType2.BigIntMinimum, schema, path3, value);
+        yield Create(ValueErrorType2.BigIntMinimum, schema, path4, value);
       }
       if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === BigInt(0))) {
-        yield Create(ValueErrorType2.BigIntMultipleOf, schema, path3, value);
+        yield Create(ValueErrorType2.BigIntMultipleOf, schema, path4, value);
       }
     }
-    function* TBoolean(schema, references, path3, value) {
+    function* TBoolean(schema, references, path4, value) {
       if (!(0, guard_1.IsBoolean)(value))
-        yield Create(ValueErrorType2.Boolean, schema, path3, value);
+        yield Create(ValueErrorType2.Boolean, schema, path4, value);
     }
-    function* TConstructor(schema, references, path3, value) {
-      yield* Visit(schema.returns, references, path3, value.prototype);
+    function* TConstructor(schema, references, path4, value) {
+      yield* Visit(schema.returns, references, path4, value.prototype);
     }
-    function* TDate(schema, references, path3, value) {
+    function* TDate(schema, references, path4, value) {
       if (!(0, guard_1.IsDate)(value))
-        return yield Create(ValueErrorType2.Date, schema, path3, value);
+        return yield Create(ValueErrorType2.Date, schema, path4, value);
       if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
-        yield Create(ValueErrorType2.DateExclusiveMaximumTimestamp, schema, path3, value);
+        yield Create(ValueErrorType2.DateExclusiveMaximumTimestamp, schema, path4, value);
       }
       if (IsDefined(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
-        yield Create(ValueErrorType2.DateExclusiveMinimumTimestamp, schema, path3, value);
+        yield Create(ValueErrorType2.DateExclusiveMinimumTimestamp, schema, path4, value);
       }
       if (IsDefined(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
-        yield Create(ValueErrorType2.DateMaximumTimestamp, schema, path3, value);
+        yield Create(ValueErrorType2.DateMaximumTimestamp, schema, path4, value);
       }
       if (IsDefined(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
-        yield Create(ValueErrorType2.DateMinimumTimestamp, schema, path3, value);
+        yield Create(ValueErrorType2.DateMinimumTimestamp, schema, path4, value);
       }
       if (IsDefined(schema.multipleOfTimestamp) && !(value.getTime() % schema.multipleOfTimestamp === 0)) {
-        yield Create(ValueErrorType2.DateMultipleOfTimestamp, schema, path3, value);
+        yield Create(ValueErrorType2.DateMultipleOfTimestamp, schema, path4, value);
       }
     }
-    function* TFunction(schema, references, path3, value) {
+    function* TFunction(schema, references, path4, value) {
       if (!(0, guard_1.IsFunction)(value))
-        yield Create(ValueErrorType2.Function, schema, path3, value);
+        yield Create(ValueErrorType2.Function, schema, path4, value);
     }
-    function* TInteger(schema, references, path3, value) {
+    function* TInteger(schema, references, path4, value) {
       if (!(0, guard_1.IsInteger)(value))
-        return yield Create(ValueErrorType2.Integer, schema, path3, value);
+        return yield Create(ValueErrorType2.Integer, schema, path4, value);
       if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-        yield Create(ValueErrorType2.IntegerExclusiveMaximum, schema, path3, value);
+        yield Create(ValueErrorType2.IntegerExclusiveMaximum, schema, path4, value);
       }
       if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-        yield Create(ValueErrorType2.IntegerExclusiveMinimum, schema, path3, value);
+        yield Create(ValueErrorType2.IntegerExclusiveMinimum, schema, path4, value);
       }
       if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
-        yield Create(ValueErrorType2.IntegerMaximum, schema, path3, value);
+        yield Create(ValueErrorType2.IntegerMaximum, schema, path4, value);
       }
       if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
-        yield Create(ValueErrorType2.IntegerMinimum, schema, path3, value);
+        yield Create(ValueErrorType2.IntegerMinimum, schema, path4, value);
       }
       if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
-        yield Create(ValueErrorType2.IntegerMultipleOf, schema, path3, value);
+        yield Create(ValueErrorType2.IntegerMultipleOf, schema, path4, value);
       }
     }
-    function* TIntersect(schema, references, path3, value) {
+    function* TIntersect(schema, references, path4, value) {
       for (const inner of schema.allOf) {
-        const next = Visit(inner, references, path3, value).next();
+        const next = Visit(inner, references, path4, value).next();
         if (!next.done) {
-          yield Create(ValueErrorType2.Intersect, schema, path3, value);
+          yield Create(ValueErrorType2.Intersect, schema, path4, value);
           yield next.value;
         }
       }
@@ -2277,7 +2277,7 @@ var require_errors = __commonJS({
         const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema));
         for (const valueKey of Object.getOwnPropertyNames(value)) {
           if (!keyCheck.test(valueKey)) {
-            yield Create(ValueErrorType2.IntersectUnevaluatedProperties, schema, `${path3}/${valueKey}`, value);
+            yield Create(ValueErrorType2.IntersectUnevaluatedProperties, schema, `${path4}/${valueKey}`, value);
           }
         }
       }
@@ -2285,59 +2285,59 @@ var require_errors = __commonJS({
         const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema));
         for (const valueKey of Object.getOwnPropertyNames(value)) {
           if (!keyCheck.test(valueKey)) {
-            const next = Visit(schema.unevaluatedProperties, references, `${path3}/${valueKey}`, value[valueKey]).next();
+            const next = Visit(schema.unevaluatedProperties, references, `${path4}/${valueKey}`, value[valueKey]).next();
             if (!next.done)
               yield next.value;
           }
         }
       }
     }
-    function* TIterator(schema, references, path3, value) {
+    function* TIterator(schema, references, path4, value) {
       if (!(0, guard_1.IsIterator)(value))
-        yield Create(ValueErrorType2.Iterator, schema, path3, value);
+        yield Create(ValueErrorType2.Iterator, schema, path4, value);
     }
-    function* TLiteral(schema, references, path3, value) {
+    function* TLiteral(schema, references, path4, value) {
       if (!(value === schema.const))
-        yield Create(ValueErrorType2.Literal, schema, path3, value);
+        yield Create(ValueErrorType2.Literal, schema, path4, value);
     }
-    function* TNever(schema, references, path3, value) {
-      yield Create(ValueErrorType2.Never, schema, path3, value);
+    function* TNever(schema, references, path4, value) {
+      yield Create(ValueErrorType2.Never, schema, path4, value);
     }
-    function* TNot(schema, references, path3, value) {
-      if (Visit(schema.not, references, path3, value).next().done === true)
-        yield Create(ValueErrorType2.Not, schema, path3, value);
+    function* TNot(schema, references, path4, value) {
+      if (Visit(schema.not, references, path4, value).next().done === true)
+        yield Create(ValueErrorType2.Not, schema, path4, value);
     }
-    function* TNull(schema, references, path3, value) {
+    function* TNull(schema, references, path4, value) {
       if (!(0, guard_1.IsNull)(value))
-        yield Create(ValueErrorType2.Null, schema, path3, value);
+        yield Create(ValueErrorType2.Null, schema, path4, value);
     }
-    function* TNumber(schema, references, path3, value) {
+    function* TNumber(schema, references, path4, value) {
       if (!system_1.TypeSystemPolicy.IsNumberLike(value))
-        return yield Create(ValueErrorType2.Number, schema, path3, value);
+        return yield Create(ValueErrorType2.Number, schema, path4, value);
       if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-        yield Create(ValueErrorType2.NumberExclusiveMaximum, schema, path3, value);
+        yield Create(ValueErrorType2.NumberExclusiveMaximum, schema, path4, value);
       }
       if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-        yield Create(ValueErrorType2.NumberExclusiveMinimum, schema, path3, value);
+        yield Create(ValueErrorType2.NumberExclusiveMinimum, schema, path4, value);
       }
       if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
-        yield Create(ValueErrorType2.NumberMaximum, schema, path3, value);
+        yield Create(ValueErrorType2.NumberMaximum, schema, path4, value);
       }
       if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
-        yield Create(ValueErrorType2.NumberMinimum, schema, path3, value);
+        yield Create(ValueErrorType2.NumberMinimum, schema, path4, value);
       }
       if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
-        yield Create(ValueErrorType2.NumberMultipleOf, schema, path3, value);
+        yield Create(ValueErrorType2.NumberMultipleOf, schema, path4, value);
       }
     }
-    function* TObject(schema, references, path3, value) {
+    function* TObject(schema, references, path4, value) {
       if (!system_1.TypeSystemPolicy.IsObjectLike(value))
-        return yield Create(ValueErrorType2.Object, schema, path3, value);
+        return yield Create(ValueErrorType2.Object, schema, path4, value);
       if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
-        yield Create(ValueErrorType2.ObjectMinProperties, schema, path3, value);
+        yield Create(ValueErrorType2.ObjectMinProperties, schema, path4, value);
       }
       if (IsDefined(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-        yield Create(ValueErrorType2.ObjectMaxProperties, schema, path3, value);
+        yield Create(ValueErrorType2.ObjectMaxProperties, schema, path4, value);
       }
       const requiredKeys = Array.isArray(schema.required) ? schema.required : [];
       const knownKeys = Object.getOwnPropertyNames(schema.properties);
@@ -2345,12 +2345,12 @@ var require_errors = __commonJS({
       for (const requiredKey of requiredKeys) {
         if (unknownKeys.includes(requiredKey))
           continue;
-        yield Create(ValueErrorType2.ObjectRequiredProperty, schema.properties[requiredKey], `${path3}/${EscapeKey(requiredKey)}`, void 0);
+        yield Create(ValueErrorType2.ObjectRequiredProperty, schema.properties[requiredKey], `${path4}/${EscapeKey(requiredKey)}`, void 0);
       }
       if (schema.additionalProperties === false) {
         for (const valueKey of unknownKeys) {
           if (!knownKeys.includes(valueKey)) {
-            yield Create(ValueErrorType2.ObjectAdditionalProperties, schema, `${path3}/${EscapeKey(valueKey)}`, value[valueKey]);
+            yield Create(ValueErrorType2.ObjectAdditionalProperties, schema, `${path4}/${EscapeKey(valueKey)}`, value[valueKey]);
           }
         }
       }
@@ -2358,221 +2358,221 @@ var require_errors = __commonJS({
         for (const valueKey of unknownKeys) {
           if (knownKeys.includes(valueKey))
             continue;
-          yield* Visit(schema.additionalProperties, references, `${path3}/${EscapeKey(valueKey)}`, value[valueKey]);
+          yield* Visit(schema.additionalProperties, references, `${path4}/${EscapeKey(valueKey)}`, value[valueKey]);
         }
       }
       for (const knownKey of knownKeys) {
         const property = schema.properties[knownKey];
         if (schema.required && schema.required.includes(knownKey)) {
-          yield* Visit(property, references, `${path3}/${EscapeKey(knownKey)}`, value[knownKey]);
+          yield* Visit(property, references, `${path4}/${EscapeKey(knownKey)}`, value[knownKey]);
           if (Types.ExtendsUndefined.Check(schema) && !(knownKey in value)) {
-            yield Create(ValueErrorType2.ObjectRequiredProperty, property, `${path3}/${EscapeKey(knownKey)}`, void 0);
+            yield Create(ValueErrorType2.ObjectRequiredProperty, property, `${path4}/${EscapeKey(knownKey)}`, void 0);
           }
         } else {
           if (system_1.TypeSystemPolicy.IsExactOptionalProperty(value, knownKey)) {
-            yield* Visit(property, references, `${path3}/${EscapeKey(knownKey)}`, value[knownKey]);
+            yield* Visit(property, references, `${path4}/${EscapeKey(knownKey)}`, value[knownKey]);
           }
         }
       }
     }
-    function* TPromise(schema, references, path3, value) {
+    function* TPromise(schema, references, path4, value) {
       if (!(0, guard_1.IsPromise)(value))
-        yield Create(ValueErrorType2.Promise, schema, path3, value);
+        yield Create(ValueErrorType2.Promise, schema, path4, value);
     }
-    function* TRecord(schema, references, path3, value) {
+    function* TRecord(schema, references, path4, value) {
       if (!system_1.TypeSystemPolicy.IsRecordLike(value))
-        return yield Create(ValueErrorType2.Object, schema, path3, value);
+        return yield Create(ValueErrorType2.Object, schema, path4, value);
       if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
-        yield Create(ValueErrorType2.ObjectMinProperties, schema, path3, value);
+        yield Create(ValueErrorType2.ObjectMinProperties, schema, path4, value);
       }
       if (IsDefined(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-        yield Create(ValueErrorType2.ObjectMaxProperties, schema, path3, value);
+        yield Create(ValueErrorType2.ObjectMaxProperties, schema, path4, value);
       }
       const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0];
       const regex = new RegExp(patternKey);
       for (const [propertyKey, propertyValue] of Object.entries(value)) {
         if (regex.test(propertyKey))
-          yield* Visit(patternSchema, references, `${path3}/${EscapeKey(propertyKey)}`, propertyValue);
+          yield* Visit(patternSchema, references, `${path4}/${EscapeKey(propertyKey)}`, propertyValue);
       }
       if (typeof schema.additionalProperties === "object") {
         for (const [propertyKey, propertyValue] of Object.entries(value)) {
           if (!regex.test(propertyKey))
-            yield* Visit(schema.additionalProperties, references, `${path3}/${EscapeKey(propertyKey)}`, propertyValue);
+            yield* Visit(schema.additionalProperties, references, `${path4}/${EscapeKey(propertyKey)}`, propertyValue);
         }
       }
       if (schema.additionalProperties === false) {
         for (const [propertyKey, propertyValue] of Object.entries(value)) {
           if (regex.test(propertyKey))
             continue;
-          return yield Create(ValueErrorType2.ObjectAdditionalProperties, schema, `${path3}/${EscapeKey(propertyKey)}`, propertyValue);
+          return yield Create(ValueErrorType2.ObjectAdditionalProperties, schema, `${path4}/${EscapeKey(propertyKey)}`, propertyValue);
         }
       }
     }
-    function* TRef(schema, references, path3, value) {
-      yield* Visit((0, deref_1.Deref)(schema, references), references, path3, value);
+    function* TRef(schema, references, path4, value) {
+      yield* Visit((0, deref_1.Deref)(schema, references), references, path4, value);
     }
-    function* TString(schema, references, path3, value) {
+    function* TString(schema, references, path4, value) {
       if (!(0, guard_1.IsString)(value))
-        return yield Create(ValueErrorType2.String, schema, path3, value);
+        return yield Create(ValueErrorType2.String, schema, path4, value);
       if (IsDefined(schema.minLength) && !(value.length >= schema.minLength)) {
-        yield Create(ValueErrorType2.StringMinLength, schema, path3, value);
+        yield Create(ValueErrorType2.StringMinLength, schema, path4, value);
       }
       if (IsDefined(schema.maxLength) && !(value.length <= schema.maxLength)) {
-        yield Create(ValueErrorType2.StringMaxLength, schema, path3, value);
+        yield Create(ValueErrorType2.StringMaxLength, schema, path4, value);
       }
       if ((0, guard_1.IsString)(schema.pattern)) {
         const regex = new RegExp(schema.pattern);
         if (!regex.test(value)) {
-          yield Create(ValueErrorType2.StringPattern, schema, path3, value);
+          yield Create(ValueErrorType2.StringPattern, schema, path4, value);
         }
       }
       if ((0, guard_1.IsString)(schema.format)) {
         if (!Types.FormatRegistry.Has(schema.format)) {
-          yield Create(ValueErrorType2.StringFormatUnknown, schema, path3, value);
+          yield Create(ValueErrorType2.StringFormatUnknown, schema, path4, value);
         } else {
           const format = Types.FormatRegistry.Get(schema.format);
           if (!format(value)) {
-            yield Create(ValueErrorType2.StringFormat, schema, path3, value);
+            yield Create(ValueErrorType2.StringFormat, schema, path4, value);
           }
         }
       }
     }
-    function* TSymbol(schema, references, path3, value) {
+    function* TSymbol(schema, references, path4, value) {
       if (!(0, guard_1.IsSymbol)(value))
-        yield Create(ValueErrorType2.Symbol, schema, path3, value);
+        yield Create(ValueErrorType2.Symbol, schema, path4, value);
     }
-    function* TTemplateLiteral(schema, references, path3, value) {
+    function* TTemplateLiteral(schema, references, path4, value) {
       if (!(0, guard_1.IsString)(value))
-        return yield Create(ValueErrorType2.String, schema, path3, value);
+        return yield Create(ValueErrorType2.String, schema, path4, value);
       const regex = new RegExp(schema.pattern);
       if (!regex.test(value)) {
-        yield Create(ValueErrorType2.StringPattern, schema, path3, value);
+        yield Create(ValueErrorType2.StringPattern, schema, path4, value);
       }
     }
-    function* TThis(schema, references, path3, value) {
-      yield* Visit((0, deref_1.Deref)(schema, references), references, path3, value);
+    function* TThis(schema, references, path4, value) {
+      yield* Visit((0, deref_1.Deref)(schema, references), references, path4, value);
     }
-    function* TTuple(schema, references, path3, value) {
+    function* TTuple(schema, references, path4, value) {
       if (!(0, guard_1.IsArray)(value))
-        return yield Create(ValueErrorType2.Tuple, schema, path3, value);
+        return yield Create(ValueErrorType2.Tuple, schema, path4, value);
       if (schema.items === void 0 && !(value.length === 0)) {
-        return yield Create(ValueErrorType2.TupleLength, schema, path3, value);
+        return yield Create(ValueErrorType2.TupleLength, schema, path4, value);
       }
       if (!(value.length === schema.maxItems)) {
-        return yield Create(ValueErrorType2.TupleLength, schema, path3, value);
+        return yield Create(ValueErrorType2.TupleLength, schema, path4, value);
       }
       if (!schema.items) {
         return;
       }
       for (let i2 = 0; i2 < schema.items.length; i2++) {
-        yield* Visit(schema.items[i2], references, `${path3}/${i2}`, value[i2]);
+        yield* Visit(schema.items[i2], references, `${path4}/${i2}`, value[i2]);
       }
     }
-    function* TUndefined(schema, references, path3, value) {
+    function* TUndefined(schema, references, path4, value) {
       if (!(0, guard_1.IsUndefined)(value))
-        yield Create(ValueErrorType2.Undefined, schema, path3, value);
+        yield Create(ValueErrorType2.Undefined, schema, path4, value);
     }
-    function* TUnion(schema, references, path3, value) {
+    function* TUnion(schema, references, path4, value) {
       let count = 0;
       for (const subschema of schema.anyOf) {
-        const errors = [...Visit(subschema, references, path3, value)];
+        const errors = [...Visit(subschema, references, path4, value)];
         if (errors.length === 0)
           return;
         count += errors.length;
       }
       if (count > 0) {
-        yield Create(ValueErrorType2.Union, schema, path3, value);
+        yield Create(ValueErrorType2.Union, schema, path4, value);
       }
     }
-    function* TUint8Array(schema, references, path3, value) {
+    function* TUint8Array(schema, references, path4, value) {
       if (!(0, guard_1.IsUint8Array)(value))
-        return yield Create(ValueErrorType2.Uint8Array, schema, path3, value);
+        return yield Create(ValueErrorType2.Uint8Array, schema, path4, value);
       if (IsDefined(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
-        yield Create(ValueErrorType2.Uint8ArrayMaxByteLength, schema, path3, value);
+        yield Create(ValueErrorType2.Uint8ArrayMaxByteLength, schema, path4, value);
       }
       if (IsDefined(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
-        yield Create(ValueErrorType2.Uint8ArrayMinByteLength, schema, path3, value);
+        yield Create(ValueErrorType2.Uint8ArrayMinByteLength, schema, path4, value);
       }
     }
-    function* TUnknown(schema, references, path3, value) {
+    function* TUnknown(schema, references, path4, value) {
     }
-    function* TVoid(schema, references, path3, value) {
+    function* TVoid(schema, references, path4, value) {
       if (!system_1.TypeSystemPolicy.IsVoidLike(value))
-        yield Create(ValueErrorType2.Void, schema, path3, value);
+        yield Create(ValueErrorType2.Void, schema, path4, value);
     }
-    function* TKind(schema, references, path3, value) {
+    function* TKind(schema, references, path4, value) {
       const check = Types.TypeRegistry.Get(schema[Types.Kind]);
       if (!check(schema, value))
-        yield Create(ValueErrorType2.Kind, schema, path3, value);
+        yield Create(ValueErrorType2.Kind, schema, path4, value);
     }
-    function* Visit(schema, references, path3, value) {
+    function* Visit(schema, references, path4, value) {
       const references_ = IsDefined(schema.$id) ? [...references, schema] : references;
       const schema_ = schema;
       switch (schema_[Types.Kind]) {
         case "Any":
-          return yield* TAny(schema_, references_, path3, value);
+          return yield* TAny(schema_, references_, path4, value);
         case "Array":
-          return yield* TArray(schema_, references_, path3, value);
+          return yield* TArray(schema_, references_, path4, value);
         case "AsyncIterator":
-          return yield* TAsyncIterator(schema_, references_, path3, value);
+          return yield* TAsyncIterator(schema_, references_, path4, value);
         case "BigInt":
-          return yield* TBigInt(schema_, references_, path3, value);
+          return yield* TBigInt(schema_, references_, path4, value);
         case "Boolean":
-          return yield* TBoolean(schema_, references_, path3, value);
+          return yield* TBoolean(schema_, references_, path4, value);
         case "Constructor":
-          return yield* TConstructor(schema_, references_, path3, value);
+          return yield* TConstructor(schema_, references_, path4, value);
         case "Date":
-          return yield* TDate(schema_, references_, path3, value);
+          return yield* TDate(schema_, references_, path4, value);
         case "Function":
-          return yield* TFunction(schema_, references_, path3, value);
+          return yield* TFunction(schema_, references_, path4, value);
         case "Integer":
-          return yield* TInteger(schema_, references_, path3, value);
+          return yield* TInteger(schema_, references_, path4, value);
         case "Intersect":
-          return yield* TIntersect(schema_, references_, path3, value);
+          return yield* TIntersect(schema_, references_, path4, value);
         case "Iterator":
-          return yield* TIterator(schema_, references_, path3, value);
+          return yield* TIterator(schema_, references_, path4, value);
         case "Literal":
-          return yield* TLiteral(schema_, references_, path3, value);
+          return yield* TLiteral(schema_, references_, path4, value);
         case "Never":
-          return yield* TNever(schema_, references_, path3, value);
+          return yield* TNever(schema_, references_, path4, value);
         case "Not":
-          return yield* TNot(schema_, references_, path3, value);
+          return yield* TNot(schema_, references_, path4, value);
         case "Null":
-          return yield* TNull(schema_, references_, path3, value);
+          return yield* TNull(schema_, references_, path4, value);
         case "Number":
-          return yield* TNumber(schema_, references_, path3, value);
+          return yield* TNumber(schema_, references_, path4, value);
         case "Object":
-          return yield* TObject(schema_, references_, path3, value);
+          return yield* TObject(schema_, references_, path4, value);
         case "Promise":
-          return yield* TPromise(schema_, references_, path3, value);
+          return yield* TPromise(schema_, references_, path4, value);
         case "Record":
-          return yield* TRecord(schema_, references_, path3, value);
+          return yield* TRecord(schema_, references_, path4, value);
         case "Ref":
-          return yield* TRef(schema_, references_, path3, value);
+          return yield* TRef(schema_, references_, path4, value);
         case "String":
-          return yield* TString(schema_, references_, path3, value);
+          return yield* TString(schema_, references_, path4, value);
         case "Symbol":
-          return yield* TSymbol(schema_, references_, path3, value);
+          return yield* TSymbol(schema_, references_, path4, value);
         case "TemplateLiteral":
-          return yield* TTemplateLiteral(schema_, references_, path3, value);
+          return yield* TTemplateLiteral(schema_, references_, path4, value);
         case "This":
-          return yield* TThis(schema_, references_, path3, value);
+          return yield* TThis(schema_, references_, path4, value);
         case "Tuple":
-          return yield* TTuple(schema_, references_, path3, value);
+          return yield* TTuple(schema_, references_, path4, value);
         case "Undefined":
-          return yield* TUndefined(schema_, references_, path3, value);
+          return yield* TUndefined(schema_, references_, path4, value);
         case "Union":
-          return yield* TUnion(schema_, references_, path3, value);
+          return yield* TUnion(schema_, references_, path4, value);
         case "Uint8Array":
-          return yield* TUint8Array(schema_, references_, path3, value);
+          return yield* TUint8Array(schema_, references_, path4, value);
         case "Unknown":
-          return yield* TUnknown(schema_, references_, path3, value);
+          return yield* TUnknown(schema_, references_, path4, value);
         case "Void":
-          return yield* TVoid(schema_, references_, path3, value);
+          return yield* TVoid(schema_, references_, path4, value);
         default:
           if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
             throw new ValueErrorsUnknownTypeError(schema);
-          return yield* TKind(schema_, references_, path3, value);
+          return yield* TKind(schema_, references_, path4, value);
       }
     }
     function Errors(...args) {
@@ -2621,19 +2621,19 @@ var require_pointer = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.ValuePointer = exports.ValuePointerRootDeleteError = exports.ValuePointerRootSetError = void 0;
     var ValuePointerRootSetError = class extends Error {
-      constructor(value, path3, update) {
+      constructor(value, path4, update) {
         super("Cannot set root value");
         this.value = value;
-        this.path = path3;
+        this.path = path4;
         this.update = update;
       }
     };
     exports.ValuePointerRootSetError = ValuePointerRootSetError;
     var ValuePointerRootDeleteError = class extends Error {
-      constructor(value, path3) {
+      constructor(value, path4) {
         super("Cannot delete root value");
         this.value = value;
-        this.path = path3;
+        this.path = path4;
       }
     };
     exports.ValuePointerRootDeleteError = ValuePointerRootDeleteError;
@@ -2807,84 +2807,84 @@ var require_delta = __commonJS({
       }
     };
     exports.ValueDeltaUnableToDiffUnknownValue = ValueDeltaUnableToDiffUnknownValue;
-    function CreateUpdate(path3, value) {
-      return { type: "update", path: path3, value };
+    function CreateUpdate(path4, value) {
+      return { type: "update", path: path4, value };
     }
-    function CreateInsert(path3, value) {
-      return { type: "insert", path: path3, value };
+    function CreateInsert(path4, value) {
+      return { type: "insert", path: path4, value };
     }
-    function CreateDelete(path3) {
-      return { type: "delete", path: path3 };
+    function CreateDelete(path4) {
+      return { type: "delete", path: path4 };
     }
-    function* ObjectType(path3, current, next) {
+    function* ObjectType(path4, current, next) {
       if (!(0, guard_1.IsPlainObject)(next))
-        return yield CreateUpdate(path3, next);
+        return yield CreateUpdate(path4, next);
       const currentKeys = [...Object.keys(current), ...Object.getOwnPropertySymbols(current)];
       const nextKeys = [...Object.keys(next), ...Object.getOwnPropertySymbols(next)];
       for (const key of currentKeys) {
         if ((0, guard_1.IsSymbol)(key))
           throw new ValueDeltaObjectWithSymbolKeyError(key);
         if ((0, guard_1.IsUndefined)(next[key]) && nextKeys.includes(key))
-          yield CreateUpdate(`${path3}/${String(key)}`, void 0);
+          yield CreateUpdate(`${path4}/${String(key)}`, void 0);
       }
       for (const key of nextKeys) {
         if ((0, guard_1.IsUndefined)(current[key]) || (0, guard_1.IsUndefined)(next[key]))
           continue;
         if ((0, guard_1.IsSymbol)(key))
           throw new ValueDeltaObjectWithSymbolKeyError(key);
-        yield* Visit(`${path3}/${String(key)}`, current[key], next[key]);
+        yield* Visit(`${path4}/${String(key)}`, current[key], next[key]);
       }
       for (const key of nextKeys) {
         if ((0, guard_1.IsSymbol)(key))
           throw new ValueDeltaObjectWithSymbolKeyError(key);
         if ((0, guard_1.IsUndefined)(current[key]))
-          yield CreateInsert(`${path3}/${String(key)}`, next[key]);
+          yield CreateInsert(`${path4}/${String(key)}`, next[key]);
       }
       for (const key of currentKeys.reverse()) {
         if ((0, guard_1.IsSymbol)(key))
           throw new ValueDeltaObjectWithSymbolKeyError(key);
         if ((0, guard_1.IsUndefined)(next[key]) && !nextKeys.includes(key))
-          yield CreateDelete(`${path3}/${String(key)}`);
+          yield CreateDelete(`${path4}/${String(key)}`);
       }
     }
-    function* ArrayType(path3, current, next) {
+    function* ArrayType(path4, current, next) {
       if (!(0, guard_1.IsArray)(next))
-        return yield CreateUpdate(path3, next);
+        return yield CreateUpdate(path4, next);
       for (let i2 = 0; i2 < Math.min(current.length, next.length); i2++) {
-        yield* Visit(`${path3}/${i2}`, current[i2], next[i2]);
+        yield* Visit(`${path4}/${i2}`, current[i2], next[i2]);
       }
       for (let i2 = 0; i2 < next.length; i2++) {
         if (i2 < current.length)
           continue;
-        yield CreateInsert(`${path3}/${i2}`, next[i2]);
+        yield CreateInsert(`${path4}/${i2}`, next[i2]);
       }
       for (let i2 = current.length - 1; i2 >= 0; i2--) {
         if (i2 < next.length)
           continue;
-        yield CreateDelete(`${path3}/${i2}`);
+        yield CreateDelete(`${path4}/${i2}`);
       }
     }
-    function* TypedArrayType(path3, current, next) {
+    function* TypedArrayType(path4, current, next) {
       if (!(0, guard_1.IsTypedArray)(next) || current.length !== next.length || Object.getPrototypeOf(current).constructor.name !== Object.getPrototypeOf(next).constructor.name)
-        return yield CreateUpdate(path3, next);
+        return yield CreateUpdate(path4, next);
       for (let i2 = 0; i2 < Math.min(current.length, next.length); i2++) {
-        yield* Visit(`${path3}/${i2}`, current[i2], next[i2]);
+        yield* Visit(`${path4}/${i2}`, current[i2], next[i2]);
       }
     }
-    function* ValueType(path3, current, next) {
+    function* ValueType(path4, current, next) {
       if (current === next)
         return;
-      yield CreateUpdate(path3, next);
+      yield CreateUpdate(path4, next);
     }
-    function* Visit(path3, current, next) {
+    function* Visit(path4, current, next) {
       if ((0, guard_1.IsPlainObject)(current))
-        return yield* ObjectType(path3, current, next);
+        return yield* ObjectType(path4, current, next);
       if ((0, guard_1.IsArray)(current))
-        return yield* ArrayType(path3, current, next);
+        return yield* ArrayType(path4, current, next);
       if ((0, guard_1.IsTypedArray)(current))
-        return yield* TypedArrayType(path3, current, next);
+        return yield* TypedArrayType(path4, current, next);
       if ((0, guard_1.IsValueType)(current))
-        return yield* ValueType(path3, current, next);
+        return yield* ValueType(path4, current, next);
       throw new ValueDeltaUnableToDiffUnknownValue(current);
     }
     function Diff(current, next) {
@@ -2949,9 +2949,9 @@ var require_mutate = __commonJS({
       }
     };
     exports.ValueMutateInvalidRootMutationError = ValueMutateInvalidRootMutationError;
-    function ObjectType(root, path3, current, next) {
+    function ObjectType(root, path4, current, next) {
       if (!(0, guard_1.IsPlainObject)(current)) {
-        pointer_1.ValuePointer.Set(root, path3, (0, clone_1.Clone)(next));
+        pointer_1.ValuePointer.Set(root, path4, (0, clone_1.Clone)(next));
       } else {
         const currentKeys = Object.keys(current);
         const nextKeys = Object.keys(next);
@@ -2966,43 +2966,43 @@ var require_mutate = __commonJS({
           }
         }
         for (const nextKey of nextKeys) {
-          Visit(root, `${path3}/${nextKey}`, current[nextKey], next[nextKey]);
+          Visit(root, `${path4}/${nextKey}`, current[nextKey], next[nextKey]);
         }
       }
     }
-    function ArrayType(root, path3, current, next) {
+    function ArrayType(root, path4, current, next) {
       if (!(0, guard_1.IsArray)(current)) {
-        pointer_1.ValuePointer.Set(root, path3, (0, clone_1.Clone)(next));
+        pointer_1.ValuePointer.Set(root, path4, (0, clone_1.Clone)(next));
       } else {
         for (let index = 0; index < next.length; index++) {
-          Visit(root, `${path3}/${index}`, current[index], next[index]);
+          Visit(root, `${path4}/${index}`, current[index], next[index]);
         }
         current.splice(next.length);
       }
     }
-    function TypedArrayType(root, path3, current, next) {
+    function TypedArrayType(root, path4, current, next) {
       if ((0, guard_1.IsTypedArray)(current) && current.length === next.length) {
         for (let i2 = 0; i2 < current.length; i2++) {
           current[i2] = next[i2];
         }
       } else {
-        pointer_1.ValuePointer.Set(root, path3, (0, clone_1.Clone)(next));
+        pointer_1.ValuePointer.Set(root, path4, (0, clone_1.Clone)(next));
       }
     }
-    function ValueType(root, path3, current, next) {
+    function ValueType(root, path4, current, next) {
       if (current === next)
         return;
-      pointer_1.ValuePointer.Set(root, path3, next);
+      pointer_1.ValuePointer.Set(root, path4, next);
     }
-    function Visit(root, path3, current, next) {
+    function Visit(root, path4, current, next) {
       if ((0, guard_1.IsArray)(next))
-        return ArrayType(root, path3, current, next);
+        return ArrayType(root, path4, current, next);
       if ((0, guard_1.IsTypedArray)(next))
-        return TypedArrayType(root, path3, current, next);
+        return TypedArrayType(root, path4, current, next);
       if ((0, guard_1.IsPlainObject)(next))
-        return ObjectType(root, path3, current, next);
+        return ObjectType(root, path4, current, next);
       if ((0, guard_1.IsValueType)(next))
-        return ValueType(root, path3, current, next);
+        return ValueType(root, path4, current, next);
     }
     function IsNonMutableValue(value) {
       return (0, guard_1.IsTypedArray)(value) || (0, guard_1.IsValueType)(value);
@@ -7225,7 +7225,7 @@ var require_dist_node10 = __commonJS({
     });
     module.exports = __toCommonJS(dist_src_exports);
     var import_core3 = require_dist_node8();
-    var generateMessage = (path3, cursorValue) => `The cursor at "${path3.join(
+    var generateMessage = (path4, cursorValue) => `The cursor at "${path4.join(
       ","
     )}" did not change its value "${cursorValue}" after a page transition. Please make sure your that your query is set up correctly.`;
     var MissingCursorChange = class extends Error {
@@ -7266,9 +7266,9 @@ var require_dist_node10 = __commonJS({
       }
       return paginatedResourcePath;
     }
-    var deepFindPathToProperty = (object, searchProp, path3 = []) => {
+    var deepFindPathToProperty = (object, searchProp, path4 = []) => {
       for (const key of Object.keys(object)) {
-        const currentPath = [...path3, key];
+        const currentPath = [...path4, key];
         const currentValue = object[key];
         if (currentValue.hasOwnProperty(searchProp)) {
           return currentPath;
@@ -7286,12 +7286,12 @@ var require_dist_node10 = __commonJS({
       }
       return [];
     };
-    var get = (object, path3) => {
-      return path3.reduce((current, nextProperty) => current[nextProperty], object);
+    var get = (object, path4) => {
+      return path4.reduce((current, nextProperty) => current[nextProperty], object);
     };
-    var set = (object, path3, mutator) => {
-      const lastProperty = path3[path3.length - 1];
-      const parentPath = [...path3].slice(0, -1);
+    var set = (object, path4, mutator) => {
+      const lastProperty = path4[path4.length - 1];
+      const parentPath = [...path4].slice(0, -1);
       const parent = get(object, parentPath);
       if (typeof mutator === "function") {
         parent[lastProperty] = mutator(parent[lastProperty]);
@@ -7346,22 +7346,22 @@ var require_dist_node10 = __commonJS({
       if (Object.keys(response1).length === 0) {
         return Object.assign(response1, response2);
       }
-      const path3 = findPaginatedResourcePath(response1);
-      const nodesPath = [...path3, "nodes"];
+      const path4 = findPaginatedResourcePath(response1);
+      const nodesPath = [...path4, "nodes"];
       const newNodes = get(response2, nodesPath);
       if (newNodes) {
         set(response1, nodesPath, (values) => {
           return [...values, ...newNodes];
         });
       }
-      const edgesPath = [...path3, "edges"];
+      const edgesPath = [...path4, "edges"];
       const newEdges = get(response2, edgesPath);
       if (newEdges) {
         set(response1, edgesPath, (values) => {
           return [...values, ...newEdges];
         });
       }
-      const pageInfoPath = [...path3, "pageInfo"];
+      const pageInfoPath = [...path4, "pageInfo"];
       set(response1, pageInfoPath, get(response2, pageInfoPath));
       return response1;
     };
@@ -11021,7 +11021,7 @@ var require_dist_node13 = __commonJS({
     ];
     function routeMatcher(paths) {
       const regexes = paths.map(
-        (path3) => path3.split("/").map((c) => c.startsWith("{") ? "(?:.+?)" : c).join("/")
+        (path4) => path4.split("/").map((c) => c.startsWith("{") ? "(?:.+?)" : c).join("/")
       );
       const regex2 = `^(?:${regexes.map((r) => `(?:${r})`).join("|")})[^/]*$`;
       return new RegExp(regex2, "i");
@@ -19935,11 +19935,11 @@ var require_dist_node24 = __commonJS({
       }
     }
     function createNodeMiddleware2(webhooks, {
-      path: path3 = "/api/github/webhooks",
+      path: path4 = "/api/github/webhooks",
       log: log2 = createLogger()
     } = {}) {
       return middleware.bind(null, webhooks, {
-        path: path3,
+        path: path4,
         log: log2
       });
     }
@@ -20428,8 +20428,8 @@ var require_package = __commonJS({
 var require_main = __commonJS({
   "../../../../node_modules/.pnpm/dotenv@16.3.1/node_modules/dotenv/lib/main.js"(exports, module) {
     init_define_ENV_DEFINED_IN_BUILD_STEP();
-    var fs2 = __require("fs");
-    var path3 = __require("path");
+    var fs3 = __require("fs");
+    var path4 = __require("path");
     var os = __require("os");
     var crypto3 = __require("crypto");
     var packageJson = require_package();
@@ -20521,14 +20521,14 @@ var require_main = __commonJS({
       return { ciphertext, key };
     }
     function _vaultPath(options) {
-      let dotenvPath = path3.resolve(process.cwd(), ".env");
+      let dotenvPath = path4.resolve(process.cwd(), ".env");
       if (options && options.path && options.path.length > 0) {
         dotenvPath = options.path;
       }
       return dotenvPath.endsWith(".vault") ? dotenvPath : `${dotenvPath}.vault`;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path3.join(os.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path4.join(os.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options) {
       _log("Loading env from encrypted .env.vault");
@@ -20541,7 +20541,7 @@ var require_main = __commonJS({
       return { parsed };
     }
     function configDotenv(options) {
-      let dotenvPath = path3.resolve(process.cwd(), ".env");
+      let dotenvPath = path4.resolve(process.cwd(), ".env");
       let encoding = "utf8";
       const debug = Boolean(options && options.debug);
       if (options) {
@@ -20553,7 +20553,7 @@ var require_main = __commonJS({
         }
       }
       try {
-        const parsed = DotenvModule.parse(fs2.readFileSync(dotenvPath, { encoding }));
+        const parsed = DotenvModule.parse(fs3.readFileSync(dotenvPath, { encoding }));
         let processEnv = process.env;
         if (options && options.processEnv != null) {
           processEnv = options.processEnv;
@@ -20572,7 +20572,7 @@ var require_main = __commonJS({
       if (_dotenvKey(options).length === 0) {
         return DotenvModule.configDotenv(options);
       }
-      if (!fs2.existsSync(vaultPath)) {
+      if (!fs3.existsSync(vaultPath)) {
         _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
         return DotenvModule.configDotenv(options);
       }
@@ -22709,21 +22709,21 @@ init_define_ENV_DEFINED_IN_BUILD_STEP();
 
 // ../../../../lix/source-code/fs/dist/utilities/helpers.js
 init_define_ENV_DEFINED_IN_BUILD_STEP();
-function normalizePath(path3, stripTrailing) {
-  if (path3 === "\\" || path3 === "/")
+function normalizePath(path4, stripTrailing) {
+  if (path4 === "\\" || path4 === "/")
     return "/";
-  const len = path3.length;
+  const len = path4.length;
   if (len <= 1)
-    return path3;
+    return path4;
   let prefix = "";
-  if (len > 4 && path3[3] === "\\") {
-    const ch = path3[2];
-    if ((ch === "?" || ch === ".") && path3.slice(0, 2) === "\\\\") {
-      path3 = path3.slice(2);
+  if (len > 4 && path4[3] === "\\") {
+    const ch = path4[2];
+    if ((ch === "?" || ch === ".") && path4.slice(0, 2) === "\\\\") {
+      path4 = path4.slice(2);
       prefix = "//";
     }
   }
-  const segs = path3.split(/[/\\]+/);
+  const segs = path4.split(/[/\\]+/);
   const stack = [];
   for (const seg of segs) {
     if (seg === "..") {
@@ -22737,32 +22737,32 @@ function normalizePath(path3, stripTrailing) {
   }
   return prefix + stack.join("/");
 }
-function normalPath(path3) {
+function normalPath(path4) {
   var _a;
   const dots = /(\/|^)(\.\/)+/g;
   const slashes = /\/+/g;
   const upreference = /(?<!\.\.)[^/]+\/\.\.\//;
-  path3 = `/${path3}/`;
-  path3 = path3.replace(/^\/\.\./, "");
-  path3 = path3.replace(dots, "/").replace(slashes, "/");
+  path4 = `/${path4}/`;
+  path4 = path4.replace(/^\/\.\./, "");
+  path4 = path4.replace(dots, "/").replace(slashes, "/");
   let match;
-  while (match = (_a = path3.match(upreference)) == null ? void 0 : _a[0]) {
-    path3 = path3.replace(match, "");
+  while (match = (_a = path4.match(upreference)) == null ? void 0 : _a[0]) {
+    path4 = path4.replace(match, "");
   }
-  return path3;
+  return path4;
 }
-function getDirname(path3) {
-  return normalPath(path3.split("/").filter((x) => x).slice(0, -1).join("/") ?? path3);
+function getDirname(path4) {
+  return normalPath(path4.split("/").filter((x) => x).slice(0, -1).join("/") ?? path4);
 }
-function getBasename(path3) {
-  return path3.split("/").filter((x) => x).at(-1) ?? path3;
+function getBasename(path4) {
+  return path4.split("/").filter((x) => x).at(-1) ?? path4;
 }
 
 // ../../sdk/dist/isAbsolutePath.js
 init_define_ENV_DEFINED_IN_BUILD_STEP();
-var isAbsolutePath = (path3) => {
+var isAbsolutePath = (path4) => {
   const matchPosixAndWindowsAbsolutePaths = /^(?:[A-Za-z]:\\(?:[^\\]+\\)*[^\\]+|[A-Za-z]:\/(?:[^/]+\/)*[^/]+|\/(?:[^/]+\/)*[^/]+)$/;
-  return matchPosixAndWindowsAbsolutePaths.test(path3);
+  return matchPosixAndWindowsAbsolutePaths.test(path4);
 };
 
 // ../../sdk/dist/createNodeishFsWithAbsolutePaths.js
@@ -22771,19 +22771,19 @@ var createNodeishFsWithAbsolutePaths = (args) => {
     throw new Error(`Expected an absolute path but received "${args.projectPath}".`);
   }
   const basePath = normalizePath(args.projectPath).split("/").slice(0, -1).join("/");
-  const makeAbsolute = (path3) => {
-    if (isAbsolutePath(path3)) {
-      return normalizePath(path3);
+  const makeAbsolute = (path4) => {
+    if (isAbsolutePath(path4)) {
+      return normalizePath(path4);
     }
-    return normalizePath(basePath + "/" + path3);
+    return normalizePath(basePath + "/" + path4);
   };
   return {
     // @ts-expect-error
-    readFile: (path3, options) => args.nodeishFs.readFile(makeAbsolute(path3), options),
-    readdir: (path3) => args.nodeishFs.readdir(makeAbsolute(path3)),
-    mkdir: (path3) => args.nodeishFs.mkdir(makeAbsolute(path3)),
-    writeFile: (path3, data) => args.nodeishFs.writeFile(makeAbsolute(path3), data),
-    watch: (path3, options) => args.nodeishFs.watch(makeAbsolute(path3), options)
+    readFile: (path4, options) => args.nodeishFs.readFile(makeAbsolute(path4), options),
+    readdir: (path4) => args.nodeishFs.readdir(makeAbsolute(path4)),
+    mkdir: (path4) => args.nodeishFs.mkdir(makeAbsolute(path4)),
+    writeFile: (path4, data) => args.nodeishFs.writeFile(makeAbsolute(path4), data),
+    watch: (path4, options) => args.nodeishFs.watch(makeAbsolute(path4), options)
   };
 };
 
@@ -22791,11 +22791,11 @@ var createNodeishFsWithAbsolutePaths = (args) => {
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 var createNodeishFsWithWatcher = (args) => {
   const pathList = [];
-  const makeWatcher = (path3) => {
+  const makeWatcher = (path4) => {
     const abortController = new AbortController();
     (async () => {
       try {
-        const watcher = args.nodeishFs.watch(path3, {
+        const watcher = args.nodeishFs.watch(path4, {
           signal: abortController.signal,
           persistent: false
         });
@@ -22813,16 +22813,16 @@ var createNodeishFsWithWatcher = (args) => {
       }
     })();
   };
-  const readFileAndExtractPath = (path3, options) => {
-    if (!pathList.includes(path3)) {
-      makeWatcher(path3);
-      pathList.push(path3);
+  const readFileAndExtractPath = (path4, options) => {
+    if (!pathList.includes(path4)) {
+      makeWatcher(path4);
+      pathList.push(path4);
     }
-    return args.nodeishFs.readFile(path3, options);
+    return args.nodeishFs.readFile(path4, options);
   };
   return {
     // @ts-expect-error
-    readFile: (path3, options) => readFileAndExtractPath(path3, options),
+    readFile: (path4, options) => readFileAndExtractPath(path4, options),
     readdir: args.nodeishFs.readdir,
     mkdir: args.nodeishFs.mkdir,
     writeFile: args.nodeishFs.writeFile,
@@ -23847,7 +23847,7 @@ var createEffect4 = createEffect3;
 // ../../../../lix/source-code/client/dist/git/commit.js
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 import { walk, TREE, STAGE, writeTree, commit as doCommit } from "isomorphic-git";
-async function commit({ fs: fs2, dir, ref, author, message }) {
+async function commit({ fs: fs3, dir, ref, author, message }) {
   const fileStates = {};
   async function createTree(currentFolder, fileStates2) {
     const entries = [];
@@ -23875,10 +23875,10 @@ async function commit({ fs: fs2, dir, ref, author, message }) {
         });
       }
     }
-    return await writeTree({ fs: fs2, dir, tree: entries });
+    return await writeTree({ fs: fs3, dir, tree: entries });
   }
   await walk({
-    fs: fs2,
+    fs: fs3,
     dir,
     // cache, gitdir,
     trees: [TREE({ ref }), STAGE()],
@@ -23938,7 +23938,7 @@ async function commit({ fs: fs2, dir, ref, author, message }) {
   });
   const tree = await createTree("/", fileStates);
   return doCommit({
-    fs: fs2,
+    fs: fs3,
     dir,
     author,
     message,
@@ -24608,15 +24608,15 @@ Valid examples:
 - "/path/to/green-elephant.inlang
 `, { argument: "projectPath" });
   }
-  const fs2 = args.repo.nodeishFs;
+  const fs3 = args.repo.nodeishFs;
   const nodeishFs = createNodeishFsWithAbsolutePaths({
     projectPath,
-    nodeishFs: fs2
+    nodeishFs: fs3
   });
-  await maybeMigrateToDirectory({ nodeishFs: fs2, projectPath });
+  await maybeMigrateToDirectory({ nodeishFs: fs3, projectPath });
   await maybeCreateFirstProjectId({ projectPath, repo: args.repo });
   return await createRoot2(async () => {
-    const { data: projectId } = await tryCatch(() => fs2.readFile(args.projectPath + "/project_id", { encoding: "utf-8" }));
+    const { data: projectId } = await tryCatch(() => fs3.readFile(args.projectPath + "/project_id", { encoding: "utf-8" }));
     const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable();
     const [settings, _setSettings] = createSignal2();
     createEffect2(() => {
@@ -24658,10 +24658,10 @@ Valid examples:
         markInitAsFailed(void 0);
         return;
       }
-      const loadAndSetMessages = async (fs3) => {
+      const loadAndSetMessages = async (fs4) => {
         makeTrulyAsync(_resolvedModules.resolvedPluginApi.loadMessages({
           settings: settingsValue,
-          nodeishFs: fs3
+          nodeishFs: fs4
         })).then((messages2) => {
           setMessages(messages2);
           markInitAsComplete();
@@ -24864,13 +24864,13 @@ init_define_ENV_DEFINED_IN_BUILD_STEP();
 var listProjects = async (nodeishFs, from3) => {
   const recursionLimit = 5;
   const projects = [];
-  async function searchDir(path3, depth) {
+  async function searchDir(path4, depth) {
     if (depth > recursionLimit) {
       return;
     }
-    const files = await nodeishFs.readdir(path3);
+    const files = await nodeishFs.readdir(path4);
     for (const file of files) {
-      const filePath = `${path3}/${file}`;
+      const filePath = `${path4}/${file}`;
       try {
         const stats = await nodeishFs.stat(filePath);
         if (stats.isDirectory()) {
@@ -25752,8 +25752,8 @@ function getErrorMap() {
   return overrideErrorMap;
 }
 var makeIssue = (params) => {
-  const { data, path: path3, errorMaps, issueData } = params;
-  const fullPath = [...path3, ...issueData.path || []];
+  const { data, path: path4, errorMaps, issueData } = params;
+  const fullPath = [...path4, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -25852,11 +25852,11 @@ var errorUtil;
   errorUtil2.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
 })(errorUtil || (errorUtil = {}));
 var ParseInputLazyPath = class {
-  constructor(parent, value, path3, key) {
+  constructor(parent, value, path4, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path3;
+    this._path = path4;
     this._key = key;
   }
   get path() {
@@ -29197,17 +29197,117 @@ function capture2(args) {
   });
 }
 
+// src/services/telemetry/stack-detection.ts
+init_define_ENV_DEFINED_IN_BUILD_STEP();
+var RelevantPackages = [
+  "next",
+  "solid",
+  "solid-start",
+  "svelte",
+  "@sveltejs/kit",
+  "@sveltejs/adaper-static",
+  "@sveltejs/adapter-node",
+  "@sveltejs/adapter-netlify",
+  "@sveltejs/adapter-vercel",
+  "@sveltejs/adapter-cloudflare-workers",
+  "@sveltejs/adapter-auto",
+  "vue",
+  "nuxt",
+  "react",
+  "react-native",
+  "remix",
+  "astro",
+  "flutter",
+  "vite",
+  "webpack",
+  "rollup",
+  "esbuild",
+  "qwick",
+  "parcel",
+  "lit",
+  "lit-html",
+  "@angular/core"
+];
+function getStackInfo(packageJson) {
+  const packages = {};
+  try {
+    const pkg = packageJson;
+    const dependencies = (pkg == null ? void 0 : pkg.dependencies) ?? {};
+    const devDependencies = (pkg == null ? void 0 : pkg.devDependencies) ?? {};
+    const peerDependencies = (pkg == null ? void 0 : pkg.peerDependencies) ?? {};
+    const allDependencies = { ...dependencies, ...devDependencies, ...peerDependencies };
+    for (const dependencyName of RelevantPackages) {
+      if (dependencyName in allDependencies) {
+        const dependencyVersion = allDependencies[dependencyName];
+        if (typeof dependencyVersion !== "string")
+          continue;
+        packages[dependencyName] = dependencyVersion;
+      }
+    }
+    return { packages };
+  } catch (error) {
+    return { packages };
+  }
+}
+
+// src/compiler/compile.ts
+import fs from "node:fs/promises";
+
+// src/services/environment/package.ts
+init_define_ENV_DEFINED_IN_BUILD_STEP();
+import path from "node:path";
+
+// src/services/file-handling/exists.ts
+init_define_ENV_DEFINED_IN_BUILD_STEP();
+async function pathExists(filePath, nodeishFs) {
+  try {
+    await nodeishFs.stat(filePath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    } else {
+      throw new Error(`Failed to check if path exists: ${error}`, { cause: error });
+    }
+  }
+}
+
+// src/services/environment/package.ts
+async function findPackageJson(fs3, cwd) {
+  const potentialPackageJsonPath = path.resolve(cwd, "package.json");
+  const packageJsonExists = await pathExists(potentialPackageJsonPath, fs3);
+  if (packageJsonExists)
+    return potentialPackageJsonPath;
+  return void 0;
+}
+async function getPackageJson(fs3, cwd) {
+  const packageJsonPath = await findPackageJson(fs3, cwd);
+  if (!packageJsonPath)
+    return void 0;
+  try {
+    const packageJsonContents = await fs3.readFile(packageJsonPath, { encoding: "utf-8" });
+    return JSON.parse(packageJsonContents);
+  } catch {
+    return void 0;
+  }
+}
+
 // src/compiler/compile.ts
 var ignoreDirectory = `# ignore everything because the directory is auto-generated by inlang paraglide-js
 # for more info visit https://inlang.com/m/gerre34r/paraglide-js
 *
 `;
-var compile = (args) => {
+var compile = async (args) => {
   const compiledMessages = args.messages.map(
     (message) => compileMessage(message, args.settings.languageTags, args.settings.sourceLanguageTag)
   );
+  const pkgJson = await getPackageJson(fs, process.cwd());
+  const stack = getStackInfo(pkgJson);
   telemetry.capture({
-    event: "PARAGLIDE-JS compile executed"
+    event: "PARAGLIDE-JS compile executed",
+    properties: {
+      stack
+    }
   });
   const resources = {};
   for (const compiledMessage of compiledMessages) {
@@ -29403,33 +29503,33 @@ import { Command } from "commander";
 
 // src/services/file-handling/write-output.ts
 init_define_ENV_DEFINED_IN_BUILD_STEP();
-import path from "node:path";
+import path2 from "node:path";
 import crypto2 from "node:crypto";
 var previousOutputHash;
-async function writeOutput(outputDirectory, output, fs2) {
+async function writeOutput(outputDirectory, output, fs3) {
   const currentOutputHash = hashOutput(output, outputDirectory);
   if (currentOutputHash === previousOutputHash)
     return;
-  await fs2.access(outputDirectory).catch(async () => {
-    await fs2.mkdir(outputDirectory, { recursive: true });
+  await fs3.access(outputDirectory).catch(async () => {
+    await fs3.mkdir(outputDirectory, { recursive: true });
   });
-  const files = await fs2.readdir(outputDirectory);
+  const files = await fs3.readdir(outputDirectory);
   await Promise.allSettled(
     files.map(async (file) => {
-      await fs2.unlink(outputDirectory + "/" + file);
+      await fs3.unlink(outputDirectory + "/" + file);
     })
   );
   await Promise.allSettled(
     Object.keys(output).map(async (filePath) => {
-      const fullPath = path.resolve(outputDirectory, filePath);
-      const directory = path.dirname(fullPath);
-      await fs2.mkdir(directory, { recursive: true });
+      const fullPath = path2.resolve(outputDirectory, filePath);
+      const directory = path2.dirname(fullPath);
+      await fs3.mkdir(directory, { recursive: true });
     })
   );
   await Promise.allSettled(
     Object.entries(output).map(async ([filePath, fileContent]) => {
-      const fullPath = path.resolve(outputDirectory, filePath);
-      await fs2.writeFile(fullPath, fileContent);
+      const fullPath = path2.resolve(outputDirectory, filePath);
+      await fs3.writeFile(fullPath, fileContent);
     })
   );
   previousOutputHash = currentOutputHash;
@@ -29506,19 +29606,19 @@ var compileCommand = new Command().name("compile").summary("Compiles inlang Para
   "./src/paraglide"
 ).requiredOption("--watch", "Watch for changes and recompile.", false).action(async (options) => {
   const logger = new Logger({ silent: false, prefix: true });
-  const path3 = resolve(process.cwd(), options.project);
+  const path4 = resolve(process.cwd(), options.project);
   const outputDirectory = resolve(process.cwd(), options.outdir);
   logger.info(`Compiling inlang project at "${options.project}".`);
-  const repoRoot = await findRepoRoot({ nodeishFs: nodeFsPromises, path: path3 });
+  const repoRoot = await findRepoRoot({ nodeishFs: nodeFsPromises, path: path4 });
   const repo = await openRepository(repoRoot || process.cwd(), {
     nodeishFs: nodeFsPromises
   });
   if (!repoRoot) {
-    logger.warn(`Could not find repository root for path ${path3}`);
+    logger.warn(`Could not find repository root for path ${path4}`);
   }
   const project = exitIfErrors(
     await loadProject({
-      projectPath: path3,
+      projectPath: path4,
       repo,
       appId: "library.inlang.paraglideJs"
     }),
@@ -29546,12 +29646,12 @@ var compileCommand = new Command().name("compile").summary("Compiles inlang Para
   }
   logger.info("Sucessfully compiled the project.");
 });
-async function executeCompilation(project, outputDirectory, fs2) {
-  const output = compile({
+async function executeCompilation(project, outputDirectory, fs3) {
+  const output = await compile({
     messages: project.query.messages.getAll(),
     settings: project.settings()
   });
-  await writeOutput(outputDirectory, output, fs2);
+  await writeOutput(outputDirectory, output, fs3);
 }
 var exitIfErrors = (project, logger) => {
   if (project.errors().length > 0) {
@@ -29575,16 +29675,16 @@ import childProcess from "node:child_process";
 
 // src/cli/state.ts
 init_define_ENV_DEFINED_IN_BUILD_STEP();
-import path2 from "node:path";
-import fs from "node:fs";
+import path3 from "node:path";
+import fs2 from "node:fs";
 import { fileURLToPath } from "node:url";
 var version = (() => {
-  const currentFilePath = fileURLToPath(import.meta.url).split(path2.sep).join(path2.posix.sep);
+  const currentFilePath = fileURLToPath(import.meta.url).split(path3.sep).join(path3.posix.sep);
   const paraglideDirectory = currentFilePath.slice(
     0,
     currentFilePath.indexOf("/paraglide-js/") + "/paraglide-js".length
   );
-  return JSON.parse(fs.readFileSync(`${paraglideDirectory}/package.json`, "utf-8")).version;
+  return JSON.parse(fs2.readFileSync(`${paraglideDirectory}/package.json`, "utf-8")).version;
 })();
 
 // src/cli/commands/init.ts
@@ -29676,7 +29776,7 @@ var maybeAddVsCodeExtension = async (args, ctx) => {
   }
   if (extensions.recommendations.includes("inlang.vs-code-extension") === false) {
     extensions.recommendations.push("inlang.vs-code-extension");
-    if (await fileExists("./.vscode", ctx.repo.nodeishFs) === false) {
+    if (await pathExists("./.vscode", ctx.repo.nodeishFs) === false) {
       await ctx.repo.nodeishFs.mkdir("./.vscode");
     }
     await ctx.repo.nodeishFs.writeFile(
@@ -29706,9 +29806,9 @@ var addParaglideJsToDevDependencies = async (ctx) => {
   ctx.logger.success("Added @inlang/paraglide-js to the devDependencies in package.json.");
 };
 var findExistingInlangProjectPath = async (ctx) => {
-  for (const path3 of ["./project.inlang", "../project.inlang", "../../project.inlang"]) {
-    if (await fileExists(path3, ctx.repo.nodeishFs)) {
-      return path3;
+  for (const path4 of ["./project.inlang", "../project.inlang", "../../project.inlang"]) {
+    if (await pathExists(path4, ctx.repo.nodeishFs)) {
+      return path4;
     }
     continue;
   }
@@ -29788,8 +29888,8 @@ var newProjectTemplate = {
   }
 };
 var checkIfPackageJsonExists = async (ctx) => {
-  const exists = await fileExists("./package.json", ctx.repo.nodeishFs);
-  if (exists === false) {
+  const packageJsonPath = await findPackageJson(ctx.repo.nodeishFs, process.cwd());
+  if (!packageJsonPath) {
     ctx.logger.warn(
       "No package.json found in the current working directory. Please change the working directory to the directory with a package.json file."
     );
@@ -29864,7 +29964,7 @@ Please add the following command to your build script manually:
 };
 var maybeChangeTsConfigModuleResolution = async (ctx) => {
   var _a, _b, _c;
-  if (await fileExists("./tsconfig.json", ctx.repo.nodeishFs) === false) {
+  if (await pathExists("./tsconfig.json", ctx.repo.nodeishFs) === false) {
     return;
   }
   const file = await ctx.repo.nodeishFs.readFile("./tsconfig.json", { encoding: "utf-8" });
@@ -29926,7 +30026,7 @@ var maybeChangeTsConfigModuleResolution = async (ctx) => {
 };
 var maybeChangeTsConfigAllowJs = async (ctx) => {
   var _a, _b;
-  if (await fileExists("./tsconfig.json", ctx.repo.nodeishFs) === false) {
+  if (await pathExists("./tsconfig.json", ctx.repo.nodeishFs) === false) {
     return;
   }
   const file = await ctx.repo.nodeishFs.readFile("./tsconfig.json", { encoding: "utf-8" });
@@ -29974,18 +30074,6 @@ var prompt = async (message, options) => {
   }
   return response;
 };
-async function fileExists(filePath, nodeishFs) {
-  try {
-    await nodeishFs.stat(filePath);
-    return true;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return false;
-    } else {
-      throw new Error(`Failed to check if file exists: ${error}`, { cause: error });
-    }
-  }
-}
 function execAsync(command) {
   return new Promise((resolve3, reject) => {
     childProcess.exec(command, (error, stdout) => {