@cortexkit/opencode-antigravity-auth 3.0.41 → 3.0.42

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (34) hide show
  1. package/dist/cli.js +1186 -1179
  2. package/dist/cli.js.map +4 -4
  3. package/dist/cli.meta.json +99 -89
  4. package/dist/index.js +532 -456
  5. package/dist/index.js.map +4 -4
  6. package/dist/index.meta.json +105 -95
  7. package/dist/server.js +532 -456
  8. package/dist/server.js.map +4 -4
  9. package/dist/server.meta.json +1 -1
  10. package/dist/src/common-auth-embedded/fs/refresh-file-lock.js +13 -9
  11. package/dist/src/common-auth-embedded/routing-accessor/index.d.ts +33 -5
  12. package/dist/src/common-auth-embedded/routing-accessor/index.js +49 -7
  13. package/dist/src/common-auth-embedded/source-output.json +15 -15
  14. package/dist/src/plugin/__fixtures__/verified-store.js +2 -2
  15. package/dist/src/plugin/request-helpers.d.ts +10 -0
  16. package/dist/src/plugin/request-helpers.d.ts.map +1 -1
  17. package/dist/src/plugin/request-helpers.js +6 -0
  18. package/dist/src/plugin/request-helpers.js.map +1 -1
  19. package/dist/src/plugin/shared/request-services.d.ts +8 -1
  20. package/dist/src/plugin/shared/request-services.d.ts.map +1 -1
  21. package/dist/src/plugin/shared/request-services.js +39 -0
  22. package/dist/src/plugin/shared/request-services.js.map +1 -1
  23. package/dist/tui-build-map.json +1 -1
  24. package/dist/tui-ga-build-map.json +1 -1
  25. package/dist/types/src/common-auth-embedded/routing-accessor/index.d.ts +33 -5
  26. package/dist/types/src/plugin/request-helpers.d.ts +10 -0
  27. package/dist/types/src/plugin/request-helpers.d.ts.map +1 -1
  28. package/dist/types/src/plugin/shared/request-services.d.ts +8 -1
  29. package/dist/types/src/plugin/shared/request-services.d.ts.map +1 -1
  30. package/package.json +2 -2
  31. package/src/common-auth-embedded/fs/refresh-file-lock.js +13 -9
  32. package/src/common-auth-embedded/routing-accessor/index.d.ts +33 -5
  33. package/src/common-auth-embedded/routing-accessor/index.js +49 -7
  34. package/src/common-auth-embedded/source-output.json +15 -15
package/dist/index.js CHANGED
@@ -12840,15 +12840,438 @@ var init_lock_record = __esm({
12840
12840
  }
12841
12841
  });
12842
12842
 
12843
+ // ../core/dist/common-auth-embedded/logger/capture-sink.js
12844
+ function createCaptureSink() {
12845
+ const records = [];
12846
+ const sink = (record5) => {
12847
+ records.push(record5);
12848
+ };
12849
+ return {
12850
+ records,
12851
+ sink,
12852
+ clear: () => {
12853
+ records.length = 0;
12854
+ }
12855
+ };
12856
+ }
12857
+ var init_capture_sink = __esm({
12858
+ "../core/dist/common-auth-embedded/logger/capture-sink.js"() {
12859
+ "use strict";
12860
+ }
12861
+ });
12862
+
12863
+ // ../core/dist/common-auth-embedded/logger/redact.js
12864
+ function isError(value) {
12865
+ return value instanceof Error || Object.prototype.toString.call(value) === "[object Error]";
12866
+ }
12867
+ function createRedactor(options = {}) {
12868
+ const patterns = [TOKEN_VALUE, ...options.extraValuePatterns ?? []].map((pattern) => new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`));
12869
+ function isSecretKey(key) {
12870
+ const normalized = key.toLowerCase().replace(/[-_]/g, "");
12871
+ return SECRET_KEY_EXACT.test(key) || normalized.includes("apikey") || normalized.endsWith("secret") || normalized.endsWith("password") || normalized.endsWith("token") && !normalized.endsWith("tokens") || !!options.extraSecretKeys?.(normalized);
12872
+ }
12873
+ function errorEntries(error) {
12874
+ const fields2 = error;
12875
+ const entries = [
12876
+ ["name", error.name],
12877
+ ["message", error.message],
12878
+ ["stack", error.stack]
12879
+ ];
12880
+ for (const key of ["code", "status", "cause"])
12881
+ if (fields2[key] !== void 0)
12882
+ entries.push([key, fields2[key]]);
12883
+ const listed = new Set(entries.map(([key]) => key));
12884
+ for (const entry of Object.entries(error))
12885
+ if (!listed.has(entry[0]))
12886
+ entries.push(entry);
12887
+ return entries;
12888
+ }
12889
+ function walk(value, keys, seen, errorDepth = 0) {
12890
+ if (typeof value === "string") {
12891
+ return patterns.reduce((text2, pattern) => text2.replace(pattern, MASK), value);
12892
+ }
12893
+ if (!value || typeof value !== "object")
12894
+ return value;
12895
+ if (seen.has(value))
12896
+ return "[Circular]";
12897
+ seen.add(value);
12898
+ try {
12899
+ if (Array.isArray(value))
12900
+ return value.map((item) => walk(item, keys, seen, errorDepth));
12901
+ const error = isError(value);
12902
+ if (error && errorDepth >= MAX_ERROR_DEPTH)
12903
+ return "[Truncated]";
12904
+ const childDepth = error ? errorDepth + 1 : errorDepth;
12905
+ return Object.fromEntries((error ? errorEntries(value) : Object.entries(value)).map(([key, item]) => [
12906
+ key,
12907
+ keys && isSecretKey(key) ? MASK : walk(item, keys, seen, childDepth)
12908
+ ]));
12909
+ } finally {
12910
+ seen.delete(value);
12911
+ }
12912
+ }
12913
+ return {
12914
+ redact: (value) => walk(value, true, /* @__PURE__ */ new WeakSet()),
12915
+ // Schema keys describe arguments, not credentials; only their string values are scrubbed.
12916
+ redactStrings: (value) => walk(value, false, /* @__PURE__ */ new WeakSet())
12917
+ };
12918
+ }
12919
+ var SECRET_KEY_EXACT, TOKEN_VALUE, MASK, MAX_ERROR_DEPTH, defaultRedactor, redact, redactStrings;
12920
+ var init_redact = __esm({
12921
+ "../core/dist/common-auth-embedded/logger/redact.js"() {
12922
+ "use strict";
12923
+ SECRET_KEY_EXACT = /^(authorization|x-api-key|cookie|set-cookie|refresh|access|token)$/i;
12924
+ TOKEN_VALUE = /\b(Bearer\s+[\w.-]+|sk-[\w-]+|eyJ[\w.-]+)\b|ckh_[A-Za-z0-9_-]{20,}/g;
12925
+ MASK = "***REDACTED***";
12926
+ MAX_ERROR_DEPTH = 8;
12927
+ defaultRedactor = createRedactor();
12928
+ redact = defaultRedactor.redact;
12929
+ redactStrings = defaultRedactor.redactStrings;
12930
+ }
12931
+ });
12932
+
12933
+ // ../core/dist/common-auth-embedded/logger/engine.js
12934
+ import { appendFileSync, chmodSync, existsSync, renameSync, statSync } from "node:fs";
12935
+ import { open as open4 } from "node:fs/promises";
12936
+ import { dirname as dirname7, resolve as resolve4 } from "node:path";
12937
+ function chmodPrivate(path5) {
12938
+ try {
12939
+ chmodSync(path5, 384);
12940
+ } catch {
12941
+ }
12942
+ }
12943
+ function rotateIfNeeded(f) {
12944
+ try {
12945
+ if (!(existsSync(f) && statSync(f).size >= MAX_BYTES))
12946
+ return;
12947
+ for (let i = ROTATE_KEEP - 1; i >= 1; i--) {
12948
+ if (existsSync(`${f}.${i}`)) {
12949
+ const rotated2 = `${f}.${i + 1}`;
12950
+ renameSync(`${f}.${i}`, rotated2);
12951
+ chmodPrivate(rotated2);
12952
+ }
12953
+ }
12954
+ const rotated = `${f}.1`;
12955
+ renameSync(f, rotated);
12956
+ chmodPrivate(rotated);
12957
+ } catch {
12958
+ }
12959
+ }
12960
+ async function closeWindowsFile(sink) {
12961
+ const { file, handle } = sink;
12962
+ sink.file = void 0;
12963
+ sink.handle = void 0;
12964
+ if (file && handle)
12965
+ await privateOperation(file, "log-close", () => handle.close());
12966
+ }
12967
+ async function openWindowsFile(sink, file) {
12968
+ await ensurePrivateDirectory(dirname7(file));
12969
+ try {
12970
+ await verifyPrivate(file, "file", true);
12971
+ } catch (error) {
12972
+ if (error.code !== "ENOENT")
12973
+ throw error;
12974
+ try {
12975
+ await createPrivateBytes(file, "");
12976
+ } catch (creationError) {
12977
+ if (creationError.code !== "EEXIST")
12978
+ throw creationError;
12979
+ await verifyPrivate(file, "file", true);
12980
+ }
12981
+ }
12982
+ sink.handle = await privateOperation(file, "log-open", () => open4(file, "a"));
12983
+ sink.file = file;
12984
+ return sink.handle;
12985
+ }
12986
+ async function flushWindowsFile(sink, file, text2) {
12987
+ file = resolve4(file);
12988
+ try {
12989
+ if (sink.file !== file)
12990
+ await closeWindowsFile(sink);
12991
+ let handle = sink.handle ?? await openWindowsFile(sink, file);
12992
+ const info = await privateOperation(file, "log-stat", () => handle.stat());
12993
+ if (info.size >= MAX_BYTES) {
12994
+ await closeWindowsFile(sink);
12995
+ for (let i = ROTATE_KEEP - 1; i >= 0; i--) {
12996
+ const source = i === 0 ? file : `${file}.${i}`;
12997
+ const target = `${file}.${i + 1}`;
12998
+ try {
12999
+ await verifyPrivate(source, "file", true);
13000
+ } catch (error) {
13001
+ if (error.code === "ENOENT")
13002
+ continue;
13003
+ throw error;
13004
+ }
13005
+ try {
13006
+ await verifyPrivate(target, "file", true);
13007
+ } catch (error) {
13008
+ if (error.code !== "ENOENT")
13009
+ throw error;
13010
+ }
13011
+ await replaceWindowsFile(source, target);
13012
+ await verifyPrivate(target, "file");
13013
+ }
13014
+ handle = await openWindowsFile(sink, file);
13015
+ }
13016
+ await privateOperation(file, "log-append", () => handle.appendFile(text2, "utf8"));
13017
+ } catch (error) {
13018
+ await closeWindowsFile(sink).catch(() => {
13019
+ });
13020
+ throw error;
13021
+ }
13022
+ }
13023
+ function safeSerialize(data) {
13024
+ try {
13025
+ return ` ${JSON.stringify(data)}`;
13026
+ } catch {
13027
+ return " [unserializable]";
13028
+ }
13029
+ }
13030
+ function createEngine(options) {
13031
+ let logFileSource;
13032
+ let initLevelSource;
13033
+ let runtimeLevel;
13034
+ let redactor = createRedactor();
13035
+ let captureSink;
13036
+ let buffer = [];
13037
+ let timer;
13038
+ let orderedSink = Promise.resolve();
13039
+ let sinkError;
13040
+ const windowsFile = {};
13041
+ function queueWindows(operation) {
13042
+ const next = orderedSink.then(operation);
13043
+ orderedSink = next.catch((error) => {
13044
+ sinkError = error;
13045
+ });
13046
+ return next;
13047
+ }
13048
+ function configure(next) {
13049
+ if (windowsPrivateFiles && next.file !== logFileSource)
13050
+ void queueWindows(() => closeWindowsFile(windowsFile)).catch(() => {
13051
+ });
13052
+ logFileSource = next.file;
13053
+ initLevelSource = next.level;
13054
+ redactor = createRedactor(next);
13055
+ captureSink = next.captureSink;
13056
+ }
13057
+ function setLogLevel3(l) {
13058
+ if (l === void 0 || l in ORDER)
13059
+ runtimeLevel = l;
13060
+ }
13061
+ function logFilePath() {
13062
+ if (logFileSource === void 0)
13063
+ return void 0;
13064
+ const resolved = typeof logFileSource === "function" ? logFileSource() : logFileSource;
13065
+ return resolved || void 0;
13066
+ }
13067
+ function configuredLevel() {
13068
+ if (runtimeLevel)
13069
+ return runtimeLevel;
13070
+ const floor = typeof initLevelSource === "function" ? initLevelSource() : initLevelSource;
13071
+ if (floor && floor in ORDER)
13072
+ return floor;
13073
+ return "info";
13074
+ }
13075
+ function flushLogs3(close = true) {
13076
+ if (timer) {
13077
+ clearTimeout(timer);
13078
+ timer = void 0;
13079
+ }
13080
+ if (!buffer.length) {
13081
+ if (windowsPrivateFiles)
13082
+ return queueWindows(async () => {
13083
+ if (close)
13084
+ await closeWindowsFile(windowsFile);
13085
+ if (sinkError)
13086
+ throw sinkError;
13087
+ });
13088
+ return;
13089
+ }
13090
+ let file;
13091
+ try {
13092
+ file = logFilePath();
13093
+ } catch {
13094
+ buffer = [];
13095
+ if (windowsPrivateFiles && close)
13096
+ return queueWindows(() => closeWindowsFile(windowsFile));
13097
+ return;
13098
+ }
13099
+ const text2 = buffer.join("");
13100
+ buffer = [];
13101
+ if (!file) {
13102
+ if (windowsPrivateFiles && close)
13103
+ return queueWindows(() => closeWindowsFile(windowsFile));
13104
+ return;
13105
+ }
13106
+ if (windowsPrivateFiles) {
13107
+ return queueWindows(async () => {
13108
+ try {
13109
+ await flushWindowsFile(windowsFile, file, text2);
13110
+ } finally {
13111
+ if (close)
13112
+ await closeWindowsFile(windowsFile);
13113
+ }
13114
+ });
13115
+ }
13116
+ try {
13117
+ rotateIfNeeded(file);
13118
+ if (existsSync(file))
13119
+ chmodPrivate(file);
13120
+ appendFileSync(file, text2, { encoding: "utf8", mode: 384 });
13121
+ } catch {
13122
+ }
13123
+ }
13124
+ function schedule2() {
13125
+ if (!timer)
13126
+ timer = setTimeout(() => {
13127
+ timer = void 0;
13128
+ const flushed = flushLogs3(false);
13129
+ if (flushed instanceof Promise)
13130
+ void flushed.catch(() => {
13131
+ });
13132
+ }, 500);
13133
+ }
13134
+ function emit(channel3, level, message, data) {
13135
+ if (logFileSource === void 0 && captureSink === void 0)
13136
+ return;
13137
+ try {
13138
+ if (ORDER[level] > ORDER[configuredLevel()])
13139
+ return;
13140
+ const scrubbedMessage = redactor.redactStrings(message);
13141
+ let scrubbedData;
13142
+ try {
13143
+ scrubbedData = redactor.redact(data);
13144
+ } catch {
13145
+ scrubbedData = "[unserializable]";
13146
+ }
13147
+ const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${level.toUpperCase()} [${channel3}] ${scrubbedMessage}` + (data === void 0 ? "" : safeSerialize(scrubbedData)) + "\n";
13148
+ try {
13149
+ captureSink?.({
13150
+ channel: channel3,
13151
+ level,
13152
+ message: scrubbedMessage,
13153
+ data: scrubbedData
13154
+ });
13155
+ } catch {
13156
+ }
13157
+ if (logFileSource === void 0)
13158
+ return;
13159
+ buffer.push(line);
13160
+ if (buffer.length >= 50) {
13161
+ const flushed = flushLogs3(false);
13162
+ if (flushed instanceof Promise)
13163
+ void flushed.catch(() => {
13164
+ });
13165
+ } else
13166
+ schedule2();
13167
+ } catch {
13168
+ }
13169
+ }
13170
+ function createLogger5(channel3) {
13171
+ return {
13172
+ error: (m, d) => emit(channel3, "error", m, d),
13173
+ warn: (m, d) => emit(channel3, "warn", m, d),
13174
+ info: (m, d) => emit(channel3, "info", m, d),
13175
+ debug: (m, d) => emit(channel3, "debug", m, d),
13176
+ trace: (m, d) => emit(channel3, "trace", m, d)
13177
+ };
13178
+ }
13179
+ function reset() {
13180
+ if (windowsPrivateFiles)
13181
+ void queueWindows(() => closeWindowsFile(windowsFile)).catch(() => {
13182
+ });
13183
+ sinkError = void 0;
13184
+ buffer = [];
13185
+ if (timer) {
13186
+ clearTimeout(timer);
13187
+ timer = void 0;
13188
+ }
13189
+ logFileSource = void 0;
13190
+ initLevelSource = void 0;
13191
+ runtimeLevel = void 0;
13192
+ redactor = createRedactor();
13193
+ captureSink = void 0;
13194
+ }
13195
+ if (options)
13196
+ configure(options);
13197
+ return { configure, createLogger: createLogger5, setLogLevel: setLogLevel3, flushLogs: flushLogs3, reset };
13198
+ }
13199
+ function createLoggerInstance(options) {
13200
+ const { configure, createLogger: createLogger5, setLogLevel: setLogLevel3, flushLogs: flushLogs3 } = createEngine(options);
13201
+ return { configure, createLogger: createLogger5, setLogLevel: setLogLevel3, flushLogs: flushLogs3 };
13202
+ }
13203
+ function initLogger(options) {
13204
+ defaultEngine.configure(options);
13205
+ const { configure, createLogger: createLogger5, setLogLevel: setLogLevel3, flushLogs: flushLogs3 } = defaultEngine;
13206
+ return { configure, createLogger: createLogger5, setLogLevel: setLogLevel3, flushLogs: flushLogs3 };
13207
+ }
13208
+ function setLogLevel(l) {
13209
+ defaultEngine.setLogLevel(l);
13210
+ }
13211
+ function flushLogs() {
13212
+ return defaultEngine.flushLogs();
13213
+ }
13214
+ function createLogger2(channel3) {
13215
+ return defaultEngine.createLogger(channel3);
13216
+ }
13217
+ async function flushForTest() {
13218
+ return defaultEngine.flushLogs();
13219
+ }
13220
+ function resetLoggerForTest() {
13221
+ defaultEngine.reset();
13222
+ }
13223
+ var ORDER, MAX_BYTES, ROTATE_KEEP, defaultEngine;
13224
+ var init_engine = __esm({
13225
+ "../core/dist/common-auth-embedded/logger/engine.js"() {
13226
+ "use strict";
13227
+ init_private_files();
13228
+ init_redact();
13229
+ ORDER = {
13230
+ error: 0,
13231
+ warn: 1,
13232
+ info: 2,
13233
+ debug: 3,
13234
+ trace: 4
13235
+ };
13236
+ MAX_BYTES = 5 * 1024 * 1024;
13237
+ ROTATE_KEEP = 3;
13238
+ defaultEngine = createEngine();
13239
+ }
13240
+ });
13241
+
13242
+ // ../core/dist/common-auth-embedded/logger/index.js
13243
+ var logger_exports = {};
13244
+ __export(logger_exports, {
13245
+ createCaptureSink: () => createCaptureSink,
13246
+ createLogger: () => createLogger2,
13247
+ createLoggerInstance: () => createLoggerInstance,
13248
+ createRedactor: () => createRedactor,
13249
+ flushForTest: () => flushForTest,
13250
+ flushLogs: () => flushLogs,
13251
+ initLogger: () => initLogger,
13252
+ redact: () => redact,
13253
+ redactStrings: () => redactStrings,
13254
+ resetLoggerForTest: () => resetLoggerForTest,
13255
+ setLogLevel: () => setLogLevel
13256
+ });
13257
+ var init_logger2 = __esm({
13258
+ "../core/dist/common-auth-embedded/logger/index.js"() {
13259
+ "use strict";
13260
+ init_capture_sink();
13261
+ init_engine();
13262
+ init_redact();
13263
+ }
13264
+ });
13265
+
12843
13266
  // ../core/dist/common-auth-embedded/fs/refresh-file-lock.js
12844
13267
  import { randomUUID as randomUUID9 } from "node:crypto";
12845
- import { link as link2, lstat as lstat3, mkdir as mkdir7, open as open4, readdir, readFile as readFile5, rename as rename6, rm as rm4, stat as stat3, unlink as unlink6 } from "node:fs/promises";
12846
- import { basename as basename3, dirname as dirname7, join as join5 } from "node:path";
13268
+ import { link as link2, lstat as lstat3, mkdir as mkdir7, open as open5, readdir, readFile as readFile5, rename as rename6, rm as rm4, stat as stat3, unlink as unlink6 } from "node:fs/promises";
13269
+ import { basename as basename3, dirname as dirname8, join as join5 } from "node:path";
12847
13270
  async function createExclusiveText(path5, text2) {
12848
13271
  const tempPath = `${path5}.${randomUUID9()}.tmp`;
12849
13272
  let handle;
12850
13273
  try {
12851
- handle = await open4(tempPath, "wx", 384);
13274
+ handle = await open5(tempPath, "wx", 384);
12852
13275
  try {
12853
13276
  if (leaseCreationTestHooks?.beforeWrite)
12854
13277
  await leaseCreationTestHooks.beforeWrite(tempPath);
@@ -12873,7 +13296,7 @@ async function createExclusiveText(path5, text2) {
12873
13296
  }
12874
13297
  }
12875
13298
  async function writeExclusiveText(path5, text2) {
12876
- const handle = await open4(path5, "wx", 384);
13299
+ const handle = await open5(path5, "wx", 384);
12877
13300
  let createdStat;
12878
13301
  try {
12879
13302
  createdStat = await handle.stat();
@@ -12914,7 +13337,7 @@ async function readStagedOwner(path5) {
12914
13337
  return void 0;
12915
13338
  if (before.size > STAGING_SWEEP_MAX_BYTES)
12916
13339
  return void 0;
12917
- const handle = await open4(path5, "r");
13340
+ const handle = await open5(path5, "r");
12918
13341
  let text2;
12919
13342
  try {
12920
13343
  if (!sameStagingFile(before, await handle.stat()))
@@ -12942,7 +13365,7 @@ async function readStagedOwner(path5) {
12942
13365
  return { identity: before, expiresAt };
12943
13366
  }
12944
13367
  async function sweepAbandonedStaging(lockPath, ttlMs, now) {
12945
- const directory = dirname7(lockPath);
13368
+ const directory = dirname8(lockPath);
12946
13369
  const lockName = basename3(lockPath);
12947
13370
  const hooks = stagingSweepTestHooks;
12948
13371
  const names = await (hooks?.readdir ?? readdir)(directory);
@@ -13084,7 +13507,7 @@ async function acquireRefreshFileLockWithClock(options) {
13084
13507
  let handle;
13085
13508
  let created = false;
13086
13509
  try {
13087
- handle = await open4(tempPath, "wx", 384);
13510
+ handle = await open5(tempPath, "wx", 384);
13088
13511
  created = true;
13089
13512
  await handle.writeFile(`${JSON.stringify({ ownerId, expiresAt: now() + options.ttlMs })}
13090
13513
  `, "utf8");
@@ -13138,7 +13561,7 @@ async function acquireRefreshFileLockWithClock(options) {
13138
13561
  }
13139
13562
  async function tryAcquire() {
13140
13563
  if (windowsPrivateFiles)
13141
- await ensurePrivateDirectory(dirname7(lockPath));
13564
+ await ensurePrivateDirectory(dirname8(lockPath));
13142
13565
  try {
13143
13566
  await createLease();
13144
13567
  return true;
@@ -13148,9 +13571,9 @@ async function acquireRefreshFileLockWithClock(options) {
13148
13571
  return false;
13149
13572
  if (code2 === "ENOENT") {
13150
13573
  if (windowsPrivateFiles)
13151
- await ensurePrivateDirectory(dirname7(lockPath));
13574
+ await ensurePrivateDirectory(dirname8(lockPath));
13152
13575
  else
13153
- await mkdir7(dirname7(lockPath), { recursive: true });
13576
+ await mkdir7(dirname8(lockPath), { recursive: true });
13154
13577
  try {
13155
13578
  await createLease();
13156
13579
  return true;
@@ -13731,17 +14154,15 @@ async function acquireRefreshFileLockWithClock(options) {
13731
14154
  removalConfirmed = true;
13732
14155
  }, deadline);
13733
14156
  changingRecordError = void 0;
13734
- if (markerAcquired) {
13735
- if (windowsPrivateFiles && !removalConfirmed)
13736
- throw new PrivateFileError(lockPath, "release-not-confirmed", {
13737
- code: "EIO"
13738
- });
13739
- releaseConfirmed = removalConfirmed;
14157
+ if (markerAcquired && removalConfirmed) {
14158
+ releaseConfirmed = true;
13740
14159
  return;
13741
14160
  }
13742
- if (signal?.aborted)
13743
- return;
13744
- await recoverStaleEvictionMarker(deadline);
14161
+ if (!markerAcquired) {
14162
+ if (signal?.aborted)
14163
+ return;
14164
+ await recoverStaleEvictionMarker(deadline);
14165
+ }
13745
14166
  } catch (error) {
13746
14167
  const changingRecord = windowsPrivateFiles && (isChangingLockCreate(error) || isWindowsAccessDeniedRead(error, [
13747
14168
  lockPath,
@@ -13771,6 +14192,9 @@ async function acquireRefreshFileLockWithClock(options) {
13771
14192
  throw changingRecordError ?? removalError ?? new PrivateFileError(lockPath, "release-not-confirmed", {
13772
14193
  code: "ETIMEDOUT"
13773
14194
  });
14195
+ createLogger2("fs").warn("File lock release deadline expired", {
14196
+ lockPath
14197
+ });
13774
14198
  }
13775
14199
  };
13776
14200
  }
@@ -13778,6 +14202,7 @@ var leaseCreationTestHooks, STAGING_UUID, STAGING_SWEEP_MIN_AGE_MS, STAGING_SWEE
13778
14202
  var init_refresh_file_lock = __esm({
13779
14203
  "../core/dist/common-auth-embedded/fs/refresh-file-lock.js"() {
13780
14204
  "use strict";
14205
+ init_logger2();
13781
14206
  init_lock_record();
13782
14207
  init_private_files();
13783
14208
  init_with_lock();
@@ -13794,12 +14219,12 @@ var init_refresh_file_lock = __esm({
13794
14219
  });
13795
14220
 
13796
14221
  // ../core/dist/common-auth-embedded/fs/with-lock.js
13797
- import { join as join6, resolve as resolve4 } from "node:path";
14222
+ import { join as join6, resolve as resolve5 } from "node:path";
13798
14223
  function lockPathFor(target, name) {
13799
14224
  return `${target}.${name}.lock`;
13800
14225
  }
13801
14226
  function isChangingLockRecord(error, target, name) {
13802
- const path5 = resolve4(lockPathFor(target, name));
14227
+ const path5 = resolve5(lockPathFor(target, name));
13803
14228
  const paths = [path5, join6(path5, "owner.json")];
13804
14229
  return (isWindowsSharingViolation(error) || isWindowsAccessDeniedRead(error, paths)) && (error.stage === "read" || error.stage === "verify") && paths.includes(error.path) || windowsPrivateFiles && (isWindowsAccessDeniedCreate(error, [path5], "create") || isWindowsAccessDeniedCreate(error, [`${path5}.evicting`], "directory-create"));
13805
14230
  }
@@ -16734,429 +17159,6 @@ var init_pull = __esm({
16734
17159
  }
16735
17160
  });
16736
17161
 
16737
- // ../core/dist/common-auth-embedded/logger/capture-sink.js
16738
- function createCaptureSink() {
16739
- const records = [];
16740
- const sink = (record5) => {
16741
- records.push(record5);
16742
- };
16743
- return {
16744
- records,
16745
- sink,
16746
- clear: () => {
16747
- records.length = 0;
16748
- }
16749
- };
16750
- }
16751
- var init_capture_sink = __esm({
16752
- "../core/dist/common-auth-embedded/logger/capture-sink.js"() {
16753
- "use strict";
16754
- }
16755
- });
16756
-
16757
- // ../core/dist/common-auth-embedded/logger/redact.js
16758
- function isError(value) {
16759
- return value instanceof Error || Object.prototype.toString.call(value) === "[object Error]";
16760
- }
16761
- function createRedactor(options = {}) {
16762
- const patterns = [TOKEN_VALUE, ...options.extraValuePatterns ?? []].map((pattern) => new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`));
16763
- function isSecretKey(key) {
16764
- const normalized = key.toLowerCase().replace(/[-_]/g, "");
16765
- return SECRET_KEY_EXACT.test(key) || normalized.includes("apikey") || normalized.endsWith("secret") || normalized.endsWith("password") || normalized.endsWith("token") && !normalized.endsWith("tokens") || !!options.extraSecretKeys?.(normalized);
16766
- }
16767
- function errorEntries(error) {
16768
- const fields2 = error;
16769
- const entries = [
16770
- ["name", error.name],
16771
- ["message", error.message],
16772
- ["stack", error.stack]
16773
- ];
16774
- for (const key of ["code", "status", "cause"])
16775
- if (fields2[key] !== void 0)
16776
- entries.push([key, fields2[key]]);
16777
- const listed = new Set(entries.map(([key]) => key));
16778
- for (const entry of Object.entries(error))
16779
- if (!listed.has(entry[0]))
16780
- entries.push(entry);
16781
- return entries;
16782
- }
16783
- function walk(value, keys, seen, errorDepth = 0) {
16784
- if (typeof value === "string") {
16785
- return patterns.reduce((text2, pattern) => text2.replace(pattern, MASK), value);
16786
- }
16787
- if (!value || typeof value !== "object")
16788
- return value;
16789
- if (seen.has(value))
16790
- return "[Circular]";
16791
- seen.add(value);
16792
- try {
16793
- if (Array.isArray(value))
16794
- return value.map((item) => walk(item, keys, seen, errorDepth));
16795
- const error = isError(value);
16796
- if (error && errorDepth >= MAX_ERROR_DEPTH)
16797
- return "[Truncated]";
16798
- const childDepth = error ? errorDepth + 1 : errorDepth;
16799
- return Object.fromEntries((error ? errorEntries(value) : Object.entries(value)).map(([key, item]) => [
16800
- key,
16801
- keys && isSecretKey(key) ? MASK : walk(item, keys, seen, childDepth)
16802
- ]));
16803
- } finally {
16804
- seen.delete(value);
16805
- }
16806
- }
16807
- return {
16808
- redact: (value) => walk(value, true, /* @__PURE__ */ new WeakSet()),
16809
- // Schema keys describe arguments, not credentials; only their string values are scrubbed.
16810
- redactStrings: (value) => walk(value, false, /* @__PURE__ */ new WeakSet())
16811
- };
16812
- }
16813
- var SECRET_KEY_EXACT, TOKEN_VALUE, MASK, MAX_ERROR_DEPTH, defaultRedactor, redact, redactStrings;
16814
- var init_redact = __esm({
16815
- "../core/dist/common-auth-embedded/logger/redact.js"() {
16816
- "use strict";
16817
- SECRET_KEY_EXACT = /^(authorization|x-api-key|cookie|set-cookie|refresh|access|token)$/i;
16818
- TOKEN_VALUE = /\b(Bearer\s+[\w.-]+|sk-[\w-]+|eyJ[\w.-]+)\b|ckh_[A-Za-z0-9_-]{20,}/g;
16819
- MASK = "***REDACTED***";
16820
- MAX_ERROR_DEPTH = 8;
16821
- defaultRedactor = createRedactor();
16822
- redact = defaultRedactor.redact;
16823
- redactStrings = defaultRedactor.redactStrings;
16824
- }
16825
- });
16826
-
16827
- // ../core/dist/common-auth-embedded/logger/engine.js
16828
- import { appendFileSync, chmodSync, existsSync, renameSync, statSync } from "node:fs";
16829
- import { open as open5 } from "node:fs/promises";
16830
- import { dirname as dirname8, resolve as resolve5 } from "node:path";
16831
- function chmodPrivate(path5) {
16832
- try {
16833
- chmodSync(path5, 384);
16834
- } catch {
16835
- }
16836
- }
16837
- function rotateIfNeeded(f) {
16838
- try {
16839
- if (!(existsSync(f) && statSync(f).size >= MAX_BYTES))
16840
- return;
16841
- for (let i = ROTATE_KEEP - 1; i >= 1; i--) {
16842
- if (existsSync(`${f}.${i}`)) {
16843
- const rotated2 = `${f}.${i + 1}`;
16844
- renameSync(`${f}.${i}`, rotated2);
16845
- chmodPrivate(rotated2);
16846
- }
16847
- }
16848
- const rotated = `${f}.1`;
16849
- renameSync(f, rotated);
16850
- chmodPrivate(rotated);
16851
- } catch {
16852
- }
16853
- }
16854
- async function closeWindowsFile(sink) {
16855
- const { file, handle } = sink;
16856
- sink.file = void 0;
16857
- sink.handle = void 0;
16858
- if (file && handle)
16859
- await privateOperation(file, "log-close", () => handle.close());
16860
- }
16861
- async function openWindowsFile(sink, file) {
16862
- await ensurePrivateDirectory(dirname8(file));
16863
- try {
16864
- await verifyPrivate(file, "file", true);
16865
- } catch (error) {
16866
- if (error.code !== "ENOENT")
16867
- throw error;
16868
- try {
16869
- await createPrivateBytes(file, "");
16870
- } catch (creationError) {
16871
- if (creationError.code !== "EEXIST")
16872
- throw creationError;
16873
- await verifyPrivate(file, "file", true);
16874
- }
16875
- }
16876
- sink.handle = await privateOperation(file, "log-open", () => open5(file, "a"));
16877
- sink.file = file;
16878
- return sink.handle;
16879
- }
16880
- async function flushWindowsFile(sink, file, text2) {
16881
- file = resolve5(file);
16882
- try {
16883
- if (sink.file !== file)
16884
- await closeWindowsFile(sink);
16885
- let handle = sink.handle ?? await openWindowsFile(sink, file);
16886
- const info = await privateOperation(file, "log-stat", () => handle.stat());
16887
- if (info.size >= MAX_BYTES) {
16888
- await closeWindowsFile(sink);
16889
- for (let i = ROTATE_KEEP - 1; i >= 0; i--) {
16890
- const source = i === 0 ? file : `${file}.${i}`;
16891
- const target = `${file}.${i + 1}`;
16892
- try {
16893
- await verifyPrivate(source, "file", true);
16894
- } catch (error) {
16895
- if (error.code === "ENOENT")
16896
- continue;
16897
- throw error;
16898
- }
16899
- try {
16900
- await verifyPrivate(target, "file", true);
16901
- } catch (error) {
16902
- if (error.code !== "ENOENT")
16903
- throw error;
16904
- }
16905
- await replaceWindowsFile(source, target);
16906
- await verifyPrivate(target, "file");
16907
- }
16908
- handle = await openWindowsFile(sink, file);
16909
- }
16910
- await privateOperation(file, "log-append", () => handle.appendFile(text2, "utf8"));
16911
- } catch (error) {
16912
- await closeWindowsFile(sink).catch(() => {
16913
- });
16914
- throw error;
16915
- }
16916
- }
16917
- function safeSerialize(data) {
16918
- try {
16919
- return ` ${JSON.stringify(data)}`;
16920
- } catch {
16921
- return " [unserializable]";
16922
- }
16923
- }
16924
- function createEngine(options) {
16925
- let logFileSource;
16926
- let initLevelSource;
16927
- let runtimeLevel;
16928
- let redactor = createRedactor();
16929
- let captureSink;
16930
- let buffer = [];
16931
- let timer;
16932
- let orderedSink = Promise.resolve();
16933
- let sinkError;
16934
- const windowsFile = {};
16935
- function queueWindows(operation) {
16936
- const next = orderedSink.then(operation);
16937
- orderedSink = next.catch((error) => {
16938
- sinkError = error;
16939
- });
16940
- return next;
16941
- }
16942
- function configure(next) {
16943
- if (windowsPrivateFiles && next.file !== logFileSource)
16944
- void queueWindows(() => closeWindowsFile(windowsFile)).catch(() => {
16945
- });
16946
- logFileSource = next.file;
16947
- initLevelSource = next.level;
16948
- redactor = createRedactor(next);
16949
- captureSink = next.captureSink;
16950
- }
16951
- function setLogLevel3(l) {
16952
- if (l === void 0 || l in ORDER)
16953
- runtimeLevel = l;
16954
- }
16955
- function logFilePath() {
16956
- if (logFileSource === void 0)
16957
- return void 0;
16958
- const resolved = typeof logFileSource === "function" ? logFileSource() : logFileSource;
16959
- return resolved || void 0;
16960
- }
16961
- function configuredLevel() {
16962
- if (runtimeLevel)
16963
- return runtimeLevel;
16964
- const floor = typeof initLevelSource === "function" ? initLevelSource() : initLevelSource;
16965
- if (floor && floor in ORDER)
16966
- return floor;
16967
- return "info";
16968
- }
16969
- function flushLogs3(close = true) {
16970
- if (timer) {
16971
- clearTimeout(timer);
16972
- timer = void 0;
16973
- }
16974
- if (!buffer.length) {
16975
- if (windowsPrivateFiles)
16976
- return queueWindows(async () => {
16977
- if (close)
16978
- await closeWindowsFile(windowsFile);
16979
- if (sinkError)
16980
- throw sinkError;
16981
- });
16982
- return;
16983
- }
16984
- let file;
16985
- try {
16986
- file = logFilePath();
16987
- } catch {
16988
- buffer = [];
16989
- if (windowsPrivateFiles && close)
16990
- return queueWindows(() => closeWindowsFile(windowsFile));
16991
- return;
16992
- }
16993
- const text2 = buffer.join("");
16994
- buffer = [];
16995
- if (!file) {
16996
- if (windowsPrivateFiles && close)
16997
- return queueWindows(() => closeWindowsFile(windowsFile));
16998
- return;
16999
- }
17000
- if (windowsPrivateFiles) {
17001
- return queueWindows(async () => {
17002
- try {
17003
- await flushWindowsFile(windowsFile, file, text2);
17004
- } finally {
17005
- if (close)
17006
- await closeWindowsFile(windowsFile);
17007
- }
17008
- });
17009
- }
17010
- try {
17011
- rotateIfNeeded(file);
17012
- if (existsSync(file))
17013
- chmodPrivate(file);
17014
- appendFileSync(file, text2, { encoding: "utf8", mode: 384 });
17015
- } catch {
17016
- }
17017
- }
17018
- function schedule2() {
17019
- if (!timer)
17020
- timer = setTimeout(() => {
17021
- timer = void 0;
17022
- const flushed = flushLogs3(false);
17023
- if (flushed instanceof Promise)
17024
- void flushed.catch(() => {
17025
- });
17026
- }, 500);
17027
- }
17028
- function emit(channel3, level, message, data) {
17029
- if (logFileSource === void 0 && captureSink === void 0)
17030
- return;
17031
- try {
17032
- if (ORDER[level] > ORDER[configuredLevel()])
17033
- return;
17034
- const scrubbedMessage = redactor.redactStrings(message);
17035
- let scrubbedData;
17036
- try {
17037
- scrubbedData = redactor.redact(data);
17038
- } catch {
17039
- scrubbedData = "[unserializable]";
17040
- }
17041
- const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${level.toUpperCase()} [${channel3}] ${scrubbedMessage}` + (data === void 0 ? "" : safeSerialize(scrubbedData)) + "\n";
17042
- try {
17043
- captureSink?.({
17044
- channel: channel3,
17045
- level,
17046
- message: scrubbedMessage,
17047
- data: scrubbedData
17048
- });
17049
- } catch {
17050
- }
17051
- if (logFileSource === void 0)
17052
- return;
17053
- buffer.push(line);
17054
- if (buffer.length >= 50) {
17055
- const flushed = flushLogs3(false);
17056
- if (flushed instanceof Promise)
17057
- void flushed.catch(() => {
17058
- });
17059
- } else
17060
- schedule2();
17061
- } catch {
17062
- }
17063
- }
17064
- function createLogger5(channel3) {
17065
- return {
17066
- error: (m, d) => emit(channel3, "error", m, d),
17067
- warn: (m, d) => emit(channel3, "warn", m, d),
17068
- info: (m, d) => emit(channel3, "info", m, d),
17069
- debug: (m, d) => emit(channel3, "debug", m, d),
17070
- trace: (m, d) => emit(channel3, "trace", m, d)
17071
- };
17072
- }
17073
- function reset() {
17074
- if (windowsPrivateFiles)
17075
- void queueWindows(() => closeWindowsFile(windowsFile)).catch(() => {
17076
- });
17077
- sinkError = void 0;
17078
- buffer = [];
17079
- if (timer) {
17080
- clearTimeout(timer);
17081
- timer = void 0;
17082
- }
17083
- logFileSource = void 0;
17084
- initLevelSource = void 0;
17085
- runtimeLevel = void 0;
17086
- redactor = createRedactor();
17087
- captureSink = void 0;
17088
- }
17089
- if (options)
17090
- configure(options);
17091
- return { configure, createLogger: createLogger5, setLogLevel: setLogLevel3, flushLogs: flushLogs3, reset };
17092
- }
17093
- function createLoggerInstance(options) {
17094
- const { configure, createLogger: createLogger5, setLogLevel: setLogLevel3, flushLogs: flushLogs3 } = createEngine(options);
17095
- return { configure, createLogger: createLogger5, setLogLevel: setLogLevel3, flushLogs: flushLogs3 };
17096
- }
17097
- function initLogger(options) {
17098
- defaultEngine.configure(options);
17099
- const { configure, createLogger: createLogger5, setLogLevel: setLogLevel3, flushLogs: flushLogs3 } = defaultEngine;
17100
- return { configure, createLogger: createLogger5, setLogLevel: setLogLevel3, flushLogs: flushLogs3 };
17101
- }
17102
- function setLogLevel(l) {
17103
- defaultEngine.setLogLevel(l);
17104
- }
17105
- function flushLogs() {
17106
- return defaultEngine.flushLogs();
17107
- }
17108
- function createLogger2(channel3) {
17109
- return defaultEngine.createLogger(channel3);
17110
- }
17111
- async function flushForTest() {
17112
- return defaultEngine.flushLogs();
17113
- }
17114
- function resetLoggerForTest() {
17115
- defaultEngine.reset();
17116
- }
17117
- var ORDER, MAX_BYTES, ROTATE_KEEP, defaultEngine;
17118
- var init_engine = __esm({
17119
- "../core/dist/common-auth-embedded/logger/engine.js"() {
17120
- "use strict";
17121
- init_private_files();
17122
- init_redact();
17123
- ORDER = {
17124
- error: 0,
17125
- warn: 1,
17126
- info: 2,
17127
- debug: 3,
17128
- trace: 4
17129
- };
17130
- MAX_BYTES = 5 * 1024 * 1024;
17131
- ROTATE_KEEP = 3;
17132
- defaultEngine = createEngine();
17133
- }
17134
- });
17135
-
17136
- // ../core/dist/common-auth-embedded/logger/index.js
17137
- var logger_exports = {};
17138
- __export(logger_exports, {
17139
- createCaptureSink: () => createCaptureSink,
17140
- createLogger: () => createLogger2,
17141
- createLoggerInstance: () => createLoggerInstance,
17142
- createRedactor: () => createRedactor,
17143
- flushForTest: () => flushForTest,
17144
- flushLogs: () => flushLogs,
17145
- initLogger: () => initLogger,
17146
- redact: () => redact,
17147
- redactStrings: () => redactStrings,
17148
- resetLoggerForTest: () => resetLoggerForTest,
17149
- setLogLevel: () => setLogLevel
17150
- });
17151
- var init_logger2 = __esm({
17152
- "../core/dist/common-auth-embedded/logger/index.js"() {
17153
- "use strict";
17154
- init_capture_sink();
17155
- init_engine();
17156
- init_redact();
17157
- }
17158
- });
17159
-
17160
17162
  // ../core/dist/common-auth-embedded/quota/commit-interval.js
17161
17163
  var QUOTA_COMMIT_INTERVAL_MS, quotaCommitTimer;
17162
17164
  var init_commit_interval = __esm({
@@ -30666,6 +30668,9 @@ function createLoggerInstance2(options) {
30666
30668
  const { configure, createLogger: createLogger5, setLogLevel: setLogLevel3, flushLogs: flushLogs3 } = createEngine2(options);
30667
30669
  return { configure, createLogger: createLogger5, setLogLevel: setLogLevel3, flushLogs: flushLogs3 };
30668
30670
  }
30671
+ function createLogger3(channel3) {
30672
+ return defaultEngine2.createLogger(channel3);
30673
+ }
30669
30674
  var ORDER2, MAX_BYTES2, ROTATE_KEEP2, defaultEngine2;
30670
30675
  var init_engine2 = __esm({
30671
30676
  "src/common-auth-embedded/logger/engine.js"() {
@@ -37825,6 +37830,7 @@ var WRITER_LOCK_CONSTANTS2 = Object.freeze({
37825
37830
  init_private_files2();
37826
37831
 
37827
37832
  // src/common-auth-embedded/fs/refresh-file-lock.js
37833
+ init_logger3();
37828
37834
  import { randomUUID as randomUUID16 } from "node:crypto";
37829
37835
  import { link as link3, lstat as lstat8, mkdir as mkdir14, open as open9, readdir as readdir5, readFile as readFile13, rename as rename11, rm as rm6, stat as stat13, unlink as unlink12 } from "node:fs/promises";
37830
37836
  import { basename as basename6, dirname as dirname19, join as join19 } from "node:path";
@@ -38779,17 +38785,15 @@ async function acquireRefreshFileLockWithClock2(options) {
38779
38785
  removalConfirmed = true;
38780
38786
  }, deadline);
38781
38787
  changingRecordError = void 0;
38782
- if (markerAcquired) {
38783
- if (windowsPrivateFiles2 && !removalConfirmed)
38784
- throw new PrivateFileError2(lockPath, "release-not-confirmed", {
38785
- code: "EIO"
38786
- });
38787
- releaseConfirmed = removalConfirmed;
38788
+ if (markerAcquired && removalConfirmed) {
38789
+ releaseConfirmed = true;
38788
38790
  return;
38789
38791
  }
38790
- if (signal?.aborted)
38791
- return;
38792
- await recoverStaleEvictionMarker(deadline);
38792
+ if (!markerAcquired) {
38793
+ if (signal?.aborted)
38794
+ return;
38795
+ await recoverStaleEvictionMarker(deadline);
38796
+ }
38793
38797
  } catch (error) {
38794
38798
  const changingRecord = windowsPrivateFiles2 && (isChangingLockCreate(error) || isWindowsAccessDeniedRead2(error, [
38795
38799
  lockPath,
@@ -38819,6 +38823,9 @@ async function acquireRefreshFileLockWithClock2(options) {
38819
38823
  throw changingRecordError ?? removalError ?? new PrivateFileError2(lockPath, "release-not-confirmed", {
38820
38824
  code: "ETIMEDOUT"
38821
38825
  });
38826
+ createLogger3("fs").warn("File lock release deadline expired", {
38827
+ lockPath
38828
+ });
38822
38829
  }
38823
38830
  };
38824
38831
  }
@@ -53977,6 +53984,7 @@ var NATIVE_GOOGLE_ERROR_MESSAGES = {
53977
53984
  soft_quota: 'Antigravity account pool is unavailable under the quota protection policy. Add accounts, wait for quota reset, or turn off soft quota protection with `"soft_quota_threshold_percent": 100` in antigravity-auth.jsonc.',
53978
53985
  pool_unavailable: "Antigravity account pool has no account available within the configured wait limit. Add accounts with `opencode auth login` or wait for quota reset.",
53979
53986
  model_unavailable: "The requested Antigravity model is not available to the configured accounts. Choose another model.",
53987
+ routing_refused: "Routing has no Antigravity account available for this request right now; try again later.",
53980
53988
  missing_access_token: "Missing access token. Run `opencode auth login` to reauthenticate.",
53981
53989
  empty_response: "Antigravity returned an empty response after the internal retry attempts."
53982
53990
  };
@@ -54003,6 +54011,9 @@ function createNativeGoogleErrorResponse(options) {
54003
54011
  let body = JSON.stringify({
54004
54012
  error: { code: options.status, status, message }
54005
54013
  });
54014
+ if (options.reason === "routing_refused" && options.retryAfterSeconds !== void 0 && options.retryAfterSeconds >= 0n) {
54015
+ headers.set("Retry-After", options.retryAfterSeconds.toString());
54016
+ }
54006
54017
  if (options.status === 412 && typeof options.resetAfterMs === "number" && Number.isFinite(options.resetAfterMs) && options.resetAfterMs >= 0) {
54007
54018
  const delaySeconds = (BigInt(Math.ceil(options.resetAfterMs)) + 999n) / 1000n;
54008
54019
  headers.set("Retry-After", delaySeconds.toString());
@@ -58534,6 +58545,28 @@ function selectionFor(answer, candidates) {
58534
58545
  }
58535
58546
  return { candidate };
58536
58547
  }
58548
+ function refusalFor(value) {
58549
+ if (!isObject2(value))
58550
+ return void 0;
58551
+ const code2 = value.code;
58552
+ if (code2 !== "account_limit_exhausted" && code2 !== "account_selection_refused" && code2 !== "account_selection_final") {
58553
+ return void 0;
58554
+ }
58555
+ const refused2 = { code: code2 };
58556
+ const routingCode = value.routing_code;
58557
+ if (typeof routingCode === "string" && /^[a-z0-9._-]{1,64}$/.test(routingCode)) {
58558
+ refused2.routingCode = routingCode;
58559
+ }
58560
+ const retryAfterSecs = value.retry_after_secs;
58561
+ if (typeof retryAfterSecs === "number" && Number.isFinite(retryAfterSecs) && retryAfterSecs >= 0) {
58562
+ refused2.retryAfterSecs = retryAfterSecs;
58563
+ }
58564
+ const resetsAtMs = value.resets_at_ms;
58565
+ if (typeof resetsAtMs === "number" && Number.isSafeInteger(resetsAtMs) && resetsAtMs > 0) {
58566
+ refused2.resetsAtMs = resetsAtMs;
58567
+ }
58568
+ return { refused: refused2 };
58569
+ }
58537
58570
  async function askRouting(input2) {
58538
58571
  let timer;
58539
58572
  try {
@@ -58543,8 +58576,8 @@ async function askRouting(input2) {
58543
58576
  const accountFor = handle.accountFor;
58544
58577
  if (typeof accountFor !== "function")
58545
58578
  return void 0;
58546
- const requested = input2.deadlineMs ?? 500;
58547
- const deadlineMs = Number.isNaN(requested) ? 500 : Math.min(2e3, Math.max(1, requested));
58579
+ const requested = input2.deadlineMs ?? 1500;
58580
+ const deadlineMs = Number.isNaN(requested) ? 1500 : Math.min(2e3, Math.max(1, requested));
58548
58581
  const expired = new Promise((resolve32) => {
58549
58582
  timer = setTimeout(() => resolve32(void 0), deadlineMs);
58550
58583
  timer.unref();
@@ -58557,10 +58590,15 @@ async function askRouting(input2) {
58557
58590
  if (typeof cap === "number" && Number.isFinite(cap)) {
58558
58591
  request2.hold_wait_max_s = Math.max(0, Math.floor(cap));
58559
58592
  }
58593
+ if (input2.refusals === true)
58594
+ request2.refusals = true;
58560
58595
  const pending = accountFor.call(handle, request2, { deadlineMs });
58561
58596
  if (!isObject2(pending) || typeof pending.then !== "function")
58562
58597
  return void 0;
58563
58598
  const answer = await Promise.race([pending, expired]);
58599
+ if (input2.refusals === true && isObject2(answer) && "refused" in answer) {
58600
+ return refusalFor(answer.refused);
58601
+ }
58564
58602
  return selectionFor(answer, input2.candidates);
58565
58603
  } catch {
58566
58604
  return void 0;
@@ -58669,6 +58707,17 @@ function reportRouting(input2) {
58669
58707
  };
58670
58708
  break;
58671
58709
  }
58710
+ case "credential_refused": {
58711
+ const { credentialId, providerCode } = input2;
58712
+ if (!isNonEmptyString(credentialId) || typeof providerCode !== "string" || !/^[a-z0-9._-]{1,64}$/.test(providerCode))
58713
+ return;
58714
+ payload = {
58715
+ ...identity4,
58716
+ outcome: "credential_refused",
58717
+ provider_code: providerCode
58718
+ };
58719
+ break;
58720
+ }
58672
58721
  default:
58673
58722
  return;
58674
58723
  }
@@ -59417,6 +59466,16 @@ function isPrimaryVaultRequest(kind, headers) {
59417
59466
  var FIRST_RETRY_DELAY_MS = 1e3;
59418
59467
  var MODEL_UNAVAILABLE_TTL_MS = 60 * 60 * 1e3;
59419
59468
  var ROUTING_ASK_DEADLINE_MS = 2e3;
59469
+ function routingRefusalRetryAfterSeconds(refused2, now) {
59470
+ const { retryAfterSecs, resetsAtMs } = refused2;
59471
+ if (typeof retryAfterSecs === "number" && Number.isFinite(retryAfterSecs) && retryAfterSecs > 0) {
59472
+ return BigInt(Math.ceil(retryAfterSecs));
59473
+ }
59474
+ if (typeof resetsAtMs === "number" && Number.isFinite(resetsAtMs) && resetsAtMs > now) {
59475
+ return (BigInt(Math.ceil(resetsAtMs - now)) + 999n) / 1000n;
59476
+ }
59477
+ return void 0;
59478
+ }
59420
59479
  function prepareAgyWireRequest(wire, request2) {
59421
59480
  return wire.prepare(
59422
59481
  request2.input,
@@ -60012,10 +60071,27 @@ function createRequestExecutor(deps) {
60012
60071
  deadlineMs: Math.min(
60013
60072
  ROUTING_ASK_DEADLINE_MS,
60014
60073
  deadline.remainingMs()
60015
- )
60074
+ ),
60075
+ refusals: true
60016
60076
  })
60017
60077
  );
60018
60078
  checkAborted();
60079
+ if (answer && "refused" in answer) {
60080
+ const { code: code2, routingCode } = answer.refused;
60081
+ log18.warn("routing-refused", {
60082
+ code: code2,
60083
+ ...routingCode === void 0 ? {} : { routingCode }
60084
+ });
60085
+ const retryAfterSeconds = routingRefusalRetryAfterSeconds(
60086
+ answer.refused,
60087
+ Date.now()
60088
+ );
60089
+ return createNativeGoogleErrorResponse({
60090
+ status: 412,
60091
+ reason: "routing_refused",
60092
+ ...retryAfterSeconds === void 0 ? {} : { retryAfterSeconds }
60093
+ });
60094
+ }
60019
60095
  if (answer && answer.candidate.index !== account.index && !excludedIndexes?.has(answer.candidate.index)) {
60020
60096
  account = accountManager.getCurrentOrNextForFamily(
60021
60097
  family,