@vinihcrosa/lumem-os 0.1.0 → 0.2.0

package/bin/lumem.mjs

@@ -371,104 +371,104 @@ ZodError.create = (issues) => {
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/locales/en.js
 var errorMap = (issue, _ctx) => {
-  let message;
+  let message2;
   switch (issue.code) {
     case ZodIssueCode.invalid_type:
       if (issue.received === ZodParsedType.undefined) {
-        message = "Required";
+        message2 = "Required";
       } else {
-        message = `Expected ${issue.expected}, received ${issue.received}`;
+        message2 = `Expected ${issue.expected}, received ${issue.received}`;
       }
       break;
     case ZodIssueCode.invalid_literal:
-      message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
+      message2 = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
       break;
     case ZodIssueCode.unrecognized_keys:
-      message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
+      message2 = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
       break;
     case ZodIssueCode.invalid_union:
-      message = `Invalid input`;
+      message2 = `Invalid input`;
       break;
     case ZodIssueCode.invalid_union_discriminator:
-      message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
+      message2 = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
       break;
     case ZodIssueCode.invalid_enum_value:
-      message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
+      message2 = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
       break;
     case ZodIssueCode.invalid_arguments:
-      message = `Invalid function arguments`;
+      message2 = `Invalid function arguments`;
       break;
     case ZodIssueCode.invalid_return_type:
-      message = `Invalid function return type`;
+      message2 = `Invalid function return type`;
       break;
     case ZodIssueCode.invalid_date:
-      message = `Invalid date`;
+      message2 = `Invalid date`;
       break;
     case ZodIssueCode.invalid_string:
       if (typeof issue.validation === "object") {
         if ("includes" in issue.validation) {
-          message = `Invalid input: must include "${issue.validation.includes}"`;
+          message2 = `Invalid input: must include "${issue.validation.includes}"`;
           if (typeof issue.validation.position === "number") {
-            message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
+            message2 = `${message2} at one or more positions greater than or equal to ${issue.validation.position}`;
           }
         } else if ("startsWith" in issue.validation) {
-          message = `Invalid input: must start with "${issue.validation.startsWith}"`;
+          message2 = `Invalid input: must start with "${issue.validation.startsWith}"`;
         } else if ("endsWith" in issue.validation) {
-          message = `Invalid input: must end with "${issue.validation.endsWith}"`;
+          message2 = `Invalid input: must end with "${issue.validation.endsWith}"`;
         } else {
           util.assertNever(issue.validation);
         }
       } else if (issue.validation !== "regex") {
-        message = `Invalid ${issue.validation}`;
+        message2 = `Invalid ${issue.validation}`;
       } else {
-        message = "Invalid";
+        message2 = "Invalid";
       }
       break;
     case ZodIssueCode.too_small:
       if (issue.type === "array")
-        message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
+        message2 = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
       else if (issue.type === "string")
-        message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
+        message2 = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
       else if (issue.type === "number")
-        message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
+        message2 = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
       else if (issue.type === "bigint")
-        message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
+        message2 = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
       else if (issue.type === "date")
-        message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;
+        message2 = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;
       else
-        message = "Invalid input";
+        message2 = "Invalid input";
       break;
     case ZodIssueCode.too_big:
       if (issue.type === "array")
-        message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
+        message2 = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
       else if (issue.type === "string")
-        message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
+        message2 = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
       else if (issue.type === "number")
-        message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
+        message2 = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
       else if (issue.type === "bigint")
-        message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
+        message2 = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
       else if (issue.type === "date")
-        message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;
+        message2 = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;
       else
-        message = "Invalid input";
+        message2 = "Invalid input";
       break;
     case ZodIssueCode.custom:
-      message = `Invalid input`;
+      message2 = `Invalid input`;
       break;
     case ZodIssueCode.invalid_intersection_types:
-      message = `Intersection results could not be merged`;
+      message2 = `Intersection results could not be merged`;
       break;
     case ZodIssueCode.not_multiple_of:
-      message = `Number must be a multiple of ${issue.multipleOf}`;
+      message2 = `Number must be a multiple of ${issue.multipleOf}`;
       break;
     case ZodIssueCode.not_finite:
-      message = "Number must be finite";
+      message2 = "Number must be finite";
       break;
     default:
-      message = _ctx.defaultError;
+      message2 = _ctx.defaultError;
       util.assertNever(issue);
   }
-  return { message };
+  return { message: message2 };
 };
 var en_default = errorMap;
 
@@ -594,8 +594,8 @@ var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/errorUtil.js
 var errorUtil;
 (function(errorUtil2) {
-  errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
-  errorUtil2.toString = (message) => typeof message === "string" ? message : message?.message;
+  errorUtil2.errToObj = (message2) => typeof message2 === "string" ? { message: message2 } : message2 || {};
+  errorUtil2.toString = (message2) => typeof message2 === "string" ? message2 : message2?.message;
 })(errorUtil || (errorUtil = {}));
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
@@ -647,16 +647,16 @@ function processCreateParams(params) {
   if (errorMap2)
     return { errorMap: errorMap2, description };
   const customMap = (iss, ctx) => {
-    const { message } = params;
+    const { message: message2 } = params;
     if (iss.code === "invalid_enum_value") {
-      return { message: message ?? ctx.defaultError };
+      return { message: message2 ?? ctx.defaultError };
     }
     if (typeof ctx.data === "undefined") {
-      return { message: message ?? required_error ?? ctx.defaultError };
+      return { message: message2 ?? required_error ?? ctx.defaultError };
     }
     if (iss.code !== "invalid_type")
       return { message: ctx.defaultError };
-    return { message: message ?? invalid_type_error ?? ctx.defaultError };
+    return { message: message2 ?? invalid_type_error ?? ctx.defaultError };
   };
   return { errorMap: customMap, description };
 }
@@ -782,14 +782,14 @@ var ZodType = class {
     const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
     return handleResult(ctx, result);
   }
-  refine(check, message) {
+  refine(check, message2) {
     const getIssueProperties = (val) => {
-      if (typeof message === "string" || typeof message === "undefined") {
-        return { message };
-      } else if (typeof message === "function") {
-        return message(val);
+      if (typeof message2 === "string" || typeof message2 === "undefined") {
+        return { message: message2 };
+      } else if (typeof message2 === "function") {
+        return message2(val);
       } else {
-        return message;
+        return message2;
       }
     };
     return this._refinement((val, ctx) => {
@@ -1325,11 +1325,11 @@ var ZodString = class _ZodString extends ZodType {
     }
     return { status: status.value, value: input.data };
   }
-  _regex(regex, validation, message) {
+  _regex(regex, validation, message2) {
     return this.refinement((data) => regex.test(data), {
       validation,
       code: ZodIssueCode.invalid_string,
-      ...errorUtil.errToObj(message)
+      ...errorUtil.errToObj(message2)
     });
   }
   _addCheck(check) {
@@ -1338,37 +1338,37 @@ var ZodString = class _ZodString extends ZodType {
       checks: [...this._def.checks, check]
     });
   }
-  email(message) {
-    return this._addCheck({ kind: "email", ...errorUtil.errToObj(message) });
+  email(message2) {
+    return this._addCheck({ kind: "email", ...errorUtil.errToObj(message2) });
   }
-  url(message) {
-    return this._addCheck({ kind: "url", ...errorUtil.errToObj(message) });
+  url(message2) {
+    return this._addCheck({ kind: "url", ...errorUtil.errToObj(message2) });
   }
-  emoji(message) {
-    return this._addCheck({ kind: "emoji", ...errorUtil.errToObj(message) });
+  emoji(message2) {
+    return this._addCheck({ kind: "emoji", ...errorUtil.errToObj(message2) });
   }
-  uuid(message) {
-    return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message) });
+  uuid(message2) {
+    return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message2) });
   }
-  nanoid(message) {
-    return this._addCheck({ kind: "nanoid", ...errorUtil.errToObj(message) });
+  nanoid(message2) {
+    return this._addCheck({ kind: "nanoid", ...errorUtil.errToObj(message2) });
   }
-  cuid(message) {
-    return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) });
+  cuid(message2) {
+    return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message2) });
   }
-  cuid2(message) {
-    return this._addCheck({ kind: "cuid2", ...errorUtil.errToObj(message) });
+  cuid2(message2) {
+    return this._addCheck({ kind: "cuid2", ...errorUtil.errToObj(message2) });
   }
-  ulid(message) {
-    return this._addCheck({ kind: "ulid", ...errorUtil.errToObj(message) });
+  ulid(message2) {
+    return this._addCheck({ kind: "ulid", ...errorUtil.errToObj(message2) });
   }
-  base64(message) {
-    return this._addCheck({ kind: "base64", ...errorUtil.errToObj(message) });
+  base64(message2) {
+    return this._addCheck({ kind: "base64", ...errorUtil.errToObj(message2) });
   }
-  base64url(message) {
+  base64url(message2) {
     return this._addCheck({
       kind: "base64url",
-      ...errorUtil.errToObj(message)
+      ...errorUtil.errToObj(message2)
     });
   }
   jwt(options) {
@@ -1398,8 +1398,8 @@ var ZodString = class _ZodString extends ZodType {
       ...errorUtil.errToObj(options?.message)
     });
   }
-  date(message) {
-    return this._addCheck({ kind: "date", message });
+  date(message2) {
+    return this._addCheck({ kind: "date", message: message2 });
   }
   time(options) {
     if (typeof options === "string") {
@@ -1415,14 +1415,14 @@ var ZodString = class _ZodString extends ZodType {
       ...errorUtil.errToObj(options?.message)
     });
   }
-  duration(message) {
-    return this._addCheck({ kind: "duration", ...errorUtil.errToObj(message) });
+  duration(message2) {
+    return this._addCheck({ kind: "duration", ...errorUtil.errToObj(message2) });
   }
-  regex(regex, message) {
+  regex(regex, message2) {
     return this._addCheck({
       kind: "regex",
       regex,
-      ...errorUtil.errToObj(message)
+      ...errorUtil.errToObj(message2)
     });
   }
   includes(value, options) {
@@ -1433,46 +1433,46 @@ var ZodString = class _ZodString extends ZodType {
       ...errorUtil.errToObj(options?.message)
     });
   }
-  startsWith(value, message) {
+  startsWith(value, message2) {
     return this._addCheck({
       kind: "startsWith",
       value,
-      ...errorUtil.errToObj(message)
+      ...errorUtil.errToObj(message2)
     });
   }
-  endsWith(value, message) {
+  endsWith(value, message2) {
     return this._addCheck({
       kind: "endsWith",
       value,
-      ...errorUtil.errToObj(message)
+      ...errorUtil.errToObj(message2)
     });
   }
-  min(minLength, message) {
+  min(minLength, message2) {
     return this._addCheck({
       kind: "min",
       value: minLength,
-      ...errorUtil.errToObj(message)
+      ...errorUtil.errToObj(message2)
     });
   }
-  max(maxLength, message) {
+  max(maxLength, message2) {
     return this._addCheck({
       kind: "max",
       value: maxLength,
-      ...errorUtil.errToObj(message)
+      ...errorUtil.errToObj(message2)
     });
   }
-  length(len, message) {
+  length(len, message2) {
     return this._addCheck({
       kind: "length",
       value: len,
-      ...errorUtil.errToObj(message)
+      ...errorUtil.errToObj(message2)
     });
   }
   /**
    * Equivalent to `.min(1)`
    */
-  nonempty(message) {
-    return this.min(1, errorUtil.errToObj(message));
+  nonempty(message2) {
+    return this.min(1, errorUtil.errToObj(message2));
   }
   trim() {
     return new _ZodString({
@@ -1665,19 +1665,19 @@ var ZodNumber = class _ZodNumber extends ZodType {
     }
     return { status: status.value, value: input.data };
   }
-  gte(value, message) {
-    return this.setLimit("min", value, true, errorUtil.toString(message));
+  gte(value, message2) {
+    return this.setLimit("min", value, true, errorUtil.toString(message2));
   }
-  gt(value, message) {
-    return this.setLimit("min", value, false, errorUtil.toString(message));
+  gt(value, message2) {
+    return this.setLimit("min", value, false, errorUtil.toString(message2));
   }
-  lte(value, message) {
-    return this.setLimit("max", value, true, errorUtil.toString(message));
+  lte(value, message2) {
+    return this.setLimit("max", value, true, errorUtil.toString(message2));
   }
-  lt(value, message) {
-    return this.setLimit("max", value, false, errorUtil.toString(message));
+  lt(value, message2) {
+    return this.setLimit("max", value, false, errorUtil.toString(message2));
   }
-  setLimit(kind, value, inclusive, message) {
+  setLimit(kind, value, inclusive, message2) {
     return new _ZodNumber({
       ...this._def,
       checks: [
@@ -1686,7 +1686,7 @@ var ZodNumber = class _ZodNumber extends ZodType {
           kind,
           value,
           inclusive,
-          message: errorUtil.toString(message)
+          message: errorUtil.toString(message2)
         }
       ]
     });
@@ -1697,68 +1697,68 @@ var ZodNumber = class _ZodNumber extends ZodType {
       checks: [...this._def.checks, check]
     });
   }
-  int(message) {
+  int(message2) {
     return this._addCheck({
       kind: "int",
-      message: errorUtil.toString(message)
+      message: errorUtil.toString(message2)
     });
   }
-  positive(message) {
+  positive(message2) {
     return this._addCheck({
       kind: "min",
       value: 0,
       inclusive: false,
-      message: errorUtil.toString(message)
+      message: errorUtil.toString(message2)
     });
   }
-  negative(message) {
+  negative(message2) {
     return this._addCheck({
       kind: "max",
       value: 0,
       inclusive: false,
-      message: errorUtil.toString(message)
+      message: errorUtil.toString(message2)
     });
   }
-  nonpositive(message) {
+  nonpositive(message2) {
     return this._addCheck({
       kind: "max",
       value: 0,
       inclusive: true,
-      message: errorUtil.toString(message)
+      message: errorUtil.toString(message2)
     });
   }
-  nonnegative(message) {
+  nonnegative(message2) {
     return this._addCheck({
       kind: "min",
       value: 0,
       inclusive: true,
-      message: errorUtil.toString(message)
+      message: errorUtil.toString(message2)
     });
   }
-  multipleOf(value, message) {
+  multipleOf(value, message2) {
     return this._addCheck({
       kind: "multipleOf",
       value,
-      message: errorUtil.toString(message)
+      message: errorUtil.toString(message2)
     });
   }
-  finite(message) {
+  finite(message2) {
     return this._addCheck({
       kind: "finite",
-      message: errorUtil.toString(message)
+      message: errorUtil.toString(message2)
     });
   }
-  safe(message) {
+  safe(message2) {
     return this._addCheck({
       kind: "min",
       inclusive: true,
       value: Number.MIN_SAFE_INTEGER,
-      message: errorUtil.toString(message)
+      message: errorUtil.toString(message2)
     })._addCheck({
       kind: "max",
       inclusive: true,
       value: Number.MAX_SAFE_INTEGER,
-      message: errorUtil.toString(message)
+      message: errorUtil.toString(message2)
     });
   }
   get minValue() {
@@ -1881,19 +1881,19 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
     });
     return INVALID;
   }
-  gte(value, message) {
-    return this.setLimit("min", value, true, errorUtil.toString(message));
+  gte(value, message2) {
+    return this.setLimit("min", value, true, errorUtil.toString(message2));
   }
-  gt(value, message) {
-    return this.setLimit("min", value, false, errorUtil.toString(message));
+  gt(value, message2) {
+    return this.setLimit("min", value, false, errorUtil.toString(message2));
   }
-  lte(value, message) {
-    return this.setLimit("max", value, true, errorUtil.toString(message));
+  lte(value, message2) {
+    return this.setLimit("max", value, true, errorUtil.toString(message2));
   }
-  lt(value, message) {
-    return this.setLimit("max", value, false, errorUtil.toString(message));
+  lt(value, message2) {
+    return this.setLimit("max", value, false, errorUtil.toString(message2));
   }
-  setLimit(kind, value, inclusive, message) {
+  setLimit(kind, value, inclusive, message2) {
     return new _ZodBigInt({
       ...this._def,
       checks: [
@@ -1902,7 +1902,7 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
           kind,
           value,
           inclusive,
-          message: errorUtil.toString(message)
+          message: errorUtil.toString(message2)
         }
       ]
     });
@@ -1913,43 +1913,43 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
       checks: [...this._def.checks, check]
     });
   }
-  positive(message) {
+  positive(message2) {
     return this._addCheck({
       kind: "min",
       value: BigInt(0),
       inclusive: false,
-      message: errorUtil.toString(message)
+      message: errorUtil.toString(message2)
     });
   }
-  negative(message) {
+  negative(message2) {
     return this._addCheck({
       kind: "max",
       value: BigInt(0),
       inclusive: false,
-      message: errorUtil.toString(message)
+      message: errorUtil.toString(message2)
     });
   }
-  nonpositive(message) {
+  nonpositive(message2) {
     return this._addCheck({
       kind: "max",
       value: BigInt(0),
       inclusive: true,
-      message: errorUtil.toString(message)
+      message: errorUtil.toString(message2)
     });
   }
-  nonnegative(message) {
+  nonnegative(message2) {
     return this._addCheck({
       kind: "min",
       value: BigInt(0),
       inclusive: true,
-      message: errorUtil.toString(message)
+      message: errorUtil.toString(message2)
     });
   }
-  multipleOf(value, message) {
+  multipleOf(value, message2) {
     return this._addCheck({
       kind: "multipleOf",
       value,
-      message: errorUtil.toString(message)
+      message: errorUtil.toString(message2)
     });
   }
   get minValue() {
@@ -2072,18 +2072,18 @@ var ZodDate = class _ZodDate extends ZodType {
       checks: [...this._def.checks, check]
     });
   }
-  min(minDate, message) {
+  min(minDate, message2) {
     return this._addCheck({
       kind: "min",
       value: minDate.getTime(),
-      message: errorUtil.toString(message)
+      message: errorUtil.toString(message2)
     });
   }
-  max(maxDate, message) {
+  max(maxDate, message2) {
     return this._addCheck({
       kind: "max",
       value: maxDate.getTime(),
-      message: errorUtil.toString(message)
+      message: errorUtil.toString(message2)
     });
   }
   get minDate() {
@@ -2315,26 +2315,26 @@ var ZodArray = class _ZodArray extends ZodType {
   get element() {
     return this._def.type;
   }
-  min(minLength, message) {
+  min(minLength, message2) {
     return new _ZodArray({
       ...this._def,
-      minLength: { value: minLength, message: errorUtil.toString(message) }
+      minLength: { value: minLength, message: errorUtil.toString(message2) }
     });
   }
-  max(maxLength, message) {
+  max(maxLength, message2) {
     return new _ZodArray({
       ...this._def,
-      maxLength: { value: maxLength, message: errorUtil.toString(message) }
+      maxLength: { value: maxLength, message: errorUtil.toString(message2) }
     });
   }
-  length(len, message) {
+  length(len, message2) {
     return new _ZodArray({
       ...this._def,
-      exactLength: { value: len, message: errorUtil.toString(message) }
+      exactLength: { value: len, message: errorUtil.toString(message2) }
     });
   }
-  nonempty(message) {
-    return this.min(1, message);
+  nonempty(message2) {
+    return this.min(1, message2);
   }
 };
 ZodArray.create = (schema, params) => {
@@ -2477,17 +2477,17 @@ var ZodObject = class _ZodObject extends ZodType {
   get shape() {
     return this._def.shape();
   }
-  strict(message) {
+  strict(message2) {
     errorUtil.errToObj;
     return new _ZodObject({
       ...this._def,
       unknownKeys: "strict",
-      ...message !== void 0 ? {
+      ...message2 !== void 0 ? {
         errorMap: (issue, ctx) => {
           const defaultError = this._def.errorMap?.(issue, ctx).message ?? ctx.defaultError;
           if (issue.code === "unrecognized_keys")
             return {
-              message: errorUtil.errToObj(message).message ?? defaultError
+              message: errorUtil.errToObj(message2).message ?? defaultError
             };
           return {
             message: defaultError
@@ -3243,23 +3243,23 @@ var ZodSet = class _ZodSet extends ZodType {
       return finalizeSet(elements);
     }
   }
-  min(minSize, message) {
+  min(minSize, message2) {
     return new _ZodSet({
       ...this._def,
-      minSize: { value: minSize, message: errorUtil.toString(message) }
+      minSize: { value: minSize, message: errorUtil.toString(message2) }
     });
   }
-  max(maxSize, message) {
+  max(maxSize, message2) {
     return new _ZodSet({
       ...this._def,
-      maxSize: { value: maxSize, message: errorUtil.toString(message) }
+      maxSize: { value: maxSize, message: errorUtil.toString(message2) }
     });
   }
-  size(size, message) {
-    return this.min(size, message).max(size, message);
+  size(size, message2) {
+    return this.min(size, message2).max(size, message2);
   }
-  nonempty(message) {
-    return this.min(1, message);
+  nonempty(message2) {
+    return this.min(1, message2);
   }
 };
 ZodSet.create = (valueType, params) => {
@@ -4083,6 +4083,9 @@ var acpPermissionOptionKindSchema = external_exports.enum([
   "reject_once",
   "reject_always"
 ]);
+var lumemModeSchema = external_exports.enum(["ask", "auto", "free"]);
+var lumemModeDefaultSchema = external_exports.enum(["ask", "auto"]);
+var acpModeOwnerSchema = external_exports.enum(["agent", "lumem"]);
 var acpPermissionOptionSchema = external_exports.object({
   optionId: external_exports.string(),
   /** The agent's own label, shown verbatim (A13). */
@@ -4186,13 +4189,40 @@ var acpEventSchema = external_exports.discriminatedUnion("type", [
     title: external_exports.string(),
     command: external_exports.string().nullish(),
     cwd: external_exports.string(),
-    options: external_exports.array(acpPermissionOptionSchema).min(1)
+    options: external_exports.array(acpPermissionOptionSchema).min(1),
+    /**
+     * Why the Lumem policy did not answer this one (`session-mode`, T7).
+     *
+     * Null under `ask`, and under an agent that owns its own modes: there is
+     * nothing to explain when asking *is* the rule. Set when a policy that would
+     * normally answer did not — `auto` facing a write, or an agent that offered
+     * no way to allow (Q6) — because "why am I being asked in auto mode?" is
+     * otherwise a question the screen cannot answer.
+     */
+    policyReason: external_exports.string().nullable().default(null)
   }),
   external_exports.object({
     type: external_exports.literal("permission_resolved"),
     requestId: external_exports.string(),
     /** `"cancelled"` is the agent giving up on the ask, not the user denying. */
-    outcome: external_exports.union([external_exports.literal("cancelled"), external_exports.object({ optionId: external_exports.string() })])
+    outcome: external_exports.union([external_exports.literal("cancelled"), external_exports.object({ optionId: external_exports.string() })]),
+    /**
+     * Who signed it (F1.6).
+     *
+     * `default` and not `optional`, for two reasons that point the same way: a
+     * transcript recorded before this feature has no field and must still open,
+     * and `"user"` is the truthful answer for every one of them — nothing but a
+     * person could answer a permission request back then.
+     */
+    by: external_exports.enum(["user", "lumem"]).default("user"),
+    /**
+     * Why the policy answered, in the words the card shows.
+     *
+     * Only ever set when `by` is `"lumem"`: a person clicking a button is its
+     * own reason, and inventing prose for it would be the daemon narrating the
+     * user's intent.
+     */
+    reason: external_exports.string().nullable().default(null)
   }),
   /**
    * The plan, whole (F2.5).
@@ -4237,7 +4267,24 @@ var acpEventSchema = external_exports.discriminatedUnion("type", [
      * sending this. So the client replaces rather than merging, and there is exactly
      * one place that has to get the merge right.
      */
-    options: external_exports.array(acpConfigOptionSchema)
+    options: external_exports.array(acpConfigOptionSchema),
+    /**
+     * Which of the two authorities is in charge right now (A1).
+     *
+     * Defaults to `"agent"` so a transcript recorded before `session-mode` reads
+     * as what it was: a conversation where only the agent could offer a mode.
+     */
+    modeOwner: acpModeOwnerSchema.default("agent"),
+    /**
+     * The policy value, whoever owns the selector.
+     *
+     * Sent even while the agent owns the mode, and that is on purpose: the value
+     * is *kept*, not erased, so an agent that stops reporting modes hands the
+     * conversation back to the policy it already had (T12).
+     */
+    lumemMode: lumemModeSchema.default("ask"),
+    /** What a new session in this workspace would start at — the menu's footer (Q5). */
+    lumemModeDefault: lumemModeDefaultSchema.default("ask")
   }),
   /** What `/` offers (F2.8). An empty list means the agent offers none. */
   external_exports.object({ type: external_exports.literal("commands"), commands: external_exports.array(acpCommandSchema) }),
@@ -4335,7 +4382,17 @@ var acpClientMessageSchema = external_exports.discriminatedUnion("type", [
     type: external_exports.literal("set_config"),
     optionId: external_exports.string().min(1),
     value: external_exports.string().min(1)
-  })
+  }),
+  /**
+   * Switch the policy Lumem applies when the agent offers no modes (F1.1).
+   *
+   * A message of its own rather than a `set_config` with `optionId: "mode"`,
+   * because it is not the same act: `set_config` forwards a value to the agent
+   * and this one never leaves the daemon. Sharing the message would put two
+   * destinations behind one name, and the first bug would be a policy change
+   * quietly forwarded to an agent that does not have the option.
+   */
+  external_exports.object({ type: external_exports.literal("set_lumem_mode"), mode: lumemModeSchema })
 ]);
 var acpServerMessageSchema = external_exports.discriminatedUnion("type", [
   /**
@@ -4358,6 +4415,23 @@ var acpServerMessageSchema = external_exports.discriminatedUnion("type", [
      * broken for as long as nothing changed.
      */
     configOptions: external_exports.array(acpConfigOptionSchema).default([]),
+    /**
+     * The mode state, on attach, for the same reason `configOptions` is here: a
+     * composer whose mode pill appeared only once something changed would look
+     * broken for as long as nothing did.
+     */
+    modeOwner: acpModeOwnerSchema.default("agent"),
+    lumemMode: lumemModeSchema.default("ask"),
+    lumemModeDefault: lumemModeDefaultSchema.default("ask"),
+    /**
+     * The checkout this conversation runs in.
+     *
+     * Here because the `free` gate has to name what it is opening, and it names
+     * it as a **path on disk** rather than as "the worktree": the path is what
+     * says the size of the damage (Q4). A gate that could not say it would be
+     * asking for a decision without stating its scope.
+     */
+    cwd: external_exports.string().default(""),
     transcript: external_exports.array(acpTranscriptEntrySchema)
   }),
   external_exports.object({
@@ -4381,7 +4455,7 @@ var acpServerMessageSchema = external_exports.discriminatedUnion("type", [
 ]);
 
 // ../shared/src/constants.ts
-var LUMEM_VERSION = "0.1.0";
+var LUMEM_VERSION = "0.2.0";
 var ACP_ADAPTER_PACKAGE = "@agentclientprotocol/claude-agent-acp";
 var ACP_ADAPTER_INSTALL = `npm i -g ${ACP_ADAPTER_PACKAGE}`;
 
@@ -4431,7 +4505,7 @@ var ptyServerMessageSchema = external_exports.discriminatedUnion("type", [
 ]);
 
 // src/run.ts
-import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/args.ts
 import { parseArgs } from "node:util";
@@ -4439,6 +4513,7 @@ var HELP = `lumem \u2014 harness local de agentes de c\xF3digo
 
 Uso:
   lumem [start] [op\xE7\xF5es]     sobe o daemon e serve a interface
+  lumem upgrade [--check]    atualiza o daemon para a \xFAltima vers\xE3o do npm
   lumem version              imprime a vers\xE3o
   lumem help                 imprime esta ajuda
 
@@ -4447,6 +4522,7 @@ Op\xE7\xF5es:
       --host <endere\xE7o>      interface de escuta (padr\xE3o: 127.0.0.1)
       --state-dir <caminho>  onde o Lumem guarda tudo (padr\xE3o: ~/.lumem)
       --open                 abre o navegador quando subir
+      --check                em \`upgrade\`, s\xF3 diz se tem vers\xE3o nova
   -v, --version              o mesmo que \`lumem version\`
   -h, --help                 o mesmo que \`lumem help\`
 
@@ -4469,6 +4545,7 @@ function parseCommand(argv) {
         host: { type: "string" },
         "state-dir": { type: "string" },
         open: { type: "boolean", default: false },
+        check: { type: "boolean", default: false },
         version: { type: "boolean", short: "v", default: false },
         help: { type: "boolean", short: "h", default: false }
       }
@@ -4485,6 +4562,7 @@ function parseCommand(argv) {
   }
   if (verb === "help") return { kind: "help" };
   if (verb === "version") return { kind: "version" };
+  if (verb === "upgrade") return { kind: "upgrade", check: values.check === true };
   if (verb !== "start") return { kind: "invalid", message: `comando desconhecido: ${verb}` };
   const port = values.port === void 0 ? null : toPort(values.port);
   if (values.port !== void 0 && port === null) {
@@ -4541,6 +4619,129 @@ async function probePort({
   }
 }
 
+// src/upgrade.ts
+import { spawn as spawn2 } from "node:child_process";
+import { fileURLToPath } from "node:url";
+var PACKAGE_NAME = "@vinihcrosa/lumem-os";
+var REGISTRY_URL = `https://registry.npmjs.org/${encodeURIComponent(PACKAGE_NAME)}/latest`;
+function detectPackageManager(installPath) {
+  const path = installPath.replace(/\\/g, "/");
+  if (/\/\.?pnpm[/-]/.test(path)) return "pnpm";
+  if (path.includes("/.bun/")) return "bun";
+  if (/\/\.?yarn\//.test(path)) return "yarn";
+  return "npm";
+}
+function installCommand(manager, spec) {
+  switch (manager) {
+    case "pnpm":
+      return { command: "pnpm", args: ["add", "--global", spec] };
+    case "yarn":
+      return { command: "yarn", args: ["global", "add", spec] };
+    case "bun":
+      return { command: "bun", args: ["add", "--global", spec] };
+    case "npm":
+      return { command: "npm", args: ["install", "--global", spec] };
+  }
+}
+function compareVersions(a, b) {
+  const split = (version) => {
+    const [core = "", pre = ""] = version.trim().replace(/^v/, "").split("-", 2);
+    return { parts: core.split(".").map((n) => Number.parseInt(n, 10) || 0), pre };
+  };
+  const left = split(a);
+  const right = split(b);
+  for (let i = 0; i < 3; i += 1) {
+    const l = left.parts[i] ?? 0;
+    const r = right.parts[i] ?? 0;
+    if (l !== r) return l < r ? -1 : 1;
+  }
+  if (left.pre === right.pre) return 0;
+  if (left.pre === "") return 1;
+  if (right.pre === "") return -1;
+  return left.pre < right.pre ? -1 : 1;
+}
+async function fetchLatestVersion({
+  request = fetch,
+  timeoutMs = 1e4
+} = {}) {
+  const response = await request(REGISTRY_URL, {
+    signal: AbortSignal.timeout(timeoutMs),
+    headers: { accept: "application/json" }
+  });
+  if (!response.ok) throw new Error(`o registry respondeu ${String(response.status)}`);
+  const body = await response.json();
+  if (typeof body.version !== "string" || body.version === "") {
+    throw new Error("o registry respondeu sem vers\xE3o");
+  }
+  return body.version;
+}
+async function upgrade(deps) {
+  const {
+    out,
+    err,
+    current,
+    check,
+    origin,
+    fetchLatest = () => fetchLatestVersion(),
+    install = runInstall,
+    manager = detectPackageManager(fileURLToPath(import.meta.url)),
+    probe = probePort
+  } = deps;
+  let latest;
+  try {
+    latest = await fetchLatest();
+  } catch (error) {
+    err(`n\xE3o consegui perguntar ao npm qual \xE9 a \xFAltima vers\xE3o: ${message(error)}`);
+    return 1;
+  }
+  const order = compareVersions(current, latest);
+  if (order === 0) {
+    out(`j\xE1 est\xE1 na \xFAltima vers\xE3o (v${current}).`);
+    return 0;
+  }
+  if (order === 1) {
+    out(`a vers\xE3o instalada (v${current}) \xE9 mais nova que a do npm (v${latest}); nada a fazer.`);
+    return 0;
+  }
+  if (check) {
+    out(`tem vers\xE3o nova: v${current} \u2192 v${latest}`);
+    out("rode `lumem upgrade` para instalar.");
+    return 0;
+  }
+  const command = installCommand(manager, `${PACKAGE_NAME}@${latest}`);
+  out(`atualizando o Lumem: v${current} \u2192 v${latest}`);
+  out(`$ ${command.command} ${command.args.join(" ")}`);
+  let code2;
+  try {
+    code2 = await install(command);
+  } catch (error) {
+    err(`n\xE3o consegui rodar o ${command.command}: ${message(error)}`);
+    return 1;
+  }
+  if (code2 !== 0) {
+    err(`o ${command.command} saiu com ${String(code2)}; o Lumem continua na v${current}.`);
+    return code2;
+  }
+  out(`pronto: v${latest} instalado.`);
+  const occupant = await probe({ origin });
+  if (occupant.kind === "lumem") {
+    out(`o daemon em ${origin} ainda est\xE1 na v${occupant.version}: pare e suba de novo para valer.`);
+  }
+  return 0;
+}
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function runInstall({ command, args }) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn2(command, args, { stdio: "inherit" });
+    child.on("error", reject);
+    child.on("close", (code2) => {
+      resolve(code2 ?? 1);
+    });
+  });
+}
+
 // src/run.ts
 var DEFAULT_PORT = 4317;
 var DEFAULT_HOST = "127.0.0.1";
@@ -4552,10 +4753,11 @@ async function run(argv, deps) {
     env,
     version,
     startDaemon = async () => {
-      await import(fileURLToPath(new URL(DAEMON_ENTRY, import.meta.url)));
+      await import(fileURLToPath2(new URL(DAEMON_ENTRY, import.meta.url)));
     },
     probe = probePort,
-    open = openInBrowser
+    open = openInBrowser,
+    upgrade: upgrade2 = upgrade
   } = deps;
   const command = parseCommand(argv);
   if (command.kind === "help") {
@@ -4571,9 +4773,20 @@ async function run(argv, deps) {
     err("`lumem help` lista o que existe.");
     return 2;
   }
+  const originOf = (port2, host2) => `http://${host2 === "0.0.0.0" ? "127.0.0.1" : host2}:${String(port2)}`;
+  if (command.kind === "upgrade") {
+    return await upgrade2({
+      out,
+      err,
+      current: version,
+      check: command.check,
+      origin: originOf(Number(env["LUMEM_PORT"] ?? DEFAULT_PORT), env["LUMEM_HOST"] ?? DEFAULT_HOST),
+      probe
+    });
+  }
   const port = command.port ?? Number(env["LUMEM_PORT"] ?? DEFAULT_PORT);
   const host = command.host ?? env["LUMEM_HOST"] ?? DEFAULT_HOST;
-  const origin = `http://${host === "0.0.0.0" ? "127.0.0.1" : host}:${String(port)}`;
+  const origin = originOf(port, host);
   const occupant = await probe({ origin });
   if (occupant.kind === "lumem") {
     out(`j\xE1 tem um Lumem em ${origin} (v${occupant.version})`);