@opentig/cli 0.1.5 → 0.1.7

package/dist/server.mjs

@@ -9098,6 +9098,132 @@ function handleIntersectionResults(result, left, right) {
   result.value = merged.data;
   return result;
 }
+const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, ctx) => {
+    const input = payload.value;
+    if (!isPlainObject(input)) {
+      payload.issues.push({
+        expected: "record",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    }
+    const proms = [];
+    const values = def.keyType._zod.values;
+    if (values) {
+      payload.value = {};
+      const recordKeys = /* @__PURE__ */ new Set();
+      for (const key of values) {
+        if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+          recordKeys.add(typeof key === "number" ? key.toString() : key);
+          const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+          if (keyResult instanceof Promise) {
+            throw new Error("Async schemas not supported in object keys currently");
+          }
+          if (keyResult.issues.length) {
+            payload.issues.push({
+              code: "invalid_key",
+              origin: "record",
+              issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+              input: key,
+              path: [key],
+              inst
+            });
+            continue;
+          }
+          const outKey = keyResult.value;
+          const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+          if (result instanceof Promise) {
+            proms.push(result.then((result2) => {
+              if (result2.issues.length) {
+                payload.issues.push(...prefixIssues(key, result2.issues));
+              }
+              payload.value[outKey] = result2.value;
+            }));
+          } else {
+            if (result.issues.length) {
+              payload.issues.push(...prefixIssues(key, result.issues));
+            }
+            payload.value[outKey] = result.value;
+          }
+        }
+      }
+      let unrecognized;
+      for (const key in input) {
+        if (!recordKeys.has(key)) {
+          unrecognized = unrecognized ?? [];
+          unrecognized.push(key);
+        }
+      }
+      if (unrecognized && unrecognized.length > 0) {
+        payload.issues.push({
+          code: "unrecognized_keys",
+          input,
+          inst,
+          keys: unrecognized
+        });
+      }
+    } else {
+      payload.value = {};
+      for (const key of Reflect.ownKeys(input)) {
+        if (key === "__proto__")
+          continue;
+        if (!Object.prototype.propertyIsEnumerable.call(input, key))
+          continue;
+        let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+        if (keyResult instanceof Promise) {
+          throw new Error("Async schemas not supported in object keys currently");
+        }
+        const checkNumericKey = typeof key === "string" && number$1.test(key) && keyResult.issues.length;
+        if (checkNumericKey) {
+          const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
+          if (retryResult instanceof Promise) {
+            throw new Error("Async schemas not supported in object keys currently");
+          }
+          if (retryResult.issues.length === 0) {
+            keyResult = retryResult;
+          }
+        }
+        if (keyResult.issues.length) {
+          if (def.mode === "loose") {
+            payload.value[key] = input[key];
+          } else {
+            payload.issues.push({
+              code: "invalid_key",
+              origin: "record",
+              issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+              input: key,
+              path: [key],
+              inst
+            });
+          }
+          continue;
+        }
+        const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+        if (result instanceof Promise) {
+          proms.push(result.then((result2) => {
+            if (result2.issues.length) {
+              payload.issues.push(...prefixIssues(key, result2.issues));
+            }
+            payload.value[keyResult.value] = result2.value;
+          }));
+        } else {
+          if (result.issues.length) {
+            payload.issues.push(...prefixIssues(key, result.issues));
+          }
+          payload.value[keyResult.value] = result.value;
+        }
+      }
+    }
+    if (proms.length) {
+      return Promise.all(proms).then(() => payload);
+    }
+    return payload;
+  };
+});
 const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
   $ZodType.init(inst, def);
   const values = getEnumValues(def.entries);
@@ -10304,29 +10430,29 @@ const formatMap = {
   // do not set
 };
 const stringProcessor = (schema, ctx, _json, _params) => {
-  const json = _json;
-  json.type = "string";
+  const json2 = _json;
+  json2.type = "string";
   const { minimum, maximum, format: format2, patterns, contentEncoding } = schema._zod.bag;
   if (typeof minimum === "number")
-    json.minLength = minimum;
+    json2.minLength = minimum;
   if (typeof maximum === "number")
-    json.maxLength = maximum;
+    json2.maxLength = maximum;
   if (format2) {
-    json.format = formatMap[format2] ?? format2;
-    if (json.format === "")
-      delete json.format;
+    json2.format = formatMap[format2] ?? format2;
+    if (json2.format === "")
+      delete json2.format;
     if (format2 === "time") {
-      delete json.format;
+      delete json2.format;
     }
   }
   if (contentEncoding)
-    json.contentEncoding = contentEncoding;
+    json2.contentEncoding = contentEncoding;
   if (patterns && patterns.size > 0) {
     const regexes = [...patterns];
     if (regexes.length === 1)
-      json.pattern = regexes[0].source;
+      json2.pattern = regexes[0].source;
     else if (regexes.length > 1) {
-      json.allOf = [
+      json2.allOf = [
         ...regexes.map((regex) => ({
           ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
           pattern: regex.source
@@ -10336,40 +10462,40 @@ const stringProcessor = (schema, ctx, _json, _params) => {
   }
 };
 const numberProcessor = (schema, ctx, _json, _params) => {
-  const json = _json;
+  const json2 = _json;
   const { minimum, maximum, format: format2, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
   if (typeof format2 === "string" && format2.includes("int"))
-    json.type = "integer";
+    json2.type = "integer";
   else
-    json.type = "number";
+    json2.type = "number";
   const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
   const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
   const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
   if (exMin) {
     if (legacy) {
-      json.minimum = exclusiveMinimum;
-      json.exclusiveMinimum = true;
+      json2.minimum = exclusiveMinimum;
+      json2.exclusiveMinimum = true;
     } else {
-      json.exclusiveMinimum = exclusiveMinimum;
+      json2.exclusiveMinimum = exclusiveMinimum;
     }
   } else if (typeof minimum === "number") {
-    json.minimum = minimum;
+    json2.minimum = minimum;
   }
   if (exMax) {
     if (legacy) {
-      json.maximum = exclusiveMaximum;
-      json.exclusiveMaximum = true;
+      json2.maximum = exclusiveMaximum;
+      json2.exclusiveMaximum = true;
     } else {
-      json.exclusiveMaximum = exclusiveMaximum;
+      json2.exclusiveMaximum = exclusiveMaximum;
     }
   } else if (typeof maximum === "number") {
-    json.maximum = maximum;
+    json2.maximum = maximum;
   }
   if (typeof multipleOf === "number")
-    json.multipleOf = multipleOf;
+    json2.multipleOf = multipleOf;
 };
-const booleanProcessor = (_schema, _ctx, json, _params) => {
-  json.type = "boolean";
+const booleanProcessor = (_schema, _ctx, json2, _params) => {
+  json2.type = "boolean";
 };
 const bigintProcessor = (_schema, ctx, _json, _params) => {
   if (ctx.unrepresentable === "throw") {
@@ -10381,13 +10507,13 @@ const symbolProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("Symbols cannot be represented in JSON Schema");
   }
 };
-const nullProcessor = (_schema, ctx, json, _params) => {
+const nullProcessor = (_schema, ctx, json2, _params) => {
   if (ctx.target === "openapi-3.0") {
-    json.type = "string";
-    json.nullable = true;
-    json.enum = [null];
+    json2.type = "string";
+    json2.nullable = true;
+    json2.enum = [null];
   } else {
-    json.type = "null";
+    json2.type = "null";
   }
 };
 const undefinedProcessor = (_schema, ctx, _json, _params) => {
@@ -10400,8 +10526,8 @@ const voidProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("Void cannot be represented in JSON Schema");
   }
 };
-const neverProcessor = (_schema, _ctx, json, _params) => {
-  json.not = {};
+const neverProcessor = (_schema, _ctx, json2, _params) => {
+  json2.not = {};
 };
 const anyProcessor = (_schema, _ctx, _json, _params) => {
 };
@@ -10412,16 +10538,16 @@ const dateProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("Date cannot be represented in JSON Schema");
   }
 };
-const enumProcessor = (schema, _ctx, json, _params) => {
+const enumProcessor = (schema, _ctx, json2, _params) => {
   const def = schema._zod.def;
   const values = getEnumValues(def.entries);
   if (values.every((v) => typeof v === "number"))
-    json.type = "number";
+    json2.type = "number";
   if (values.every((v) => typeof v === "string"))
-    json.type = "string";
-  json.enum = values;
+    json2.type = "string";
+  json2.enum = values;
 };
-const literalProcessor = (schema, ctx, json, _params) => {
+const literalProcessor = (schema, ctx, json2, _params) => {
   const def = schema._zod.def;
   const vals = [];
   for (const val of def.values) {
@@ -10442,22 +10568,22 @@ const literalProcessor = (schema, ctx, json, _params) => {
   if (vals.length === 0) ;
   else if (vals.length === 1) {
     const val = vals[0];
-    json.type = val === null ? "null" : typeof val;
+    json2.type = val === null ? "null" : typeof val;
     if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
-      json.enum = [val];
+      json2.enum = [val];
     } else {
-      json.const = val;
+      json2.const = val;
     }
   } else {
     if (vals.every((v) => typeof v === "number"))
-      json.type = "number";
+      json2.type = "number";
     if (vals.every((v) => typeof v === "string"))
-      json.type = "string";
+      json2.type = "string";
     if (vals.every((v) => typeof v === "boolean"))
-      json.type = "boolean";
+      json2.type = "boolean";
     if (vals.every((v) => v === null))
-      json.type = "null";
-    json.enum = vals;
+      json2.type = "null";
+    json2.enum = vals;
   }
 };
 const nanProcessor = (_schema, ctx, _json, _params) => {
@@ -10465,16 +10591,16 @@ const nanProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("NaN cannot be represented in JSON Schema");
   }
 };
-const templateLiteralProcessor = (schema, _ctx, json, _params) => {
-  const _json = json;
+const templateLiteralProcessor = (schema, _ctx, json2, _params) => {
+  const _json = json2;
   const pattern = schema._zod.pattern;
   if (!pattern)
     throw new Error("Pattern not found in template literal");
   _json.type = "string";
   _json.pattern = pattern.source;
 };
-const fileProcessor = (schema, _ctx, json, _params) => {
-  const _json = json;
+const fileProcessor = (schema, _ctx, json2, _params) => {
+  const _json = json2;
   const file = {
     type: "string",
     format: "binary",
@@ -10497,8 +10623,8 @@ const fileProcessor = (schema, _ctx, json, _params) => {
     Object.assign(_json, file);
   }
 };
-const successProcessor = (_schema, _ctx, json, _params) => {
-  json.type = "boolean";
+const successProcessor = (_schema, _ctx, json2, _params) => {
+  json2.type = "boolean";
 };
 const customProcessor = (_schema, ctx, _json, _params) => {
   if (ctx.unrepresentable === "throw") {
@@ -10526,27 +10652,27 @@ const setProcessor = (_schema, ctx, _json, _params) => {
   }
 };
 const arrayProcessor = (schema, ctx, _json, params) => {
-  const json = _json;
+  const json2 = _json;
   const def = schema._zod.def;
   const { minimum, maximum } = schema._zod.bag;
   if (typeof minimum === "number")
-    json.minItems = minimum;
+    json2.minItems = minimum;
   if (typeof maximum === "number")
-    json.maxItems = maximum;
-  json.type = "array";
-  json.items = process$1(def.element, ctx, {
+    json2.maxItems = maximum;
+  json2.type = "array";
+  json2.items = process$1(def.element, ctx, {
     ...params,
     path: [...params.path, "items"]
   });
 };
 const objectProcessor = (schema, ctx, _json, params) => {
-  const json = _json;
+  const json2 = _json;
   const def = schema._zod.def;
-  json.type = "object";
-  json.properties = {};
+  json2.type = "object";
+  json2.properties = {};
   const shape = def.shape;
   for (const key in shape) {
-    json.properties[key] = process$1(shape[key], ctx, {
+    json2.properties[key] = process$1(shape[key], ctx, {
       ...params,
       path: [...params.path, "properties", key]
     });
@@ -10561,21 +10687,21 @@ const objectProcessor = (schema, ctx, _json, params) => {
     }
   }));
   if (requiredKeys.size > 0) {
-    json.required = Array.from(requiredKeys);
+    json2.required = Array.from(requiredKeys);
   }
   if (def.catchall?._zod.def.type === "never") {
-    json.additionalProperties = false;
+    json2.additionalProperties = false;
   } else if (!def.catchall) {
     if (ctx.io === "output")
-      json.additionalProperties = false;
+      json2.additionalProperties = false;
   } else if (def.catchall) {
-    json.additionalProperties = process$1(def.catchall, ctx, {
+    json2.additionalProperties = process$1(def.catchall, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
   }
 };
-const unionProcessor = (schema, ctx, json, params) => {
+const unionProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   const isExclusive = def.inclusive === false;
   const options = def.options.map((x, i2) => process$1(x, ctx, {
@@ -10583,12 +10709,12 @@ const unionProcessor = (schema, ctx, json, params) => {
     path: [...params.path, isExclusive ? "oneOf" : "anyOf", i2]
   }));
   if (isExclusive) {
-    json.oneOf = options;
+    json2.oneOf = options;
   } else {
-    json.anyOf = options;
+    json2.anyOf = options;
   }
 };
-const intersectionProcessor = (schema, ctx, json, params) => {
+const intersectionProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   const a2 = process$1(def.left, ctx, {
     ...params,
@@ -10603,12 +10729,12 @@ const intersectionProcessor = (schema, ctx, json, params) => {
     ...isSimpleIntersection(a2) ? a2.allOf : [a2],
     ...isSimpleIntersection(b) ? b.allOf : [b]
   ];
-  json.allOf = allOf;
+  json2.allOf = allOf;
 };
 const tupleProcessor = (schema, ctx, _json, params) => {
-  const json = _json;
+  const json2 = _json;
   const def = schema._zod.def;
-  json.type = "array";
+  json2.type = "array";
   const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
   const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
   const prefixItems = def.items.map((x, i2) => process$1(x, ctx, {
@@ -10620,37 +10746,37 @@ const tupleProcessor = (schema, ctx, _json, params) => {
     path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
   }) : null;
   if (ctx.target === "draft-2020-12") {
-    json.prefixItems = prefixItems;
+    json2.prefixItems = prefixItems;
     if (rest) {
-      json.items = rest;
+      json2.items = rest;
     }
   } else if (ctx.target === "openapi-3.0") {
-    json.items = {
+    json2.items = {
       anyOf: prefixItems
     };
     if (rest) {
-      json.items.anyOf.push(rest);
+      json2.items.anyOf.push(rest);
     }
-    json.minItems = prefixItems.length;
+    json2.minItems = prefixItems.length;
     if (!rest) {
-      json.maxItems = prefixItems.length;
+      json2.maxItems = prefixItems.length;
     }
   } else {
-    json.items = prefixItems;
+    json2.items = prefixItems;
     if (rest) {
-      json.additionalItems = rest;
+      json2.additionalItems = rest;
     }
   }
   const { minimum, maximum } = schema._zod.bag;
   if (typeof minimum === "number")
-    json.minItems = minimum;
+    json2.minItems = minimum;
   if (typeof maximum === "number")
-    json.maxItems = maximum;
+    json2.maxItems = maximum;
 };
 const recordProcessor = (schema, ctx, _json, params) => {
-  const json = _json;
+  const json2 = _json;
   const def = schema._zod.def;
-  json.type = "object";
+  json2.type = "object";
   const keyType = def.keyType;
   const keyBag = keyType._zod.bag;
   const patterns = keyBag?.patterns;
@@ -10659,18 +10785,18 @@ const recordProcessor = (schema, ctx, _json, params) => {
       ...params,
       path: [...params.path, "patternProperties", "*"]
     });
-    json.patternProperties = {};
+    json2.patternProperties = {};
     for (const pattern of patterns) {
-      json.patternProperties[pattern.source] = valueSchema;
+      json2.patternProperties[pattern.source] = valueSchema;
     }
   } else {
     if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-      json.propertyNames = process$1(def.keyType, ctx, {
+      json2.propertyNames = process$1(def.keyType, ctx, {
         ...params,
         path: [...params.path, "propertyNames"]
       });
     }
-    json.additionalProperties = process$1(def.valueType, ctx, {
+    json2.additionalProperties = process$1(def.valueType, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -10679,19 +10805,19 @@ const recordProcessor = (schema, ctx, _json, params) => {
   if (keyValues) {
     const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
     if (validKeyValues.length > 0) {
-      json.required = validKeyValues;
+      json2.required = validKeyValues;
     }
   }
 };
-const nullableProcessor = (schema, ctx, json, params) => {
+const nullableProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   const inner = process$1(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
-    json.nullable = true;
+    json2.nullable = true;
   } else {
-    json.anyOf = [inner, { type: "null" }];
+    json2.anyOf = [inner, { type: "null" }];
   }
 };
 const nonoptionalProcessor = (schema, ctx, _json, params) => {
@@ -10700,22 +10826,22 @@ const nonoptionalProcessor = (schema, ctx, _json, params) => {
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
-const defaultProcessor = (schema, ctx, json, params) => {
+const defaultProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   process$1(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
-  json.default = JSON.parse(JSON.stringify(def.defaultValue));
+  json2.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
-const prefaultProcessor = (schema, ctx, json, params) => {
+const prefaultProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   process$1(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   if (ctx.io === "input")
-    json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
+    json2._prefault = JSON.parse(JSON.stringify(def.defaultValue));
 };
-const catchProcessor = (schema, ctx, json, params) => {
+const catchProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   process$1(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
@@ -10726,7 +10852,7 @@ const catchProcessor = (schema, ctx, json, params) => {
   } catch {
     throw new Error("Dynamic catch values are not supported in JSON Schema");
   }
-  json.default = catchValue;
+  json2.default = catchValue;
 };
 const pipeProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
@@ -10736,12 +10862,12 @@ const pipeProcessor = (schema, ctx, _json, params) => {
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
-const readonlyProcessor = (schema, ctx, json, params) => {
+const readonlyProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   process$1(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
-  json.readOnly = true;
+  json2.readOnly = true;
 };
 const promiseProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
@@ -11082,7 +11208,7 @@ const ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
 const _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
   $ZodString.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => stringProcessor(inst, ctx, json);
+  inst._zod.processJSONSchema = (ctx, json2, params) => stringProcessor(inst, ctx, json2);
   const bag = inst._zod.bag;
   inst.format = bag.format ?? null;
   inst.minLength = bag.minimum ?? null;
@@ -11252,7 +11378,7 @@ const ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
 const ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
   $ZodNumber.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => numberProcessor(inst, ctx, json);
+  inst._zod.processJSONSchema = (ctx, json2, params) => numberProcessor(inst, ctx, json2);
   _installLazyMethods(inst, "ZodNumber", {
     gt(value, params) {
       return this.check(/* @__PURE__ */ _gt(value, params));
@@ -11320,7 +11446,7 @@ function int(params) {
 const ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
   $ZodBoolean.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => booleanProcessor(inst, ctx, json);
+  inst._zod.processJSONSchema = (ctx, json2, params) => booleanProcessor(inst, ctx, json2);
 });
 function boolean(params) {
   return /* @__PURE__ */ _boolean(ZodBoolean, params);
@@ -11328,7 +11454,7 @@ function boolean(params) {
 const ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
   $ZodUnknown.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => unknownProcessor();
+  inst._zod.processJSONSchema = (ctx, json2, params) => unknownProcessor();
 });
 function unknown() {
   return /* @__PURE__ */ _unknown(ZodUnknown);
@@ -11336,7 +11462,7 @@ function unknown() {
 const ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
   $ZodNever.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => neverProcessor(inst, ctx, json);
+  inst._zod.processJSONSchema = (ctx, json2, params) => neverProcessor(inst, ctx, json2);
 });
 function never(params) {
   return /* @__PURE__ */ _never(ZodNever, params);
@@ -11344,7 +11470,7 @@ function never(params) {
 const ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
   $ZodArray.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => arrayProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => arrayProcessor(inst, ctx, json2, params);
   inst.element = def.element;
   _installLazyMethods(inst, "ZodArray", {
     min(n2, params) {
@@ -11370,7 +11496,7 @@ function array(element, params) {
 const ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
   $ZodObjectJIT.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => objectProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => objectProcessor(inst, ctx, json2, params);
   defineLazy(inst, "shape", () => {
     return def.shape;
   });
@@ -11435,7 +11561,7 @@ function looseObject(shape, params) {
 const ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
   $ZodUnion.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => unionProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
   inst.options = def.options;
 });
 function union(options, params) {
@@ -11448,7 +11574,7 @@ function union(options, params) {
 const ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
   $ZodIntersection.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => intersectionProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => intersectionProcessor(inst, ctx, json2, params);
 });
 function intersection(left, right) {
   return new ZodIntersection({
@@ -11457,10 +11583,33 @@ function intersection(left, right) {
     right
   });
 }
+const ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
+  $ZodRecord.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json2, params) => recordProcessor(inst, ctx, json2, params);
+  inst.keyType = def.keyType;
+  inst.valueType = def.valueType;
+});
+function record(keyType, valueType, params) {
+  if (!valueType || !valueType._zod) {
+    return new ZodRecord({
+      type: "record",
+      keyType: string(),
+      valueType: keyType,
+      ...normalizeParams(valueType)
+    });
+  }
+  return new ZodRecord({
+    type: "record",
+    keyType,
+    valueType,
+    ...normalizeParams(params)
+  });
+}
 const ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   $ZodEnum.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => enumProcessor(inst, ctx, json);
+  inst._zod.processJSONSchema = (ctx, json2, params) => enumProcessor(inst, ctx, json2);
   inst.enum = def.entries;
   inst.options = Object.values(def.entries);
   const keys = new Set(Object.keys(def.entries));
@@ -11506,7 +11655,7 @@ function _enum(values, params) {
 const ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
   $ZodTransform.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => transformProcessor(inst, ctx);
+  inst._zod.processJSONSchema = (ctx, json2, params) => transformProcessor(inst, ctx);
   inst._zod.parse = (payload, _ctx) => {
     if (_ctx.direction === "backward") {
       throw new $ZodEncodeError(inst.constructor.name);
@@ -11546,7 +11695,7 @@ function transform(fn) {
 const ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
   $ZodOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function optional(innerType) {
@@ -11558,7 +11707,7 @@ function optional(innerType) {
 const ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
   $ZodExactOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function exactOptional(innerType) {
@@ -11570,7 +11719,7 @@ function exactOptional(innerType) {
 const ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
   $ZodNullable.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => nullableProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => nullableProcessor(inst, ctx, json2, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function nullable(innerType) {
@@ -11582,7 +11731,7 @@ function nullable(innerType) {
 const ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
   $ZodDefault.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => defaultProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => defaultProcessor(inst, ctx, json2, params);
   inst.unwrap = () => inst._zod.def.innerType;
   inst.removeDefault = inst.unwrap;
 });
@@ -11598,7 +11747,7 @@ function _default(innerType, defaultValue) {
 const ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
   $ZodPrefault.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => prefaultProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => prefaultProcessor(inst, ctx, json2, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function prefault(innerType, defaultValue) {
@@ -11613,7 +11762,7 @@ function prefault(innerType, defaultValue) {
 const ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
   $ZodNonOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => nonoptionalProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => nonoptionalProcessor(inst, ctx, json2, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function nonoptional(innerType, params) {
@@ -11626,7 +11775,7 @@ function nonoptional(innerType, params) {
 const ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
   $ZodCatch.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => catchProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => catchProcessor(inst, ctx, json2, params);
   inst.unwrap = () => inst._zod.def.innerType;
   inst.removeCatch = inst.unwrap;
 });
@@ -11640,7 +11789,7 @@ function _catch(innerType, catchValue) {
 const ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
   $ZodPipe.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => pipeProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => pipeProcessor(inst, ctx, json2, params);
   inst.in = def.in;
   inst.out = def.out;
 });
@@ -11655,7 +11804,7 @@ function pipe(in_, out) {
 const ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
   $ZodReadonly.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => readonlyProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => readonlyProcessor(inst, ctx, json2, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function readonly(innerType) {
@@ -11667,7 +11816,7 @@ function readonly(innerType) {
 const ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
   $ZodCustom.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => customProcessor(inst, ctx);
+  inst._zod.processJSONSchema = (ctx, json2, params) => customProcessor(inst, ctx);
 });
 function refine(fn, _params = {}) {
   return /* @__PURE__ */ _refine(ZodCustom, fn, _params);
@@ -11884,8 +12033,8 @@ class AiLogStore {
   }
   /** Records one run. Never rejects; failures are dropped on purpose. */
   append(entry) {
-    const record = { ...entry, id: randomUUID(), at: (/* @__PURE__ */ new Date()).toISOString() };
-    const normalized = normalizeAiLogEntry(record);
+    const record2 = { ...entry, id: randomUUID(), at: (/* @__PURE__ */ new Date()).toISOString() };
+    const normalized = normalizeAiLogEntry(record2);
     if (!normalized) return;
     this.pending = this.pending.then(async () => {
       await mkdir(path.dirname(this.filePath), { recursive: true });
@@ -11990,18 +12139,18 @@ ${parsed.data.body}`.length > 1e4) throw invalidOutput$3();
 }
 function parseCommitSplitProposal(value, stagedPaths) {
   if (!value || typeof value !== "object") return { status: "absent" };
-  const record = value;
-  if (record.commits === void 0 || Array.isArray(record.commits) && record.commits.length === 0) return { status: "absent" };
-  if (!Array.isArray(record.commits)) return { status: "rejected", reason: "commits was not a list" };
+  const record2 = value;
+  if (record2.commits === void 0 || Array.isArray(record2.commits) && record2.commits.length === 0) return { status: "absent" };
+  if (!Array.isArray(record2.commits)) return { status: "rejected", reason: "commits was not a list" };
   if (stagedPaths.length < 2) return { status: "absent" };
-  if (record.commits.length < 2) return { status: "rejected", reason: "fewer than two groups" };
-  if (record.commits.length > 8) return { status: "rejected", reason: `too many groups (${record.commits.length})` };
-  const rationale = cleanText(record.rationale, 1e3);
+  if (record2.commits.length < 2) return { status: "rejected", reason: "fewer than two groups" };
+  if (record2.commits.length > 8) return { status: "rejected", reason: `too many groups (${record2.commits.length})` };
+  const rationale = cleanText(record2.rationale, 1e3);
   if (rationale === null) return { status: "rejected", reason: "missing or unusable rationale" };
   const allowed = new Set(stagedPaths);
   const used = /* @__PURE__ */ new Set();
   const commits = [];
-  for (const candidate of record.commits) {
+  for (const candidate of record2.commits) {
     if (!candidate || typeof candidate !== "object") return { status: "rejected", reason: "a group was not an object" };
     let parts;
     try {
@@ -12323,8 +12472,8 @@ const AI_SERVER_TIMEOUT_MS = AI_PROVIDER_TIMEOUT_MS + 3e4;
 const DEFAULT_MODEL = { id: "default", label: "Default (CLI)" };
 function claudeUsage(envelope) {
   if (!envelope || typeof envelope !== "object") return { ...EMPTY_AI_USAGE };
-  const record = envelope;
-  const usage = record.usage ?? {};
+  const record2 = envelope;
+  const usage = record2.usage ?? {};
   const details = usage.output_tokens_details ?? {};
   return {
     inputTokens: count(usage.input_tokens),
@@ -12332,7 +12481,7 @@ function claudeUsage(envelope) {
     reasoningTokens: count(details.thinking_tokens),
     cacheReadTokens: count(usage.cache_read_input_tokens),
     cacheWriteTokens: count(usage.cache_creation_input_tokens),
-    costUsd: count(record.total_cost_usd, true)
+    costUsd: count(record2.total_cost_usd, true)
   };
 }
 function codexUsage(stdout) {
@@ -12360,8 +12509,8 @@ function codexUsage(stdout) {
 }
 function openCodeUsage(info) {
   if (!info || typeof info !== "object") return { ...EMPTY_AI_USAGE };
-  const record = info;
-  const tokens = record.tokens ?? {};
+  const record2 = info;
+  const tokens = record2.tokens ?? {};
   const cache = tokens.cache ?? {};
   return {
     inputTokens: count(tokens.input),
@@ -12369,7 +12518,7 @@ function openCodeUsage(info) {
     reasoningTokens: count(tokens.reasoning),
     cacheReadTokens: count(cache.read),
     cacheWriteTokens: count(cache.write),
-    costUsd: count(record.cost, true)
+    costUsd: count(record2.cost, true)
   };
 }
 function count(value, fractional = false) {
@@ -12431,29 +12580,29 @@ function toCodexOutputSchema(schema) {
 function strictify(value) {
   if (!value || typeof value !== "object") return value;
   if (Array.isArray(value)) return value.map(strictify);
-  const record = { ...value };
-  delete record.$schema;
-  if (record.properties && typeof record.properties === "object" && !Array.isArray(record.properties)) {
+  const record2 = { ...value };
+  delete record2.$schema;
+  if (record2.properties && typeof record2.properties === "object" && !Array.isArray(record2.properties)) {
     const properties = Object.fromEntries(
-      Object.entries(record.properties).map(([key, item]) => [key, strictify(item)])
+      Object.entries(record2.properties).map(([key, item]) => [key, strictify(item)])
     );
-    record.properties = properties;
-    record.required = Object.keys(properties);
-    record.additionalProperties = false;
+    record2.properties = properties;
+    record2.required = Object.keys(properties);
+    record2.additionalProperties = false;
   }
-  if ("items" in record) record.items = strictify(record.items);
+  if ("items" in record2) record2.items = strictify(record2.items);
   for (const key of ["$defs", "definitions"]) {
-    const defs = record[key];
+    const defs = record2[key];
     if (defs && typeof defs === "object" && !Array.isArray(defs)) {
-      record[key] = Object.fromEntries(
+      record2[key] = Object.fromEntries(
         Object.entries(defs).map(([name, item]) => [name, strictify(item)])
       );
     }
   }
   for (const key of ["anyOf", "oneOf", "allOf"]) {
-    if (Array.isArray(record[key])) record[key] = record[key].map(strictify);
+    if (Array.isArray(record2[key])) record2[key] = record2[key].map(strictify);
   }
-  return record;
+  return record2;
 }
 function cliDiagnostic(result) {
   let fromTurn = null;
@@ -16472,9 +16621,9 @@ function parseNumstat$1(output) {
   const stats = /* @__PURE__ */ new Map();
   const tokens = output.split("\0");
   for (let index = 0; index < tokens.length; index += 1) {
-    const record = tokens[index];
-    if (!record) continue;
-    const match = /^(\d+|-)\t(\d+|-)\t(.*)$/s.exec(record);
+    const record2 = tokens[index];
+    if (!record2) continue;
+    const match = /^(\d+|-)\t(\d+|-)\t(.*)$/s.exec(record2);
     if (!match) continue;
     const binary = match[1] === "-" || match[2] === "-";
     const entry = {
@@ -16495,8 +16644,8 @@ const FIELD = "";
 const RECORD = "";
 const LOG_FORMAT = `%H${FIELD}%h${FIELD}%s${FIELD}%b${FIELD}%an${FIELD}%ae${FIELD}%aI${FIELD}%D${FIELD}%P${RECORD}`;
 function parseLog(output) {
-  return output.split(RECORD).map((record) => record.trim()).filter(Boolean).flatMap((record) => {
-    const fields = record.split(FIELD);
+  return output.split(RECORD).map((record2) => record2.trim()).filter(Boolean).flatMap((record2) => {
+    const fields = record2.split(FIELD);
     if (fields.length < 9) return [];
     const oid = fields[0] ?? "";
     if (!/^[0-9a-f]{40,64}$/i.test(oid)) return [];
@@ -16517,6 +16666,21 @@ function parseLog(output) {
     }];
   });
 }
+function selectHistoryBase(output, upstream) {
+  const refs = output.trim().split("\n").map((line) => {
+    const [ref = "", oid = "", target = ""] = line.split("\0");
+    return { ref, oid, target };
+  }).filter((ref) => /^[a-f0-9]{40,64}$/i.test(ref.oid));
+  const remoteDefaults = refs.filter((ref) => ref.ref.startsWith("refs/remotes/") && ref.ref.endsWith("/HEAD") && ref.target);
+  const preferred = remoteDefaults.filter((ref) => upstream?.startsWith(ref.ref.slice("refs/remotes/".length, -4))).sort((a2, b) => b.ref.length - a2.ref.length)[0] ?? remoteDefaults.find((ref) => ref.ref === "refs/remotes/origin/HEAD");
+  if (preferred) return { ref: preferred.target.replace(/^refs\/(heads|remotes)\//, ""), oid: preferred.oid };
+  const remotePrefix = upstream?.split("/")[0] ?? "origin";
+  for (const name of [`refs/remotes/${remotePrefix}/main`, `refs/remotes/${remotePrefix}/master`, "refs/heads/main", "refs/heads/master"]) {
+    const ref = refs.find((candidate) => candidate.ref === name);
+    if (ref) return { ref: name.replace(/^refs\/(heads|remotes)\//, ""), oid: ref.oid };
+  }
+  return null;
+}
 const REF_FORMAT = "%(refname)%00%(refname:short)%00%(HEAD)%00%(upstream:short)%00%(upstream:track)%00%(worktreepath)%00%(objectname)%00%(objectname:short)%00%(subject)%00%(authorname)%00%(committerdate:iso-strict)%00";
 const FIELDS_PER_REF = 11;
 function parseRefs(buffer) {
@@ -16618,25 +16782,25 @@ function parseStatus(buffer) {
   };
   const chunks = splitNul(buffer).map((chunk) => chunk.toString("utf8"));
   for (let index = 0; index < chunks.length; index += 1) {
-    const record = chunks[index] ?? "";
-    if (!record) continue;
-    if (record.startsWith("# ")) {
-      parseHeader(record, status);
+    const record2 = chunks[index] ?? "";
+    if (!record2) continue;
+    if (record2.startsWith("# ")) {
+      parseHeader(record2, status);
       continue;
     }
-    if (record.startsWith("? ")) {
-      status.changes.push(makeChange(record.slice(2), "?", "?"));
+    if (record2.startsWith("? ")) {
+      status.changes.push(makeChange(record2.slice(2), "?", "?"));
       continue;
     }
-    if (record.startsWith("1 ") || record.startsWith("u ")) {
-      const fields = record.split(" ");
+    if (record2.startsWith("1 ") || record2.startsWith("u ")) {
+      const fields = record2.split(" ");
       const xy = fields[1] ?? "..";
-      const pathIndex = record.startsWith("1 ") ? 8 : 10;
+      const pathIndex = record2.startsWith("1 ") ? 8 : 10;
       status.changes.push(makeChange(fields.slice(pathIndex).join(" "), xy[0] ?? ".", xy[1] ?? ".", fields[2] ?? ""));
       continue;
     }
-    if (record.startsWith("2 ")) {
-      const fields = record.split(" ");
+    if (record2.startsWith("2 ")) {
+      const fields = record2.split(" ");
       const xy = fields[1] ?? "..";
       const next = chunks[index + 1] ?? "";
       const pathValue = fields.slice(9).join(" ");
@@ -16984,14 +17148,18 @@ ${base}
       if (cursor && commits[0]?.oid === cursor) commits = commits.slice(1);
       const hasMore = commits.length > 100;
       commits = commits.slice(0, 100);
-      const localOids = await this.localOnlyOids(repository.path, status.upstream, status.detached || status.unborn);
+      const [localOids, base] = await Promise.all([
+        this.localOnlyOids(repository.path, status.upstream, status.detached || status.unborn),
+        this.historyBase(repository.path, revision2, status.upstream)
+      ]);
       commits = commits.map((commit) => ({
         ...commit,
         isHead: commit.oid === status.oid,
-        upstreamState: localOids === null ? "unknown" : localOids.has(commit.oid) ? "local-only" : "published"
+        upstreamState: localOids === null ? "unknown" : localOids.has(commit.oid) ? "local-only" : "published",
+        baseState: base === null ? "unknown" : base.outside.has(commit.oid) ? "outside" : "included"
       }));
       for (const commit of commits) this.rememberOid(repositoryId, commit.oid);
-      return { commits, nextCursor: hasMore ? commits.at(-1)?.oid ?? null : null };
+      return { commits, nextCursor: hasMore ? commits.at(-1)?.oid ?? null : null, baseRef: base?.ref ?? null };
     } catch (error) {
       if (!cursor && error instanceof GitOperationError && /does not have any commits|unknown revision|bad revision/i.test(error.message)) return { commits: [], nextCursor: null };
       throw error;
@@ -17215,13 +17383,13 @@ ${base}
     const nextStatus = await this.repositories.status(repositoryId, false);
     return { status: "success", commits, restoredLocalChanges: hasLocalChanges, rebased, localCommits: nextStatus.ahead };
   }
-  async push(repositoryId) {
+  async push(repositoryId, publish) {
     const repository = this.repositories.get(repositoryId);
     let status = await this.repositories.status(repositoryId, false);
     const existingConflicts = conflictPaths(status);
     if (existingConflicts.length > 0) return { status: "blocked-conflicts", files: existingConflicts };
     if (status.operation) return { status: "blocked-operation", operation: status.operation };
-    if (!status.upstream) return { status: "no-upstream" };
+    if (!status.upstream || publish) return this.publishBranch(repositoryId, status.branch, status.oid, publish);
     if (status.ahead === 0) return { status: "up-to-date" };
     try {
       await this.runFetch(repository.path, "push-fetch");
@@ -17247,6 +17415,48 @@ ${base}
     }
     return { status: "success", commits };
   }
+  async publishBranch(repositoryId, expectedBranch, expectedOid, publish) {
+    const repository = this.repositories.get(repositoryId);
+    const rejected = (message) => ({ status: "rejected", reason: "configuration", message });
+    return this.git.runWriteTask(repository.path, async (run) => {
+      const status = await this.repositories.status(repositoryId, false);
+      if (status.operation || status.readOnly) return { status: "blocked-operation", operation: status.operation ?? "another Git operation" };
+      const conflicts = conflictPaths(status);
+      if (conflicts.length > 0) return { status: "blocked-conflicts", files: conflicts };
+      if (status.detached || !status.branch) return rejected("Check out a branch before publishing.");
+      if (status.unborn || !status.oid) return rejected("Create the first commit before publishing this branch.");
+      if (status.upstream || status.branch !== (publish?.expectedBranch ?? expectedBranch) || status.oid !== (publish?.expectedOid ?? expectedOid)) {
+        return rejected("The branch changed. Refresh and try publishing again.");
+      }
+      try {
+        const remotes = (await run(["remote"], { operation: "publish-remotes", readOnly: true })).stdout.toString("utf8").trim().split(/\r?\n/).filter(Boolean);
+        if (remotes.length === 0) return rejected("No remote is configured. Add a remote before publishing this branch.");
+        let remote = publish?.remote;
+        if (!remote) {
+          for (const key of [`branch.${status.branch}.pushRemote`, "remote.pushDefault", `branch.${status.branch}.remote`]) {
+            try {
+              remote = (await run(["config", "--get", key], { operation: "publish-remote-config", readOnly: true })).stdout.toString("utf8").trim();
+            } catch (error) {
+              if (!(error instanceof GitOperationError) || error.detail.exitCode !== 1) throw error;
+            }
+            if (remote) break;
+          }
+          remote ||= remotes.length === 1 ? remotes[0] : void 0;
+        }
+        if (!remote) return { status: "remote-required", branch: status.branch, oid: status.oid, remotes };
+        if (!remotes.includes(remote)) return rejected("The selected push remote is not configured. Check the repository remote settings.");
+        const ref = `refs/heads/${status.branch}`;
+        await run(["-c", `remote.${remote}.mirror=false`, "push", "--porcelain", "--set-upstream", "--no-follow-tags", "--", remote, `${ref}:${ref}`], {
+          operation: "publish-branch",
+          timeoutMs: 12e4,
+          maxOutputBytes: 16 * 1024 * 1024
+        });
+        return { status: "published", branch: status.branch, remote };
+      } catch (error) {
+        return pushFailure(error);
+      }
+    }, repository.commonDir);
+  }
   async worktrees(repositoryId) {
     const repository = this.repositories.get(repositoryId);
     const output = await this.git.run(repository.path, ["worktree", "list", "--porcelain", "-z"], { operation: "worktrees", readOnly: true });
@@ -17522,6 +17732,18 @@ ${body}
     const status = await this.repositories.status(repositoryId, false);
     if (status.readOnly) throw new GitOperationError({ code: "INVALID_ARGUMENT", operation: "write", message: `The repository is in the middle of ${status.operation}; OpenTig keeps it read-only.` });
   }
+  async historyBase(repositoryPath, revision2, upstream) {
+    try {
+      const options = { operation: "history-base", readOnly: true, maxOutputBytes: 8 * 1024 * 1024 };
+      const refs = await this.git.run(repositoryPath, ["for-each-ref", "--format=%(refname)%00%(objectname)%00%(symref)", "refs/heads/main", "refs/heads/master", "refs/remotes"], options);
+      const base = selectHistoryBase(refs.stdout.toString("utf8"), upstream);
+      if (!base) return null;
+      const output = await this.git.run(repositoryPath, ["rev-list", revision2, `^${base.oid}`, "--"], options);
+      return { ref: base.ref, outside: new Set(output.stdout.toString("utf8").trim().split("\n").filter(Boolean)) };
+    } catch {
+      return null;
+    }
+  }
   async localOnlyOids(repositoryPath, upstream, unavailable) {
     if (!upstream || unavailable) return null;
     try {
@@ -18211,6 +18433,73 @@ function revision(bytes) {
 function invalidReplacement(message) {
   return new GitOperationError({ code: "INVALID_ARGUMENT", operation: "replace-search", message });
 }
+const positive = number().int().positive().safe();
+const membershipSchema = object({
+  stack: object({ number: positive, size: positive, baseRefName: string().min(1) }).nullable(),
+  stackEntry: object({ position: positive }).nullable()
+});
+const stackSchema = object({
+  number: positive,
+  base: union([string().min(1), object({ ref: string().min(1) })]),
+  pull_requests: array(object({
+    number: positive,
+    title: string().optional(),
+    draft: boolean().optional(),
+    head: object({ ref: string().min(1) }),
+    state: _enum(["open", "closed", "merged"]),
+    merged_at: string().nullable().optional()
+  })).min(1)
+});
+function invalid() {
+  return new GhOperationError({ code: "GH_INVALID_OUTPUT", operation: "gh-pr-stack", message: "GitHub returned unreadable stack information." });
+}
+function json(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw invalid();
+  }
+}
+function stackMembershipQuery(numbers) {
+  if (!numbers.length || numbers.some((number2) => !positive.safeParse(number2).success)) throw invalid();
+  return `query($owner:String!,$name:String!){repository(owner:$owner,name:$name){${numbers.map((number2) => `pr${number2}:pullRequest(number:${number2}){stack{number size baseRefName} stackEntry{position}}`).join(" ")}}}`;
+}
+function parseStackMemberships(raw, numbers) {
+  const envelope = object({ data: object({ repository: record(string(), membershipSchema.nullable()) }), errors: array(unknown()).optional() }).safeParse(json(raw));
+  if (!envelope.success || envelope.data.errors?.length) throw invalid();
+  const result = /* @__PURE__ */ new Map();
+  for (const number2 of numbers) {
+    const entry = envelope.data.data.repository[`pr${number2}`];
+    if (entry === void 0) throw invalid();
+    if (!entry?.stack && !entry?.stackEntry) continue;
+    if (!entry?.stack || !entry.stackEntry || entry.stackEntry.position > entry.stack.size) throw invalid();
+    result.set(number2, { number: entry.stack.number, size: entry.stack.size, position: entry.stackEntry.position, base: entry.stack.baseRefName });
+  }
+  return result;
+}
+function parsePullRequestStack(raw, prNumber, listing = false) {
+  let value = json(raw);
+  if (listing) {
+    if (!Array.isArray(value) || value.length > 1) throw invalid();
+    if (!value.length) return null;
+    value = value[0];
+  }
+  const parsed = stackSchema.safeParse(value);
+  if (!parsed.success) throw invalid();
+  const stack = parsed.data;
+  if (!stack.pull_requests.some((pr) => pr.number === prNumber) || new Set(stack.pull_requests.map((pr) => pr.number)).size !== stack.pull_requests.length) throw invalid();
+  return {
+    number: stack.number,
+    base: typeof stack.base === "string" ? stack.base : stack.base.ref,
+    layers: stack.pull_requests.map((pr) => ({
+      number: pr.number,
+      title: pr.title || pr.head.ref,
+      headRefName: pr.head.ref,
+      state: pr.merged_at || pr.state === "merged" ? "MERGED" : pr.state === "closed" ? "CLOSED" : "OPEN",
+      isDraft: pr.draft ?? false
+    }))
+  };
+}
 const OWNER_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?$/;
 const REPO_PATTERN = /^[A-Za-z0-9._-]+$/;
 function parseGitHubRemote(url) {
@@ -18250,13 +18539,13 @@ function parsePullRequestList(raw) {
 function parsePullRequestDetails(raw) {
   const item = parseJson(raw, "gh-pr-view");
   const summary = parseSummary(item, "gh-pr-view");
-  const record = item;
+  const record2 = item;
   return {
     ...summary,
-    body: typeof record.body === "string" ? record.body : "",
-    changedFiles: numberOrZero(record.changedFiles),
-    labels: parseLabels(record.labels),
-    commits: parseCommits(record.commits)
+    body: typeof record2.body === "string" ? record2.body : "",
+    changedFiles: numberOrZero(record2.changedFiles),
+    labels: parseLabels(record2.labels),
+    commits: parseCommits(record2.commits)
   };
 }
 function sortPullRequestsNewestFirst(pulls) {
@@ -18283,27 +18572,27 @@ function parseCreatedPullRequestUrl(stdout) {
 function parseSummary(item, operation) {
   const parsed = summaryRecordSchema.safeParse(item);
   if (!parsed.success) throw invalidOutput(operation);
-  const record = parsed.data;
+  const record2 = parsed.data;
   const { number: number2, state } = parsed.data;
-  const parsedAuthor = tolerantRecordSchema.safeParse(record.author);
+  const parsedAuthor = tolerantRecordSchema.safeParse(record2.author);
   const authorRecord = parsedAuthor.success ? parsedAuthor.data : null;
   const author = authorRecord?.login;
   const authorLogin = typeof author === "string" ? author : "unknown";
   return {
     number: number2,
-    title: typeof record.title === "string" ? record.title : "",
+    title: typeof record2.title === "string" ? record2.title : "",
     state,
-    isDraft: record.isDraft === true,
+    isDraft: record2.isDraft === true,
     author: authorLogin,
     authorAvatarUrl: avatarUrl(authorLogin, authorRecord?.is_bot === true),
-    headRefName: typeof record.headRefName === "string" ? record.headRefName : "",
-    baseRefName: typeof record.baseRefName === "string" ? record.baseRefName : "",
-    updatedAt: typeof record.updatedAt === "string" ? record.updatedAt : "",
-    url: typeof record.url === "string" ? record.url : "",
-    reviewDecision: typeof record.reviewDecision === "string" && record.reviewDecision ? record.reviewDecision : null,
-    additions: numberOrZero(record.additions),
-    deletions: numberOrZero(record.deletions),
-    checksState: parseChecksState(record.statusCheckRollup)
+    headRefName: typeof record2.headRefName === "string" ? record2.headRefName : "",
+    baseRefName: typeof record2.baseRefName === "string" ? record2.baseRefName : "",
+    updatedAt: typeof record2.updatedAt === "string" ? record2.updatedAt : "",
+    url: typeof record2.url === "string" ? record2.url : "",
+    reviewDecision: typeof record2.reviewDecision === "string" && record2.reviewDecision ? record2.reviewDecision : null,
+    additions: numberOrZero(record2.additions),
+    deletions: numberOrZero(record2.deletions),
+    checksState: parseChecksState(record2.statusCheckRollup)
   };
 }
 function parseLabels(value) {
@@ -18312,10 +18601,10 @@ function parseLabels(value) {
   return parsed.data.flatMap((item) => {
     const candidate = tolerantRecordSchema.safeParse(item);
     if (!candidate.success) return [];
-    const record = candidate.data;
-    if (typeof record.name !== "string" || !record.name) return [];
-    const color = typeof record.color === "string" && /^[0-9a-f]{6}$/i.test(record.color) ? record.color : "6e7781";
-    return [{ name: record.name, color }];
+    const record2 = candidate.data;
+    if (typeof record2.name !== "string" || !record2.name) return [];
+    const color = typeof record2.color === "string" && /^[0-9a-f]{6}$/i.test(record2.color) ? record2.color : "6e7781";
+    return [{ name: record2.name, color }];
   });
 }
 function parseCommits(value) {
@@ -18324,16 +18613,16 @@ function parseCommits(value) {
   return parsed.data.flatMap((item) => {
     const candidate = tolerantRecordSchema.safeParse(item);
     if (!candidate.success) return [];
-    const record = candidate.data;
-    if (typeof record.oid !== "string" || !record.oid) return [];
-    const authors = Array.isArray(record.authors) ? record.authors : [];
+    const record2 = candidate.data;
+    if (typeof record2.oid !== "string" || !record2.oid) return [];
+    const authors = Array.isArray(record2.authors) ? record2.authors : [];
     const authorRecord = authors.map((author) => tolerantRecordSchema.safeParse(author)).find((author) => author.success)?.data;
     const login = typeof authorRecord?.login === "string" ? authorRecord.login : null;
     const name = typeof authorRecord?.name === "string" && authorRecord.name ? authorRecord.name : login ?? "unknown";
     return [{
-      oid: record.oid,
-      messageHeadline: typeof record.messageHeadline === "string" ? record.messageHeadline : "",
-      authoredAt: typeof record.authoredDate === "string" ? record.authoredDate : "",
+      oid: record2.oid,
+      messageHeadline: typeof record2.messageHeadline === "string" ? record2.messageHeadline : "",
+      authoredAt: typeof record2.authoredDate === "string" ? record2.authoredDate : "",
       author: name,
       authorAvatarUrl: login ? avatarUrl(login, login.endsWith("[bot]")) : null
     }];
@@ -18345,11 +18634,11 @@ function parseChecksState(value) {
   for (const item of value) {
     const parsed = tolerantRecordSchema.safeParse(item);
     if (!parsed.success) continue;
-    const record = parsed.data;
-    const conclusion = typeof record.conclusion === "string" ? record.conclusion.toUpperCase() : "";
-    const state = typeof record.state === "string" ? record.state.toUpperCase() : "";
+    const record2 = parsed.data;
+    const conclusion = typeof record2.conclusion === "string" ? record2.conclusion.toUpperCase() : "";
+    const state = typeof record2.state === "string" ? record2.state.toUpperCase() : "";
     if (["FAILURE", "ERROR", "TIMED_OUT", "CANCELLED", "ACTION_REQUIRED", "STARTUP_FAILURE"].includes(conclusion || state)) return "FAILING";
-    const status = typeof record.status === "string" ? record.status.toUpperCase() : "";
+    const status = typeof record2.status === "string" ? record2.status.toUpperCase() : "";
     if (status && status !== "COMPLETED" || ["PENDING", "EXPECTED"].includes(state)) pending = true;
   }
   return pending ? "PENDING" : "PASSING";
@@ -18414,7 +18703,7 @@ class GitHubService {
       ["pr", "list", "-R", nameWithOwner, "--state", state.toLowerCase(), "--json", PR_SUMMARY_FIELDS, "--limit", "50"],
       { cwd: repository.path, operation: "gh-pr-list", timeoutMs: NETWORK_TIMEOUT_MS, maxOutputBytes: 4 * 1024 * 1024 }
     )));
-    return selectPullRequestsNewestFirst(results.flatMap((result) => parsePullRequestList(result.stdout)), states);
+    return this.withStackMembership(repository.path, nameWithOwner, selectPullRequestsNewestFirst(results.flatMap((result) => parsePullRequestList(result.stdout)), states));
   }
   async findPullRequestForBranch(repositoryId, branchName) {
     const operation = "gh-pr-for-branch";
@@ -18432,7 +18721,51 @@ class GitHubService {
       ["pr", "view", String(prNumber), "-R", nameWithOwner, "--json", PR_DETAIL_FIELDS],
       { cwd: repository.path, operation: "gh-pr-view", timeoutMs: NETWORK_TIMEOUT_MS, maxOutputBytes: 4 * 1024 * 1024 }
     );
-    return parsePullRequestDetails(result.stdout);
+    const details = parsePullRequestDetails(result.stdout);
+    return (await this.withStackMembership(repository.path, nameWithOwner, [details]))[0];
+  }
+  async withStackMembership(cwd, nameWithOwner, pulls) {
+    const [owner, name] = nameWithOwner.split("/");
+    const enriched = [];
+    for (let start = 0; start < pulls.length; start += 25) {
+      const batch = pulls.slice(start, start + 25);
+      try {
+        const numbers = batch.map((pr) => pr.number);
+        const result = await this.runGh(["api", "graphql", "-f", `owner=${owner}`, "-f", `name=${name}`, "-f", `query=${stackMembershipQuery(numbers)}`], {
+          cwd,
+          operation: "gh-pr-stack-membership",
+          timeoutMs: 1e4,
+          maxOutputBytes: 1024 * 1024
+        });
+        const memberships = parseStackMemberships(result.stdout, numbers);
+        enriched.push(...batch.map((pr) => {
+          const stack = memberships.get(pr.number);
+          return stack ? { ...pr, stack } : pr;
+        }));
+      } catch {
+        enriched.push(...batch);
+      }
+    }
+    return enriched;
+  }
+  async getPullRequestStack(repositoryId, prNumber) {
+    const operation = "gh-pr-stack";
+    const { repository, nameWithOwner } = await this.requireGitHub(repositoryId, operation);
+    const options = { cwd: repository.path, operation, timeoutMs: NETWORK_TIMEOUT_MS, maxOutputBytes: 4 * 1024 * 1024 };
+    const read = async (endpoint) => this.runGh(["api", endpoint], options);
+    let listing;
+    try {
+      listing = await read(`repos/${nameWithOwner}/stacks?pull_request=${prNumber}`);
+    } catch (error) {
+      if (error instanceof GhOperationError && error.detail.code === "GH_PROCESS_FAILED" && /HTTP 404/.test(error.message)) return null;
+      throw error;
+    }
+    const stack = parsePullRequestStack(listing.stdout, prNumber, true);
+    if (!stack) return null;
+    const details = await read(`repos/${nameWithOwner}/stacks/${stack.number}`);
+    const complete = parsePullRequestStack(details.stdout, prNumber);
+    if (complete?.number !== stack.number) throw new GhOperationError({ code: "GH_INVALID_OUTPUT", operation, message: "The stack changed while loading. Refresh to try again." });
+    return complete;
   }
   async getPullRequestDiff(repositoryId, prNumber) {
     const { repository, nameWithOwner } = await this.requireGitHub(repositoryId, "gh-pr-diff");
@@ -18676,7 +19009,7 @@ class ProblemsLogStore {
     this.loaded = true;
   }
   record(entry) {
-    const record = {
+    const record2 = {
       id: randomUUID(),
       at: (/* @__PURE__ */ new Date()).toISOString(),
       level: entry.level ?? "error",
@@ -18686,7 +19019,7 @@ class ProblemsLogStore {
       message: entry.message,
       repositoryId: entry.repositoryId ?? null
     };
-    const normalized = normalizeProblemLogEntry(record);
+    const normalized = normalizeProblemLogEntry(record2);
     if (!normalized) return;
     this.pending = this.pending.then(async () => {
       await mkdir(path.dirname(this.filePath), { recursive: true });
@@ -18785,10 +19118,10 @@ resolveShortcuts();
 function sanitizeShortcutOverrides(value) {
   const result = {};
   if (!value || typeof value !== "object") return result;
-  const record = value;
+  const record2 = value;
   const usedCombos = /* @__PURE__ */ new Set();
   for (const def of SHORTCUT_DEFINITIONS) {
-    const combo = record[def.id];
+    const combo = record2[def.id];
     if (typeof combo !== "string" || combo === def.defaultCombo) continue;
     if (!isValidCombo(combo, def.allowBare)) continue;
     if (RESERVED_COMBOS.has(combo) || usedCombos.has(combo)) continue;
@@ -19794,6 +20127,7 @@ const IPC = {
   githubPrForBranch: "github:pr-for-branch",
   githubPrList: "github:pr-list",
   githubPrView: "github:pr-view",
+  githubPrStack: "github:pr-stack",
   githubPrDiff: "github:pr-diff",
   githubPrCommitDiff: "github:pr-commit-diff",
   githubPrCreate: "github:pr-create",
@@ -19878,6 +20212,7 @@ const OPEN_TIG_SERVER_COMMANDS = {
   "github.findPullRequestForBranch": command(IPC.githubPrForBranch, "gh-pr-for-branch", false),
   "github.listPullRequests": command(IPC.githubPrList, "gh-pr-list", false),
   "github.getPullRequest": command(IPC.githubPrView, "gh-pr-view", false),
+  "github.getPullRequestStack": command(IPC.githubPrStack, "gh-pr-stack", false),
   "github.getPullRequestDiff": command(IPC.githubPrDiff, "gh-pr-diff", false),
   "github.getPullRequestCommitDiff": command(IPC.githubPrCommitDiff, "gh-pr-commit-diff", false),
   "github.createPullRequest": command(IPC.githubPrCreate, "gh-pr-create", true),
@@ -20127,28 +20462,28 @@ function filesTreeStateArg(repositoryId, value, operation) {
   return { repositoryId, expandedPaths: normalizeExpandedPaths(expandedPaths) };
 }
 function openFilesStateArg(repositoryId, tabs, activePath, previewPath, operation) {
-  const invalid = () => new GitOperationError({ code: "INVALID_ARGUMENT", operation, message: "Invalid open files state." });
+  const invalid2 = () => new GitOperationError({ code: "INVALID_ARGUMENT", operation, message: "Invalid open files state." });
   const parsedTabs = array(openFileTabSchema).max(MAX_OPEN_FILE_TABS).safeParse(tabs);
-  if (!isOpenFilesRepositoryId(repositoryId) || !parsedTabs.success) throw invalid();
+  if (!isOpenFilesRepositoryId(repositoryId) || !parsedTabs.success) throw invalid2();
   const normalizedTabs = [];
   const seen = /* @__PURE__ */ new Set();
   for (const input of parsedTabs.data) {
     const path2 = normalizeOpenFilePath(input.path);
-    if (!path2 || typeof input.pinned !== "boolean") throw invalid();
+    if (!path2 || typeof input.pinned !== "boolean") throw invalid2();
     if (seen.has(path2)) continue;
     seen.add(path2);
     normalizedTabs.push({ path: path2, pinned: input.pinned });
   }
-  const active = optionalOpenFilePath(activePath, invalid);
-  const preview = optionalOpenFilePath(previewPath, invalid);
-  if (active && !seen.has(active)) throw invalid();
-  if (preview && !seen.has(preview)) throw invalid();
+  const active = optionalOpenFilePath(activePath, invalid2);
+  const preview = optionalOpenFilePath(previewPath, invalid2);
+  if (active && !seen.has(active)) throw invalid2();
+  if (preview && !seen.has(preview)) throw invalid2();
   return { repositoryId, tabs: normalizedTabs, activePath: active, previewPath: preview };
 }
-function optionalOpenFilePath(value, invalid) {
+function optionalOpenFilePath(value, invalid2) {
   if (value === null || value === void 0) return null;
   const normalized = normalizeOpenFilePath(value);
-  if (!normalized) throw invalid();
+  if (!normalized) throw invalid2();
   return normalized;
 }
 function projectNameArg(value, operation) {
@@ -20182,6 +20517,15 @@ function oidArg(value, operation) {
 }
 const MAX_BRANCH_REF_LENGTH = 512;
 const MAX_WORKTREE_PATH_LENGTH = 4096;
+function publishBranchArg(value) {
+  if (value == null) return void 0;
+  const request = requestObject(value, "push");
+  return {
+    remote: refsString(request.remote, "push", MAX_BRANCH_REF_LENGTH),
+    expectedBranch: refsString(request.expectedBranch, "push", MAX_BRANCH_REF_LENGTH),
+    expectedOid: oidArg(request.expectedOid, "push")
+  };
+}
 function branchDetailsArg(value, operation) {
   const request = requestObject(value, operation);
   return { repositoryId: refsString(request.repositoryId, operation, 64), fullName: refsString(request.fullName, operation, MAX_BRANCH_REF_LENGTH) };
@@ -20679,7 +21023,7 @@ function registerServerCommands(registry2, services, host) {
     return services.operations.removeWorktree(repositoryId, path2, expectedOid, force, deleteBranch);
   });
   handle(IPC.refsPull, "pull", (id) => services.operations.pull(stringArg(id, "pull", 64)));
-  handle(IPC.refsPush, "push", (id) => services.operations.push(stringArg(id, "push", 64)));
+  handle(IPC.refsPush, "push", (id, publish) => services.operations.push(stringArg(id, "push", 64), publishBranchArg(publish)));
   handle(IPC.refsFetch, "fetch", (id) => services.operations.fetch(stringArg(id, "fetch", 64)));
   handle(IPC.aiStatuses, "ai-statuses", (forceRefresh) => services.ai.statuses(booleanArg(forceRefresh, "ai-statuses")));
   handleWithContext(IPC.aiGenerateCommitMessage, "ai-generate-commit-message", (context, input) => services.ai.generate(generateCommitMessageArg(input), context.signal));
@@ -20719,6 +21063,7 @@ function registerServerCommands(registry2, services, host) {
     pullRequestStatesArg(states, "gh-pr-list")
   ));
   handle(IPC.githubPrView, "gh-pr-view", (id, prNumber) => services.github.getPullRequest(stringArg(id, "gh-pr-view", 64), prNumberArg(prNumber, "gh-pr-view")));
+  handle(IPC.githubPrStack, "gh-pr-stack", (id, prNumber) => services.github.getPullRequestStack(stringArg(id, "gh-pr-stack", 64), prNumberArg(prNumber, "gh-pr-stack")));
   handle(IPC.githubPrDiff, "gh-pr-diff", (id, prNumber) => services.github.getPullRequestDiff(stringArg(id, "gh-pr-diff", 64), prNumberArg(prNumber, "gh-pr-diff")));
   handle(IPC.githubPrCommitDiff, "gh-pr-commit-diff", (id, oid) => services.github.getPullRequestCommitDiff(stringArg(id, "gh-pr-commit-diff", 64), oidArg(oid, "gh-pr-commit-diff")));
   handle(IPC.githubPrCreate, "gh-pr-create", (input) => services.github.createPullRequest(createPullRequestArg(input)));