@dotdo/do 0.1.0

package/dist/do/colo/followers.js

@@ -0,0 +1,224 @@
+/**
+ * Follower Management
+ *
+ * Manage follower DOs for leader-follower replication topology.
+ * Followers receive replicated data from the leader for read performance.
+ *
+ * @module colo/followers
+ */
+/**
+ * Add a follower DO for replication
+ *
+ * Adds a DO as a follower in leader-follower replication topology.
+ * The follower will receive replicated data from this DO (the leader).
+ *
+ * @param state - The DurableObjectState instance (leader)
+ * @param ref - Reference to the follower DO
+ * @throws ColoError if follower already exists or cannot be reached
+ *
+ * @example
+ * ```typescript
+ * // Add a follower in Europe
+ * await addFollower(state, 'https://my-app.workers.dev/do/europe-replica')
+ *
+ * // Add multiple followers
+ * await addFollower(state, 'https://my-app.workers.dev/do/asia-replica')
+ * await addFollower(state, 'https://my-app.workers.dev/do/latam-replica')
+ * ```
+ */
+export async function addFollower(state, ref) {
+    // TODO: Implement addFollower
+    //
+    // 1. Get current followers list from storage
+    // 2. Check if follower already exists
+    // 3. Validate follower is reachable (health check)
+    // 4. Add to followers list
+    // 5. Store updated list
+    // 6. Send initial sync to follower
+    // 7. Emit FOLLOWER_ADDED event
+    //
+    throw new Error('Not implemented');
+}
+/**
+ * Remove a follower DO
+ *
+ * Removes a DO from the followers list. The follower will stop receiving
+ * replicated data but will retain its current state.
+ *
+ * @param state - The DurableObjectState instance (leader)
+ * @param ref - Reference to the follower DO to remove
+ * @throws ColoError if follower not found
+ *
+ * @example
+ * ```typescript
+ * await removeFollower(state, 'https://my-app.workers.dev/do/europe-replica')
+ * ```
+ */
+export async function removeFollower(state, ref) {
+    // TODO: Implement removeFollower
+    //
+    // 1. Get current followers list from storage
+    // 2. Find follower in list
+    // 3. Throw FOLLOWER_NOT_FOUND if not found
+    // 4. Remove from list
+    // 5. Store updated list
+    // 6. Notify follower of removal (optional)
+    // 7. Emit FOLLOWER_REMOVED event
+    //
+    throw new Error('Not implemented');
+}
+/**
+ * List all followers
+ *
+ * Returns the list of all follower DO references.
+ *
+ * @param state - The DurableObjectState instance (leader)
+ * @returns Array of follower references
+ *
+ * @example
+ * ```typescript
+ * const followers = await listFollowers(state)
+ * // ['https://...', 'https://...']
+ *
+ * console.log(`${followers.length} followers configured`)
+ * ```
+ */
+export async function listFollowers(state) {
+    // TODO: Implement listFollowers
+    //
+    // 1. Get followers list from storage
+    // 2. Return empty array if not set
+    //
+    throw new Error('Not implemented');
+}
+/**
+ * Get replication status for all followers
+ *
+ * Returns detailed status information about the replication topology,
+ * including lag and health for each follower.
+ *
+ * @param state - The DurableObjectState instance
+ * @returns Full replication status
+ *
+ * @example
+ * ```typescript
+ * const status = await getReplicationStatus(state)
+ * // {
+ * //   mode: 'leader-follower',
+ * //   role: 'leader',
+ * //   followers: [
+ * //     { ref: '...', colo: 'fra', lag: 45, healthy: true },
+ * //     { ref: '...', colo: 'sin', lag: 120, healthy: true },
+ * //   ],
+ * //   lastSyncTimestamp: 1706000000000,
+ * //   lag: 0,
+ * //   healthy: true,
+ * // }
+ * ```
+ */
+export async function getReplicationStatus(state) {
+    // TODO: Implement getReplicationStatus
+    //
+    // 1. Get replication config from storage
+    // 2. Get followers list
+    // 3. Check health of each follower
+    // 4. Calculate overall health
+    // 5. Return status object
+    //
+    throw new Error('Not implemented');
+}
+/**
+ * Check health of a specific follower
+ *
+ * Performs a health check on a follower to verify reachability and measure lag.
+ *
+ * @param state - The DurableObjectState instance (leader)
+ * @param ref - Reference to the follower to check
+ * @returns Health check result
+ *
+ * @example
+ * ```typescript
+ * const health = await checkFollowerHealth(state, followerRef)
+ * if (!health.reachable) {
+ *   console.warn(`Follower unreachable: ${health.error}`)
+ * } else if (health.lag > 1000) {
+ *   console.warn(`Follower lag high: ${health.lag}ms`)
+ * }
+ * ```
+ */
+export async function checkFollowerHealth(state, ref) {
+    // TODO: Implement checkFollowerHealth
+    //
+    // 1. Send ping/heartbeat to follower
+    // 2. Measure round-trip time
+    // 3. Get follower's replication cursor
+    // 4. Calculate lag from leader timestamp
+    // 5. Return health check result
+    //
+    throw new Error('Not implemented');
+}
+/**
+ * Replicate a change to all followers
+ *
+ * Sends a change to all followers. Used internally when writes occur on the leader.
+ *
+ * @param state - The DurableObjectState instance (leader)
+ * @param change - The change to replicate
+ * @returns Results for each follower
+ */
+export async function replicateToFollowers(state, change) {
+    // TODO: Implement replicateToFollowers
+    //
+    // 1. Get followers list
+    // 2. Send change to each follower in parallel
+    // 3. Track success/failure for each
+    // 4. Update follower status based on results
+    // 5. Emit REPLICATION_LAG_HIGH if any followers are behind
+    // 6. Return results map
+    //
+    throw new Error('Not implemented');
+}
+/**
+ * Configure replication settings
+ *
+ * Sets the replication configuration for this DO.
+ *
+ * @param state - The DurableObjectState instance
+ * @param config - Replication configuration
+ *
+ * @example
+ * ```typescript
+ * await configureReplication(state, {
+ *   mode: 'leader-follower',
+ *   maxLag: 1000,
+ *   conflictResolution: { strategy: 'last-write-wins' },
+ *   collections: ['users', 'orders'],
+ * })
+ * ```
+ */
+export async function configureReplication(state, config) {
+    // TODO: Implement configureReplication
+    //
+    // 1. Get existing config
+    // 2. Merge with new config
+    // 3. Validate config (e.g., valid mode, collections exist)
+    // 4. Store updated config
+    // 5. Apply new settings (e.g., update lag monitoring)
+    //
+    throw new Error('Not implemented');
+}
+/**
+ * Get the current replication configuration
+ *
+ * @param state - The DurableObjectState instance
+ * @returns Current replication config
+ */
+export async function getReplicationConfig(state) {
+    // TODO: Implement getReplicationConfig
+    //
+    // 1. Get config from storage
+    // 2. Return default config if not set
+    //
+    throw new Error('Not implemented');
+}
+//# sourceMappingURL=followers.js.map

package/dist/do/colo/followers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"followers.js","sourceRoot":"","sources":["../../../do/colo/followers.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AA2BH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,KAAyB,EACzB,GAAqB;IAErB,8BAA8B;IAC9B,EAAE;IACF,6CAA6C;IAC7C,sCAAsC;IACtC,mDAAmD;IACnD,2BAA2B;IAC3B,wBAAwB;IACxB,mCAAmC;IACnC,+BAA+B;IAC/B,EAAE;IACF,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAA;AACpC,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,KAAyB,EACzB,GAAqB;IAErB,iCAAiC;IACjC,EAAE;IACF,6CAA6C;IAC7C,2BAA2B;IAC3B,2CAA2C;IAC3C,sBAAsB;IACtB,wBAAwB;IACxB,2CAA2C;IAC3C,iCAAiC;IACjC,EAAE;IACF,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAA;AACpC,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,KAAyB;IAEzB,gCAAgC;IAChC,EAAE;IACF,qCAAqC;IACrC,mCAAmC;IACnC,EAAE;IACF,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAA;AACpC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,KAAyB;IAEzB,uCAAuC;IACvC,EAAE;IACF,yCAAyC;IACzC,wBAAwB;IACxB,mCAAmC;IACnC,8BAA8B;IAC9B,0BAA0B;IAC1B,EAAE;IACF,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAA;AACpC,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,KAAyB,EACzB,GAAqB;IAErB,sCAAsC;IACtC,EAAE;IACF,qCAAqC;IACrC,6BAA6B;IAC7B,uCAAuC;IACvC,yCAAyC;IACzC,gCAAgC;IAChC,EAAE;IACF,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAA;AACpC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,KAAyB,EACzB,MAAyB;IAEzB,uCAAuC;IACvC,EAAE;IACF,wBAAwB;IACxB,8CAA8C;IAC9C,oCAAoC;IACpC,6CAA6C;IAC7C,2DAA2D;IAC3D,wBAAwB;IACxB,EAAE;IACF,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAA;AACpC,CAAC;AAgCD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,KAAyB,EACzB,MAAkC;IAElC,uCAAuC;IACvC,EAAE;IACF,yBAAyB;IACzB,2BAA2B;IAC3B,2DAA2D;IAC3D,0BAA0B;IAC1B,sDAAsD;IACtD,EAAE;IACF,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAA;AACpC,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,KAAyB;IAEzB,uCAAuC;IACvC,EAAE;IACF,6BAA6B;IAC7B,sCAAsC;IACtC,EAAE;IACF,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAA;AACpC,CAAC"}

package/dist/do/colo/fork.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Fork Operations
+ *
+ * Create replicas of Digital Objects in other colos for low-latency reads
+ * and geographic distribution.
+ *
+ * @module colo/fork
+ */
+import type { ForkOptions } from '../../types/colo';
+import type { DigitalObjectRef } from '../../types/identity';
+/**
+ * Fork options with defaults applied
+ */
+export interface ResolvedForkOptions {
+    /** Name for the forked DO (generated if not provided) */
+    name: string;
+    /** Whether to sync data immediately (default: true) */
+    syncData: boolean;
+    /** Whether to set up continuous replication (default: false) */
+    continuous: boolean;
+    /** Replication lag tolerance in ms (default: 1000) */
+    maxLag: number;
+}
+/**
+ * Result of a fork operation
+ */
+export interface ForkResult {
+    /** Reference to the forked DO */
+    ref: DigitalObjectRef;
+    /** Target colo where fork was created */
+    colo: string;
+    /** Whether initial data sync completed */
+    synced: boolean;
+    /** Whether continuous replication is active */
+    replicating: boolean;
+}
+/**
+ * Fork this DO to another colo
+ *
+ * Creates a replica of the current DO in the target colo. The fork can be
+ * a one-time snapshot or set up for continuous replication.
+ *
+ * For leader-follower replication:
+ * - The current DO becomes (or remains) the leader
+ * - The forked DO becomes a follower
+ * - Writes go to the leader, reads can go to any replica
+ *
+ * @param state - The DurableObjectState instance
+ * @param env - Environment bindings for creating new DOs
+ * @param targetColo - IATA code of target colo (e.g., 'fra', 'nrt')
+ * @param options - Fork configuration options
+ * @returns Reference to the newly created fork
+ * @throws ColoError if target colo is invalid or fork fails
+ *
+ * @example
+ * ```typescript
+ * // Simple fork with data sync
+ * const replica = await forkDO(state, env, 'fra')
+ *
+ * // Fork with continuous replication
+ * const liveReplica = await forkDO(state, env, 'sin', {
+ *   continuous: true,
+ *   maxLag: 500,
+ * })
+ *
+ * // Fork with custom name
+ * const namedReplica = await forkDO(state, env, 'nrt', {
+ *   name: 'tokyo-replica',
+ *   syncData: true,
+ * })
+ * ```
+ */
+export declare function forkDO(state: DurableObjectState, env: unknown, targetColo: string, options?: ForkOptions): Promise<DigitalObjectRef>;
+/**
+ * Apply default values to fork options
+ *
+ * @param options - Partial options from caller
+ * @returns Fully resolved options with defaults
+ */
+export declare function resolveForkOptions(options?: ForkOptions): ResolvedForkOptions;
+/**
+ * Sync current state to a fork
+ *
+ * Transfers all storage entries from the current DO to the fork.
+ * Used for initial data sync during fork creation.
+ *
+ * @param state - Current DO state
+ * @param forkRef - Reference to the fork DO
+ * @returns Number of entries synced
+ */
+export declare function syncStateToFork(state: DurableObjectState, forkRef: DigitalObjectRef): Promise<number>;
+/**
+ * Set up continuous replication to a fork
+ *
+ * Configures the fork as a follower and enables ongoing replication
+ * of changes from this DO.
+ *
+ * @param state - Current DO state
+ * @param forkRef - Reference to the fork DO
+ * @param maxLag - Maximum allowed replication lag in ms
+ */
+export declare function setupContinuousReplication(state: DurableObjectState, forkRef: DigitalObjectRef, maxLag: number): Promise<void>;
+//# sourceMappingURL=fork.d.ts.map

package/dist/do/colo/fork.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fork.d.ts","sourceRoot":"","sources":["../../../do/colo/fork.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAqB,MAAM,kBAAkB,CAAA;AACtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAI5D;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAA;IACZ,uDAAuD;IACvD,QAAQ,EAAE,OAAO,CAAA;IACjB,gEAAgE;IAChE,UAAU,EAAE,OAAO,CAAA;IACnB,sDAAsD;IACtD,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,iCAAiC;IACjC,GAAG,EAAE,gBAAgB,CAAA;IACrB,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAA;IACZ,0CAA0C;IAC1C,MAAM,EAAE,OAAO,CAAA;IACf,+CAA+C;IAC/C,WAAW,EAAE,OAAO,CAAA;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAsB,MAAM,CAC1B,KAAK,EAAE,kBAAkB,EACzB,GAAG,EAAE,OAAO,EACZ,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,gBAAgB,CAAC,CAgC3B;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,mBAAmB,CAO7E;AAaD;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,kBAAkB,EACzB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,MAAM,CAAC,CASjB;AAED;;;;;;;;;GASG;AACH,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,kBAAkB,EACzB,OAAO,EAAE,gBAAgB,EACzB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAUf"}

package/dist/do/colo/fork.js

@@ -0,0 +1,143 @@
+/**
+ * Fork Operations
+ *
+ * Create replicas of Digital Objects in other colos for low-latency reads
+ * and geographic distribution.
+ *
+ * @module colo/fork
+ */
+/**
+ * Fork this DO to another colo
+ *
+ * Creates a replica of the current DO in the target colo. The fork can be
+ * a one-time snapshot or set up for continuous replication.
+ *
+ * For leader-follower replication:
+ * - The current DO becomes (or remains) the leader
+ * - The forked DO becomes a follower
+ * - Writes go to the leader, reads can go to any replica
+ *
+ * @param state - The DurableObjectState instance
+ * @param env - Environment bindings for creating new DOs
+ * @param targetColo - IATA code of target colo (e.g., 'fra', 'nrt')
+ * @param options - Fork configuration options
+ * @returns Reference to the newly created fork
+ * @throws ColoError if target colo is invalid or fork fails
+ *
+ * @example
+ * ```typescript
+ * // Simple fork with data sync
+ * const replica = await forkDO(state, env, 'fra')
+ *
+ * // Fork with continuous replication
+ * const liveReplica = await forkDO(state, env, 'sin', {
+ *   continuous: true,
+ *   maxLag: 500,
+ * })
+ *
+ * // Fork with custom name
+ * const namedReplica = await forkDO(state, env, 'nrt', {
+ *   name: 'tokyo-replica',
+ *   syncData: true,
+ * })
+ * ```
+ */
+export async function forkDO(state, env, targetColo, options) {
+    // TODO: Implement forkDO
+    //
+    // 1. Validate target colo
+    //    - Use isValidColo() to check
+    //    - Throw INVALID_COLO error if invalid
+    //
+    // 2. Resolve options with defaults
+    //    - name: generate unique name if not provided
+    //    - syncData: default true
+    //    - continuous: default false
+    //    - maxLag: default 1000ms
+    //
+    // 3. Emit FORK_STARTED event
+    //
+    // 4. Create new DO in target colo
+    //    - Use env.DO_BINDING.newUniqueId({ locationHint: targetColo })
+    //    - Get stub and initialize
+    //
+    // 5. If syncData, transfer current state to fork
+    //    - Get all storage entries
+    //    - Send to fork via RPC
+    //
+    // 6. If continuous, set up replication
+    //    - Add fork to followers list
+    //    - Configure replication settings
+    //
+    // 7. Emit FORK_COMPLETED event
+    //
+    // 8. Return fork reference
+    //
+    throw new Error('Not implemented');
+}
+/**
+ * Apply default values to fork options
+ *
+ * @param options - Partial options from caller
+ * @returns Fully resolved options with defaults
+ */
+export function resolveForkOptions(options) {
+    return {
+        name: options?.name ?? generateForkName(),
+        syncData: options?.syncData ?? true,
+        continuous: options?.continuous ?? false,
+        maxLag: options?.maxLag ?? 1000,
+    };
+}
+/**
+ * Generate a unique name for a fork
+ *
+ * @returns Generated fork name
+ */
+function generateForkName() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 8);
+    return `fork-${timestamp}-${random}`;
+}
+/**
+ * Sync current state to a fork
+ *
+ * Transfers all storage entries from the current DO to the fork.
+ * Used for initial data sync during fork creation.
+ *
+ * @param state - Current DO state
+ * @param forkRef - Reference to the fork DO
+ * @returns Number of entries synced
+ */
+export async function syncStateToFork(state, forkRef) {
+    // TODO: Implement syncStateToFork
+    //
+    // 1. List all storage entries
+    // 2. Batch entries for efficient transfer
+    // 3. Send batches to fork via RPC
+    // 4. Return count of synced entries
+    //
+    throw new Error('Not implemented');
+}
+/**
+ * Set up continuous replication to a fork
+ *
+ * Configures the fork as a follower and enables ongoing replication
+ * of changes from this DO.
+ *
+ * @param state - Current DO state
+ * @param forkRef - Reference to the fork DO
+ * @param maxLag - Maximum allowed replication lag in ms
+ */
+export async function setupContinuousReplication(state, forkRef, maxLag) {
+    // TODO: Implement setupContinuousReplication
+    //
+    // 1. Get current replication config from storage
+    // 2. Add fork to followers list
+    // 3. Update config with maxLag
+    // 4. Store updated config
+    // 5. Send initial heartbeat to fork
+    //
+    throw new Error('Not implemented');
+}
+//# sourceMappingURL=fork.js.map

package/dist/do/colo/fork.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fork.js","sourceRoot":"","sources":["../../../do/colo/fork.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAmCH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,KAAK,UAAU,MAAM,CAC1B,KAAyB,EACzB,GAAY,EACZ,UAAkB,EAClB,OAAqB;IAErB,yBAAyB;IACzB,EAAE;IACF,0BAA0B;IAC1B,kCAAkC;IAClC,2CAA2C;IAC3C,EAAE;IACF,mCAAmC;IACnC,kDAAkD;IAClD,8BAA8B;IAC9B,iCAAiC;IACjC,8BAA8B;IAC9B,EAAE;IACF,6BAA6B;IAC7B,EAAE;IACF,kCAAkC;IAClC,oEAAoE;IACpE,+BAA+B;IAC/B,EAAE;IACF,iDAAiD;IACjD,+BAA+B;IAC/B,4BAA4B;IAC5B,EAAE;IACF,uCAAuC;IACvC,kCAAkC;IAClC,sCAAsC;IACtC,EAAE;IACF,+BAA+B;IAC/B,EAAE;IACF,2BAA2B;IAC3B,EAAE;IACF,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAA;AACpC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAAC,OAAqB;IACtD,OAAO;QACL,IAAI,EAAE,OAAO,EAAE,IAAI,IAAI,gBAAgB,EAAE;QACzC,QAAQ,EAAE,OAAO,EAAE,QAAQ,IAAI,IAAI;QACnC,UAAU,EAAE,OAAO,EAAE,UAAU,IAAI,KAAK;QACxC,MAAM,EAAE,OAAO,EAAE,MAAM,IAAI,IAAI;KAChC,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,gBAAgB;IACvB,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAA;IACzC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;IACzD,OAAO,QAAQ,SAAS,IAAI,MAAM,EAAE,CAAA;AACtC,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,KAAyB,EACzB,OAAyB;IAEzB,kCAAkC;IAClC,EAAE;IACF,8BAA8B;IAC9B,0CAA0C;IAC1C,kCAAkC;IAClC,oCAAoC;IACpC,EAAE;IACF,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAA;AACpC,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,0BAA0B,CAC9C,KAAyB,EACzB,OAAyB,EACzB,MAAc;IAEd,6CAA6C;IAC7C,EAAE;IACF,iDAAiD;IACjD,gCAAgC;IAChC,+BAA+B;IAC/B,0BAA0B;IAC1B,oCAAoC;IACpC,EAAE;IACF,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAA;AACpC,CAAC"}

package/dist/do/colo/index.d.ts

@@ -0,0 +1,181 @@
+/**
+ * Colo Awareness Layer
+ *
+ * Geographic intelligence for Digital Objects. Know where your DOs live,
+ * move them where you need them.
+ *
+ * @module colo
+ *
+ * @example
+ * ```typescript
+ * import { createColoOperations } from '@do/core/colo'
+ *
+ * // Create colo operations for a DO instance
+ * const colo = createColoOperations(doInstance)
+ *
+ * // Get current colo info
+ * const info = await colo.getInfo()
+ * // { colo: 'iad', region: 'enam', city: 'Ashburn', ... }
+ *
+ * // Fork to another region
+ * const replica = await colo.fork('fra', { continuous: true })
+ *
+ * // Migrate when usage patterns change
+ * await colo.migrate('nrt', { strategy: 'graceful' })
+ * ```
+ */
+import type { ColoOperations } from '../../types/colo';
+export { getColoInfo, getColoInfoByColo, listColos } from './info';
+export { forkDO } from './fork';
+export { migrateDO } from './migrate';
+export { addFollower, removeFollower, listFollowers } from './followers';
+export { findNearestColo, pingColo } from './routing';
+export type { ColoInfo, ColoOperations, ForkOptions, MigrateOptions, Region, ReplicationConfig, ReplicationStatus, ReplicationMode, ReplicationPeerStatus, LocationHint, JurisdictionConfig, RegionInfo, ConflictResolution, } from '../../types/colo';
+/**
+ * Storage key prefixes for colo-related data
+ */
+export declare const COLO_STORAGE_KEYS: {
+    /** Current colo information */
+    readonly COLO_INFO: "colo:info";
+    /** List of follower DO references */
+    readonly FOLLOWERS: "colo:followers";
+    /** Replication configuration */
+    readonly REPLICATION_CONFIG: "colo:replication:config";
+    /** Current replication status */
+    readonly REPLICATION_STATUS: "colo:replication:status";
+};
+/**
+ * Colo-related event names following NS.Object.event pattern
+ */
+export declare const COLO_EVENTS: {
+    /** Emitted when fork operation starts */
+    readonly FORK_STARTED: "Colo.Fork.started";
+    /** Emitted when fork operation completes successfully */
+    readonly FORK_COMPLETED: "Colo.Fork.completed";
+    /** Emitted when fork operation fails */
+    readonly FORK_FAILED: "Colo.Fork.failed";
+    /** Emitted when migration starts */
+    readonly MIGRATION_STARTED: "Colo.Migration.started";
+    /** Emitted when migration completes successfully */
+    readonly MIGRATION_COMPLETED: "Colo.Migration.completed";
+    /** Emitted when migration fails */
+    readonly MIGRATION_FAILED: "Colo.Migration.failed";
+    /** Emitted when a follower is added */
+    readonly FOLLOWER_ADDED: "Colo.Follower.added";
+    /** Emitted when a follower is removed */
+    readonly FOLLOWER_REMOVED: "Colo.Follower.removed";
+    /** Emitted when replication lag exceeds threshold */
+    readonly REPLICATION_LAG_HIGH: "Colo.Replication.lagHigh";
+};
+/**
+ * Error codes for colo operations
+ */
+export declare const COLO_ERRORS: {
+    /** Invalid colo code provided */
+    readonly INVALID_COLO: "INVALID_COLO";
+    /** Migration operation failed */
+    readonly MIGRATION_FAILED: "MIGRATION_FAILED";
+    /** Fork operation failed */
+    readonly FORK_FAILED: "FORK_FAILED";
+    /** Follower not found in list */
+    readonly FOLLOWER_NOT_FOUND: "FOLLOWER_NOT_FOUND";
+    /** Operation violates jurisdiction constraints */
+    readonly JURISDICTION_VIOLATION: "JURISDICTION_VIOLATION";
+    /** Replication error */
+    readonly REPLICATION_FAILED: "REPLICATION_FAILED";
+};
+/**
+ * Error class for colo operations
+ */
+export declare class ColoError extends Error {
+    readonly code: keyof typeof COLO_ERRORS;
+    /**
+     * Create a new ColoError
+     *
+     * @param message - Error message
+     * @param code - Error code from COLO_ERRORS
+     */
+    constructor(message: string, code: keyof typeof COLO_ERRORS);
+}
+/**
+ * Create colo operations interface for a Digital Object instance
+ *
+ * Factory function that wraps a DO instance with all colo-related operations.
+ * Returns an object implementing the ColoOperations interface.
+ *
+ * @param state - The DurableObjectState instance
+ * @param env - The environment bindings (for accessing other DOs)
+ * @returns ColoOperations interface with all colo methods
+ *
+ * @example
+ * ```typescript
+ * import { createColoOperations } from '@do/core/colo'
+ *
+ * class MyDO {
+ *   private colo: ColoOperations
+ *
+ *   constructor(state: DurableObjectState, env: Env) {
+ *     this.colo = createColoOperations(state, env)
+ *   }
+ *
+ *   async fetch(request: Request) {
+ *     const info = await this.colo.getInfo()
+ *     return Response.json(info)
+ *   }
+ * }
+ * ```
+ */
+export declare function createColoOperations(state: DurableObjectState, env: unknown): ColoOperations;
+/**
+ * Default export for convenience
+ */
+declare const _default: {
+    createColoOperations: typeof createColoOperations;
+    COLO_STORAGE_KEYS: {
+        /** Current colo information */
+        readonly COLO_INFO: "colo:info";
+        /** List of follower DO references */
+        readonly FOLLOWERS: "colo:followers";
+        /** Replication configuration */
+        readonly REPLICATION_CONFIG: "colo:replication:config";
+        /** Current replication status */
+        readonly REPLICATION_STATUS: "colo:replication:status";
+    };
+    COLO_EVENTS: {
+        /** Emitted when fork operation starts */
+        readonly FORK_STARTED: "Colo.Fork.started";
+        /** Emitted when fork operation completes successfully */
+        readonly FORK_COMPLETED: "Colo.Fork.completed";
+        /** Emitted when fork operation fails */
+        readonly FORK_FAILED: "Colo.Fork.failed";
+        /** Emitted when migration starts */
+        readonly MIGRATION_STARTED: "Colo.Migration.started";
+        /** Emitted when migration completes successfully */
+        readonly MIGRATION_COMPLETED: "Colo.Migration.completed";
+        /** Emitted when migration fails */
+        readonly MIGRATION_FAILED: "Colo.Migration.failed";
+        /** Emitted when a follower is added */
+        readonly FOLLOWER_ADDED: "Colo.Follower.added";
+        /** Emitted when a follower is removed */
+        readonly FOLLOWER_REMOVED: "Colo.Follower.removed";
+        /** Emitted when replication lag exceeds threshold */
+        readonly REPLICATION_LAG_HIGH: "Colo.Replication.lagHigh";
+    };
+    COLO_ERRORS: {
+        /** Invalid colo code provided */
+        readonly INVALID_COLO: "INVALID_COLO";
+        /** Migration operation failed */
+        readonly MIGRATION_FAILED: "MIGRATION_FAILED";
+        /** Fork operation failed */
+        readonly FORK_FAILED: "FORK_FAILED";
+        /** Follower not found in list */
+        readonly FOLLOWER_NOT_FOUND: "FOLLOWER_NOT_FOUND";
+        /** Operation violates jurisdiction constraints */
+        readonly JURISDICTION_VIOLATION: "JURISDICTION_VIOLATION";
+        /** Replication error */
+        readonly REPLICATION_FAILED: "REPLICATION_FAILED";
+    };
+    ColoError: typeof ColoError;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/do/colo/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../do/colo/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAEV,cAAc,EAIf,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAClE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AACrC,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AACxE,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAGrD,YAAY,EACV,QAAQ,EACR,cAAc,EACd,WAAW,EACX,cAAc,EACd,MAAM,EACN,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,qBAAqB,EACrB,YAAY,EACZ,kBAAkB,EAClB,UAAU,EACV,kBAAkB,GACnB,MAAM,kBAAkB,CAAA;AAEzB;;GAEG;AACH,eAAO,MAAM,iBAAiB;IAC5B,+BAA+B;;IAE/B,qCAAqC;;IAErC,gCAAgC;;IAEhC,iCAAiC;;CAEzB,CAAA;AAEV;;GAEG;AACH,eAAO,MAAM,WAAW;IACtB,yCAAyC;;IAEzC,yDAAyD;;IAEzD,wCAAwC;;IAExC,oCAAoC;;IAEpC,oDAAoD;;IAEpD,mCAAmC;;IAEnC,uCAAuC;;IAEvC,yCAAyC;;IAEzC,qDAAqD;;CAE7C,CAAA;AAEV;;GAEG;AACH,eAAO,MAAM,WAAW;IACtB,iCAAiC;;IAEjC,iCAAiC;;IAEjC,4BAA4B;;IAE5B,iCAAiC;;IAEjC,kDAAkD;;IAElD,wBAAwB;;CAEhB,CAAA;AAEV;;GAEG;AACH,qBAAa,SAAU,SAAQ,KAAK;aAShB,IAAI,EAAE,MAAM,OAAO,WAAW;IARhD;;;;;OAKG;gBAED,OAAO,EAAE,MAAM,EACC,IAAI,EAAE,MAAM,OAAO,WAAW;CAKjD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,kBAAkB,EACzB,GAAG,EAAE,OAAO,GACX,cAAc,CAGhB;AAED;;GAEG;;;;QA7GD,+BAA+B;;QAE/B,qCAAqC;;QAErC,gCAAgC;;QAEhC,iCAAiC;;;;QAQjC,yCAAyC;;QAEzC,yDAAyD;;QAEzD,wCAAwC;;QAExC,oCAAoC;;QAEpC,oDAAoD;;QAEpD,mCAAmC;;QAEnC,uCAAuC;;QAEvC,yCAAyC;;QAEzC,qDAAqD;;;;QAQrD,iCAAiC;;QAEjC,iCAAiC;;QAEjC,4BAA4B;;QAE5B,iCAAiC;;QAEjC,kDAAkD;;QAElD,wBAAwB;;;;;AA8D1B,wBAMC"}