@opengeni/contracts 0.22.0 → 0.26.1

package/dist/codex-fleet-policy.d.ts

@@ -0,0 +1,210 @@
+/**
+ * Adaptive Codex fleet policy, replay contract, and shadow evaluator.
+ *
+ * This module is deliberately pure and browser-safe. It accepts only bounded,
+ * metadata-only snapshots whose candidate keys are opaque aliases assigned by
+ * the caller. It never accepts credential ids, account emails, labels, token
+ * material, prompts, or tenant activity. The same normalized snapshot can be
+ * persisted in a session event, replayed offline, and compared byte-for-byte.
+ *
+ * V1 is shadow-only at the runtime integration boundary. The evaluator models
+ * later placement, admission, manager priority, borrowing, emergency-fuse, and
+ * named-overlay semantics so they can be proven with deterministic simulations
+ * before any independent kill switch is allowed to affect a live allocation.
+ */
+export declare const CODEX_FLEET_POLICY_SCHEMA_VERSION: 1;
+export declare const CODEX_FLEET_POLICY_VERSION: "adaptive-shadow-v1";
+export declare const CODEX_FLEET_POLICY_MAX_CANDIDATES = 32;
+export declare const CODEX_FLEET_POLICY_MAX_OVERLAYS_PER_CANDIDATE = 4;
+/**
+ * Replay-integrity ordering for bounded ASCII-safe fleet keys and aliases.
+ *
+ * Locale-aware collation is intentionally forbidden here because its result
+ * can depend on locale and ICU data. Relational string comparison uses
+ * ECMAScript UTF-16 code-unit ordering and is therefore identical in Bun,
+ * Node, and browsers.
+ */
+export declare function compareCodexFleetCanonicalStringsV1(left: string, right: string): number;
+export type CodexFleetConfidence = "unknown" | "low" | "medium" | "high";
+export type CodexFleetCandidateStatus = "active" | "needs_relogin" | "error" | "unknown";
+export type CodexFleetCacheState = "unknown" | "healthy" | "collapsed";
+export type CodexFleetPriority = "standard" | "manager";
+export type CodexFleetPlacementKind = "new" | "fenced_in_flight";
+export type CodexFleetOverlayMode = "none" | "prefer" | "isolate";
+export type CodexFleetQuotaWindowV1 = {
+    /** Provider-reported percentage from a workspace-local cache, never inferred tenant truth. */
+    usedPercent: number | null;
+    /** Relative to input.observedAtMs. Zero means the reported window has reset. */
+    resetRemainingMs: number | null;
+};
+export type CodexFleetCandidateV1 = {
+    /** Opaque, event-local alias such as c00. Never a credential/account id. */
+    key: string;
+    status: CodexFleetCandidateStatus;
+    allocatorEnabled: boolean;
+    /** Relative cooldown. A positive value excludes only NEW placements. */
+    cooldownRemainingMs: number | null;
+    activeLeaseCount: number;
+    quota: {
+        primary: CodexFleetQuotaWindowV1;
+        secondary: CodexFleetQuotaWindowV1;
+        checkedAgeMs: number | null;
+        confidence: CodexFleetConfidence;
+    };
+    /**
+     * Runtime-observed cache evidence. It may be absent because the production
+     * baseline currently exists as aggregate metrics/logs rather than allocator
+     * state. Absence is explicit uncertainty, not a zero cache hit.
+     */
+    cache: {
+        hitRatio: number | null;
+        sampledTokens: number | null;
+        checkedAgeMs: number | null;
+        confidence: CodexFleetConfidence;
+        /** Previously latched state; the evaluator applies dwell and recovery thresholds. */
+        state: CodexFleetCacheState;
+        /** Duration of the current continuous below/above-threshold observation. */
+        thresholdObservedForMs: number | null;
+    };
+    /** Workspace-local observed burn, separate from unexplained/external inference. */
+    observedBurn: {
+        primaryPercentPerHour: number | null;
+        secondaryPercentPerHour: number | null;
+        confidence: CodexFleetConfidence;
+    };
+    /**
+     * Unexplained/external burn is an inference only. The name and confidence are
+     * load-bearing: consumers must never relabel it as provider or tenant truth.
+     */
+    inferredUnexplainedBurn: {
+        primaryPercentPerHour: number | null;
+        secondaryPercentPerHour: number | null;
+        confidence: CodexFleetConfidence;
+    };
+    /** Opaque named-policy keys. Ignored unless overlaysEnabled is independently true. */
+    overlayKeys: string[];
+};
+export type CodexFleetAdmissionSnapshotV1 = {
+    /** Dynamically observed capacity, not a static per-account slot allocation. */
+    dynamicCapacityUnits: number | null;
+    inUseUnits: number;
+    queuedManagerCount: number;
+    emergencyFuseActive: boolean;
+};
+export type CodexFleetDecisionInputV1 = {
+    observedAtMs: number;
+    request: {
+        placement: CodexFleetPlacementKind;
+        priority: CodexFleetPriority;
+        currentCandidateKey: string | null;
+        waitAgeMs: number;
+        overlayKey: string | null;
+        overlayMode: CodexFleetOverlayMode;
+    };
+    admission: CodexFleetAdmissionSnapshotV1;
+    candidates: CodexFleetCandidateV1[];
+};
+export type CodexFleetPolicyConfigV1 = {
+    maxCandidates: number;
+    quotaFreshForMs: number;
+    quotaStaleAfterMs: number;
+    placementUsageCeilingPercent: number;
+    cacheFreshForMs: number;
+    cacheCollapseThreshold: number;
+    cacheCollapseRecoveryThreshold: number;
+    cacheMinimumSampledTokens: number;
+    cacheCollapseDwellMs: number;
+    cacheRecoveryDwellMs: number;
+    activeLeaseScore: number;
+    unknownQuotaScore: number;
+    lowQuotaConfidenceScore: number;
+    mediumQuotaConfidenceScore: number;
+    inferredBurnScorePerPercentHour: number;
+    observedBurnScorePerPercentHour: number;
+    /** Maximum exhaustion-before-reset gap that contributes placement pressure. */
+    runwayRiskCapHours: number;
+    runwayScorePerAtRiskHour: number;
+    healthyCacheAffinityBenefit: number;
+    unknownCacheAffinityBenefit: number;
+    collapsedCacheAffinityBenefit: number;
+    switchHysteresisScore: number;
+    admissionPacingEnabled: boolean;
+    managerPriorityEnabled: boolean;
+    managerStandardStarvationMs: number;
+    emergencyFuseEnabled: boolean;
+    overlaysEnabled: boolean;
+    overlayPreferenceScore: number;
+};
+/**
+ * Experimental shadow defaults. None of the boolean control fields is enabled;
+ * production behavior therefore remains sticky-sharded until operators enable
+ * each independently after shadow acceptance.
+ */
+export declare const DEFAULT_CODEX_FLEET_POLICY_V1: CodexFleetPolicyConfigV1;
+export type CodexFleetScoreV1 = {
+    candidateKey: string;
+    eligible: boolean;
+    rejectionReason: "allocator_disabled" | "unavailable" | "cooling" | "quota_ceiling" | "overlay_isolation" | null;
+    quotaPressure: number;
+    leasePressure: number;
+    observedBurnPressure: number;
+    inferredBurnPressure: number;
+    runwayPressure: number;
+    uncertaintyPressure: number;
+    cacheAffinityBenefit: number;
+    cacheState: CodexFleetCacheState;
+    overlayPreferenceBenefit: number;
+    total: number;
+    confidence: CodexFleetConfidence;
+};
+export type CodexFleetAdmissionDecisionV1 = {
+    outcome: "admit" | "pace";
+    reason: "fenced_in_flight" | "pacing_disabled" | "capacity_unknown" | "capacity_available" | "work_conserving_borrow" | "manager_priority" | "standard_starvation_bound" | "capacity_saturated" | "emergency_fuse";
+    /** True only when standard work uses otherwise-idle capacity with no manager backlog. */
+    borrowedIdleCapacity: boolean;
+};
+export type CodexFleetDecisionV1 = {
+    outcome: "selected" | "paced" | "none";
+    selectedCandidateKey: string | null;
+    reason: "fenced_in_flight" | "fenced_candidate_missing" | "admission_paced" | "no_eligible_candidate" | "overlay_isolated_empty" | "best_score" | "affinity_best" | "hysteresis_hold";
+    admission: CodexFleetAdmissionDecisionV1;
+    borrowedOverlayCapacity: boolean;
+    strandedEligibleCount: number;
+    confidence: CodexFleetConfidence;
+    scores: CodexFleetScoreV1[];
+};
+export type CodexFleetReplayRecordV1 = {
+    schemaVersion: typeof CODEX_FLEET_POLICY_SCHEMA_VERSION;
+    policyVersion: typeof CODEX_FLEET_POLICY_VERSION;
+    mode: "shadow";
+    policy: CodexFleetPolicyConfigV1;
+    input: CodexFleetDecisionInputV1;
+    truncatedCandidateCount: number;
+    policyFingerprint: string;
+    inputFingerprint: string;
+    decision: CodexFleetDecisionV1;
+    decisionFingerprint: string;
+};
+export type CodexFleetReplayVerdictV1 = {
+    matches: boolean;
+    policyFingerprintMatches: boolean;
+    inputFingerprintMatches: boolean;
+    decisionFingerprintMatches: boolean;
+    recordedDecisionFingerprintMatches: boolean;
+    decision: CodexFleetDecisionV1;
+};
+export declare function createCodexFleetReplayRecordV1(input: CodexFleetDecisionInputV1, policy?: CodexFleetPolicyConfigV1): CodexFleetReplayRecordV1;
+export declare function replayCodexFleetDecisionV1(value: unknown): CodexFleetReplayVerdictV1;
+/**
+ * Canonical replay bytes for already-bounded, identity-free fleet values.
+ * This is exported so offline tools can prove the exact bytes across runtimes;
+ * it performs no redaction and must not be used with raw account metadata.
+ */
+export declare function canonicalCodexFleetReplayJsonV1(value: CodexFleetReplayRecordV1): string;
+/**
+ * Strict reader for durable/offline replay. Unknown fields, lossy normalization,
+ * malformed decisions, and non-SHA-256 digests are rejected before comparison.
+ */
+export declare function readCodexFleetReplayRecordV1(value: unknown): CodexFleetReplayRecordV1;
+export declare function evaluateCodexFleetDecisionV1(input: CodexFleetDecisionInputV1, policy?: CodexFleetPolicyConfigV1): CodexFleetDecisionV1;
+export declare function effectiveCodexFleetCacheStateV1(cache: CodexFleetCandidateV1["cache"], policy: CodexFleetPolicyConfigV1): CodexFleetCacheState;

package/dist/event-preview.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Canonical bounded representation for `session_events.payload`.
+ *
+ * Session events are the lossy human/audit projection, not model memory and not
+ * an evidence blob store. This helper keeps that projection useful while making
+ * the loss explicit. It deliberately has no server-only dependency so the DB,
+ * realtime transports, SDK/React, and tests can share one wire contract.
+ */
+import { type RetainedOutputEvidence } from "./retained-output";
+export declare const SESSION_EVENT_PAYLOAD_MAX_BYTES: number;
+export type SessionEventBoundarySurface = "durable_audit" | "database_guard" | "database_read_projection" | "http_projection" | "nats_legacy_guard" | "sse_legacy_guard" | "browser_legacy_guard";
+export type SessionEventPayloadTruncation = {
+    truncated: true;
+    surface: SessionEventBoundarySurface;
+    reason: "payload_bytes_exceeded" | "payload_not_serializable" | "payload_measurement_bounded" | "inline_media_not_retained" | "database_guard";
+    originalBytes: number | null;
+    deliveredBytes: number;
+    omittedBytes: number | null;
+    estimatedOriginalTokens: number | null;
+    estimatedDeliveredTokens: number;
+    fullEvidence: RetainedOutputEvidence;
+    details: Array<{
+        path: string;
+        kind: "string" | "array" | "object" | "depth" | "budget" | "media" | "binary" | "unserializable";
+        originalBytes?: number;
+        deliveredBytes?: number;
+        omittedEntries?: number | null;
+        mediaType?: string;
+    }>;
+};
+export type BoundSessionEventPayloadOptions = {
+    surface?: SessionEventBoundarySurface;
+    maxBytes?: number;
+    /**
+     * Separately trusted durable receipt. Producer payload fields never populate
+     * this slot; invalid values fail closed to not_retained.
+     */
+    fullEvidence?: unknown;
+};
+export type SessionEventJsonMeasurement = {
+    bytes: number;
+    reason: null;
+} | {
+    bytes: null;
+    reason: "payload_not_serializable" | "payload_measurement_bounded";
+};
+export type SessionEventMediaPreview = {
+    type: "media_preview";
+    mediaType: string;
+    inlineBytes: number | null;
+    fullOutputAvailable: false;
+    preview: string;
+};
+/** UTF-8 bytes used by the JSON wire/storage representation. */
+export declare function sessionEventJsonBytes(value: unknown): number;
+/**
+ * Inspect a prospective event value without invoking accessors, custom
+ * serializers, or allocating its complete JSON representation. A null byte
+ * count is explicit: the traversal stopped at the global work/depth boundary
+ * or found serialization behavior that must first be normalized.
+ */
+export declare function measureSessionEventJson(value: unknown): SessionEventJsonMeasurement;
+/** The same deliberately coarse bytes/4 token estimate used by Codex parity code. */
+export declare function approximateSessionEventTokens(bytes: number): number;
+/** Truthful audit fact for inline media whose source bytes are not durably retained. */
+export declare function sessionEventMediaPreview(mediaType: string, inlineBytes: number | null): SessionEventMediaPreview;
+/** Parse a base64 data URL into a compact audit fact without decoding/copying its bytes. */
+export declare function sessionEventMediaPreviewFromDataUrl(value: string): SessionEventMediaPreview | null;
+/** Read explicit truncation metadata from a bounded object payload. */
+export declare function sessionEventPayloadTruncation(payload: unknown): SessionEventPayloadTruncation | null;
+/**
+ * Return a byte-bounded audit payload. Unchanged ordinary payloads retain their
+ * reference. Oversized strings/containers get deterministic head+tail previews;
+ * inline images/binary values become metadata because `session_events` does not
+ * durably retain their source bytes as independently retrievable evidence.
+ */
+export declare function boundSessionEventPayload<T>(payload: T, options?: BoundSessionEventPayloadOptions): T;

package/dist/google-drive.d.ts

@@ -0,0 +1,215 @@
+import { z } from "zod";
+export declare const GOOGLE_DRIVE_PROVIDER_DOMAIN: "googleapis.com";
+export declare const GOOGLE_DRIVE_METADATA_READONLY_SCOPE: "https://www.googleapis.com/auth/drive.metadata.readonly";
+export declare const GOOGLE_DRIVE_READONLY_SCOPE: "https://www.googleapis.com/auth/drive.readonly";
+export declare const GOOGLE_DRIVE_CREDENTIAL_ROLE: "google_drive_metadata";
+export declare const GOOGLE_DRIVE_CREDENTIAL_LABEL: "Google Drive metadata browser";
+export declare const GoogleDriveTargetScope: z.ZodEnum<{
+    organization: "organization";
+    user: "user";
+    workspace: "workspace";
+}>;
+export type GoogleDriveTargetScope = z.infer<typeof GoogleDriveTargetScope>;
+export declare const GoogleDriveSyncCadence: z.ZodEnum<{
+    daily: "daily";
+    hourly: "hourly";
+    manual: "manual";
+}>;
+export type GoogleDriveSyncCadence = z.infer<typeof GoogleDriveSyncCadence>;
+export declare const GoogleDriveReadPolicy: z.ZodEnum<{
+    allow: "allow";
+    ask: "ask";
+    block: "block";
+}>;
+export type GoogleDriveReadPolicy = z.infer<typeof GoogleDriveReadPolicy>;
+export declare const GoogleDriveSelectedSource: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    mimeType: z.ZodString;
+    driveId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    targetScope: z.ZodEnum<{
+        organization: "organization";
+        user: "user";
+        workspace: "workspace";
+    }>;
+    syncCadence: z.ZodDefault<z.ZodEnum<{
+        daily: "daily";
+        hourly: "hourly";
+        manual: "manual";
+    }>>;
+    readPolicy: z.ZodDefault<z.ZodEnum<{
+        allow: "allow";
+        ask: "ask";
+        block: "block";
+    }>>;
+    selectedAt: z.ZodString;
+}, z.core.$strip>;
+export type GoogleDriveSelectedSource = z.infer<typeof GoogleDriveSelectedSource>;
+export declare const GoogleDriveConnectionMetadata: z.ZodObject<{
+    credentialRole: z.ZodLiteral<"google_drive_metadata">;
+    credentialLabel: z.ZodLiteral<"Google Drive metadata browser">;
+    googlePermissionId: z.ZodString;
+    googleEmail: z.ZodString;
+    googleDisplayName: z.ZodNullable<z.ZodString>;
+    verifiedAt: z.ZodString;
+    accessMode: z.ZodEnum<{
+        metadata_readonly: "metadata_readonly";
+        readonly: "readonly";
+    }>;
+    selectedSources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        mimeType: z.ZodString;
+        driveId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        targetScope: z.ZodEnum<{
+            organization: "organization";
+            user: "user";
+            workspace: "workspace";
+        }>;
+        syncCadence: z.ZodDefault<z.ZodEnum<{
+            daily: "daily";
+            hourly: "hourly";
+            manual: "manual";
+        }>>;
+        readPolicy: z.ZodDefault<z.ZodEnum<{
+            allow: "allow";
+            ask: "ask";
+            block: "block";
+        }>>;
+        selectedAt: z.ZodString;
+    }, z.core.$strip>>>;
+    selectedSource: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        mimeType: z.ZodString;
+        driveId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        targetScope: z.ZodEnum<{
+            organization: "organization";
+            user: "user";
+            workspace: "workspace";
+        }>;
+        syncCadence: z.ZodDefault<z.ZodEnum<{
+            daily: "daily";
+            hourly: "hourly";
+            manual: "manual";
+        }>>;
+        readPolicy: z.ZodDefault<z.ZodEnum<{
+            allow: "allow";
+            ask: "ask";
+            block: "block";
+        }>>;
+        selectedAt: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$loose>;
+export type GoogleDriveConnectionMetadata = z.infer<typeof GoogleDriveConnectionMetadata>;
+export declare const GoogleDriveOAuthStartRequest: z.ZodObject<{
+    connectionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GoogleDriveOAuthStartRequest = z.infer<typeof GoogleDriveOAuthStartRequest>;
+export declare const GoogleDriveOAuthStartResponse: z.ZodObject<{
+    authorizationUrl: z.ZodString;
+    expiresAt: z.ZodString;
+}, z.core.$strip>;
+export type GoogleDriveOAuthStartResponse = z.infer<typeof GoogleDriveOAuthStartResponse>;
+export declare const GoogleDriveBrowseItem: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    mimeType: z.ZodString;
+    kind: z.ZodEnum<{
+        file: "file";
+        folder: "folder";
+    }>;
+    driveId: z.ZodNullable<z.ZodString>;
+    modifiedTime: z.ZodNullable<z.ZodString>;
+    size: z.ZodNullable<z.ZodString>;
+    webViewLink: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type GoogleDriveBrowseItem = z.infer<typeof GoogleDriveBrowseItem>;
+export declare const GoogleDriveBrowseResponse: z.ZodObject<{
+    connection: z.ZodLazy<z.ZodObject<{
+        id: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        subjectId: z.ZodNullable<z.ZodString>;
+        providerDomain: z.ZodString;
+        kind: z.ZodEnum<{
+            api_key: "api_key";
+            app_install: "app_install";
+            delegated: "delegated";
+            oauth2: "oauth2";
+        }>;
+        status: z.ZodEnum<{
+            active: "active";
+            error: "error";
+            needs_reauth: "needs_reauth";
+            revoked: "revoked";
+        }>;
+        grantedScopes: z.ZodArray<z.ZodString>;
+        expiresAt: z.ZodNullable<z.ZodString>;
+        lastRefreshAt: z.ZodNullable<z.ZodString>;
+        lastUsedAt: z.ZodNullable<z.ZodString>;
+        lastError: z.ZodNullable<z.ZodString>;
+        version: z.ZodNumber;
+        verifiedInstallAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        verifiedInstallVersion: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        createdBySubjectId: z.ZodNullable<z.ZodString>;
+        updatedBySubjectId: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    parentId: z.ZodString;
+    current: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        mimeType: z.ZodString;
+        kind: z.ZodEnum<{
+            file: "file";
+            folder: "folder";
+        }>;
+        driveId: z.ZodNullable<z.ZodString>;
+        modifiedTime: z.ZodNullable<z.ZodString>;
+        size: z.ZodNullable<z.ZodString>;
+        webViewLink: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        mimeType: z.ZodString;
+        kind: z.ZodEnum<{
+            file: "file";
+            folder: "folder";
+        }>;
+        driveId: z.ZodNullable<z.ZodString>;
+        modifiedTime: z.ZodNullable<z.ZodString>;
+        size: z.ZodNullable<z.ZodString>;
+        webViewLink: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    nextPageToken: z.ZodNullable<z.ZodString>;
+    incompleteSearch: z.ZodBoolean;
+}, z.core.$strip>;
+export type GoogleDriveBrowseResponse = z.infer<typeof GoogleDriveBrowseResponse>;
+export declare const SaveGoogleDriveSourceRequest: z.ZodObject<{
+    sources: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        mimeType: z.ZodString;
+        driveId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    targetScope: z.ZodEnum<{
+        organization: "organization";
+        user: "user";
+        workspace: "workspace";
+    }>;
+    syncCadence: z.ZodDefault<z.ZodEnum<{
+        daily: "daily";
+        hourly: "hourly";
+        manual: "manual";
+    }>>;
+    readPolicy: z.ZodDefault<z.ZodEnum<{
+        allow: "allow";
+        ask: "ask";
+        block: "block";
+    }>>;
+}, z.core.$strip>;
+export type SaveGoogleDriveSourceRequest = z.infer<typeof SaveGoogleDriveSourceRequest>;

package/dist/google-drive.js

@@ -0,0 +1,95 @@
+import {
+  ConnectionMetadata
+} from "./chunk-ESXP7QLV.js";
+import "./chunk-3B3XEYMN.js";
+
+// src/google-drive.ts
+import { z } from "zod";
+var GOOGLE_DRIVE_PROVIDER_DOMAIN = "googleapis.com";
+var GOOGLE_DRIVE_METADATA_READONLY_SCOPE = "https://www.googleapis.com/auth/drive.metadata.readonly";
+var GOOGLE_DRIVE_READONLY_SCOPE = "https://www.googleapis.com/auth/drive.readonly";
+var GOOGLE_DRIVE_CREDENTIAL_ROLE = "google_drive_metadata";
+var GOOGLE_DRIVE_CREDENTIAL_LABEL = "Google Drive metadata browser";
+var GoogleDriveTargetScope = z.enum(["user", "workspace", "organization"]);
+var GoogleDriveSyncCadence = z.enum(["manual", "hourly", "daily"]);
+var GoogleDriveReadPolicy = z.enum(["allow", "ask", "block"]);
+var GoogleDriveSelectedSource = z.object({
+  id: z.string().min(1).max(256),
+  name: z.string().min(1).max(1024),
+  mimeType: z.string().min(1).max(256),
+  driveId: z.string().min(1).max(256).nullable().default(null),
+  targetScope: GoogleDriveTargetScope,
+  syncCadence: GoogleDriveSyncCadence.default("hourly"),
+  readPolicy: GoogleDriveReadPolicy.default("allow"),
+  selectedAt: z.string().datetime({ offset: true })
+});
+var GoogleDriveConnectionMetadata = z.object({
+  credentialRole: z.literal(GOOGLE_DRIVE_CREDENTIAL_ROLE),
+  credentialLabel: z.literal(GOOGLE_DRIVE_CREDENTIAL_LABEL),
+  googlePermissionId: z.string().min(1).max(256),
+  googleEmail: z.string().email().max(320),
+  googleDisplayName: z.string().min(1).max(512).nullable(),
+  verifiedAt: z.string().datetime({ offset: true }),
+  accessMode: z.enum(["metadata_readonly", "readonly"]),
+  selectedSources: z.array(GoogleDriveSelectedSource).max(100).optional(),
+  /** @deprecated Read `selectedSources`; retained while existing connections migrate. */
+  selectedSource: GoogleDriveSelectedSource.nullable().optional()
+}).passthrough();
+var GoogleDriveOAuthStartRequest = z.object({
+  connectionId: z.string().uuid().optional()
+});
+var GoogleDriveOAuthStartResponse = z.object({
+  authorizationUrl: z.string().url(),
+  expiresAt: z.string().datetime({ offset: true })
+});
+var GoogleDriveBrowseItem = z.object({
+  id: z.string().min(1).max(256),
+  name: z.string().min(1).max(1024),
+  mimeType: z.string().min(1).max(256),
+  kind: z.enum(["folder", "file"]),
+  driveId: z.string().min(1).max(256).nullable(),
+  modifiedTime: z.string().datetime({ offset: true }).nullable(),
+  size: z.string().regex(/^\d+$/).nullable(),
+  webViewLink: z.string().url().nullable()
+});
+var GoogleDriveBrowseResponse = z.object({
+  connection: z.lazy(() => ConnectionMetadata),
+  parentId: z.string().min(1).max(256),
+  current: GoogleDriveBrowseItem.nullable(),
+  items: z.array(GoogleDriveBrowseItem),
+  nextPageToken: z.string().min(1).max(4096).nullable(),
+  incompleteSearch: z.boolean()
+});
+var SaveGoogleDriveSourceRequest = z.object({
+  sources: z.array(
+    GoogleDriveBrowseItem.pick({
+      id: true,
+      name: true,
+      mimeType: true,
+      driveId: true
+    })
+  ).max(100).refine((sources) => new Set(sources.map((source) => source.id)).size === sources.length, {
+    message: "Google Drive sources must be unique"
+  }),
+  targetScope: GoogleDriveTargetScope,
+  syncCadence: GoogleDriveSyncCadence.default("hourly"),
+  readPolicy: GoogleDriveReadPolicy.default("allow")
+});
+export {
+  GOOGLE_DRIVE_CREDENTIAL_LABEL,
+  GOOGLE_DRIVE_CREDENTIAL_ROLE,
+  GOOGLE_DRIVE_METADATA_READONLY_SCOPE,
+  GOOGLE_DRIVE_PROVIDER_DOMAIN,
+  GOOGLE_DRIVE_READONLY_SCOPE,
+  GoogleDriveBrowseItem,
+  GoogleDriveBrowseResponse,
+  GoogleDriveConnectionMetadata,
+  GoogleDriveOAuthStartRequest,
+  GoogleDriveOAuthStartResponse,
+  GoogleDriveReadPolicy,
+  GoogleDriveSelectedSource,
+  GoogleDriveSyncCadence,
+  GoogleDriveTargetScope,
+  SaveGoogleDriveSourceRequest
+};
+//# sourceMappingURL=google-drive.js.map

package/dist/google-drive.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/google-drive.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { ConnectionMetadata } from \"./index\";\n\nexport const GOOGLE_DRIVE_PROVIDER_DOMAIN = \"googleapis.com\" as const;\nexport const GOOGLE_DRIVE_METADATA_READONLY_SCOPE =\n  \"https://www.googleapis.com/auth/drive.metadata.readonly\" as const;\nexport const GOOGLE_DRIVE_READONLY_SCOPE =\n  \"https://www.googleapis.com/auth/drive.readonly\" as const;\nexport const GOOGLE_DRIVE_CREDENTIAL_ROLE = \"google_drive_metadata\" as const;\nexport const GOOGLE_DRIVE_CREDENTIAL_LABEL = \"Google Drive metadata browser\" as const;\n\nexport const GoogleDriveTargetScope = z.enum([\"user\", \"workspace\", \"organization\"]);\nexport type GoogleDriveTargetScope = z.infer<typeof GoogleDriveTargetScope>;\n\nexport const GoogleDriveSyncCadence = z.enum([\"manual\", \"hourly\", \"daily\"]);\nexport type GoogleDriveSyncCadence = z.infer<typeof GoogleDriveSyncCadence>;\n\nexport const GoogleDriveReadPolicy = z.enum([\"allow\", \"ask\", \"block\"]);\nexport type GoogleDriveReadPolicy = z.infer<typeof GoogleDriveReadPolicy>;\n\nexport const GoogleDriveSelectedSource = z.object({\n  id: z.string().min(1).max(256),\n  name: z.string().min(1).max(1024),\n  mimeType: z.string().min(1).max(256),\n  driveId: z.string().min(1).max(256).nullable().default(null),\n  targetScope: GoogleDriveTargetScope,\n  syncCadence: GoogleDriveSyncCadence.default(\"hourly\"),\n  readPolicy: GoogleDriveReadPolicy.default(\"allow\"),\n  selectedAt: z.string().datetime({ offset: true }),\n});\nexport type GoogleDriveSelectedSource = z.infer<typeof GoogleDriveSelectedSource>;\n\nexport const GoogleDriveConnectionMetadata = z\n  .object({\n    credentialRole: z.literal(GOOGLE_DRIVE_CREDENTIAL_ROLE),\n    credentialLabel: z.literal(GOOGLE_DRIVE_CREDENTIAL_LABEL),\n    googlePermissionId: z.string().min(1).max(256),\n    googleEmail: z.string().email().max(320),\n    googleDisplayName: z.string().min(1).max(512).nullable(),\n    verifiedAt: z.string().datetime({ offset: true }),\n    accessMode: z.enum([\"metadata_readonly\", \"readonly\"]),\n    selectedSources: z.array(GoogleDriveSelectedSource).max(100).optional(),\n    /** @deprecated Read `selectedSources`; retained while existing connections migrate. */\n    selectedSource: GoogleDriveSelectedSource.nullable().optional(),\n  })\n  .passthrough();\nexport type GoogleDriveConnectionMetadata = z.infer<typeof GoogleDriveConnectionMetadata>;\n\nexport const GoogleDriveOAuthStartRequest = z.object({\n  connectionId: z.string().uuid().optional(),\n});\nexport type GoogleDriveOAuthStartRequest = z.infer<typeof GoogleDriveOAuthStartRequest>;\n\nexport const GoogleDriveOAuthStartResponse = z.object({\n  authorizationUrl: z.string().url(),\n  expiresAt: z.string().datetime({ offset: true }),\n});\nexport type GoogleDriveOAuthStartResponse = z.infer<typeof GoogleDriveOAuthStartResponse>;\n\nexport const GoogleDriveBrowseItem = z.object({\n  id: z.string().min(1).max(256),\n  name: z.string().min(1).max(1024),\n  mimeType: z.string().min(1).max(256),\n  kind: z.enum([\"folder\", \"file\"]),\n  driveId: z.string().min(1).max(256).nullable(),\n  modifiedTime: z.string().datetime({ offset: true }).nullable(),\n  size: z.string().regex(/^\\d+$/).nullable(),\n  webViewLink: z.string().url().nullable(),\n});\nexport type GoogleDriveBrowseItem = z.infer<typeof GoogleDriveBrowseItem>;\n\nexport const GoogleDriveBrowseResponse = z.object({\n  connection: z.lazy(() => ConnectionMetadata),\n  parentId: z.string().min(1).max(256),\n  current: GoogleDriveBrowseItem.nullable(),\n  items: z.array(GoogleDriveBrowseItem),\n  nextPageToken: z.string().min(1).max(4096).nullable(),\n  incompleteSearch: z.boolean(),\n});\nexport type GoogleDriveBrowseResponse = z.infer<typeof GoogleDriveBrowseResponse>;\n\nexport const SaveGoogleDriveSourceRequest = z.object({\n  sources: z\n    .array(\n      GoogleDriveBrowseItem.pick({\n        id: true,\n        name: true,\n        mimeType: true,\n        driveId: true,\n      }),\n    )\n    .max(100)\n    .refine((sources) => new Set(sources.map((source) => source.id)).size === sources.length, {\n      message: \"Google Drive sources must be unique\",\n    }),\n  targetScope: GoogleDriveTargetScope,\n  syncCadence: GoogleDriveSyncCadence.default(\"hourly\"),\n  readPolicy: GoogleDriveReadPolicy.default(\"allow\"),\n});\nexport type SaveGoogleDriveSourceRequest = z.infer<typeof SaveGoogleDriveSourceRequest>;\n"],"mappings":";;;;;;AAAA,SAAS,SAAS;AAIX,IAAM,+BAA+B;AACrC,IAAM,uCACX;AACK,IAAM,8BACX;AACK,IAAM,+BAA+B;AACrC,IAAM,gCAAgC;AAEtC,IAAM,yBAAyB,EAAE,KAAK,CAAC,QAAQ,aAAa,cAAc,CAAC;AAG3E,IAAM,yBAAyB,EAAE,KAAK,CAAC,UAAU,UAAU,OAAO,CAAC;AAGnE,IAAM,wBAAwB,EAAE,KAAK,CAAC,SAAS,OAAO,OAAO,CAAC;AAG9D,IAAM,4BAA4B,EAAE,OAAO;AAAA,EAChD,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG;AAAA,EAC7B,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,IAAI,IAAI;AAAA,EAChC,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG;AAAA,EACnC,SAAS,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG,EAAE,SAAS,EAAE,QAAQ,IAAI;AAAA,EAC3D,aAAa;AAAA,EACb,aAAa,uBAAuB,QAAQ,QAAQ;AAAA,EACpD,YAAY,sBAAsB,QAAQ,OAAO;AAAA,EACjD,YAAY,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,KAAK,CAAC;AAClD,CAAC;AAGM,IAAM,gCAAgC,EAC1C,OAAO;AAAA,EACN,gBAAgB,EAAE,QAAQ,4BAA4B;AAAA,EACtD,iBAAiB,EAAE,QAAQ,6BAA6B;AAAA,EACxD,oBAAoB,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG;AAAA,EAC7C,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,GAAG;AAAA,EACvC,mBAAmB,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG,EAAE,SAAS;AAAA,EACvD,YAAY,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,KAAK,CAAC;AAAA,EAChD,YAAY,EAAE,KAAK,CAAC,qBAAqB,UAAU,CAAC;AAAA,EACpD,iBAAiB,EAAE,MAAM,yBAAyB,EAAE,IAAI,GAAG,EAAE,SAAS;AAAA;AAAA,EAEtE,gBAAgB,0BAA0B,SAAS,EAAE,SAAS;AAChE,CAAC,EACA,YAAY;AAGR,IAAM,+BAA+B,EAAE,OAAO;AAAA,EACnD,cAAc,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS;AAC3C,CAAC;AAGM,IAAM,gCAAgC,EAAE,OAAO;AAAA,EACpD,kBAAkB,EAAE,OAAO,EAAE,IAAI;AAAA,EACjC,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,KAAK,CAAC;AACjD,CAAC;AAGM,IAAM,wBAAwB,EAAE,OAAO;AAAA,EAC5C,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG;AAAA,EAC7B,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,IAAI,IAAI;AAAA,EAChC,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG;AAAA,EACnC,MAAM,EAAE,KAAK,CAAC,UAAU,MAAM,CAAC;AAAA,EAC/B,SAAS,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG,EAAE,SAAS;AAAA,EAC7C,cAAc,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,KAAK,CAAC,EAAE,SAAS;AAAA,EAC7D,MAAM,EAAE,OAAO,EAAE,MAAM,OAAO,EAAE,SAAS;AAAA,EACzC,aAAa,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS;AACzC,CAAC;AAGM,IAAM,4BAA4B,EAAE,OAAO;AAAA,EAChD,YAAY,EAAE,KAAK,MAAM,kBAAkB;AAAA,EAC3C,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG;AAAA,EACnC,SAAS,sBAAsB,SAAS;AAAA,EACxC,OAAO,EAAE,MAAM,qBAAqB;AAAA,EACpC,eAAe,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,IAAI,IAAI,EAAE,SAAS;AAAA,EACpD,kBAAkB,EAAE,QAAQ;AAC9B,CAAC;AAGM,IAAM,+BAA+B,EAAE,OAAO;AAAA,EACnD,SAAS,EACN;AAAA,IACC,sBAAsB,KAAK;AAAA,MACzB,IAAI;AAAA,MACJ,MAAM;AAAA,MACN,UAAU;AAAA,MACV,SAAS;AAAA,IACX,CAAC;AAAA,EACH,EACC,IAAI,GAAG,EACP,OAAO,CAAC,YAAY,IAAI,IAAI,QAAQ,IAAI,CAAC,WAAW,OAAO,EAAE,CAAC,EAAE,SAAS,QAAQ,QAAQ;AAAA,IACxF,SAAS;AAAA,EACX,CAAC;AAAA,EACH,aAAa;AAAA,EACb,aAAa,uBAAuB,QAAQ,QAAQ;AAAA,EACpD,YAAY,sBAAsB,QAAQ,OAAO;AACnD,CAAC;","names":[]}