@skaile/workspaces 5.1.3 → 5.3.0

package/dist/factory-assets/connectors/git/repo.d.ts

@@ -0,0 +1,496 @@
+/**
+ * Git repo operations of the git connector: everything that changes or reads a
+ * mount's checkout through git - clone and bootstrap, session branches, commit,
+ * merge, push, pull, auto-commit, conflict resolution, the agent's own
+ * `push` / `pull` / `fetch` ops - each running hook-free git commands (see
+ * `exec.ts`) authenticated by the mount's {@link GitCredentials} handle.
+ *
+ * A {@link GitRepo} owns the state those operations share (the active branch,
+ * the outcome of the last session-branch fetch, the mount lock, the disposed
+ * flag). It never schedules anything: when to fetch, commit or push is the
+ * lifecycle module's call, and the credential itself is the credentials
+ * module's.
+ */
+import type { ConnectorChangeEvent, ConnectorDeclaration } from "@skaile/workspaces/connectors";
+import type { ConnectorPushState, Logger } from "@skaile/workspaces/types";
+import type { GitSessionConfig } from "./config.js";
+import { type GitCredentials } from "./credentials.js";
+import { type GitSyncStatusResult } from "./inspect.js";
+/**
+ * Result of the agent-facing `push`, `pull` and `fetch` tool ops, JSON-serialised.
+ * An expected outcome the agent must act on (a rejected push, a conflicting
+ * pull) is a `status`, not a thrown error; auth or network failures throw.
+ */
+export interface GitRemoteOpResult {
+    op: "push" | "pull" | "fetch";
+    /** The mount's branch the op acted on (the session branch on a branching mount). */
+    branch: string;
+    status: "pushed" | "rejected" | "fetched" | "merged" | "up-to-date" | "no-upstream" | "conflict" | "blocked";
+    /** What happened and what to do next, in words the agent can act on. */
+    message?: string;
+    /** Files that conflicted, for `status: "conflict"` (the merge itself was aborted). */
+    conflicts?: string[];
+    /** Sync status after the op. */
+    sync: GitSyncStatusResult;
+}
+/** What {@link GitRepo.open} needs beyond what the repo already knows. */
+export interface GitOpenOptions {
+    /** The declared access level; a read-only ref-less remote is never published to. */
+    access: ConnectorDeclaration["access"];
+    session: GitSessionConfig;
+    /** Push a freshly cut session branch to origin (best effort). */
+    publishOnCreate: boolean;
+    /** False when every lifecycle push flag is off: a bootstrapped branch then stays local. */
+    publish: boolean;
+    /** Tier-2: wire the credential into the agent's own `git`. */
+    exposeAccessToken: boolean;
+    /** Connect start time, for duration logs. */
+    started: number;
+    /** The mount's declaration id, for log context. */
+    connectorId: string;
+}
+/** Construction inputs of a {@link GitRepo}. */
+export interface GitRepoInit {
+    /** Checkout path. */
+    dir: string;
+    /** Declared remote URL (never holds a credential). */
+    url: string;
+    /** Base branch to track. */
+    branch: string;
+    /** The mount's credential. Read at spawn time, so a rotated token is picked up. */
+    credentials: GitCredentials;
+    /**
+     * A reference checkout of the base branch: this repo never commits or pushes
+     * it ({@link GitRepo.pushActiveBranch} refuses).
+     */
+    readOnly: boolean;
+    log: Logger;
+    /** Told about files the repo writes for the agent (the `.conflict` copies). */
+    onChange?: (event: ConnectorChangeEvent) => void;
+}
+/** How a merge of the session branch into the base ended. */
+export type SessionMergeOutcome = {
+    kind: "skipped";
+    reason: string;
+} | {
+    kind: "merged";
+    resolvedConflicts: boolean;
+} | {
+    kind: "failed";
+};
+/**
+ * One mount's checkout and the git operations on it. Methods that touch the
+ * index or the network are meant to run under {@link withLock}; the caller
+ * (the lifecycle module, the connector's `sync`) takes it, because one job can
+ * span several calls.
+ */
+export declare class GitRepo {
+    readonly dir: string;
+    readonly url: string;
+    readonly branch: string;
+    readonly readOnly: boolean;
+    private readonly credentials;
+    /** The remote a driver command authenticates against. Holds the credential handle, not its token. */
+    private readonly auth;
+    private readonly log;
+    private readonly onChange?;
+    /** Active branch (differs from the base branch when session branching is active). */
+    private _activeBranch;
+    /** Outcome of the last connect-time fetch of the session branch. */
+    private sessionBranchFetch?;
+    /** True when this connect cut the session branch from the base or `fromRef` (it holds no work yet). */
+    private sessionBranchCreated;
+    /** Tail of the queue behind {@link withLock}. */
+    private lock;
+    private _disposed;
+    private alignAttempted;
+    private scopeUrl;
+    constructor(init: GitRepoInit);
+    /** The branch the mount pushes and pulls: the session branch on a branching mount, else the base. */
+    get activeBranch(): string;
+    /**
+     * Set by {@link dispose}. A tick already awaiting a git child cannot be
+     * cancelled, so it re-reads this at each resumption point and drops its
+     * remaining work instead of acting on a checkout the manager has torn down.
+     */
+    get disposed(): boolean;
+    /**
+     * The URL a failed connect registers its "unavailable" credential helper
+     * for. `repo` is undefined when the connect failed before one existed. A
+     * Tier-2 mount whose origin was never aligned (the failure came first) is
+     * aligned now, so the helper's scope matches the URL git will look up.
+     */
+    static scopeUrlAfterFailedConnect(repo: GitRepo | undefined, o: {
+        dir: string;
+        url: string;
+        exposeAccessToken: boolean;
+        connectorId: string;
+        log: Logger;
+    }): Promise<string>;
+    /** Stop acting on the checkout. Idempotent. */
+    dispose(): void;
+    /**
+     * Run `fn` after every earlier job on this mount has settled. Network git and
+     * index-writing git on one checkout must not overlap: two of them contend for
+     * `.git/index.lock`, and a push racing a pull can push a half-merged branch.
+     * Not re-entrant - a job must never wait on the lock it runs under.
+     */
+    withLock<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * The mount's credential, scoped to its repository (see {@link GitRemoteAuth.repoScoped}).
+     * The handle is passed, not its token, so a token rotated while the op waits for the
+     * lock is still read at spawn time.
+     */
+    private repoScopedAuth;
+    /**
+     * Bring the checkout up for a connect: clone or reuse it, cut the session
+     * branch, point `origin` at the declared URL, hand the credential to the agent
+     * (Tier-2) or keep it driver-only (Tier-1), keep `.skaile/` out of the index,
+     * and set the push guard of a read-write mount. Never auto-syncs an existing
+     * checkout (see {@link prepareCheckout}).
+     */
+    open(o: GitOpenOptions): Promise<void>;
+    /** True when the checkout already carries the read-only push block. */
+    hasPushBlock(): Promise<boolean>;
+    /**
+     * The agent's network git: the driver runs it with the mount's credential, so
+     * an agent on a mount without `exposeAccessToken` can push and pull without
+     * ever holding the token. Acts only on the mount's own branch, never forces.
+     * The caller has checked that the mount is connected, not fleet-managed, and
+     * (for `push`) not declared read-only.
+     */
+    agentOp(op: GitRemoteOpResult["op"]): Promise<GitRemoteOpResult>;
+    /**
+     * Refuse an agent git op when `origin` no longer resolves to the mount's URL
+     * for fetch or push. The config is agent-writable: a `pushurl`, an
+     * `insteadOf` / `pushInsteadOf` rule or a re-pointed `url` could send the
+     * mount's credential to another repository on the same host. `remote get-url`
+     * applies all of them, so one comparison covers each.
+     */
+    private assertOriginIsMount;
+    /** `git pull` of the active branch by merge, then align submodule checkouts with the merged pins. */
+    pull(): Promise<void>;
+    /**
+     * Stage everything and commit with `message`; the new commit's short sha, or
+     * `null` when there was nothing to commit or a merge/rebase is unfinished.
+     */
+    commit(message: string): Promise<string | null>;
+    /**
+     * One idle auto-commit: commit what changed under a message naming the files,
+     * and push it when `push` is set. Best-effort - a failure leaves the work
+     * staged and is logged, never thrown. Skips a read-only checkout, an
+     * unfinished merge or rebase, and a repo disposed meanwhile.
+     */
+    autoCommit(opts: {
+        push: boolean;
+    }): Promise<void>;
+    /**
+     * Commits that exist only locally, measured as the platform's hibernate save
+     * gate reads `sync_status`: ahead of the upstream, or, with no upstream, ahead
+     * of `origin/<base>`. Zero when HEAD is detached or on another branch than the
+     * one this repo pushes.
+     */
+    unpushedCommits(): Promise<number>;
+    /** Sync status of the checkout against its upstream and the base branch. Never fetches. */
+    syncStatus(): Promise<GitSyncStatusResult>;
+    /** What the checkout can prove about being pushed (see {@link readPushState}). */
+    pushState(): Promise<ConnectorPushState>;
+    /**
+     * The periodic tick of a read-write mount: fetch origin, then (per config)
+     * merge or rebase the base into a session branch, or pull the active branch.
+     * Bails out at each resumption point once disposed.
+     */
+    syncFromOrigin(opts: {
+        autoRebase: boolean;
+        autoPull: boolean;
+    }): Promise<void>;
+    /**
+     * Merge the session branch into the base branch for a session close: check
+     * the base out, pull it, merge, and (with `push`) push it. Conflicts keep
+     * "ours" and save "theirs" as `.conflict` files; a merge that cannot finish is
+     * aborted. An unfinished merge or rebase found beforehand skips the merge.
+     */
+    mergeSessionIntoBase(push: boolean): Promise<SessionMergeOutcome>;
+    /** `git fetch origin <base>` for a read-only refresh; throws when origin cannot be reached. */
+    fetchBase(): Promise<void>;
+    /**
+     * The commit a read-only refresh returns to: `FETCH_HEAD` after a fetch, else
+     * the last fetched `origin/<base>`, else HEAD. `null` for an unborn checkout
+     * made in place: there is no commit to return to, and cleaning would delete
+     * the only copy of the files.
+     */
+    resetTarget(fetched: boolean): Promise<string | null>;
+    /** True when HEAD is on the base branch at exactly `target`. */
+    isAtBase(target: string): Promise<boolean>;
+    /**
+     * Drop every local change and put the checkout on `target` as the base branch:
+     * edits, untracked files (ignored ones stay, so `.skaile/` and build output
+     * survive), local commits, an unfinished merge or rebase, and a branch switch.
+     * With `fetched`, `origin/<base>` follows and submodules are fetched; without,
+     * only pins already local are checked out.
+     */
+    resetToBase(target: string, fetched: boolean): Promise<void>;
+    /** Fetch origin's base branch and, on a branching mount, the session branch. */
+    private fetchActiveBranch;
+    private agentFetch;
+    private agentPush;
+    private agentPull;
+    /**
+     * Bring `targetDir` into a usable checkout state for `connect()`.
+     *
+     * Minimal-connect policy: `connect()` never auto-syncs with the remote.
+     * The lifecycle hooks (`pushOnHibernate`, `pushAfterCommit`,
+     * `sync.autoPull`) and the explicit `filesystem.sync()` method are the
+     * only paths that touch the network with the existing checkout. Recreating
+     * a container is therefore idempotent — the on-disk dir is preserved.
+     *
+     * Three cases:
+     *   - `.git` exists       → use as-is. No pull, no reset.
+     *   - dir empty           → fresh clone (only network fetch on connect), or
+     *     `bootstrapEmptyRemote` when the remote has no refs at all.
+     *   - dir populated, no `.git` → `git init` + `remote add origin` so
+     *     lifecycle hooks (commit/push) can do their job. No fetch, no
+     *     reset, no clean. Existing files become uncommitted-on-init; the
+     *     agent or `pushAfterCommit` reconciles with remote later.
+     */
+    private prepareCheckout;
+    /**
+     * Create and check out the session branch for a non-main session, updating
+     * `state.activeBranch`. Reuses an existing local branch (unpushed work);
+     * else prefers `origin/<branch>`; otherwise branches off `fromRef` (platform
+     * fork flow) when supplied and valid, else off the currently-checked-out
+     * HEAD (== base branch).
+     */
+    private checkoutSessionBranch;
+    /**
+     * Fetch the session branch into `refs/remotes/origin/<sessionBranch>` and,
+     * when origin has it, map it with a fetch refspec. Never throws: a missing
+     * remote branch is the normal case for a new session, and any other failure
+     * leaves the checkout as it was (the caller creates the branch from the base).
+     *
+     * The refspec is added only once origin has the branch, and removed when
+     * origin does not have it: a configured refspec for a missing branch makes
+     * every plain `git fetch origin` fail. Runs on every connect, so it also
+     * repairs a checkout cloned before the refspec existed.
+     */
+    private trackSessionBranch;
+    /**
+     * Re-point a session branch that this connect cut from the base at
+     * `origin/<sessionBranch>`, once the retried fetch shows origin has it.
+     * Safe because the freshly-cut branch holds no work. Never throws: when the
+     * checkout is refused (for example local changes in the way), the branch
+     * stays as it is and the push later fails as non-fast-forward.
+     */
+    private adoptOriginSessionBranch;
+    /**
+     * Line up a reused local session branch (checked out) with
+     * `origin/<sessionBranch>` after a successful fetch. Never rewrites local
+     * history and never throws:
+     *   - local is an ancestor of origin → fast-forward (another node pushed
+     *     newer work);
+     *   - local has commits that origin does not have → keep them and log a
+     *     warning; when origin also has commits that local lacks (diverged),
+     *     merge origin in with {@link integrateOriginSessionBranch};
+     *   - origin has no such branch → nothing to do.
+     * In the first two cases the upstream is set to `origin/<sessionBranch>`.
+     */
+    private reconcileLocalSessionBranch;
+    /**
+     * Merge `origin/<branch>` into the checked-out session branch when origin
+     * holds commits that the local branch lacks (another node or the agent
+     * pushed, or an older driver rewrote the local branch). A merge, never a
+     * rebase: the commits on origin are published. After this, a push of the
+     * branch is a fast-forward and needs no force. Never throws; a merge that
+     * cannot complete is aborted, and the push that follows fails as before.
+     */
+    private integrateOriginSessionBranch;
+    /**
+     * After a successful push of a session branch: map it with a fetch refspec
+     * and point `refs/remotes/origin/<branch>` at the pushed tip. The push ran
+     * before the refspec existed (a refspec for a branch that origin does not
+     * have yet would break `git fetch origin`), so git did not update the
+     * tracking ref itself. With both, `@{upstream}` resolves and the platform's
+     * hibernate save gate sees `ahead` 0. Never throws.
+     */
+    private recordPushedSessionBranch;
+    /**
+     * Push the active branch. A session branch first gets any commits that are
+     * only on `origin/<branch>` merged in, so the push is a fast-forward and
+     * never needs a force. It is pushed with `-u` and then recorded (see
+     * {@link recordPushedSessionBranch}), so `@{upstream}` resolves — the
+     * platform's hibernate save gate reads exactly that. The base branch is
+     * first brought up to date with origin ({@link integrateOriginBaseBranch}),
+     * so a base branch that origin moved past is pushed rather than rejected.
+     */
+    pushActiveBranch(): Promise<void>;
+    /**
+     * Attempt to create `sessionBranch` anchored on `session.fromRef`. Returns
+     * true when the branch was created from the anchor; false when no valid
+     * `fromRef` was supplied or the fetch failed (caller falls back to base).
+     */
+    private branchFromRef;
+    /**
+     * Bring a populated, non-git directory under git tracking without
+     * touching the working tree. Runs only on the "dir populated, no `.git`"
+     * branch of `connect()` — exactly when a previous connect aborted before
+     * `.git` was written, or when the bind-mounted host dir's `.git` FILE
+     * pointed outside the container.
+     *
+     * The intent is to preserve whatever the agent last had on disk. We
+     * therefore:
+     *   - `git init` — creates `.git/`; does not modify any existing file.
+     *   - `git remote add origin <remoteUrl>` — wires up the remote so the
+     *     normal lifecycle hooks (`pushOnHibernate`, `pushAfterCommit`)
+     *     have a target.
+     *
+     * Deliberately omitted:
+     *   - `fetch` — would touch the network on every recreate. The lifecycle
+     *     handles sync explicitly (periodic `fetch`/`pull` via
+     *     `sync.autoPull`, push on hibernate, etc.).
+     *   - `checkout -f` / `reset --hard` / `clean -fd` — would discard the
+     *     user's last on-disk state. The agent or autocommit reconciles
+     *     with the remote later.
+     *
+     * `remoteUrl` carries no credential; network commands authenticate per
+     * command (see `runRemoteGit`).
+     */
+    private initInPlace;
+    /**
+     * Count `refs/heads/*` on the remote, optionally narrowed to one `branch`.
+     *
+     * Returns `null` when the probe itself fails (network, auth, bad URL).
+     * "Cannot tell" must never collapse into "no refs": the empty-remote
+     * fallback WRITES to origin, and every caller therefore treats `null` as
+     * "assume populated" and falls through to the path that fails loudly.
+     */
+    private countRemoteHeads;
+    /**
+     * Bootstrap a checkout against a remote that has no refs at all — the state
+     * of a GitHub repo created without "Add a README".
+     *
+     * A plain `git clone` is NOT a substitute: cloning a ref-less remote leaves
+     * local HEAD on git's `init.defaultBranch` (`master`), not the declared
+     * branch, so the branch is created explicitly here.
+     *
+     * The root commit is created REGARDLESS of `access` and `publish`; only the
+     * push to origin is gated on them (`publish` is false when every lifecycle
+     * push flag is off). An unborn HEAD is not a stable resting state: the
+     * next connect sees `.git` with no resolvable HEAD, routes to
+     * `bootstrapFromOrigin`, and its `fetch origin <branch>` dies on the still
+     * ref-less remote — turning a fixed first connect into a broken second one.
+     * A local commit costs a read-only connector nothing (it is never pushed)
+     * and makes reconnect take the cheap "use as-is" path.
+     *
+     * With the push done, `origin/<branch>` exists for everything downstream —
+     * notably `checkoutSessionBranch`, whose publish-on-create push needs a
+     * commit to point at.
+     *
+     * Invariant: this method never throws on a failed push. The session must
+     * come up with a usable checkout even when origin is unreachable — the
+     * lifecycle hooks (`pushAfterCommit`, hibernate/close push) publish later.
+     */
+    private bootstrapEmptyRemote;
+    /**
+     * True when `<targetDir>/.git` contains at least one resolvable commit
+     * (i.e. `HEAD` points at a real object). False when `.git` is an empty
+     * shell — e.g. just-initialised but never fetched, or all refs deleted.
+     *
+     * Used by `connect()` to tell the difference between a working agent
+     * checkout (preserve, don't touch) and a half-initialised one
+     * (bootstrap by fetching from origin).
+     */
+    private isInitialisedCheckout;
+    /**
+     * One-shot bootstrap path for the "`.git` exists but is empty" state.
+     *
+     * Runs `fetch --depth=1 origin <branch>` followed by `checkout -B
+     * <branch> origin/<branch>` so the working tree gets the remote
+     * content. Before the checkout, any untracked file whose path also
+     * exists in the remote tree is renamed to `<path>.local` so the user
+     * (or previous agent run) does not lose data. Other untracked files
+     * are left in place.
+     *
+     * Deliberately not destructive: we never `clean -fd` and never
+     * `reset --hard`. Files that do not conflict with the remote stay
+     * exactly where they are.
+     *
+     * A pre-existing `origin` is replaced with the declared URL, which also
+     * drops a token an older driver wrote into it.
+     */
+    private bootstrapFromOrigin;
+    /**
+     * Walk the remote tree at `origin/<branch>` and rename any untracked
+     * working-tree file whose path also exists there. Renames go to
+     * `<path>.local`; on `.local` collision a millisecond suffix is
+     * appended so nothing is overwritten.
+     *
+     * This makes the subsequent `git checkout -B <branch> origin/<branch>`
+     * safe: without it, `checkout` aborts with "untracked working tree
+     * files would be overwritten" the moment any local file collides with
+     * a tracked path on the remote.
+     *
+     * Files in the local tree whose paths are NOT in the remote tree are
+     * left untouched — they are pure local additions and survive the
+     * bootstrap.
+     */
+    private preserveConflictingUntracked;
+    /**
+     * Point `origin` at the declared URL, without a credential in it.
+     *
+     * Clones made before the driver authenticated per command hold
+     * `https://x-access-token:<token>@…` in `.git/config`, where the agent can
+     * read it; this is what removes it, on the first connect after an upgrade.
+     * With a token in hand `origin` is set to the declared URL, as the old
+     * re-bake did. Without one only a token-bearing origin is rewritten: a URL
+     * the user declared with their own userinfo is theirs to keep.
+     */
+    reconcileRemoteUrl(): Promise<void>;
+    /**
+     * Set `remote.origin.pushurl` to {@link READ_ONLY_PUSH_URL} on a read-only
+     * mount, and remove it again (only that value) once the mount is read-write,
+     * because the driver's own pushes go through `origin` and would hit it too.
+     */
+    applyPushGuard(): Promise<void>;
+    /**
+     * `git fetch origin` for the periodic tick. When origin no longer has a
+     * branch that a session refspec names (for example a session branch deleted
+     * after a merge, or one from an earlier session on this checkout), that
+     * refspec fails the whole fetch. Drop it and fetch again. The base branch
+     * refspec is never dropped.
+     */
+    private fetchOrigin;
+    /**
+     * Merge `origin/<base>` into a published session branch (periodic tick with
+     * `autoRebase`). No-op when the base is already contained. Conflicts are
+     * handled like the merge on close: keep "ours" (the session branch) and
+     * save "theirs" as `.conflict` files.
+     */
+    mergeBaseIntoSessionBranch(): Promise<void>;
+    /**
+     * True (and logged) when a merge or rebase is already open in the checkout,
+     * so a driver merge must not start: its failure path would abort or resolve
+     * the agent's own operation.
+     */
+    private skipOverUnfinishedOperation;
+    /**
+     * Attempt to resolve merge/rebase conflicts by keeping "ours" and copying
+     * "theirs" to a .conflict file. If resolution fails entirely, abort.
+     * Returns true if conflicts were resolved, false if aborted.
+     */
+    resolveConflictsOrAbort(mode: "rebase" | "merge"): Promise<boolean>;
+    /**
+     * For a single conflicted file: keep "ours", save "theirs" as .conflict file.
+     */
+    private resolveFileConflict;
+    private stripConflictKeepOurs;
+    private generateCommitMessage;
+    /**
+     * Save what the first read-only discard would destroy on a checkout that was
+     * used read-write: local commits on the base branch or a detached HEAD go to a
+     * `skaile/pre-read-only-<time>` branch, uncommitted edits and untracked files
+     * to a stash. Other local branches are left alone by the discard anyway.
+     * False (logged) when the stash fails, e.g. over unmerged paths.
+     */
+    saveLocalWork(target: string): Promise<boolean>;
+}
+//# sourceMappingURL=repo.d.ts.map

package/dist/factory-assets/connectors/git/repo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repo.d.ts","sourceRoot":"","sources":["../../../../factory-assets/connectors/git/repo.ts"],"names":[],"mappings":"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"}

package/dist/factory-assets/connectors/git.js

@@ -1,37 +1,37 @@
-export { GitConnector, MAX_REARM_MS, MIN_REFRESH_DELAY_MS, REFRESH_LEAD_MS, __test, createConnector5 as createConnector, readGitSyncStatus } from '../../chunk-M4ISBWXR.js';
-import '../../chunk-KC3OF6B2.js';
-import '../../chunk-WKIOWDLQ.js';
-import '../../chunk-QU4J5YSJ.js';
-import '../../chunk-TVOODIZE.js';
+export { GitConnector, createConnector5 as createConnector, readGitSyncStatus } from '../../chunk-OOKFZW6H.js';
+import '../../chunk-QMWMSZQ4.js';
+import '../../chunk-CZ35I4RK.js';
+import '../../chunk-7L4WFH3Y.js';
+import '../../chunk-LAI7X6I2.js';
 import '../../chunk-EINLFFP6.js';
 import '../../chunk-LOO5CB5M.js';
-import '../../chunk-RDYI4MML.js';
-import '../../chunk-KVAI5DGL.js';
+import '../../chunk-BNUZEYC3.js';
+import '../../chunk-ERCSHLTF.js';
 import '../../chunk-XBSQ4KMC.js';
 import '../../chunk-YROR332M.js';
-import '../../chunk-ZD7CX25M.js';
+import '../../chunk-FTYM4VRZ.js';
 import '../../chunk-6E6PKKAD.js';
 import '../../chunk-IFGTRL2I.js';
-import '../../chunk-UMSWQKCY.js';
+import '../../chunk-LM5XEFNS.js';
 import '../../chunk-37FTLYFP.js';
 import '../../chunk-QZLWJETK.js';
 import '../../chunk-XUUYAS3Z.js';
 import '../../chunk-NFGRW3L7.js';
 import '../../chunk-QCI6D7E4.js';
-import '../../chunk-IDEA6CYI.js';
-import '../../chunk-IWCCZL7C.js';
+import '../../chunk-K2K7OF4P.js';
+import '../../chunk-6GBQND2F.js';
 import '../../chunk-4GY63JU6.js';
-import '../../chunk-YDJZRLGN.js';
-import '../../chunk-U6K3I3AX.js';
-import '../../chunk-K5GBV4SA.js';
+import '../../chunk-4SSKKFDF.js';
+import '../../chunk-XGIS325V.js';
+import '../../chunk-5BEFNLOR.js';
 import '../../chunk-A2ULN3KX.js';
-import '../../chunk-MXXKTQXJ.js';
-import '../../chunk-TLKM4M47.js';
+import '../../chunk-KBAE7PU7.js';
+import '../../chunk-MFHKHXDE.js';
 import '../../chunk-TOSHZX4C.js';
-import '../../chunk-AG44ZJ7W.js';
+import '../../chunk-SR4RFKHM.js';
 import '../../chunk-RVRB27AN.js';
-import '../../chunk-DXUQCMVT.js';
-import '../../chunk-43ZBF3WH.js';
+import '../../chunk-LFMX2UEF.js';
+import '../../chunk-WX74MVNA.js';
 import '../../chunk-ICSCSM5D.js';
 import '../../chunk-JMKB7IB4.js';
 import '../../chunk-MJHSLODD.js';

package/dist/factory-assets/connectors/gmail.js

@@ -1,37 +1,37 @@
-export { GmailConnector, createConnector6 as createConnector } from '../../chunk-M4ISBWXR.js';
-import '../../chunk-KC3OF6B2.js';
-import '../../chunk-WKIOWDLQ.js';
-import '../../chunk-QU4J5YSJ.js';
-import '../../chunk-TVOODIZE.js';
+export { GmailConnector, createConnector6 as createConnector } from '../../chunk-OOKFZW6H.js';
+import '../../chunk-QMWMSZQ4.js';
+import '../../chunk-CZ35I4RK.js';
+import '../../chunk-7L4WFH3Y.js';
+import '../../chunk-LAI7X6I2.js';
 import '../../chunk-EINLFFP6.js';
 import '../../chunk-LOO5CB5M.js';
-import '../../chunk-RDYI4MML.js';
-import '../../chunk-KVAI5DGL.js';
+import '../../chunk-BNUZEYC3.js';
+import '../../chunk-ERCSHLTF.js';
 import '../../chunk-XBSQ4KMC.js';
 import '../../chunk-YROR332M.js';
-import '../../chunk-ZD7CX25M.js';
+import '../../chunk-FTYM4VRZ.js';
 import '../../chunk-6E6PKKAD.js';
 import '../../chunk-IFGTRL2I.js';
-import '../../chunk-UMSWQKCY.js';
+import '../../chunk-LM5XEFNS.js';
 import '../../chunk-37FTLYFP.js';
 import '../../chunk-QZLWJETK.js';
 import '../../chunk-XUUYAS3Z.js';
 import '../../chunk-NFGRW3L7.js';
 import '../../chunk-QCI6D7E4.js';
-import '../../chunk-IDEA6CYI.js';
-import '../../chunk-IWCCZL7C.js';
+import '../../chunk-K2K7OF4P.js';
+import '../../chunk-6GBQND2F.js';
 import '../../chunk-4GY63JU6.js';
-import '../../chunk-YDJZRLGN.js';
-import '../../chunk-U6K3I3AX.js';
-import '../../chunk-K5GBV4SA.js';
+import '../../chunk-4SSKKFDF.js';
+import '../../chunk-XGIS325V.js';
+import '../../chunk-5BEFNLOR.js';
 import '../../chunk-A2ULN3KX.js';
-import '../../chunk-MXXKTQXJ.js';
-import '../../chunk-TLKM4M47.js';
+import '../../chunk-KBAE7PU7.js';
+import '../../chunk-MFHKHXDE.js';
 import '../../chunk-TOSHZX4C.js';
-import '../../chunk-AG44ZJ7W.js';
+import '../../chunk-SR4RFKHM.js';
 import '../../chunk-RVRB27AN.js';
-import '../../chunk-DXUQCMVT.js';
-import '../../chunk-43ZBF3WH.js';
+import '../../chunk-LFMX2UEF.js';
+import '../../chunk-WX74MVNA.js';
 import '../../chunk-ICSCSM5D.js';
 import '../../chunk-JMKB7IB4.js';
 import '../../chunk-MJHSLODD.js';