@dbx-tools/databricks 0.6.168 → 0.6.175

package/lib/index.js

@@ -1,14 +1,1033 @@
-// GENERATED by projen watch - DO NOT EDIT.
-// Regenerated from the exporting modules in ./src.
-// Hand edits are overwritten on the next watch; this file is read-only.
-export const PACKAGE_IDENTIFIER = "@dbx-tools/databricks";
-export * as cloud from "./src/cloud.js";
-export * as databricksFS from "./src/databricks-fs.js";
-export * as databricksPath from "./src/databricks-path.js";
-export * as net from "./src/net.js";
-export * as workspace from "./src/workspace.js";
-export { RANGE_CACHE_TTL_MS, CloudProvider } from "./src/cloud.js";
-export { DatabricksFileSystem } from "./src/databricks-fs.js";
-export { isHomeRelativePath } from "./src/databricks-path.js";
-export { getPublicIp } from "./src/net.js";
-//# sourceMappingURL=data:application/json;base64,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
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/_bindings-ffi.ts
+import lib from "@ubjs/node";
+var { UniffiNativeModule, FfiType, resolveLibPath } = lib;
+var DEFINITIONS = {
+  symbols: {
+    rustbuffer_alloc: "ffi_dbx_tools_databricks_rustbuffer_alloc",
+    rustbuffer_free: "ffi_dbx_tools_databricks_rustbuffer_free",
+    rustbuffer_from_bytes: "ffi_dbx_tools_databricks_rustbuffer_from_bytes"
+  },
+  functions: {
+    ffi_dbx_tools_databricks_rust_future_poll_u8: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_cancel_u8: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_complete_u8: {
+      args: [FfiType.Handle],
+      ret: FfiType.UInt8,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_databricks_rust_future_free_u8: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_poll_i8: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_cancel_i8: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_complete_i8: {
+      args: [FfiType.Handle],
+      ret: FfiType.Int8,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_databricks_rust_future_free_i8: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_poll_u16: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_cancel_u16: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_complete_u16: {
+      args: [FfiType.Handle],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_databricks_rust_future_free_u16: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_poll_i16: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_cancel_i16: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_complete_i16: {
+      args: [FfiType.Handle],
+      ret: FfiType.Int16,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_databricks_rust_future_free_i16: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_poll_u32: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_cancel_u32: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_complete_u32: {
+      args: [FfiType.Handle],
+      ret: FfiType.UInt32,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_databricks_rust_future_free_u32: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_poll_i32: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_cancel_i32: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_complete_i32: {
+      args: [FfiType.Handle],
+      ret: FfiType.Int32,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_databricks_rust_future_free_i32: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_poll_u64: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_cancel_u64: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_complete_u64: {
+      args: [FfiType.Handle],
+      ret: FfiType.Handle,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_databricks_rust_future_free_u64: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_poll_i64: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_cancel_i64: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_complete_i64: {
+      args: [FfiType.Handle],
+      ret: FfiType.Int64,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_databricks_rust_future_free_i64: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_poll_f32: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_cancel_f32: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_complete_f32: {
+      args: [FfiType.Handle],
+      ret: FfiType.Float32,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_databricks_rust_future_free_f32: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_poll_f64: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_cancel_f64: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_complete_f64: {
+      args: [FfiType.Handle],
+      ret: FfiType.Float64,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_databricks_rust_future_free_f64: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_poll_rust_buffer: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_cancel_rust_buffer: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_complete_rust_buffer: {
+      args: [FfiType.Handle],
+      ret: FfiType.RustBuffer,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_databricks_rust_future_free_rust_buffer: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_poll_void: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_cancel_void: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_databricks_rust_future_complete_void: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_databricks_rust_future_free_void: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_databricks_fn_func_databricks_cli_available: {
+      args: [],
+      ret: FfiType.Int8,
+      hasRustCallStatus: true
+    },
+    uniffi_dbx_tools_databricks_fn_func_is_databricks_app: {
+      args: [],
+      ret: FfiType.Int8,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_databricks_uniffi_contract_version: {
+      args: [],
+      ret: FfiType.UInt32,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_databricks_checksum_func_databricks_cli_available: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_databricks_checksum_func_is_databricks_app: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    }
+  },
+  callbacks: {
+    RustFutureContinuationCallback: {
+      args: [FfiType.Handle, FfiType.Int8],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ForeignFutureDroppedCallback: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    }
+  },
+  structs: {
+    ForeignFutureDroppedCallbackStruct: [
+      { name: "handle", type: FfiType.Handle },
+      { name: "free", type: FfiType.Callback("ForeignFutureDroppedCallback") }
+    ]
+  }
+};
+var _nativeModule;
+var getter = () => {
+  if (!_nativeModule) {
+    const libPath = resolveLibPath({
+      crateName: "dbx_tools_databricks",
+      callerUrl: import.meta.url,
+      npmPackageBase: "@dbx-tools/databricks-",
+      tripleStyle: "node"
+    });
+    const mod_ = UniffiNativeModule.open(libPath);
+    _nativeModule = mod_.register(DEFINITIONS);
+  }
+  return _nativeModule;
+};
+var _bindings_ffi_default = getter;
+
+// src/_bindings.ts
+import {
+  FfiConverterBool,
+  UniffiInternalError,
+  UniffiRustCaller,
+  uniffiCreateFfiConverterString
+} from "@ubjs/core";
+var uniffiCaller = new UniffiRustCaller(() => ({ code: 0 }));
+var uniffiIsDebug = typeof process !== "object" || process?.env?.NODE_ENV !== "production" || false;
+function databricksCliAvailable() {
+  return FfiConverterBool.lift(uniffiCaller.rustCall((callStatus) => {
+    return _bindings_ffi_default().uniffi_dbx_tools_databricks_fn_func_databricks_cli_available(callStatus);
+  }, FfiConverterString.lift.bind(FfiConverterString)));
+}
+function isDatabricksApp() {
+  return FfiConverterBool.lift(uniffiCaller.rustCall((callStatus) => {
+    return _bindings_ffi_default().uniffi_dbx_tools_databricks_fn_func_is_databricks_app(callStatus);
+  }, FfiConverterString.lift.bind(FfiConverterString)));
+}
+var stringConverter = (() => {
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  return {
+    stringToBytes: (s) => encoder.encode(s),
+    bytesToString: (ab) => decoder.decode(ab),
+    stringByteLength: (s) => encoder.encode(s).byteLength,
+    writeStringIntoBuffer: (s, buf, offset) => {
+      const view = new Uint8Array(buf.arrayBuffer, offset, buf.arrayBuffer.byteLength - offset);
+      return encoder.encodeInto(s, view).written;
+    },
+    readStringFromBuffer: (buf, offset, length) => decoder.decode(new Uint8Array(buf.arrayBuffer, offset, length))
+  };
+})();
+var FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+function uniffiEnsureInitialized() {
+  const bindingsContractVersion = 30;
+  const scaffoldingContractVersion = _bindings_ffi_default().ffi_dbx_tools_databricks_uniffi_contract_version();
+  if (bindingsContractVersion !== scaffoldingContractVersion) {
+    throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_databricks_checksum_func_databricks_cli_available() !== 19375) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_databricks_checksum_func_databricks_cli_available");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_databricks_checksum_func_is_databricks_app() !== 27360) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_databricks_checksum_func_is_databricks_app");
+  }
+}
+var _bindings_default = Object.freeze({
+  initialize: uniffiEnsureInitialized
+});
+// src/bindings.ts
+_bindings_default.initialize();
+async function uniffiInitAsync() {}
+// src/cloud.ts
+var exports_cloud = {};
+__export(exports_cloud, {
+  resolveCloudLocation: () => resolveCloudLocation,
+  loadProviderRanges: () => loadProviderRanges,
+  RANGE_CACHE_TTL_MS: () => RANGE_CACHE_TTL_MS,
+  CloudProvider: () => CloudProvider
+});
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { file } from "@dbx-tools/core";
+import { error, functionModule as functionModule2, hash, http as http2, json, log, net as net2 } from "@dbx-tools/shared-core";
+
+// src/net.ts
+var exports_net = {};
+__export(exports_net, {
+  resolveHostIps: () => resolveHostIps,
+  getPublicIp: () => getPublicIp
+});
+import { lookup } from "node:dns/promises";
+import { functionModule, http, net } from "@dbx-tools/shared-core";
+var getPublicIp = functionModule.memoize(async () => {
+  const cloudflareResponse = await fetch("https://cloudflare.com/cdn-cgi/trace");
+  if (cloudflareResponse.ok) {
+    const trace = await cloudflareResponse.text();
+    const ipKey = "ip=";
+    const ip2 = trace.split(`
+`).map((line) => line.trim()).find((line) => line.startsWith(ipKey))?.slice(ipKey.length);
+    if (ip2)
+      return ip2;
+  }
+  const ipifyResponse = await fetch("https://api.ipify.org?format=json");
+  if (!ipifyResponse.ok) {
+    throw await http.createFetchError(ipifyResponse);
+  }
+  const ipifyData = await ipifyResponse.json();
+  const ip = ipifyData?.ip;
+  if (ip)
+    return ip;
+  throw new Error("Could not determine public IP");
+}, { ttlMs: 1000 * 60 * 5 });
+async function resolveHostIps(input) {
+  const host = net.urlBuilder(input)?.hostname;
+  if (!host)
+    return [];
+  const literal = net.parseIp(host.replace(/^\[|\]$/g, ""));
+  if (literal)
+    return [host.replace(/^\[|\]$/g, "")];
+  try {
+    const results = await lookup(host, { all: true });
+    return [...new Set(results.map((r) => r.address))];
+  } catch {
+    return [];
+  }
+}
+
+// src/cloud.ts
+var logger = log.logger("cloud");
+var RANGE_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+var AWS_RANGES_URL = "https://ip-ranges.amazonaws.com/ip-ranges.json";
+var GCP_RANGES_URL = "https://www.gstatic.com/ipranges/cloud.json";
+var AZURE_DOWNLOAD_PAGE = "https://www.microsoft.com/en-us/download/details.aspx?id=56519";
+var AZURE_JSON_LINK = /https:\/\/download\.microsoft\.com\/download\/[^"']*ServiceTags_Public_\d+\.json/;
+var CloudProvider;
+((CloudProvider2) => {
+  CloudProvider2["Aws"] = "aws";
+  CloudProvider2["Azure"] = "azure";
+  CloudProvider2["Gcp"] = "gcp";
+})(CloudProvider ||= {});
+async function resolveCloudLocation(input) {
+  const ips = await resolveHostIps(input);
+  if (ips.length === 0) {
+    logger.debug("no ips resolved", { input: String(input) });
+    return null;
+  }
+  const providers = await loadProviderRanges();
+  for (const ip of ips) {
+    const parsed = net2.parseIp(ip);
+    if (!parsed)
+      continue;
+    for (const { provider, ranges } of providers) {
+      const match = net2.findContainingCidr(parsed, ranges);
+      if (match) {
+        return { provider, region: match.region, ip, cidr: match.cidr };
+      }
+    }
+  }
+  logger.debug("no cloud range matched", { ips });
+  return null;
+}
+async function loadProviderRanges() {
+  const settled = await Promise.allSettled([loadAwsRanges(), loadAzureRanges(), loadGcpRanges()]);
+  const out = [];
+  for (const result of settled) {
+    if (result.status === "fulfilled")
+      out.push(result.value);
+    else
+      logger.warn("provider range load failed", { error: error.errorMessage(result.reason) });
+  }
+  return out;
+}
+var loadAwsRanges = functionModule2.memoize(fetchAwsRanges, { ttlMs: RANGE_CACHE_TTL_MS });
+var loadAzureRanges = functionModule2.memoize(fetchAzureRanges, { ttlMs: RANGE_CACHE_TTL_MS });
+var loadGcpRanges = functionModule2.memoize(fetchGcpRanges, { ttlMs: RANGE_CACHE_TTL_MS });
+async function fetchAwsRanges() {
+  const feed = await fetchJson(AWS_RANGES_URL);
+  const ranges = [];
+  for (const entry of feed.prefixes ?? []) {
+    addRange(ranges, entry.ip_prefix, entry.region);
+  }
+  for (const entry of feed.ipv6_prefixes ?? []) {
+    addRange(ranges, entry.ipv6_prefix, entry.region);
+  }
+  logger.debug("loaded aws ranges", { count: ranges.length });
+  return { provider: "aws" /* Aws */, ranges };
+}
+async function fetchGcpRanges() {
+  const feed = await fetchJson(GCP_RANGES_URL);
+  const ranges = [];
+  for (const entry of feed.prefixes ?? []) {
+    addRange(ranges, entry.ipv4Prefix ?? entry.ipv6Prefix, entry.scope);
+  }
+  logger.debug("loaded gcp ranges", { count: ranges.length });
+  return { provider: "gcp" /* Gcp */, ranges };
+}
+async function fetchAzureRanges() {
+  const page = await fetchText(AZURE_DOWNLOAD_PAGE);
+  const jsonUrl = page.match(AZURE_JSON_LINK)?.[0];
+  if (!jsonUrl) {
+    throw new Error("could not find ServiceTags JSON link on Azure download page");
+  }
+  const feed = await fetchJson(jsonUrl);
+  const ranges = [];
+  for (const value of feed.values ?? []) {
+    const region = value.properties?.region;
+    if (!region || !value.name?.startsWith("AzureCloud."))
+      continue;
+    for (const prefix of value.properties?.addressPrefixes ?? []) {
+      addRange(ranges, prefix, region);
+    }
+  }
+  logger.debug("loaded azure ranges", { count: ranges.length });
+  return { provider: "azure" /* Azure */, ranges };
+}
+function addRange(ranges, cidr, region) {
+  if (!cidr || !region)
+    return;
+  const parsed = net2.parseCidr(cidr);
+  if (parsed)
+    ranges.push({ ...parsed, region });
+}
+async function fetchJson(url) {
+  const text = await fetchText(url);
+  const parsed = json.parse(text);
+  if (parsed === undefined) {
+    throw new Error(`range feed returned non-JSON content: ${url}`);
+  }
+  return parsed;
+}
+async function fetchText(url) {
+  const cacheDir = join(tmpdir(), "dbx-tools", "shared", "cloud");
+  const cacheDirCreated = await mkdir(cacheDir, { recursive: true });
+  const cachePath = join(cacheDir, `fetch-${hash.fnvHash(url)}.txt`);
+  const createdAt = cacheDirCreated ? undefined : await getCreated(cachePath);
+  if (createdAt) {
+    const expiresAt = new Date(createdAt.getTime() + RANGE_CACHE_TTL_MS);
+    if (expiresAt > new Date) {
+      logger.debug("cached fetch hit", { url, cachePath });
+      return readFile(cachePath, "utf8");
+    }
+  }
+  let tempPath = join(cacheDir, `${hash.id()}.txt`);
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw await http2.createFetchError(response, url);
+    }
+    const responseText = await response.text();
+    await mkdir(dirname(tempPath), { recursive: true });
+    await writeFile(tempPath, responseText);
+    await rename(tempPath, cachePath);
+    logger.debug("cached fetch load", { url, cachePath });
+    tempPath = null;
+    return responseText;
+  } finally {
+    if (tempPath) {
+      await unlink(tempPath);
+    }
+  }
+}
+async function getCreated(path) {
+  return (await file.statSync(path))?.birthtime;
+}
+// src/databricks-fs.ts
+var exports_databricks_fs = {};
+__export(exports_databricks_fs, {
+  DatabricksFileSystem: () => DatabricksFileSystem
+});
+import { hash as hash2, object } from "@dbx-tools/shared-core";
+import {
+  BaseFileSystem,
+  baseFS,
+  FileSystemError,
+  posixPath as posixPath2
+} from "@dbx-tools/shared-fs";
+
+// src/databricks-path.ts
+var exports_databricks_path = {};
+__export(exports_databricks_path, {
+  resolveDatabricksRoot: () => resolveDatabricksRoot,
+  resolveDatabricksFilesBackend: () => resolveDatabricksFilesBackend,
+  normalizeDatabricksRoot: () => normalizeDatabricksRoot,
+  isWorkspaceFilesPath: () => isWorkspaceFilesPath,
+  isVolumesPath: () => isVolumesPath,
+  isHomeRelativePath: () => isHomeRelativePath,
+  isDbfsPath: () => isDbfsPath,
+  expandHomePath: () => expandHomePath
+});
+import { posixPath } from "@dbx-tools/shared-fs";
+
+// src/workspace.ts
+var exports_workspace = {};
+__export(exports_workspace, {
+  tryGetWorkspaceClient: () => tryGetWorkspaceClient,
+  toLegacyWorkspaceClient: () => toLegacyWorkspaceClient,
+  getWorkspaceUrl: () => getWorkspaceUrl,
+  getWorkspaceId: () => getWorkspaceId,
+  getWorkspaceClient: () => getWorkspaceClient,
+  getCurrentUserName: () => getCurrentUserName
+});
+import {
+  createWorkspaceClient
+} from "@databricks/appkit";
+import { appkit } from "@dbx-tools/appkit";
+import { functionModule as functionModule3, net as net3 } from "@dbx-tools/shared-core";
+var WORKSPACE_ID_REGEX = /\d{10,20}/;
+function toLegacyWorkspaceClient(client) {
+  return "toLegacyWorkspaceClient" in client ? client.toLegacyWorkspaceClient() : client;
+}
+var getDefaultWorkspaceClient = functionModule3.memoize(async () => createWorkspaceClient().toLegacyWorkspaceClient());
+function tryGetWorkspaceClient() {
+  return appkit.tryGetExecutionContext()?.client.toLegacyWorkspaceClient();
+}
+async function getWorkspaceClient() {
+  return tryGetWorkspaceClient() ?? await getDefaultWorkspaceClient();
+}
+async function getWorkspaceConfig() {
+  try {
+    return (await getWorkspaceClient()).config;
+  } catch {
+    return;
+  }
+}
+async function getCurrentUserName(client) {
+  const contextUser = readContextUserName(appkit.tryGetExecutionContext());
+  if (contextUser)
+    return contextUser;
+  const resolved = client ?? await getWorkspaceClient();
+  const me = await resolved.currentUser.me();
+  const userName = me.userName?.trim();
+  if (!userName) {
+    throw new Error("Databricks currentUser.me() did not return a userName");
+  }
+  return userName;
+}
+function readContextUserName(ctx) {
+  if (typeof ctx !== "object" || ctx === null || !("userName" in ctx))
+    return;
+  const value = ctx.userName;
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+async function getWorkspaceUrl() {
+  const config = await getWorkspaceConfig();
+  if (config) {
+    const configHost = net3.urlBuilder(await config.getHost());
+    if (configHost)
+      return configHost;
+  }
+  const databricksHost = net3.urlBuilder(process.env.DATABRICKS_HOST);
+  if (databricksHost)
+    return databricksHost;
+  return;
+}
+async function getWorkspaceId(workspaceHost) {
+  const workspaceId = (await getWorkspaceConfig())?.workspaceId;
+  if (workspaceId)
+    return workspaceId;
+  workspaceHost = workspaceHost ?? (await getWorkspaceUrl())?.host;
+  if (workspaceHost) {
+    const match = workspaceHost.match(WORKSPACE_ID_REGEX)?.[0];
+    if (match)
+      return match;
+  }
+  return;
+}
+
+// src/databricks-path.ts
+var VOLUME_THREE_PART = /^([^.\/\s]+)\.([^.\/\s]+)\.([^.\/\s]+)$/;
+var isHomeRelativePath = posixPath.isHomeRelativePath;
+function expandHomePath(input, userName) {
+  const name = userName.trim();
+  if (!name) {
+    throw new TypeError("Databricks home expansion requires a non-empty userName");
+  }
+  if (!isHomeRelativePath(input)) {
+    return posixPath.toPosix(input.trim());
+  }
+  return posixPath.expandHome(input, `/Workspace/Users/${name}`);
+}
+function normalizeDatabricksRoot(root, options = {}) {
+  const trimmed = root.trim();
+  if (!trimmed) {
+    throw new TypeError("Databricks filesystem root cannot be empty");
+  }
+  if (isHomeRelativePath(trimmed)) {
+    if (!options.userName?.trim()) {
+      throw new TypeError(`Databricks home path "${root}" requires userName; use resolveDatabricksRoot() or pass userName`);
+    }
+    return posixPath.normalizeRoot(expandHomePath(trimmed, options.userName));
+  }
+  const threePart = VOLUME_THREE_PART.exec(trimmed);
+  if (threePart) {
+    return posixPath.normalizeRoot(`/Volumes/${threePart[1]}/${threePart[2]}/${threePart[3]}`);
+  }
+  let posix = posixPath.toPosix(trimmed);
+  if (posix === "/Volume" || posix.startsWith("/Volume/")) {
+    posix = `/Volumes${posix.slice("/Volume".length)}`;
+  }
+  if (!posixPath.isAbsolute(posix)) {
+    throw new TypeError(`Databricks filesystem root must be absolute, catalog.schema.volume, or ~, got: ${root}`);
+  }
+  return posixPath.normalizeRoot(posix);
+}
+async function resolveDatabricksRoot(root, options = {}) {
+  if (!isHomeRelativePath(root)) {
+    return normalizeDatabricksRoot(root);
+  }
+  const userName = await getCurrentUserName(options.client);
+  return normalizeDatabricksRoot(root, { userName });
+}
+function isWorkspaceFilesPath(absolutePath) {
+  const p = posixPath.toPosix(absolutePath);
+  return p === "/Workspace" || p.startsWith("/Workspace/") || p.startsWith("/Users/") || p.startsWith("/Repos/") || p.startsWith("/Shared/");
+}
+function isVolumesPath(absolutePath) {
+  const p = posixPath.toPosix(absolutePath);
+  return p === "/Volumes" || p.startsWith("/Volumes/");
+}
+function isDbfsPath(absolutePath) {
+  const p = posixPath.toPosix(absolutePath);
+  return p === "/dbfs" || p.startsWith("/dbfs/");
+}
+function resolveDatabricksFilesBackend(absolutePath) {
+  if (isDbfsPath(absolutePath))
+    return "dbfs";
+  if (isWorkspaceFilesPath(absolutePath))
+    return "workspace";
+  if (isVolumesPath(absolutePath))
+    return "volumes";
+  return "volumes";
+}
+
+// src/databricks-fs.ts
+var DBFS_READ_CHUNK_BYTES = 1024 * 1024;
+var DBFS_PUT_MAX_BYTES = 1024 * 1024;
+var VOLUME_ROOT_DEPTH = 4;
+
+class DatabricksFileSystem extends BaseFileSystem {
+  client;
+  clientOption;
+  constructor(options) {
+    const root = normalizeDatabricksRoot(options.root, { userName: options.userName });
+    super({
+      id: options.id ?? `databricks-${hash2.fnvHash(root)}`,
+      backend: "databricks",
+      root,
+      readOnly: options.readOnly,
+      createRoot: options.createRoot ?? false
+    });
+    this.clientOption = options.client;
+    this.client = options.client;
+  }
+  static async create(options) {
+    if (!isHomeRelativePath(options.root) || options.userName?.trim()) {
+      return new DatabricksFileSystem(options);
+    }
+    const client = options.client ?? await getWorkspaceClient();
+    const root = await resolveDatabricksRoot(options.root, { client });
+    return new DatabricksFileSystem({ ...options, root, client });
+  }
+  async onInit() {
+    this.client = this.clientOption ?? await getWorkspaceClient();
+  }
+  dispatch(absolutePath, handlers) {
+    if (!this.client) {
+      throw new FileSystemError("IO_ERROR", "Databricks filesystem is not initialized (no WorkspaceClient)", absolutePath);
+    }
+    return handlers[resolveDatabricksFilesBackend(absolutePath)](this.client);
+  }
+  async createRootDirectory() {
+    await this.createDirectoryAt(this.root);
+  }
+  async readBytesAt(resolvedPath) {
+    const buffer = await this.dispatch(resolvedPath, {
+      dbfs: (client) => this.readDbfsFile(client, resolvedPath),
+      workspace: async (client) => {
+        const response = await client.workspace.export({ path: resolvedPath, format: "AUTO" });
+        return decodeBase64(response.content);
+      },
+      volumes: async (client) => {
+        const response = await client.files.download({ file_path: resolvedPath });
+        return readResponseBody(response.contents);
+      }
+    });
+    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+  async writeBytesAt(resolvedPath, content, options) {
+    const buffer = Buffer.from(content);
+    const overwrite = options.overwrite;
+    await this.dispatch(resolvedPath, {
+      dbfs: (client) => this.writeDbfsFile(client, resolvedPath, buffer, overwrite),
+      workspace: (client) => client.workspace.import({
+        path: resolvedPath,
+        format: "AUTO",
+        content: buffer.toString("base64"),
+        overwrite
+      }),
+      volumes: (client) => client.files.upload({
+        file_path: resolvedPath,
+        contents: bufferToReadableStream(buffer),
+        overwrite
+      })
+    });
+  }
+  async deleteFileAt(resolvedPath) {
+    await this.dispatch(resolvedPath, {
+      dbfs: (client) => client.dbfs.delete({ path: resolvedPath, recursive: false }),
+      workspace: (client) => client.workspace.delete({ path: resolvedPath, recursive: false }),
+      volumes: (client) => client.files.delete({ file_path: resolvedPath })
+    });
+  }
+  async createDirectoryAt(resolvedPath) {
+    await this.dispatch(resolvedPath, {
+      dbfs: (client) => client.dbfs.mkdirs({ path: resolvedPath }),
+      workspace: (client) => client.workspace.mkdirs({ path: resolvedPath }),
+      volumes: (client) => this.createVolumeDirectories(client, resolvedPath)
+    });
+  }
+  async removeDirectoryAt(resolvedPath) {
+    await this.dispatch(resolvedPath, {
+      dbfs: (client) => client.dbfs.delete({ path: resolvedPath, recursive: false }),
+      workspace: (client) => client.workspace.delete({ path: resolvedPath, recursive: false }),
+      volumes: (client) => client.files.deleteDirectory({ directory_path: resolvedPath })
+    });
+  }
+  async listDirectoryAt(resolvedPath) {
+    return this.dispatch(resolvedPath, {
+      dbfs: (client) => collect(client.dbfs.list({ path: resolvedPath }), (info) => ({
+        name: posixPath2.basename(info.path ?? ""),
+        type: info.is_dir ? "directory" : "file",
+        size: info.file_size
+      })),
+      workspace: (client) => collect(client.workspace.list({ path: resolvedPath }), (info) => ({
+        name: posixPath2.basename(info.path ?? ""),
+        type: info.object_type === "DIRECTORY" ? "directory" : "file"
+      })),
+      volumes: (client) => collect(client.files.listDirectoryContents({ directory_path: resolvedPath }), (entry) => ({
+        name: entry.name ?? posixPath2.basename(entry.path ?? ""),
+        type: entry.is_directory ? "directory" : "file",
+        size: entry.file_size
+      }))
+    });
+  }
+  async statAt(resolvedPath) {
+    const fallbackName = posixPath2.basename(resolvedPath) || posixPath2.basename(this.root);
+    return this.dispatch(resolvedPath, {
+      dbfs: async (client) => {
+        const info = await client.dbfs.getStatus({ path: resolvedPath });
+        const modified = object.toDate(info.modification_time);
+        return {
+          name: posixPath2.basename(info.path ?? resolvedPath) || fallbackName,
+          type: info.is_dir ? "directory" : "file",
+          size: info.file_size,
+          createdAt: modified,
+          modifiedAt: modified
+        };
+      },
+      workspace: async (client) => {
+        const info = await client.workspace.getStatus({ path: resolvedPath });
+        return {
+          name: posixPath2.basename(info.path ?? resolvedPath) || fallbackName,
+          type: info.object_type === "DIRECTORY" ? "directory" : "file",
+          createdAt: object.toDate(info.created_at),
+          modifiedAt: object.toDate(info.modified_at)
+        };
+      },
+      volumes: (client) => this.statVolumePath(client, resolvedPath, fallbackName)
+    });
+  }
+  async tryMoveFileAt(sourcePath, destinationPath, _options) {
+    if (resolveDatabricksFilesBackend(sourcePath) !== "dbfs" || resolveDatabricksFilesBackend(destinationPath) !== "dbfs") {
+      return false;
+    }
+    await this.dispatch(sourcePath, {
+      dbfs: (client) => client.dbfs.move({ source_path: sourcePath, destination_path: destinationPath }),
+      workspace: unreachableBackend,
+      volumes: unreachableBackend
+    });
+    return true;
+  }
+  async createVolumeDirectories(client, absolutePath) {
+    const parts = absolutePath.split("/").filter(Boolean);
+    let current = "";
+    for (let i = 0;i < parts.length; i++) {
+      current = `${current}/${parts[i]}`;
+      if (i < VOLUME_ROOT_DEPTH)
+        continue;
+      try {
+        await client.files.createDirectory({ directory_path: current });
+      } catch (err) {
+        try {
+          await client.files.getDirectoryMetadata({ directory_path: current });
+        } catch {
+          throw err;
+        }
+      }
+    }
+  }
+  async statVolumePath(client, absolutePath, fallbackName) {
+    try {
+      const metadata = await client.files.getMetadata({ file_path: absolutePath });
+      const modified = object.toDate(metadata["last-modified"]);
+      return {
+        name: fallbackName,
+        type: "file",
+        size: Number(metadata["content-length"] ?? 0),
+        createdAt: modified,
+        modifiedAt: modified,
+        mimeType: metadata["content-type"]
+      };
+    } catch (fileErr) {
+      const code = baseFS.mapFileSystemError(fileErr, absolutePath).code;
+      if (code !== "NOT_FOUND" && code !== "PERMISSION_DENIED")
+        throw fileErr;
+      await client.files.getDirectoryMetadata({ directory_path: absolutePath });
+      return { name: fallbackName, type: "directory" };
+    }
+  }
+  async readDbfsFile(client, absolutePath) {
+    const chunks = [];
+    let offset = 0;
+    while (true) {
+      const response = await client.dbfs.read({
+        path: absolutePath,
+        offset,
+        length: DBFS_READ_CHUNK_BYTES
+      });
+      const chunk = decodeBase64(response.data);
+      if (chunk.length === 0)
+        break;
+      chunks.push(chunk);
+      offset += chunk.length;
+      if (chunk.length < DBFS_READ_CHUNK_BYTES)
+        break;
+    }
+    return Buffer.concat(chunks);
+  }
+  async writeDbfsFile(client, absolutePath, buffer, overwrite) {
+    if (buffer.length <= DBFS_PUT_MAX_BYTES) {
+      await client.dbfs.put({
+        path: absolutePath,
+        contents: buffer.toString("base64"),
+        overwrite
+      });
+      return;
+    }
+    const created = await client.dbfs.create({ path: absolutePath, overwrite });
+    const handle = created.handle;
+    if (handle === undefined) {
+      throw new FileSystemError("IO_ERROR", "DBFS upload handle missing", absolutePath);
+    }
+    try {
+      for (let offset = 0;offset < buffer.length; offset += DBFS_PUT_MAX_BYTES) {
+        const slice = buffer.subarray(offset, offset + DBFS_PUT_MAX_BYTES);
+        await client.dbfs.addBlock({ handle, data: slice.toString("base64") });
+      }
+    } catch (err) {
+      await client.dbfs.close({ handle }).catch(() => {
+        return;
+      });
+      throw err;
+    }
+    await client.dbfs.close({ handle });
+  }
+}
+async function collect(source, map) {
+  const items = [];
+  for await (const item of source)
+    items.push(map(item));
+  return items;
+}
+function unreachableBackend() {
+  throw new FileSystemError("NOT_SUPPORTED", "Unsupported Databricks backend for this operation");
+}
+function decodeBase64(data) {
+  if (!data)
+    return Buffer.alloc(0);
+  return Buffer.from(data, "base64");
+}
+async function readResponseBody(contents) {
+  if (!contents)
+    return Buffer.alloc(0);
+  const reader = contents.getReader();
+  const chunks = [];
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    if (value)
+      chunks.push(value);
+  }
+  return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)));
+}
+function bufferToReadableStream(buffer) {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(new Uint8Array(buffer));
+      controller.close();
+    }
+  });
+}
+
+// index.ts
+var PACKAGE_IDENTIFIER = "@dbx-tools/databricks";
+var PACKAGE_VERSION = "0.6.175";
+export {
+  exports_workspace as workspace,
+  _bindings_default as uniffiModule,
+  uniffiInitAsync,
+  exports_net as net,
+  isHomeRelativePath,
+  isDatabricksApp,
+  getPublicIp,
+  exports_databricks_path as databricksPath,
+  exports_databricks_fs as databricksFS,
+  databricksCliAvailable,
+  exports_cloud as cloud,
+  RANGE_CACHE_TTL_MS,
+  PACKAGE_VERSION,
+  PACKAGE_IDENTIFIER,
+  DatabricksFileSystem,
+  CloudProvider
+};