@inlang/paraglide-js 1.3.4 → 1.3.6

package/dist/index.js

@@ -5540,10 +5540,10 @@ var require_compiler2 = __commonJS({
   }
 });
 
-// ../../../../lix/source-code/fs/dist/errors/FilesystemError.js
+// ../../../../lix/packages/fs/dist/errors/FilesystemError.js
 var FilesystemError;
 var init_FilesystemError = __esm({
-  "../../../../lix/source-code/fs/dist/errors/FilesystemError.js"() {
+  "../../../../lix/packages/fs/dist/errors/FilesystemError.js"() {
     "use strict";
     init_define_ENV_DEFINED_IN_BUILD_STEP();
     FilesystemError = class extends Error {
@@ -5586,7 +5586,7 @@ var init_FilesystemError = __esm({
   }
 });
 
-// ../../../../lix/source-code/fs/dist/utilities/helpers.js
+// ../../../../lix/packages/fs/dist/utilities/helpers.js
 function assertIsAbsolutePath(path4) {
   if ((path4.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path4)) === false) {
     {
@@ -5643,13 +5643,13 @@ function getBasename(path4) {
   return path4.split("/").filter((x) => x).at(-1) ?? path4;
 }
 var init_helpers = __esm({
-  "../../../../lix/source-code/fs/dist/utilities/helpers.js"() {
+  "../../../../lix/packages/fs/dist/utilities/helpers.js"() {
     "use strict";
     init_define_ENV_DEFINED_IN_BUILD_STEP();
   }
 });
 
-// ../../../../lix/source-code/fs/dist/memoryFs.js
+// ../../../../lix/packages/fs/dist/memoryFs.js
 function toSnapshot(fs3) {
   return {
     fsMap: Object.fromEntries([...fs3._state.fsMap].map(([path4, content]) => {
@@ -6057,7 +6057,7 @@ function createNodeishMemoryFs() {
   }
 }
 var init_memoryFs = __esm({
-  "../../../../lix/source-code/fs/dist/memoryFs.js"() {
+  "../../../../lix/packages/fs/dist/memoryFs.js"() {
     "use strict";
     init_define_ENV_DEFINED_IN_BUILD_STEP();
     init_FilesystemError();
@@ -6065,7 +6065,7 @@ var init_memoryFs = __esm({
   }
 });
 
-// ../../../../lix/source-code/fs/dist/index.js
+// ../../../../lix/packages/fs/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
   assertIsAbsolutePath: () => assertIsAbsolutePath,
@@ -6078,7 +6078,7 @@ __export(dist_exports, {
   toSnapshot: () => toSnapshot
 });
 var init_dist = __esm({
-  "../../../../lix/source-code/fs/dist/index.js"() {
+  "../../../../lix/packages/fs/dist/index.js"() {
     "use strict";
     init_define_ENV_DEFINED_IN_BUILD_STEP();
     init_memoryFs();
@@ -17009,8 +17009,8 @@ var require_lodash = __commonJS({
         return value === 0 ? value : +value;
       }
       value = value.replace(reTrim, "");
-      var isBinary = reIsBinary.test(value);
-      return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+      var isBinary2 = reIsBinary.test(value);
+      return isBinary2 || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary2 ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
     }
     function keys(object) {
       return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
@@ -17097,8 +17097,8 @@ var require_lodash3 = __commonJS({
         return value === 0 ? value : +value;
       }
       value = value.replace(reTrim, "");
-      var isBinary = reIsBinary.test(value);
-      return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+      var isBinary2 = reIsBinary.test(value);
+      return isBinary2 || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary2 ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
     }
     module.exports = isInteger;
   }
@@ -17259,8 +17259,8 @@ var require_lodash7 = __commonJS({
         return value === 0 ? value : +value;
       }
       value = value.replace(reTrim, "");
-      var isBinary = reIsBinary.test(value);
-      return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+      var isBinary2 = reIsBinary.test(value);
+      return isBinary2 || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary2 ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
     }
     module.exports = once;
   }
@@ -20362,9 +20362,9 @@ var require_dist_node23 = __commonJS({
   }
 });
 
-// ../../../../node_modules/.pnpm/@octokit+webhooks@12.1.2/node_modules/@octokit/webhooks/dist-node/index.js
+// ../../../../node_modules/.pnpm/@octokit+webhooks@12.2.0/node_modules/@octokit/webhooks/dist-node/index.js
 var require_dist_node24 = __commonJS({
-  "../../../../node_modules/.pnpm/@octokit+webhooks@12.1.2/node_modules/@octokit/webhooks/dist-node/index.js"(exports, module) {
+  "../../../../node_modules/.pnpm/@octokit+webhooks@12.2.0/node_modules/@octokit/webhooks/dist-node/index.js"(exports, module) {
     "use strict";
     init_define_ENV_DEFINED_IN_BUILD_STEP();
     var __create2 = Object.create;
@@ -20412,6 +20412,9 @@ var require_dist_node24 = __commonJS({
       ...logger
     });
     var emitterEventNames = [
+      "branch_protection_configuration",
+      "branch_protection_rule.disabled",
+      "branch_protection_rule.enabled",
       "branch_protection_rule",
       "branch_protection_rule.created",
       "branch_protection_rule.deleted",
@@ -20435,6 +20438,11 @@ var require_dist_node24 = __commonJS({
       "commit_comment",
       "commit_comment.created",
       "create",
+      "custom_property",
+      "custom_property.created",
+      "custom_property.deleted",
+      "custom_property_values",
+      "custom_property_values.updated",
       "delete",
       "dependabot_alert",
       "dependabot_alert.created",
@@ -35932,7 +35940,7 @@ init_define_ENV_DEFINED_IN_BUILD_STEP();
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 import { Command as Command3 } from "commander";
 
-// src/cli/commands/compile.ts
+// src/cli/commands/compile/command.ts
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 
 // ../../sdk/dist/index.js
@@ -35993,6 +36001,7 @@ function lookup(languageTag, options) {
 
 // ../../versioned-interfaces/language-tag/dist/validate.js
 init_define_ENV_DEFINED_IN_BUILD_STEP();
+var isValidLanguageTag = (languageTag) => RegExp(`${pattern}`).test(languageTag);
 
 // ../../versioned-interfaces/translatable/dist/interface.js
 var import_typebox2 = __toESM(require_typebox(), 1);
@@ -39062,16 +39071,16 @@ var createNodeishFsWithWatcher = (args) => {
 // ../../sdk/dist/migrations/maybeCreateFirstProjectId.js
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 
-// ../../../../lix/source-code/client/dist/index.js
+// ../../../../lix/packages/client/dist/index.js
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 
-// ../../../../lix/source-code/client/dist/api.js
+// ../../../../lix/packages/client/dist/api.js
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 
-// ../../../../lix/source-code/client/dist/openRepository.js
+// ../../../../lix/packages/client/dist/openRepository.js
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 
-// ../../../../lix/source-code/client/dist/helpers.js
+// ../../../../lix/packages/client/dist/helpers.js
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 var withProxy = ({ nodeishFs, verbose = false, description, intercept }) => {
   return new Proxy(nodeishFs, {
@@ -39175,7 +39184,7 @@ function parseLixUri(uriText) {
   };
 }
 
-// ../../../../lix/source-code/client/dist/git-http/client.js
+// ../../../../lix/packages/client/dist/git-http/client.js
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 function fromValue(value) {
   let queue = [value];
@@ -39299,10 +39308,10 @@ function makeHttpClient({ verbose, description, onReq, onRes }) {
   return { request };
 }
 
-// ../../../../lix/source-code/client/dist/git-http/optimize-refs.js
+// ../../../../lix/packages/client/dist/git-http/optimize-refs.js
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 
-// ../../../../lix/source-code/client/dist/git-http/helpers.js
+// ../../../../lix/packages/client/dist/git-http/helpers.js
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 function padHex(pad, n) {
   const s = n.toString(16);
@@ -39340,7 +39349,7 @@ function decodeGitPackLines(concatenatedUint8Array) {
   return strings;
 }
 
-// ../../../../lix/source-code/client/dist/git-http/optimize-refs.js
+// ../../../../lix/packages/client/dist/git-http/optimize-refs.js
 async function optimizedRefsReq({ url, addRef }) {
   if (!url.endsWith("info/refs?service=git-upload-pack")) {
     return;
@@ -39400,10 +39409,10 @@ async function optimizedRefsRes({ origUrl, resBody, statusCode, resHeaders }) {
   }
 }
 
-// ../../../../lix/source-code/client/dist/openRepository.js
+// ../../../../lix/packages/client/dist/openRepository.js
 var import_octokit = __toESM(require_dist_node26(), 1);
 
-// ../../../../lix/source-code/client/dist/solid.js
+// ../../../../lix/packages/client/dist/solid.js
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 
 // ../../../../node_modules/.pnpm/solid-js@1.7.11/node_modules/solid-js/dist/solid.js
@@ -40029,14 +40038,14 @@ function createProvider2(id, options) {
 var FALLBACK2 = Symbol("fallback");
 var SuspenseListContext2 = createContext2();
 
-// ../../../../lix/source-code/client/dist/solid.js
+// ../../../../lix/packages/client/dist/solid.js
 var createSignal4 = createSignal3;
 var createEffect4 = createEffect3;
 
-// ../../../../lix/source-code/client/dist/git/commit.js
+// ../../../../lix/packages/client/dist/git/commit.js
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 
-// ../../../../lix/source-code/client/vendored/isomorphic-git/index.js
+// ../../../../lix/packages/client/vendored/isomorphic-git/index.js
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 var import_async_lock = __toESM(require_async_lock(), 1);
 var import_sha1 = __toESM(require_sha1(), 1);
@@ -41223,6 +41232,12 @@ var refpaths = (ref) => [
   `refs/remotes/${ref}/HEAD`
 ];
 var GIT_FILES = ["config", "description", "index", "shallow", "commondir"];
+var lock$1;
+async function acquireLock(ref, callback) {
+  if (lock$1 === void 0)
+    lock$1 = new import_async_lock.default();
+  return lock$1.acquire(ref, callback);
+}
 var GitRefManager = class _GitRefManager {
   static async updateRemoteRefs({
     fs: fs3,
@@ -41304,8 +41319,11 @@ var GitRefManager = class _GitRefManager {
       }
     }
     for (const [key, value] of actualRefsToWrite) {
-      await fs3.write(join(gitdir, key), `${value.trim()}
-`, "utf8");
+      await acquireLock(
+        key,
+        async () => fs3.write(join(gitdir, key), `${value.trim()}
+`, "utf8")
+      );
     }
     return { pruned };
   }
@@ -41314,19 +41332,28 @@ var GitRefManager = class _GitRefManager {
     if (!value.match(/[0-9a-f]{40}/)) {
       throw new InvalidOidError(value);
     }
-    await fs3.write(join(gitdir, ref), `${value.trim()}
-`, "utf8");
+    await acquireLock(
+      ref,
+      async () => fs3.write(join(gitdir, ref), `${value.trim()}
+`, "utf8")
+    );
   }
   static async writeSymbolicRef({ fs: fs3, gitdir, ref, value }) {
-    await fs3.write(join(gitdir, ref), `ref: ${value.trim()}
-`, "utf8");
+    await acquireLock(
+      ref,
+      async () => fs3.write(join(gitdir, ref), `ref: ${value.trim()}
+`, "utf8")
+    );
   }
   static async deleteRef({ fs: fs3, gitdir, ref }) {
     return _GitRefManager.deleteRefs({ fs: fs3, gitdir, refs: [ref] });
   }
   static async deleteRefs({ fs: fs3, gitdir, refs }) {
     await Promise.all(refs.map((ref) => fs3.rm(join(gitdir, ref))));
-    let text = await fs3.read(`${gitdir}/packed-refs`, { encoding: "utf8" });
+    let text = await acquireLock(
+      "packed-refs",
+      async () => fs3.read(`${gitdir}/packed-refs`, { encoding: "utf8" })
+    );
     const packed = GitPackedRefs.from(text);
     const beforeSize = packed.refs.size;
     for (const ref of refs) {
@@ -41336,7 +41363,10 @@ var GitRefManager = class _GitRefManager {
     }
     if (packed.refs.size < beforeSize) {
       text = packed.toString();
-      await fs3.write(`${gitdir}/packed-refs`, text, { encoding: "utf8" });
+      await acquireLock(
+        "packed-refs",
+        async () => fs3.write(`${gitdir}/packed-refs`, text, { encoding: "utf8" })
+      );
     }
   }
   /**
@@ -41354,7 +41384,6 @@ var GitRefManager = class _GitRefManager {
         return ref;
       }
     }
-    let sha;
     if (ref.startsWith("ref: ")) {
       ref = ref.slice("ref: ".length);
       return _GitRefManager.resolve({ fs: fs3, gitdir, ref, depth });
@@ -41365,7 +41394,10 @@ var GitRefManager = class _GitRefManager {
     const packedMap = await _GitRefManager.packedRefs({ fs: fs3, gitdir });
     const allpaths = refpaths(ref).filter((p) => !GIT_FILES.includes(p));
     for (const ref2 of allpaths) {
-      sha = await fs3.read(`${gitdir}/${ref2}`, { encoding: "utf8" }) || packedMap.get(ref2);
+      const sha = await acquireLock(
+        ref2,
+        async () => await fs3.read(`${gitdir}/${ref2}`, { encoding: "utf8" }) || packedMap.get(ref2)
+      );
       if (sha) {
         return _GitRefManager.resolve({ fs: fs3, gitdir, ref: sha.trim(), depth });
       }
@@ -41387,7 +41419,11 @@ var GitRefManager = class _GitRefManager {
     const packedMap = await _GitRefManager.packedRefs({ fs: fs3, gitdir });
     const allpaths = refpaths(ref);
     for (const ref2 of allpaths) {
-      if (await fs3.exists(`${gitdir}/${ref2}`))
+      const refExists = await acquireLock(
+        ref2,
+        async () => fs3.exists(`${gitdir}/${ref2}`)
+      );
+      if (refExists)
         return ref2;
       if (packedMap.has(ref2))
         return ref2;
@@ -41431,7 +41467,10 @@ var GitRefManager = class _GitRefManager {
     throw new NotFoundError(ref);
   }
   static async packedRefs({ fs: fs3, gitdir }) {
-    const text = await fs3.read(`${gitdir}/packed-refs`, { encoding: "utf8" });
+    const text = await acquireLock(
+      "packed-refs",
+      async () => fs3.read(`${gitdir}/packed-refs`, { encoding: "utf8" })
+    );
     const packed = GitPackedRefs.from(text);
     return packed.refs;
   }
@@ -44399,7 +44438,7 @@ async function _branch({
   gitdir,
   ref,
   object,
-  checkout: checkout2 = false,
+  checkout: checkout4 = false,
   force = false
 }) {
   if (ref !== import_clean_git_ref.default.clean(ref)) {
@@ -44420,7 +44459,7 @@ async function _branch({
   if (oid) {
     await GitRefManager.writeRef({ fs: fs3, gitdir, ref: fullref, value: oid });
   }
-  if (checkout2) {
+  if (checkout4) {
     await GitRefManager.writeSymbolicRef({
       fs: fs3,
       gitdir,
@@ -44435,7 +44474,7 @@ async function branch({
   gitdir = join(dir, ".git"),
   ref,
   object,
-  checkout: checkout2 = false,
+  checkout: checkout4 = false,
   force = false
 }) {
   try {
@@ -44447,7 +44486,7 @@ async function branch({
       gitdir,
       ref,
       object,
-      checkout: checkout2,
+      checkout: checkout4,
       force
     });
   } catch (err) {
@@ -45336,14 +45375,14 @@ var GitRemoteManager = class {
     );
   }
 };
-var lock$1 = null;
+var lock$2 = null;
 var GitShallowManager = class {
   static async read({ fs: fs3, gitdir }) {
-    if (lock$1 === null)
-      lock$1 = new import_async_lock.default();
+    if (lock$2 === null)
+      lock$2 = new import_async_lock.default();
     const filepath = join(gitdir, "shallow");
     const oids = /* @__PURE__ */ new Set();
-    await lock$1.acquire(filepath, async function() {
+    await lock$2.acquire(filepath, async function() {
       const text = await fs3.read(filepath, { encoding: "utf8" });
       if (text === null)
         return oids;
@@ -45354,18 +45393,18 @@ var GitShallowManager = class {
     return oids;
   }
   static async write({ fs: fs3, gitdir, oids }) {
-    if (lock$1 === null)
-      lock$1 = new import_async_lock.default();
+    if (lock$2 === null)
+      lock$2 = new import_async_lock.default();
     const filepath = join(gitdir, "shallow");
     if (oids.size > 0) {
       const text = [...oids].join("\n") + "\n";
-      await lock$1.acquire(filepath, async function() {
+      await lock$2.acquire(filepath, async function() {
         await fs3.write(filepath, text, {
           encoding: "utf8"
         });
       });
     } else {
-      await lock$1.acquire(filepath, async function() {
+      await lock$2.acquire(filepath, async function() {
         await fs3.rm(filepath);
       });
     }
@@ -48922,7 +48961,7 @@ async function _renameBranch({
   gitdir,
   oldref,
   ref,
-  checkout: checkout2 = false
+  checkout: checkout4 = false
 }) {
   if (ref !== import_clean_git_ref.default.clean(ref)) {
     throw new InvalidRefNameError(ref, import_clean_git_ref.default.clean(ref));
@@ -48950,7 +48989,7 @@ async function _renameBranch({
     fullname: true
   });
   const isCurrentBranch = fullCurrentBranchRef === fulloldref;
-  if (checkout2 || isCurrentBranch) {
+  if (checkout4 || isCurrentBranch) {
     await GitRefManager.writeSymbolicRef({
       fs: fs3,
       gitdir,
@@ -48965,7 +49004,7 @@ async function renameBranch({
   gitdir = join(dir, ".git"),
   ref,
   oldref,
-  checkout: checkout2 = false
+  checkout: checkout4 = false
 }) {
   try {
     assertParameter("fs", fs3);
@@ -48977,7 +49016,7 @@ async function renameBranch({
       gitdir,
       ref,
       oldref,
-      checkout: checkout2
+      checkout: checkout4
     });
   } catch (err) {
     err.caller = "git.renameBranch";
@@ -49200,9 +49239,9 @@ async function status({
 async function getOidAtPath({ fs: fs3, cache, gitdir, tree, path: path4 }) {
   if (typeof path4 === "string")
     path4 = path4.split("/");
-  const dirname2 = path4.shift();
+  const dirname3 = path4.shift();
   for (const entry of tree) {
-    if (entry.path === dirname2) {
+    if (entry.path === dirname3) {
       if (path4.length === 0) {
         return entry.oid;
       }
@@ -49649,6 +49688,241 @@ async function writeTree({ fs: fs3, dir, gitdir = join(dir, ".git"), tree }) {
     throw err;
   }
 }
+async function writeRefsAdResponse({ capabilities, refs, symrefs }) {
+  const stream = [];
+  let syms = "";
+  for (const [key, value] of Object.entries(symrefs)) {
+    syms += `symref=${key}:${value} `;
+  }
+  let caps = `\0${[...capabilities].join(" ")} ${syms}agent=${pkg.agent}`;
+  for (const [key, value] of Object.entries(refs)) {
+    stream.push(GitPktLine.encode(`${value} ${key}${caps}
+`));
+    caps = "";
+  }
+  stream.push(GitPktLine.flush());
+  return stream;
+}
+async function uploadPack({
+  fs: fs3,
+  dir,
+  gitdir = join(dir, ".git"),
+  advertiseRefs = false
+}) {
+  try {
+    if (advertiseRefs) {
+      const capabilities = [
+        "thin-pack",
+        "side-band",
+        "side-band-64k",
+        "shallow",
+        "deepen-since",
+        "deepen-not",
+        "allow-tip-sha1-in-want",
+        "allow-reachable-sha1-in-want"
+      ];
+      let keys = await GitRefManager.listRefs({
+        fs: fs3,
+        gitdir,
+        filepath: "refs"
+      });
+      keys = keys.map((ref) => `refs/${ref}`);
+      const refs = {};
+      keys.unshift("HEAD");
+      for (const key of keys) {
+        refs[key] = await GitRefManager.resolve({ fs: fs3, gitdir, ref: key });
+      }
+      const symrefs = {};
+      symrefs.HEAD = await GitRefManager.resolve({
+        fs: fs3,
+        gitdir,
+        ref: "HEAD",
+        depth: 2
+      });
+      return writeRefsAdResponse({
+        capabilities,
+        refs,
+        symrefs
+      });
+    }
+  } catch (err) {
+    err.caller = "git.uploadPack";
+    throw err;
+  }
+}
+var deepget = (keys, map) => {
+  for (const key of keys) {
+    if (!map.has(key))
+      map.set(key, /* @__PURE__ */ new Map());
+    map = map.get(key);
+  }
+  return map;
+};
+var DeepMap = class {
+  constructor() {
+    this._root = /* @__PURE__ */ new Map();
+  }
+  set(keys, value) {
+    const lastKey = keys.pop();
+    const lastMap = deepget(keys, this._root);
+    lastMap.set(lastKey, value);
+  }
+  get(keys) {
+    const lastKey = keys.pop();
+    const lastMap = deepget(keys, this._root);
+    return lastMap.get(lastKey);
+  }
+  has(keys) {
+    const lastKey = keys.pop();
+    const lastMap = deepget(keys, this._root);
+    return lastMap.has(lastKey);
+  }
+};
+function fromEntries(map) {
+  const o = {};
+  for (const [key, value] of map) {
+    o[key] = value;
+  }
+  return o;
+}
+function fromNodeStream(stream) {
+  const asyncIterator = Object.getOwnPropertyDescriptor(
+    stream,
+    Symbol.asyncIterator
+  );
+  if (asyncIterator && asyncIterator.enumerable) {
+    return stream;
+  }
+  let ended = false;
+  const queue = [];
+  let defer = {};
+  stream.on("data", (chunk) => {
+    queue.push(chunk);
+    if (defer.resolve) {
+      defer.resolve({ value: queue.shift(), done: false });
+      defer = {};
+    }
+  });
+  stream.on("error", (err) => {
+    if (defer.reject) {
+      defer.reject(err);
+      defer = {};
+    }
+  });
+  stream.on("end", () => {
+    ended = true;
+    if (defer.resolve) {
+      defer.resolve({ done: true });
+      defer = {};
+    }
+  });
+  return {
+    next() {
+      return new Promise((resolve3, reject) => {
+        if (queue.length === 0 && ended) {
+          return resolve3({ done: true });
+        } else if (queue.length > 0) {
+          return resolve3({ value: queue.shift(), done: false });
+        } else if (queue.length === 0 && !ended) {
+          defer = { resolve: resolve3, reject };
+        }
+      });
+    },
+    return() {
+      stream.removeAllListeners();
+      if (stream.destroy)
+        stream.destroy();
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+}
+function fromStream2(stream) {
+  if (stream[Symbol.asyncIterator])
+    return stream;
+  const reader = stream.getReader();
+  return {
+    next() {
+      return reader.read();
+    },
+    return() {
+      reader.releaseLock();
+      return {};
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+}
+function isBinary(buffer) {
+  const MAX_XDIFF_SIZE = 1024 * 1024 * 1023;
+  if (buffer.length > MAX_XDIFF_SIZE)
+    return true;
+  return buffer.slice(0, 8e3).some((value) => value === 0);
+}
+async function sleep(ms) {
+  return new Promise((resolve3, reject) => setTimeout(resolve3, ms));
+}
+async function parseUploadPackRequest(stream) {
+  const read = GitPktLine.streamReader(stream);
+  let done = false;
+  let capabilities = null;
+  const wants = [];
+  const haves = [];
+  const shallows = [];
+  let depth;
+  let since;
+  const exclude = [];
+  let relative = false;
+  while (!done) {
+    const line = await read();
+    if (line === true)
+      break;
+    if (line === null)
+      continue;
+    const [key, value, ...rest] = line.toString("utf8").trim().split(" ");
+    if (!capabilities)
+      capabilities = rest;
+    switch (key) {
+      case "want":
+        wants.push(value);
+        break;
+      case "have":
+        haves.push(value);
+        break;
+      case "shallow":
+        shallows.push(value);
+        break;
+      case "deepen":
+        depth = parseInt(value);
+        break;
+      case "deepen-since":
+        since = parseInt(value);
+        break;
+      case "deepen-not":
+        exclude.push(value);
+        break;
+      case "deepen-relative":
+        relative = true;
+        break;
+      case "done":
+        done = true;
+        break;
+    }
+  }
+  return {
+    capabilities,
+    wants,
+    haves,
+    shallows,
+    depth,
+    since,
+    exclude,
+    relative,
+    done
+  };
+}
 var index = {
   Errors,
   STAGE,
@@ -49712,16 +49986,134 @@ var index = {
   tag,
   version,
   walk,
+  _walk,
   writeBlob,
   writeCommit,
   writeObject,
   writeRef,
   writeTag,
-  writeTree
+  writeTree,
+  _listObjects: listObjects,
+  _pack,
+  _uploadPack: uploadPack,
+  _GitConfigManager: GitConfigManager,
+  _GitIgnoreManager: GitIgnoreManager,
+  _GitIndexManager: GitIndexManager,
+  _GitRefManager: GitRefManager,
+  _GitRemoteHTTP: GitRemoteHTTP,
+  _GitRemoteManager: GitRemoteManager,
+  _GitShallowManager: GitShallowManager,
+  _FileSystem: FileSystem,
+  _GitAnnotatedTag: GitAnnotatedTag,
+  _GitCommit: GitCommit,
+  _GitConfig: GitConfig,
+  _GitIndex: GitIndex,
+  _GitObject: GitObject,
+  _GitPackIndex: GitPackIndex,
+  _GitPktLine: GitPktLine,
+  _GitRefSpec: GitRefSpec,
+  _GitRefSpecSet: GitRefSpecSet,
+  _GitSideBand: GitSideBand,
+  _GitTree: GitTree,
+  _GitWalkerFs: GitWalkerFs,
+  _GitWalkerIndex: GitWalkerIndex,
+  _GitWalkerRepo: GitWalkerRepo,
+  _RunningMinimum: RunningMinimum,
+  _expandOid,
+  _expandOidLoose: expandOidLoose,
+  _expandOidPacked: expandOidPacked,
+  _hasObject: hasObject,
+  _hasObjectLoose: hasObjectLoose,
+  _hasObjectPacked: hasObjectPacked,
+  _hashObject: hashObject,
+  _readObject,
+  _readObjectLoose: readObjectLoose,
+  _readObjectPacked: readObjectPacked,
+  _readPackIndex: readPackIndex,
+  _writeObject,
+  _writeObjectLoose: writeObjectLoose,
+  _BufferCursor: BufferCursor,
+  _DeepMap: DeepMap,
+  _FIFO: FIFO,
+  _StreamReader: StreamReader,
+  _abbreviateRef: abbreviateRef,
+  _applyDelta: applyDelta,
+  _arrayRange: arrayRange,
+  _assertParameter: assertParameter,
+  // _asyncIteratorToStream,
+  _basename: basename,
+  _calculateBasicAuthHeader: calculateBasicAuthHeader,
+  _collect: collect2,
+  _compareAge: compareAge,
+  _comparePath: comparePath,
+  _compareRefNames: compareRefNames,
+  _compareStats: compareStats,
+  _compareStrings: compareStrings,
+  _compareTreeEntryPath: compareTreeEntryPath,
+  _deflate: deflate,
+  _dirname: dirname,
+  _emptyPackfile: emptyPackfile,
+  _extractAuthFromUrl: extractAuthFromUrl,
+  _filterCapabilities: filterCapabilities,
+  _flat: flat,
+  _flatFileListToDirectoryStructure: flatFileListToDirectoryStructure,
+  _forAwait: forAwait2,
+  _formatAuthor: formatAuthor,
+  _formatInfoRefs: formatInfoRefs,
+  _fromEntries: fromEntries,
+  _fromNodeStream: fromNodeStream,
+  _fromStream: fromStream2,
+  _fromValue: fromValue2,
+  _getIterator: getIterator2,
+  _listpack: listpack,
+  _utils_hashObject: hashObject$1,
+  _indent: indent,
+  _inflate: inflate,
+  _isBinary: isBinary,
+  _join: join,
+  _mergeFile: mergeFile,
+  _mergeTree: mergeTree,
+  _mode2type: mode2type,
+  _modified: modified,
+  _normalizeAuthorObject: normalizeAuthorObject,
+  _normalizeCommitterObject: normalizeCommitterObject,
+  _normalizeMode: normalizeMode,
+  _normalizeNewlines: normalizeNewlines,
+  _normalizePath: normalizePath2,
+  _normalizeStats: normalizeStats,
+  _outdent: outdent,
+  _padHex: padHex2,
+  _parseAuthor: parseAuthor,
+  _pkg: pkg,
+  _posixifyPathBuffer: posixifyPathBuffer,
+  _resolveBlob: resolveBlob,
+  _resolveCommit: resolveCommit,
+  _resolveFileIdInTree: resolveFileIdInTree,
+  _resolveFilepath: resolveFilepath,
+  _resolveTree: resolveTree,
+  _rmRecursive: rmRecursive,
+  _shasum: shasum,
+  _sleep: sleep,
+  _splitLines: splitLines,
+  // _symbols,
+  _toHex: toHex,
+  _translateSSHtoHTTP: translateSSHtoHTTP,
+  _unionOfIterators: unionOfIterators,
+  _worthWalking: worthWalking,
+  _parseCapabilitiesV2: parseCapabilitiesV2,
+  _parseListRefsResponse: parseListRefsResponse,
+  _parseReceivePackResponse: parseReceivePackResponse,
+  _parseRefsAdResponse: parseRefsAdResponse,
+  _parseUploadPackRequest: parseUploadPackRequest,
+  _parseUploadPackResponse: parseUploadPackResponse,
+  _writeListRefsRequest: writeListRefsRequest,
+  _writeReceivePackRequest: writeReceivePackRequest,
+  _writeRefsAdResponse: writeRefsAdResponse,
+  _writeUploadPackRequest: writeUploadPackRequest
 };
 var isomorphic_git_default = index;
 
-// ../../../../lix/source-code/client/dist/git/commit.js
+// ../../../../lix/packages/client/dist/git/commit.js
 init_dist();
 async function commit2({ cache, fs: fs3, dir, ref, author, message }) {
   const fileStates = {};
@@ -49827,10 +50219,10 @@ async function commit2({ cache, fs: fs3, dir, ref, author, message }) {
   });
 }
 
-// ../../../../lix/source-code/client/dist/git/status-list.js
+// ../../../../lix/packages/client/dist/git/status-list.js
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 
-// ../../../../lix/source-code/client/dist/git/helpers.js
+// ../../../../lix/packages/client/dist/git/helpers.js
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 var fileModeTypeMapping = {
   "40": "folder",
@@ -49842,18 +50234,8 @@ function modeToFileType(mode) {
   return fileModeTypeMapping[fileMode] || "unknown";
 }
 
-// ../../../../lix/source-code/client/dist/git/status-list.js
+// ../../../../lix/packages/client/dist/git/status-list.js
 var { walk: walk2, TREE: TREE2, WORKDIR: WORKDIR2, STAGE: STAGE2, isIgnored: isIgnored2 } = isomorphic_git_default;
-var worthWalking2 = (filepath, root) => {
-  if (filepath === "." || root == void 0 || root.length === 0 || root === "." || root === filepath) {
-    return true;
-  }
-  if (root.length > filepath.length) {
-    return root.startsWith(filepath + "/");
-  } else {
-    return filepath.startsWith(root + "/");
-  }
-};
 function normalizePath3(path4) {
   return path4.replace(/\/\.\//g, "/").replace(/\/{2,}/g, "/").replace(/^\/\.$/, "/").replace(/^\.\/$/, ".").replace(/^\.\//, "").replace(/\/\.$/, "").replace(/(.+)\/$/, "$1").replace(/^$/, ".");
 }
@@ -49902,7 +50284,7 @@ async function statusList({
             return null;
           }
         }
-        if (!filepaths.some((base) => worthWalking2(filepath, base))) {
+        if (!filepaths.some((base) => worthWalking(filepath, base))) {
           return null;
         }
         if (filter && !filter(filepath)) {
@@ -50021,7 +50403,430 @@ async function statusList({
   }
 }
 
-// ../../../../lix/source-code/client/dist/openRepository.js
+// ../../../../lix/packages/client/dist/git/checkout.js
+init_define_ENV_DEFINED_IN_BUILD_STEP();
+
+// ../../../../lix/packages/client/dist/git/_checkout.js
+init_define_ENV_DEFINED_IN_BUILD_STEP();
+async function _checkout2({ fs: fs3, cache, onProgress, dir, gitdir, remote, ref, filepaths, noCheckout, noUpdateHead, dryRun, force, track = true }) {
+  let oid;
+  try {
+    oid = await GitRefManager.resolve({ fs: fs3, gitdir, ref });
+  } catch (err) {
+    if (ref === "HEAD")
+      throw err;
+    const remoteRef = `${remote}/${ref}`;
+    oid = await GitRefManager.resolve({
+      fs: fs3,
+      gitdir,
+      ref: remoteRef
+    });
+    if (track) {
+      const config2 = await GitConfigManager.get({ fs: fs3, gitdir });
+      await config2.set(`branch.${ref}.remote`, remote);
+      await config2.set(`branch.${ref}.merge`, `refs/heads/${ref}`);
+      await GitConfigManager.save({ fs: fs3, gitdir, config: config2 });
+    }
+    await GitRefManager.writeRef({
+      fs: fs3,
+      gitdir,
+      ref: `refs/heads/${ref}`,
+      value: oid
+    });
+  }
+  if (!noCheckout) {
+    let ops;
+    try {
+      ops = await analyze2({
+        fs: fs3,
+        cache,
+        onProgress,
+        dir,
+        gitdir,
+        ref,
+        force,
+        filepaths
+      });
+    } catch (err) {
+      if (err instanceof Errors.NotFoundError && err.data.what === oid) {
+        throw new Errors.CommitNotFetchedError(ref, oid);
+      } else {
+        throw err;
+      }
+    }
+    const conflicts = ops.filter(([method]) => method === "conflict").map(([method, fullpath]) => fullpath);
+    if (conflicts.length > 0) {
+      throw new Errors.CheckoutConflictError(conflicts);
+    }
+    const errors = ops.filter(([method]) => method === "error").map(([method, fullpath]) => fullpath);
+    if (errors.length > 0) {
+      throw new Errors.InternalError(errors.join(", "));
+    }
+    if (dryRun) {
+      return;
+    }
+    let count = 0;
+    const total = ops.length;
+    await GitIndexManager.acquire({ fs: fs3, gitdir, cache }, async function(index2) {
+      await Promise.all(
+        // @ts-ignore
+        ops.filter(([method]) => method === "delete" || method === "delete-index").map(async function([method, fullpath]) {
+          const filepath = `${dir}/${fullpath}`;
+          if (method === "delete") {
+            await fs3.rm(filepath);
+          }
+          index2.delete({ filepath: fullpath });
+          if (onProgress) {
+            await onProgress({
+              phase: "Updating workdir",
+              loaded: ++count,
+              total
+            });
+          }
+        })
+      );
+    });
+    await GitIndexManager.acquire({ fs: fs3, gitdir, cache }, async function(index2) {
+      for (const [method, fullpath] of ops) {
+        if (method === "rmdir" || method === "rmdir-index") {
+          const filepath = `${dir}/${fullpath}`;
+          try {
+            if (method === "rmdir-index") {
+              index2.delete({ filepath: fullpath });
+            }
+            await fs3.rmdir(filepath);
+            if (onProgress) {
+              await onProgress({
+                phase: "Updating workdir",
+                loaded: ++count,
+                total
+              });
+            }
+          } catch (e) {
+            if (e.code === "ENOTEMPTY") {
+              console.log(`Did not delete ${fullpath} because directory is not empty`);
+            } else {
+              throw e;
+            }
+          }
+        }
+      }
+    });
+    await Promise.all(ops.filter(([method]) => method === "mkdir" || method === "mkdir-index").map(async function([_, fullpath]) {
+      const filepath = `${dir}/${fullpath}`;
+      await fs3.mkdir(filepath);
+      if (onProgress) {
+        await onProgress({
+          phase: "Updating workdir",
+          loaded: ++count,
+          total
+        });
+      }
+    }));
+    await GitIndexManager.acquire({ fs: fs3, gitdir, cache }, async function(index2) {
+      await Promise.all(
+        // @ts-ignore
+        ops.filter(
+          // @ts-ignore
+          ([method]) => method === "create" || method === "create-index" || method === "update" || method === "mkdir-index"
+        ).map(async function([method, fullpath, oid2, mode, chmod]) {
+          const filepath = `${dir}/${fullpath}`;
+          try {
+            if (method !== "create-index" && method !== "mkdir-index") {
+              const { object } = await _readObject({ fs: fs3, cache, gitdir, oid: oid2 });
+              if (chmod) {
+                await fs3.rm(filepath);
+              }
+              if (mode === 33188) {
+                await fs3.write(filepath, object);
+              } else if (mode === 33261) {
+                await fs3.write(filepath, object, { mode: 511 });
+              } else if (mode === 40960) {
+                await fs3.writelink(filepath, object);
+              } else {
+                throw new Errors.InternalError(`Invalid mode 0o${mode.toString(8)} detected in blob ${oid2}`);
+              }
+            }
+            const stats = await fs3.lstat(filepath);
+            if (mode === 33261) {
+              stats.mode = 493;
+            }
+            if (method === "mkdir-index") {
+              stats.mode = 57344;
+            }
+            index2.insert({
+              filepath: fullpath,
+              stats,
+              oid: oid2
+            });
+            if (onProgress) {
+              await onProgress({
+                phase: "Updating workdir",
+                loaded: ++count,
+                total
+              });
+            }
+          } catch (e) {
+            console.log(e);
+          }
+        })
+      );
+    });
+  }
+  if (!noUpdateHead) {
+    const fullRef = await GitRefManager.expand({ fs: fs3, gitdir, ref });
+    if (fullRef.startsWith("refs/heads")) {
+      await GitRefManager.writeSymbolicRef({
+        fs: fs3,
+        gitdir,
+        ref: "HEAD",
+        value: fullRef
+      });
+    } else {
+      await GitRefManager.writeRef({ fs: fs3, gitdir, ref: "HEAD", value: oid });
+    }
+  }
+}
+async function analyze2({ fs: fs3, cache, onProgress, dir, gitdir, ref, force, filepaths }) {
+  let count = 0;
+  return _walk({
+    fs: fs3,
+    cache,
+    dir,
+    gitdir,
+    trees: [TREE({ ref }), WORKDIR(), STAGE()],
+    // @ts-ignore
+    map: async function(fullpath, [commit3, workdir, stage]) {
+      if (fullpath === ".")
+        return;
+      if (filepaths && !filepaths.some((base) => worthWalking(fullpath, base))) {
+        return null;
+      }
+      if (onProgress) {
+        await onProgress({ phase: "Analyzing workdir", loaded: ++count });
+      }
+      const key = [!!stage, !!commit3, !!workdir].map(Number).join("");
+      switch (key) {
+        case "000":
+          return;
+        case "001":
+          if (force && filepaths && filepaths.includes(fullpath)) {
+            return ["delete", fullpath];
+          }
+          return;
+        case "010": {
+          switch (await commit3.type()) {
+            case "tree": {
+              return ["mkdir", fullpath];
+            }
+            case "blob": {
+              return ["create", fullpath, await commit3.oid(), await commit3.mode()];
+            }
+            case "commit": {
+              return ["mkdir-index", fullpath, await commit3.oid(), await commit3.mode()];
+            }
+            default: {
+              return ["error", `new entry Unhandled type ${await commit3.type()}`];
+            }
+          }
+        }
+        case "011": {
+          switch (`${await commit3.type()}-${await workdir.type()}`) {
+            case "tree-tree": {
+              return;
+            }
+            case "tree-blob":
+            case "blob-tree": {
+              return ["conflict", fullpath];
+            }
+            case "blob-blob": {
+              if (await commit3.oid() !== await workdir.oid()) {
+                if (force) {
+                  return [
+                    "update",
+                    fullpath,
+                    // @ts-ignore
+                    await commit3.oid(),
+                    // @ts-ignore
+                    await commit3.mode(),
+                    // @ts-ignore
+                    await commit3.mode() !== await workdir.mode()
+                  ];
+                } else {
+                  return ["conflict", fullpath];
+                }
+              } else {
+                if (await commit3.mode() !== await workdir.mode()) {
+                  if (force) {
+                    return ["update", fullpath, await commit3.oid(), await commit3.mode(), true];
+                  } else {
+                    return ["conflict", fullpath];
+                  }
+                } else {
+                  return ["create-index", fullpath, await commit3.oid(), await commit3.mode()];
+                }
+              }
+            }
+            case "commit-tree": {
+              return;
+            }
+            case "commit-blob": {
+              return ["conflict", fullpath];
+            }
+            default: {
+              return ["error", `new entry Unhandled type ${commit3.type}`];
+            }
+          }
+        }
+        case "100": {
+          return ["delete-index", fullpath];
+        }
+        case "101": {
+          switch (await stage.type()) {
+            case "tree": {
+              return ["rmdir", fullpath];
+            }
+            case "blob": {
+              if (await stage.oid() !== await workdir.oid()) {
+                if (force) {
+                  return ["delete", fullpath];
+                } else {
+                  return ["conflict", fullpath];
+                }
+              } else {
+                return ["delete", fullpath];
+              }
+            }
+            case "commit": {
+              return ["rmdir-index", fullpath];
+            }
+            default: {
+              return ["error", `delete entry Unhandled type ${await stage.type()}`];
+            }
+          }
+        }
+        case "110":
+        case "111": {
+          switch (`${await stage.type()}-${await commit3.type()}`) {
+            case "tree-tree": {
+              return;
+            }
+            case "blob-blob": {
+              if (
+                // @ts-ignore
+                await stage.oid() === await commit3.oid() && // @ts-ignore
+                await stage.mode() === await commit3.mode() && !force
+              ) {
+                return;
+              }
+              if (workdir) {
+                if (
+                  // @ts-ignore
+                  await workdir.oid() !== await stage.oid() && // @ts-ignore
+                  await workdir.oid() !== await commit3.oid()
+                ) {
+                  if (force) {
+                    return [
+                      "update",
+                      fullpath,
+                      // @ts-ignore
+                      await commit3.oid(),
+                      // @ts-ignore
+                      await commit3.mode(),
+                      // @ts-ignore
+                      await commit3.mode() !== await workdir.mode()
+                    ];
+                  } else {
+                    return ["conflict", fullpath];
+                  }
+                }
+              } else if (force) {
+                return [
+                  "update",
+                  fullpath,
+                  // @ts-ignore
+                  await commit3.oid(),
+                  // @ts-ignore
+                  await commit3.mode(),
+                  // @ts-ignore
+                  await commit3.mode() !== await stage.mode()
+                ];
+              }
+              if (await commit3.mode() !== await stage.mode()) {
+                return ["update", fullpath, await commit3.oid(), await commit3.mode(), true];
+              }
+              if (await commit3.oid() !== await stage.oid()) {
+                return ["update", fullpath, await commit3.oid(), await commit3.mode(), false];
+              } else {
+                return;
+              }
+            }
+            case "tree-blob": {
+              return ["update-dir-to-blob", fullpath, await commit3.oid()];
+            }
+            case "blob-tree": {
+              return ["update-blob-to-tree", fullpath];
+            }
+            case "commit-commit": {
+              return ["mkdir-index", fullpath, await commit3.oid(), await commit3.mode()];
+            }
+            default: {
+              return [
+                "error",
+                // @ts-ignore
+                `update entry Unhandled type ${await stage.type()}-${await commit3.type()}`
+              ];
+            }
+          }
+        }
+      }
+    },
+    // Modify the default flat mapping
+    reduce: async function(parent, children3) {
+      children3 = flat(children3);
+      if (!parent) {
+        return children3;
+      } else if (parent && parent[0] === "rmdir") {
+        children3.push(parent);
+        return children3;
+      } else {
+        children3.unshift(parent);
+        return children3;
+      }
+    }
+  });
+}
+
+// ../../../../lix/packages/client/dist/git/checkout.js
+async function checkout2({ fs: fs3, onProgress, dir, gitdir = join(dir, ".git"), remote = "origin", ref: _ref, filepaths, noCheckout = false, noUpdateHead = _ref === void 0, dryRun = false, force = false, track = true, cache = {} }) {
+  try {
+    assertParameter("fs", fs3);
+    assertParameter("dir", dir);
+    assertParameter("gitdir", gitdir);
+    const ref = _ref || "HEAD";
+    return await _checkout2({
+      fs: new FileSystem(fs3),
+      cache,
+      onProgress,
+      dir,
+      gitdir,
+      remote,
+      ref,
+      filepaths,
+      noCheckout,
+      noUpdateHead,
+      dryRun,
+      force,
+      track
+    });
+  } catch (err) {
+    err.caller = "git.checkout";
+    throw err;
+  }
+}
+
+// ../../../../lix/packages/client/dist/openRepository.js
+var checkout3 = checkout2;
 var whitelistedExperimentalRepos = [
   "inlang/example",
   "inlang/ci-test-repo",
@@ -50071,7 +50876,7 @@ async function openRepository(url, args) {
       freshClone = true;
     }
   }
-  const { protocol, lixHost, repoHost, owner, repoName, username, password } = parseLixUri(url);
+  const { protocol, lixHost, repoHost, owner, repoName, username, password, namespace } = parseLixUri(url);
   if (debug2 && (username || password)) {
     console.warn("username and password and providers other than github are not supported yet. Only local commands will work.");
   }
@@ -50079,8 +50884,12 @@ async function openRepository(url, args) {
   const experimentalFeatures = args.experimentalFeatures || (isWhitelistedRepo ? { lazyClone: true, lixCommit: true } : {});
   const lazyFS = typeof experimentalFeatures.lazyClone === "undefined" ? freshClone : experimentalFeatures.lazyClone;
   const cache = lazyFS ? {} : void 0;
-  const gitProxyUrl = lixHost ? `${protocol}//${lixHost}/git-proxy` : "";
-  const gitHubProxyUrl = lixHost ? `${protocol}//${lixHost}/github-proxy` : "";
+  let gitProxyUrl;
+  let gitHubProxyUrl;
+  if (namespace === "git") {
+    gitProxyUrl = lixHost ? `${protocol}//${lixHost}/git-proxy` : "";
+    gitHubProxyUrl = lixHost ? `${protocol}//${lixHost}/github-proxy` : "";
+  }
   debug2 && console.info({
     gitProxyUrl,
     gitHubProxyUrl,
@@ -50107,8 +50916,8 @@ async function openRepository(url, args) {
     }
   });
   const gitUrl = repoName ? `https://${repoHost}/${owner}/${repoName}` : "";
-  if (!gitUrl) {
-    console.warn("valid repo url / local repo not found, only limited features will be available.");
+  if (!gitUrl && debug2) {
+    console.warn("valid repo url / local repo not found, only fs features available outside of repo");
   }
   const expFeatures = Object.entries(experimentalFeatures).filter(([_, value]) => value).map(([key]) => key);
   if (expFeatures.length) {
@@ -50132,7 +50941,7 @@ async function openRepository(url, args) {
     })) {
       await rawFs.rm(placeholder);
     }
-    const res = await isomorphic_git_default.checkout({
+    const res = await checkout3({
       fs: withProxy({
         nodeishFs: rawFs,
         verbose: debug2,
@@ -50160,7 +50969,7 @@ async function openRepository(url, args) {
     if (!experimentalFeatures.lazyClone) {
       return;
     }
-    await isomorphic_git_default.checkout({
+    await checkout3({
       fs: withProxy({
         nodeishFs: rawFs,
         verbose: debug2,
@@ -50212,7 +51021,7 @@ async function openRepository(url, args) {
       }
     });
     if (gitignoreFiles.length) {
-      await isomorphic_git_default.checkout({
+      await checkout3({
         fs: withProxy({
           nodeishFs: rawFs,
           verbose: debug2,
@@ -50438,7 +51247,7 @@ async function openRepository(url, args) {
       if (lazyFS) {
         throw new Error("not implemented for lazy lix mode yet, use openRepo with different branch instead");
       }
-      await isomorphic_git_default.checkout({
+      await checkout3({
         fs: withProxy({
           nodeishFs: rawFs,
           verbose: debug2,
@@ -50452,6 +51261,9 @@ async function openRepository(url, args) {
     status: status2,
     statusList: statusList2,
     async forkStatus() {
+      if (!gitUrl) {
+        throw new Error("Could not find repo url, only github supported for forkStatus at the moment");
+      }
       const repo = await this;
       const { isFork, parent } = await repo.getMeta();
       if (!isFork) {
@@ -50590,6 +51402,9 @@ async function openRepository(url, args) {
       }
     },
     push() {
+      if (!gitUrl) {
+        throw new Error("Could not find repo url, only github supported for push at the moment");
+      }
       return isomorphic_git_default.push({
         fs: withProxy({
           nodeishFs: rawFs,
@@ -50605,6 +51420,9 @@ async function openRepository(url, args) {
       });
     },
     async pull(cmdArgs) {
+      if (!gitUrl) {
+        throw new Error("Could not find repo url, only github supported for pull at the moment");
+      }
       const pullFs = withProxy({
         nodeishFs: rawFs,
         verbose: debug2,
@@ -50648,7 +51466,7 @@ async function openRepository(url, args) {
         await emptyWorkdir();
         experimentalFeatures.lazyClone = false;
         console.info('checking out "HEAD" after pull');
-        await isomorphic_git_default.checkout({
+        await checkout3({
           fs: rawFs,
           cache,
           dir,
@@ -50656,7 +51474,7 @@ async function openRepository(url, args) {
           noCheckout: false
         });
       } else {
-        await isomorphic_git_default.checkout({
+        await checkout3({
           fs: rawFs,
           cache,
           dir,
@@ -50683,6 +51501,9 @@ async function openRepository(url, args) {
       });
     },
     async mergeUpstream(cmdArgs) {
+      if (!gitUrl) {
+        throw new Error("Could not find repo url, only github supported for mergeUpstream at the moment");
+      }
       const branch2 = (cmdArgs == null ? void 0 : cmdArgs.branch) || await isomorphic_git_default.currentBranch({
         fs: withProxy({
           nodeishFs: rawFs,
@@ -50744,6 +51565,9 @@ async function openRepository(url, args) {
       }) || void 0;
     },
     async getBranches() {
+      if (!gitUrl) {
+        throw new Error("Could not find repo url, only github supported for getBranches at the moment");
+      }
       const serverRefs = await isomorphic_git_default.listServerRefs({
         url: gitUrl,
         corsProxy: gitProxyUrl,
@@ -50818,6 +51642,9 @@ async function openRepository(url, args) {
      */
     async getMeta() {
       var _a2, _b, _c;
+      if (!gitUrl) {
+        throw new Error("Could not find repo url, only github supported for getMeta at the moment");
+      }
       const res = await github.request("GET /repos/{owner}/{repo}", {
         owner,
         repo: repoName
@@ -50852,10 +51679,10 @@ async function openRepository(url, args) {
   };
 }
 
-// ../../../../lix/source-code/client/dist/index.js
+// ../../../../lix/packages/client/dist/index.js
 init_dist();
 
-// ../../../../lix/source-code/client/dist/hash.js
+// ../../../../lix/packages/client/dist/hash.js
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 async function hash(inputStr) {
   var _a;
@@ -50873,7 +51700,7 @@ async function hash(inputStr) {
   return [...new Uint8Array(idDigest)].map((b) => ("00" + b.toString(16)).slice(-2)).join("");
 }
 
-// ../../../../lix/source-code/client/dist/mockRepo.js
+// ../../../../lix/packages/client/dist/mockRepo.js
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 init_dist();
 
@@ -56024,7 +56851,7 @@ export function isAvailableLanguageTag(thing) {
   };
 };
 
-// src/cli/commands/compile.ts
+// src/cli/commands/compile/command.ts
 import nodeFsPromises from "node:fs/promises";
 import { resolve } from "node:path";
 import { Command } from "commander";
@@ -56127,7 +56954,7 @@ var Logger = class {
   }
 };
 
-// src/cli/commands/compile.ts
+// src/cli/commands/compile/command.ts
 var compileCommand = new Command().name("compile").summary("Compiles inlang Paraglide-JS.").requiredOption("--project <path>", 'The path to the inlang project. Example: "./project.inlang"').requiredOption(
   "--outdir <path>",
   'The path to the output directory. Example: "./src/paraglide"',
@@ -56193,31 +57020,13 @@ var exitIfErrors = (project, logger) => {
   return project;
 };
 
-// src/cli/commands/init.ts
+// src/cli/commands/init/command.ts
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 import { Command as Command2 } from "commander";
 import consola2 from "consola";
-import { resolve as resolve2 } from "node:path";
-import { detectJsonFormatting } from "@inlang/detect-json-formatting";
-import JSON5 from "json5";
-import childProcess from "node:child_process";
-
-// src/cli/state.ts
-init_define_ENV_DEFINED_IN_BUILD_STEP();
-import path3 from "node:path";
-import fs2 from "node:fs";
-import { fileURLToPath } from "node:url";
-var version2 = (() => {
-  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(fs2.readFileSync(`${paraglideDirectory}/package.json`, "utf-8")).version;
-})();
-
-// src/cli/commands/init.ts
 import dedent2 from "dedent";
+import * as nodePath from "node:path";
+import JSON5 from "json5";
 import nodeFsPromises2 from "node:fs/promises";
 
 // ../../cross-sell/cross-sell-sherlock/dist/index.js
@@ -56304,13 +57113,79 @@ async function add2(args) {
   await addRecommendationToWorkspace(args.fs, args.workingDirectory);
 }
 
-// src/cli/commands/init.ts
+// src/cli/commands/init/command.ts
+import { detectJsonFormatting } from "@inlang/detect-json-formatting";
+
+// src/cli/state.ts
+init_define_ENV_DEFINED_IN_BUILD_STEP();
+import path3 from "node:path";
+import fs2 from "node:fs";
+import { fileURLToPath } from "node:url";
+var version2 = (() => {
+  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(fs2.readFileSync(`${paraglideDirectory}/package.json`, "utf-8")).version;
+})();
+
+// src/cli/commands/init/utils.ts
+init_define_ENV_DEFINED_IN_BUILD_STEP();
+import childProcess from "node:child_process";
+function execAsync(command) {
+  return new Promise((resolve3, reject) => {
+    childProcess.exec(command, (error, stdout) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve3(stdout);
+      }
+    });
+  });
+}
+
+// src/cli/commands/init/defaults.ts
+init_define_ENV_DEFINED_IN_BUILD_STEP();
+var newProjectTemplate = {
+  $schema: "https://inlang.com/schema/project-settings",
+  sourceLanguageTag: "en",
+  languageTags: ["en"],
+  modules: [
+    // for instant gratification, we're adding common rules
+    "https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-empty-pattern@latest/dist/index.js",
+    "https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-missing-translation@latest/dist/index.js",
+    "https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-without-source@latest/dist/index.js",
+    "https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-valid-js-identifier@latest/dist/index.js",
+    // default to the message format plugin because it supports all features
+    "https://cdn.jsdelivr.net/npm/@inlang/plugin-message-format@latest/dist/index.js",
+    // the m function matcher should be installed by default in case Sherlock (VS Code extension) is adopted
+    "https://cdn.jsdelivr.net/npm/@inlang/plugin-m-function-matcher@latest/dist/index.js"
+  ],
+  "plugin.inlang.messageFormat": {
+    pathPattern: "./messages/{languageTag}.json"
+  }
+};
+function getNewProjectTemplate() {
+  if (!("structuredClone" in globalThis)) {
+    try {
+      return JSON.parse(JSON.stringify(newProjectTemplate));
+    } catch {
+      throw new Error(
+        "structuredClone is not supported in your Node Version. Please use version 17 or higher"
+      );
+    }
+  }
+  return structuredClone(newProjectTemplate);
+}
 var DEFAULT_PROJECT_PATH = "./project.inlang";
+
+// src/cli/commands/init/command.ts
 var ADAPTER_LINKS = {
-  sveltekit: "https://inlang.com/m/dxnzrydw/library-inlang-paraglideJsAdapterSvelteKit",
-  nextjs: "https://inlang.com/m/osslbuzt/library-inlang-paraglideJsAdapterNextJs",
-  astro: "https://inlang.com/m/iljlwzfs/library-inlang-paraglideJsAdapterAstro",
-  solidstart: "https://inlang.com/m/n860p17j/library-inlang-paraglideJsAdapterSolidStart",
+  sveltekit: "https://inlang.com/m/dxnzrydw/paraglide-sveltekit-i18n",
+  nextjs: "https://inlang.com/m/osslbuzt/paraglide-next-i18n",
+  astro: "https://inlang.com/m/iljlwzfs/paraglide-astro-i18n",
+  solidstart: "https://inlang.com/m/n860p17j/paraglide-solidstart-i18n",
   vite: "https://github.com/opral/monorepo/tree/main/inlang/source-code/paraglide/paraglide-js-adapter-vite"
 };
 var initCommand = new Command2().name("init").summary("Initializes inlang Paraglide-JS.").action(async () => {
@@ -56318,7 +57193,7 @@ var initCommand = new Command2().name("init").summary("Initializes inlang Paragl
     nodeishFs: nodeFsPromises2,
     path: process.cwd()
   });
-  const repo = await openRepository(repoRoot ?? process.cwd(), {
+  const repo = await openRepository(repoRoot ?? "file://" + process.cwd(), {
     nodeishFs: nodeFsPromises2
   });
   const ctx = {
@@ -56339,7 +57214,7 @@ var initCommand = new Command2().name("init").summary("Initializes inlang Paragl
   await maybeChangeTsConfigAllowJs(ctx);
   await maybeAddVsCodeExtension({ projectPath }, ctx);
   telemetry.capture({ event: "PARAGLIDE-JS init finished" });
-  const absoluteSettingsPath = resolve2(projectPath, "settings.json");
+  const absoluteSettingsPath = nodePath.resolve(projectPath, "settings.json");
   const relativeSettingsFilePath = absoluteSettingsPath.replace(process.cwd(), ".");
   let successMessage = dedent2`inlang Paraglide-JS has been set up sucessfully.
 			
@@ -56391,7 +57266,7 @@ var maybeAddVsCodeExtension = async (args, ctx) => {
   if (response === false)
     return;
   const project = await loadProject({
-    projectPath: resolve2(process.cwd(), args.projectPath),
+    projectPath: nodePath.resolve(process.cwd(), args.projectPath),
     repo: ctx.repo
   });
   const settings = project.settings();
@@ -56457,7 +57332,7 @@ var existingProjectFlow = async (args, ctx) => {
     return createNewProjectFlow(ctx);
   }
   const project = await loadProject({
-    projectPath: resolve2(process.cwd(), args.existingProjectPath),
+    projectPath: nodePath.resolve(process.cwd(), args.existingProjectPath),
     repo: ctx.repo
   });
   if (project.errors().length > 0) {
@@ -56468,15 +57343,69 @@ var existingProjectFlow = async (args, ctx) => {
     process.exit(1);
   }
 };
+function parseLanguageTagInput(input) {
+  const languageTags = input.replaceAll(/[,:\s]/g, " ").split(" ").filter(Boolean).map((tag2) => tag2.toLowerCase());
+  const validLanguageTags = [];
+  const invalidLanguageTags = [];
+  for (const tag2 of languageTags) {
+    if (isValidLanguageTag(tag2)) {
+      validLanguageTags.push(tag2);
+    } else {
+      invalidLanguageTags.push(tag2);
+    }
+  }
+  return {
+    validLanguageTags,
+    invalidLanguageTags
+  };
+}
+async function promptForLanguageTags(initialLanguageTags = []) {
+  const languageTagsInput = await prompt("Which languages do you want to support?", {
+    type: "text",
+    placeholder: "en, de-ch, ar",
+    initial: initialLanguageTags.length ? initialLanguageTags.join(", ") : void 0
+  }) ?? "";
+  const { invalidLanguageTags, validLanguageTags } = parseLanguageTagInput(languageTagsInput);
+  if (validLanguageTags.length === 0) {
+    consola2.warn("You must specify at least one language tag");
+    return await promptForLanguageTags();
+  }
+  if (invalidLanguageTags.length > 0) {
+    const message = invalidLanguageTags.length === 1 ? invalidLanguageTags[0] + " isn't a valid language tag. Please stick to IEEE BCP-47 Language Tags" : invalidLanguageTags.map((tag2) => `"${tag2}"`).join(", ") + " aren't valid language tags. Please stick to IEEE BCP-47 Language Tags";
+    consola2.warn(message);
+    return await promptForLanguageTags(validLanguageTags);
+  }
+  return validLanguageTags;
+}
 var createNewProjectFlow = async (ctx) => {
+  const languageTags = await promptForLanguageTags();
+  const settings = getNewProjectTemplate();
+  const sourceLanguageTag = languageTags.at(0);
+  if (!sourceLanguageTag)
+    throw new Error("sourceLanguageTag is not defined");
+  settings.languageTags = languageTags;
+  settings.sourceLanguageTag = sourceLanguageTag;
+  const messagePath = settings["plugin.inlang.messageFormat"].pathPattern;
+  const messageDir = nodePath.dirname(nodePath.resolve(process.cwd(), messagePath));
+  ctx.repo.nodeishFs.mkdir(messageDir, { recursive: true });
+  for (const languageTag of languageTags) {
+    const languageFile = nodePath.resolve(messageDir, languageTag + ".json");
+    ctx.repo.nodeishFs.writeFile(
+      languageFile,
+      dedent2`
+			{
+				"$schema": "https://inlang.com/schema/inlang-message-format"
+			}`
+    );
+  }
   ctx.logger.info(`Creating a new inlang project in the current working directory.`);
   await ctx.repo.nodeishFs.mkdir(DEFAULT_PROJECT_PATH, { recursive: true });
   await ctx.repo.nodeishFs.writeFile(
     DEFAULT_PROJECT_PATH + "/settings.json",
-    JSON.stringify(newProjectTemplate, void 0, 2)
+    JSON.stringify(settings, void 0, 2)
   );
   const project = await loadProject({
-    projectPath: resolve2(process.cwd(), DEFAULT_PROJECT_PATH),
+    projectPath: nodePath.resolve(process.cwd(), DEFAULT_PROJECT_PATH),
     repo: ctx.repo
   });
   if (project.errors().length > 0) {
@@ -56491,30 +57420,6 @@ var createNewProjectFlow = async (ctx) => {
     ctx.logger.success("Successfully created a new inlang project.");
   }
 };
-var newProjectTemplate = {
-  $schema: "https://inlang.com/schema/project-settings",
-  // defaulting to english to not overwhelm new users
-  // with prompts. The user can change this later.
-  sourceLanguageTag: "en",
-  languageTags: ["en"],
-  modules: [
-    // for instant gratification, we're adding common rules
-    "https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-empty-pattern@latest/dist/index.js",
-    "https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-identical-pattern@latest/dist/index.js",
-    "https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-missing-translation@latest/dist/index.js",
-    "https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-without-source@latest/dist/index.js",
-    "https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-valid-js-identifier@latest/dist/index.js",
-    // default to the message format plugin because it supports all features
-    "https://cdn.jsdelivr.net/npm/@inlang/plugin-message-format@latest/dist/index.js",
-    // the m function matcher should be installed by default in case Sherlock (VS Code extension) is adopted
-    "https://cdn.jsdelivr.net/npm/@inlang/plugin-m-function-matcher@latest/dist/index.js"
-  ],
-  "plugin.inlang.messageFormat": {
-    // using .inlang/paraglide-js as directory to avoid future conflicts when an official .inlang
-    // directory is introduced, see https://github.com/opral/monorepo/discussions/1418
-    pathPattern: "./messages/{languageTag}.json"
-  }
-};
 var checkIfPackageJsonExists = async (ctx) => {
   const packageJsonPath = await findPackageJson(ctx.repo.nodeishFs, process.cwd());
   if (!packageJsonPath) {
@@ -56600,7 +57505,7 @@ var maybeChangeTsConfigModuleResolution = async (ctx) => {
   let parentTsConfig;
   if (tsconfig.extends) {
     try {
-      const parentTsConfigPath = resolve2(process.cwd(), tsconfig.extends);
+      const parentTsConfigPath = nodePath.resolve(process.cwd(), tsconfig.extends);
       const parentTsConfigFile = await ctx.repo.nodeishFs.readFile(parentTsConfigPath, {
         encoding: "utf-8"
       });
@@ -56719,17 +57624,6 @@ var prompt = async (message, options) => {
   }
   return response;
 };
-function execAsync(command) {
-  return new Promise((resolve3, reject) => {
-    childProcess.exec(command, (error, stdout) => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve3(stdout);
-      }
-    });
-  });
-}
 
 // src/cli/main.ts
 var cli = new Command3().name("paraglide-js").addCommand(compileCommand).addCommand(initCommand).showHelpAfterError().version(version2);