🎯 MapView v2.0 - Global Deployment Ready

✨ MAJOR FEATURES:
• Auto-zoom intelligence với smart bounds fitting
• Enhanced 3D GPS markers với pulsing effects
• Professional route display với 6-layer rendering
• Status-based parking icons với availability indicators
• Production-ready build optimizations

🗺️ AUTO-ZOOM FEATURES:
• Smart bounds fitting cho GPS + selected parking
• Adaptive padding (50px) cho visual balance
• Max zoom control (level 16) để tránh quá gần
• Dynamic centering khi không có selection

🎨 ENHANCED VISUALS:
• 3D GPS marker với multi-layer pulse effects
• Advanced parking icons với status colors
• Selection highlighting với animation
• Dimming system cho non-selected items

🛣️ ROUTE SYSTEM:
• OpenRouteService API integration
• Multi-layer route rendering (glow, shadow, main, animated)
• Real-time distance & duration calculation
• Visual route info trong popup

📱 PRODUCTION READY:
• SSR safe với dynamic imports
• Build errors resolved
• Global deployment via Vercel
• Optimized performance

🌍 DEPLOYMENT:
• Vercel: https://whatever-ctk2auuxr-phong12hexdockworks-projects.vercel.app
• Bundle size: 22.8 kB optimized
• Global CDN distribution
• HTTPS enabled

💾 VERSION CONTROL:
• MapView-v2.0.tsx backup created
• MAPVIEW_VERSIONS.md documentation
• Full version history tracking

frontend/node_modules/next/dist/build/turborepo-access-trace/env.d.ts

@@ -0,0 +1,9 @@
+import type { EnvVars, RestoreOriginalFunction } from './types';
+/**
+ * Proxy the environment to track environment variables keys that
+ * are accessed during the build.
+ *
+ * @param envVars A set to track environment variable keys that are accessed.
+ * @returns A function that restores the original environment.
+ */
+export declare function envProxy(envVars: EnvVars): RestoreOriginalFunction;

frontend/node_modules/next/dist/build/turborepo-access-trace/env.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "envProxy", {
+    enumerable: true,
+    get: function() {
+        return envProxy;
+    }
+});
+function envProxy(envVars) {
+    const newEnv = new Proxy(process.env, {
+        get: (target, key, receiver)=>{
+            envVars.add(key);
+            return Reflect.get(target, key, receiver);
+        },
+        set: (target, key, value)=>{
+            return Reflect.set(target, key, value);
+        }
+    });
+    const oldEnv = process.env;
+    process.env = newEnv;
+    // Return a function that restores the original environment.
+    return ()=>{
+        process.env = oldEnv;
+    };
+}
+
+//# sourceMappingURL=env.js.map

frontend/node_modules/next/dist/build/turborepo-access-trace/env.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/build/turborepo-access-trace/env.ts"],"names":["envProxy","envVars","newEnv","Proxy","process","env","get","target","key","receiver","add","Reflect","set","value","oldEnv"],"mappings":";;;;+BASgBA;;;eAAAA;;;AAAT,SAASA,SAASC,OAAgB;IACvC,MAAMC,SAAS,IAAIC,MAAMC,QAAQC,GAAG,EAAE;QACpCC,KAAK,CAACC,QAAQC,KAAKC;YACjBR,QAAQS,GAAG,CAACF;YACZ,OAAOG,QAAQL,GAAG,CAACC,QAAQC,KAAKC;QAClC;QACAG,KAAK,CAACL,QAAQC,KAAKK;YACjB,OAAOF,QAAQC,GAAG,CAACL,QAAQC,KAAKK;QAClC;IACF;IAEA,MAAMC,SAASV,QAAQC,GAAG;IAC1BD,QAAQC,GAAG,GAAGH;IAEd,4DAA4D;IAC5D,OAAO;QACLE,QAAQC,GAAG,GAAGS;IAChB;AACF"}

frontend/node_modules/next/dist/build/turborepo-access-trace/helpers.d.ts

@@ -0,0 +1,20 @@
+import { TurborepoAccessTraceResult } from './result';
+/**
+ * Trace access to the filesystem (TODO), environment variables, and TCP addresses and
+ * merge the results into the parent `TurborepoAccessTraceResult`.
+ *
+ * @param f the function to trace
+ * @param parent the `TurborepoAccessTraceResult` to merge the results into
+ * @returns the result of the function
+ */
+export declare function turborepoTraceAccess<T>(f: () => T | Promise<T>, parent: TurborepoAccessTraceResult): Promise<T> | T;
+/**
+ * Write the access trace to the trace file.
+ *
+ * @param distDir the directory to write the trace file to
+ * @param traces an array of traces to merge and write to the trace file
+ */
+export declare function writeTurborepoAccessTraceResult({ distDir, traces, }: {
+    distDir: string;
+    traces: Array<TurborepoAccessTraceResult>;
+}): Promise<void>;

frontend/node_modules/next/dist/build/turborepo-access-trace/helpers.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    turborepoTraceAccess: null,
+    writeTurborepoAccessTraceResult: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    turborepoTraceAccess: function() {
+        return turborepoTraceAccess;
+    },
+    writeTurborepoAccessTraceResult: function() {
+        return writeTurborepoAccessTraceResult;
+    }
+});
+const _promises = /*#__PURE__*/ _interop_require_default(require("fs/promises"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _env = require("./env");
+const _tcp = require("./tcp");
+const _result = require("./result");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function turborepoTraceAccess(f, parent) {
+    // If the trace file is not set, don't trace and instead just call the
+    // function.
+    if (!process.env.TURBOREPO_TRACE_FILE) return f();
+    // Otherwise, trace the function and merge the results into the parent. Using
+    // `then` instead of `await` here to avoid creating a new async context when
+    // tracing is disabled.
+    return withTurborepoTraceAccess(f).then(([result, proxy])=>{
+        parent.merge(proxy);
+        // Return the result of the function.
+        return result;
+    });
+}
+async function writeTurborepoAccessTraceResult({ distDir, traces }) {
+    const configTraceFile = process.env.TURBOREPO_TRACE_FILE;
+    if (!configTraceFile || traces.length === 0) return;
+    // merge traces
+    const [accessTrace, ...otherTraces] = traces;
+    for (const trace of otherTraces){
+        accessTrace.merge(trace);
+    }
+    try {
+        // make sure the directory exists
+        await _promises.default.mkdir(_path.default.dirname(configTraceFile), {
+            recursive: true
+        });
+        await _promises.default.writeFile(configTraceFile, JSON.stringify({
+            outputs: [
+                `${distDir}/**`,
+                `!${distDir}/cache/**`
+            ],
+            accessed: accessTrace.toPublicTrace()
+        }));
+    } catch (err) {
+        // if we can't write this file, we should bail out here to avoid
+        // the possibility of incorrect turborepo cache hits.
+        throw new Error(`Failed to write turborepo access trace file`, {
+            cause: err
+        });
+    }
+}
+async function withTurborepoTraceAccess(f) {
+    const envVars = new Set([]);
+    // addresses is an array of objects, so a set is useless
+    const addresses = [];
+    // TODO: watch fsPaths (removed from this implementation for now)
+    const fsPaths = new Set();
+    // setup proxies
+    const restoreTCP = (0, _tcp.tcpProxy)(addresses);
+    const restoreEnv = (0, _env.envProxy)(envVars);
+    let functionResult;
+    // NOTE: we intentionally don't catch errors here so the calling function can handle them
+    try {
+        // call the wrapped function
+        functionResult = await f();
+    } finally{
+        // remove proxies
+        restoreTCP();
+        restoreEnv();
+    }
+    const traceResult = new _result.TurborepoAccessTraceResult(envVars, addresses, fsPaths);
+    return [
+        functionResult,
+        traceResult
+    ];
+}
+
+//# sourceMappingURL=helpers.js.map

frontend/node_modules/next/dist/build/turborepo-access-trace/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/build/turborepo-access-trace/helpers.ts"],"names":["turborepoTraceAccess","writeTurborepoAccessTraceResult","f","parent","process","env","TURBOREPO_TRACE_FILE","withTurborepoTraceAccess","then","result","proxy","merge","distDir","traces","configTraceFile","length","accessTrace","otherTraces","trace","fs","mkdir","path","dirname","recursive","writeFile","JSON","stringify","outputs","accessed","toPublicTrace","err","Error","cause","envVars","Set","addresses","fsPaths","restoreTCP","tcpProxy","restoreEnv","envProxy","functionResult","traceResult","TurborepoAccessTraceResult"],"mappings":";;;;;;;;;;;;;;;IAegBA,oBAAoB;eAApBA;;IAyBMC,+BAA+B;eAA/BA;;;iEAxCP;6DACE;qBAEQ;qBACA;wBACkB;;;;;;AAUpC,SAASD,qBACdE,CAAuB,EACvBC,MAAkC;IAElC,sEAAsE;IACtE,YAAY;IACZ,IAAI,CAACC,QAAQC,GAAG,CAACC,oBAAoB,EAAE,OAAOJ;IAE9C,6EAA6E;IAC7E,4EAA4E;IAC5E,uBAAuB;IACvB,OAAOK,yBAAyBL,GAAGM,IAAI,CAAC,CAAC,CAACC,QAAQC,MAAM;QACtDP,OAAOQ,KAAK,CAACD;QAEb,qCAAqC;QACrC,OAAOD;IACT;AACF;AAQO,eAAeR,gCAAgC,EACpDW,OAAO,EACPC,MAAM,EAIP;IACC,MAAMC,kBAAkBV,QAAQC,GAAG,CAACC,oBAAoB;IAExD,IAAI,CAACQ,mBAAmBD,OAAOE,MAAM,KAAK,GAAG;IAE7C,eAAe;IACf,MAAM,CAACC,aAAa,GAAGC,YAAY,GAAGJ;IACtC,KAAK,MAAMK,SAASD,YAAa;QAC/BD,YAAYL,KAAK,CAACO;IACpB;IAEA,IAAI;QACF,iCAAiC;QACjC,MAAMC,iBAAE,CAACC,KAAK,CAACC,aAAI,CAACC,OAAO,CAACR,kBAAkB;YAAES,WAAW;QAAK;QAChE,MAAMJ,iBAAE,CAACK,SAAS,CAChBV,iBACAW,KAAKC,SAAS,CAAC;YACbC,SAAS;gBAAC,CAAC,EAAEf,QAAQ,GAAG,CAAC;gBAAE,CAAC,CAAC,EAAEA,QAAQ,SAAS,CAAC;aAAC;YAClDgB,UAAUZ,YAAYa,aAAa;QACrC;IAEJ,EAAE,OAAOC,KAAK;QACZ,gEAAgE;QAChE,qDAAqD;QACrD,MAAM,IAAIC,MAAM,CAAC,2CAA2C,CAAC,EAAE;YAC7DC,OAAOF;QACT;IACF;AACF;AAEA,eAAevB,yBACbL,CAAuB;IAEvB,MAAM+B,UAAmB,IAAIC,IAAI,EAAE;IACnC,wDAAwD;IACxD,MAAMC,YAAuB,EAAE;IAC/B,iEAAiE;IACjE,MAAMC,UAAc,IAAIF;IAExB,gBAAgB;IAChB,MAAMG,aAAaC,IAAAA,aAAQ,EAACH;IAC5B,MAAMI,aAAaC,IAAAA,aAAQ,EAACP;IAE5B,IAAIQ;IAEJ,yFAAyF;IACzF,IAAI;QACF,4BAA4B;QAC5BA,iBAAiB,MAAMvC;IACzB,SAAU;QACR,iBAAiB;QACjBmC;QACAE;IACF;IAEA,MAAMG,cAAc,IAAIC,kCAA0B,CAChDV,SACAE,WACAC;IAGF,OAAO;QAACK;QAAgBC;KAAY;AACtC"}

frontend/node_modules/next/dist/build/turborepo-access-trace/index.d.ts

@@ -0,0 +1,3 @@
+export type { SerializableTurborepoAccessTraceResult } from './types';
+export { turborepoTraceAccess, writeTurborepoAccessTraceResult, } from './helpers';
+export { TurborepoAccessTraceResult } from './result';

frontend/node_modules/next/dist/build/turborepo-access-trace/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    TurborepoAccessTraceResult: null,
+    turborepoTraceAccess: null,
+    writeTurborepoAccessTraceResult: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    TurborepoAccessTraceResult: function() {
+        return _result.TurborepoAccessTraceResult;
+    },
+    turborepoTraceAccess: function() {
+        return _helpers.turborepoTraceAccess;
+    },
+    writeTurborepoAccessTraceResult: function() {
+        return _helpers.writeTurborepoAccessTraceResult;
+    }
+});
+const _helpers = require("./helpers");
+const _result = require("./result");
+
+//# sourceMappingURL=index.js.map

frontend/node_modules/next/dist/build/turborepo-access-trace/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/build/turborepo-access-trace/index.ts"],"names":["TurborepoAccessTraceResult","turborepoTraceAccess","writeTurborepoAccessTraceResult"],"mappings":";;;;;;;;;;;;;;;;IAKSA,0BAA0B;eAA1BA,kCAA0B;;IAHjCC,oBAAoB;eAApBA,6BAAoB;;IACpBC,+BAA+B;eAA/BA,wCAA+B;;;yBAC1B;wBACoC"}

frontend/node_modules/next/dist/build/turborepo-access-trace/result.d.ts

@@ -0,0 +1,24 @@
+import type { Addresses, EnvVars, FS, SerializableTurborepoAccessTraceResult, PublicTurborepoAccessTraceResult } from './types';
+export declare class TurborepoAccessTraceResult {
+    private envVars;
+    private addresses;
+    private fsPaths;
+    constructor(envVars?: EnvVars, addresses?: Addresses, fsPaths?: FS);
+    /**
+     * Merge another `TurborepoAccessTraceResult` into this one, mutating this `TurborepoAccessTraceResult`.
+     */
+    merge(other: TurborepoAccessTraceResult): this;
+    /**
+     * Serialize this `TurborepoAccessTraceResult` into a serializable object. Used for passing
+     * the `TurborepoAccessTraceResult` between workers where Sets are not serializable.
+     */
+    serialize(): SerializableTurborepoAccessTraceResult;
+    /**
+     * Squash this `TurborepoAccessTraceResult` into a public trace object that can be written to a file
+     */
+    toPublicTrace(): PublicTurborepoAccessTraceResult;
+    /**
+     * Create an `TurborepoAccessTraceResult` from a serialized `SerializableTurborepoAccessTraceResult`
+     */
+    static fromSerialized(serialized: SerializableTurborepoAccessTraceResult): TurborepoAccessTraceResult;
+}

frontend/node_modules/next/dist/build/turborepo-access-trace/result.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TurborepoAccessTraceResult", {
+    enumerable: true,
+    get: function() {
+        return TurborepoAccessTraceResult;
+    }
+});
+class TurborepoAccessTraceResult {
+    constructor(envVars = new Set([]), addresses = [], fsPaths = new Set([])){
+        this.envVars = envVars;
+        this.addresses = addresses;
+        this.fsPaths = fsPaths;
+    }
+    /**
+   * Merge another `TurborepoAccessTraceResult` into this one, mutating this `TurborepoAccessTraceResult`.
+   */ merge(other) {
+        other.envVars.forEach((envVar)=>this.envVars.add(envVar));
+        other.fsPaths.forEach((path)=>this.fsPaths.add(path));
+        this.addresses.push(...other.addresses);
+        return this;
+    }
+    /**
+   * Serialize this `TurborepoAccessTraceResult` into a serializable object. Used for passing
+   * the `TurborepoAccessTraceResult` between workers where Sets are not serializable.
+   */ serialize() {
+        return {
+            fs: Array.from(this.fsPaths).map(String),
+            addresses: this.addresses,
+            envVars: Array.from(this.envVars).map(String)
+        };
+    }
+    /**
+   * Squash this `TurborepoAccessTraceResult` into a public trace object that can be written to a file
+   */ toPublicTrace() {
+        return {
+            network: this.addresses.length > 0,
+            envVarKeys: Array.from(this.envVars).map(String),
+            filePaths: Array.from(this.fsPaths).map(String)
+        };
+    }
+    /**
+   * Create an `TurborepoAccessTraceResult` from a serialized `SerializableTurborepoAccessTraceResult`
+   */ static fromSerialized(serialized) {
+        return new TurborepoAccessTraceResult(new Set(serialized.envVars), serialized.addresses, new Set(serialized.fs));
+    }
+}
+
+//# sourceMappingURL=result.js.map

frontend/node_modules/next/dist/build/turborepo-access-trace/result.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/build/turborepo-access-trace/result.ts"],"names":["TurborepoAccessTraceResult","constructor","envVars","Set","addresses","fsPaths","merge","other","forEach","envVar","add","path","push","serialize","fs","Array","from","map","String","toPublicTrace","network","length","envVarKeys","filePaths","fromSerialized","serialized"],"mappings":";;;;+BAQaA;;;eAAAA;;;AAAN,MAAMA;IACXC,YACE,AAAQC,UAAmB,IAAIC,IAAI,EAAE,CAAC,EACtC,AAAQC,YAAuB,EAAE,EACjC,AAAQC,UAAc,IAAIF,IAAI,EAAE,CAAC,CACjC;aAHQD,UAAAA;aACAE,YAAAA;aACAC,UAAAA;IACP;IAEH;;GAEC,GACD,AAAOC,MAAMC,KAAiC,EAAE;QAC9CA,MAAML,OAAO,CAACM,OAAO,CAAC,CAACC,SAAW,IAAI,CAACP,OAAO,CAACQ,GAAG,CAACD;QACnDF,MAAMF,OAAO,CAACG,OAAO,CAAC,CAACG,OAAS,IAAI,CAACN,OAAO,CAACK,GAAG,CAACC;QACjD,IAAI,CAACP,SAAS,CAACQ,IAAI,IAAIL,MAAMH,SAAS;QAEtC,OAAO,IAAI;IACb;IAEA;;;GAGC,GACD,AAAOS,YAAoD;QACzD,OAAO;YACLC,IAAIC,MAAMC,IAAI,CAAC,IAAI,CAACX,OAAO,EAAEY,GAAG,CAACC;YACjCd,WAAW,IAAI,CAACA,SAAS;YACzBF,SAASa,MAAMC,IAAI,CAAC,IAAI,CAACd,OAAO,EAAEe,GAAG,CAACC;QACxC;IACF;IAEA;;GAEC,GACD,AAAOC,gBAAkD;QACvD,OAAO;YACLC,SAAS,IAAI,CAAChB,SAAS,CAACiB,MAAM,GAAG;YACjCC,YAAYP,MAAMC,IAAI,CAAC,IAAI,CAACd,OAAO,EAAEe,GAAG,CAACC;YACzCK,WAAWR,MAAMC,IAAI,CAAC,IAAI,CAACX,OAAO,EAAEY,GAAG,CAACC;QAC1C;IACF;IAEA;;GAEC,GACD,OAAcM,eACZC,UAAkD,EAClD;QACA,OAAO,IAAIzB,2BACT,IAAIG,IAAIsB,WAAWvB,OAAO,GAC1BuB,WAAWrB,SAAS,EACpB,IAAID,IAAIsB,WAAWX,EAAE;IAEzB;AACF"}

frontend/node_modules/next/dist/build/turborepo-access-trace/tcp.d.ts

@@ -0,0 +1,8 @@
+import type { Addresses, RestoreOriginalFunction } from './types';
+/**
+ * Proxy the TCP connect method to determine if any network access is made during the build
+ *
+ * @param addresses An array to track the addresses that are accessed.
+ * @returns A function that restores the original connect method.
+ */
+export declare function tcpProxy(addresses: Addresses): RestoreOriginalFunction;

frontend/node_modules/next/dist/build/turborepo-access-trace/tcp.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "tcpProxy", {
+    enumerable: true,
+    get: function() {
+        return tcpProxy;
+    }
+});
+const _net = /*#__PURE__*/ _interop_require_default(require("net"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function tcpProxy(addresses) {
+    // net.Socket docs https://nodejs.org/api/net.html#class-netsocket
+    const originalConnect = _net.default.Socket.prototype.connect;
+    // Override the connect method
+    _net.default.Socket.prototype.connect = function(...args) {
+        // First, check if the first argument is an object and not null
+        if (typeof args[0] === "object" && args[0] !== null) {
+            const options = args[0];
+            // check if the options has what we need
+            if ("port" in options && options.port !== undefined && "host" in options && options.host !== undefined) {
+                addresses.push({
+                    addr: options.host,
+                    port: options.port.toString()
+                });
+            }
+        }
+        return originalConnect.apply(this, args);
+    };
+    return ()=>{
+        // Restore the original connect method
+        _net.default.Socket.prototype.connect = originalConnect;
+    };
+}
+
+//# sourceMappingURL=tcp.js.map

frontend/node_modules/next/dist/build/turborepo-access-trace/tcp.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/build/turborepo-access-trace/tcp.ts"],"names":["tcpProxy","addresses","originalConnect","net","Socket","prototype","connect","args","options","port","undefined","host","push","addr","toString","apply"],"mappings":";;;;+BASgBA;;;eAAAA;;;4DATA;;;;;;AAST,SAASA,SAASC,SAAoB;IAC3C,kEAAkE;IAClE,MAAMC,kBAAkBC,YAAG,CAACC,MAAM,CAACC,SAAS,CAACC,OAAO;IAEpD,8BAA8B;IAC9BH,YAAG,CAACC,MAAM,CAACC,SAAS,CAACC,OAAO,GAAG,SAAU,GAAGC,IAAS;QACnD,+DAA+D;QAC/D,IAAI,OAAOA,IAAI,CAAC,EAAE,KAAK,YAAYA,IAAI,CAAC,EAAE,KAAK,MAAM;YACnD,MAAMC,UAAUD,IAAI,CAAC,EAAE;YAEvB,wCAAwC;YACxC,IACE,UAAUC,WACVA,QAAQC,IAAI,KAAKC,aACjB,UAAUF,WACVA,QAAQG,IAAI,KAAKD,WACjB;gBACAT,UAAUW,IAAI,CAAC;oBAAEC,MAAML,QAAQG,IAAI;oBAAEF,MAAMD,QAAQC,IAAI,CAACK,QAAQ;gBAAG;YACrE;QACF;QAEA,OAAOZ,gBAAgBa,KAAK,CAAC,IAAI,EAAER;IACrC;IAEA,OAAO;QACL,sCAAsC;QACtCJ,YAAG,CAACC,MAAM,CAACC,SAAS,CAACC,OAAO,GAAGJ;IACjC;AACF"}

frontend/node_modules/next/dist/build/turborepo-access-trace/types.d.ts

@@ -0,0 +1,40 @@
+/**
+ * A single Addr / Port pair that was accessed during the duration of the trace
+ */
+export interface Address {
+    addr: string;
+    port: string;
+}
+/**
+ * Tracked environment variable keys that were accessed during the duration of the trace
+ */
+export type EnvVars = Set<string | Symbol>;
+/**
+ * Tracks the file system paths that were accessed during the duration of the trace
+ */
+export type FS = Set<string>;
+/**
+ * Tracked Addr / Port pairs that were accessed during the duration of the trace
+ */
+export type Addresses = Array<Address>;
+/**
+ * The serializable version of `TurborepoAccessTraceResult` - this is required to pass the `TurborepoAccessTraceResult`
+ * between workers where Sets are not serializable.
+ */
+export type SerializableTurborepoAccessTraceResult = Readonly<{
+    fs: Array<string>;
+    addresses: Addresses;
+    envVars: Array<string>;
+}>;
+/**
+ *  The public version of `TurborepoAccessTraceResult` - this is what is written to the trace file
+ */
+export type PublicTurborepoAccessTraceResult = Readonly<{
+    filePaths: Array<string>;
+    network: boolean;
+    envVarKeys: Array<string>;
+}>;
+/**
+ * A function that restores the original state of a proxy
+ */
+export type RestoreOriginalFunction = () => void;

frontend/node_modules/next/dist/build/turborepo-access-trace/types.js

@@ -0,0 +1,8 @@
+/**
+ * A single Addr / Port pair that was accessed during the duration of the trace
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=types.js.map

frontend/node_modules/next/dist/build/turborepo-access-trace/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/build/turborepo-access-trace/types.ts"],"names":[],"mappings":"AAAA;;CAEC"}