@classytic/stage 0.2.0 → 0.4.0

package/dist/networking/delivery.mjs

@@ -0,0 +1,52 @@
+//#region src/networking/delivery.ts
+function compareDelivery(mode, viewers, bitrateMbps) {
+	const audience = Math.max(1, Math.round(viewers));
+	const rate = Math.max(.1, bitrateMbps);
+	const unicast = mode === "unicast";
+	return {
+		mode,
+		viewers: audience,
+		bitrateMbps: rate,
+		sourceStreams: unicast ? audience : 1,
+		segmentCopies: unicast ? audience : 1,
+		segmentMbps: rate * (unicast ? audience : 1),
+		returnPath: mode !== "terrestrial",
+		personalized: unicast
+	};
+}
+function deliverGroupMessage(recipients, devicesEach, offlineDevices) {
+	const copies = Math.max(0, recipients) * Math.max(1, devicesEach);
+	const queued = Math.min(copies, Math.max(0, offlineDevices));
+	return {
+		copies,
+		queued,
+		delivered: copies - queued
+	};
+}
+const roundTenth = (value) => Math.round(value * 10) / 10;
+function simulateLiveStream(segmentSeconds, bufferSeconds, outageSeconds) {
+	const segment = Math.max(.5, segmentSeconds);
+	const buffer = Math.max(0, bufferSeconds);
+	const outage = Math.max(0, outageSeconds);
+	const stallSeconds = Math.max(0, outage - buffer);
+	return {
+		segmentSeconds: segment,
+		bufferSeconds: buffer,
+		outageSeconds: outage,
+		startupSeconds: roundTenth(segment + buffer + .4),
+		liveLatencySeconds: roundTenth(segment + buffer + .8),
+		stallSeconds: roundTenth(stallSeconds),
+		bufferedThroughDrop: stallSeconds === 0
+	};
+}
+const STREAM_STAGES = [
+	"camera",
+	"encoder",
+	"origin",
+	"cdn",
+	"buffer",
+	"viewer"
+];
+
+//#endregion
+export { STREAM_STAGES, compareDelivery, deliverGroupMessage, simulateLiveStream };

package/dist/networking/index.d.mts

@@ -0,0 +1,47 @@
+import { AccessDesign, AccessIncident, AccessSnapshot, CloudResource, Permission, ResourceAccess, ResourceAction, WorkloadKind, evaluateWorkloadAccess } from "./cloud/access.mjs";
+import { Artifact, ContainerDeploymentResult, HostDrift, ReplicaVersion, StatePlacement, VERSION_TEXT, evaluateContainerDeployment } from "./cloud/containers.mjs";
+import { CachePolicy, EdgeResult, OriginState, simulateEdgeCache } from "./cloud/edge.mjs";
+import { DataPlacement, FailureDomainResult, FailureScope, Placement, simulateFailureDomains } from "./cloud/failure-domains.mjs";
+import { CustomerContext, GeoMarketResult, GeoRoutingPolicy, ShopperLocation, resolveGeoMarket } from "./cloud/geo-routing.mjs";
+import { BatchSize, ContextSize, DistributedInferenceResult, DistributedStrategy, GpuCount, GpuInterconnect, GpuMemory, InferenceCapacityResult, InferenceRequestResult, InferenceScheduler, InferenceWorkloadMix, ModelRoutingPolicy, ModelRoutingResult, ModelSize, OutputTokens, Precision, PrefixCacheResult, PrefixCacheScope, PrefixCacheState, PrefixRequester, PrefixTokens, PromptTokens, ResponseQualityTarget, UniquePromptTokens, planInference, simulateDistributedInference, simulateInferenceRequest, simulateModelRouting, simulatePrefixCache } from "./cloud/inference.mjs";
+import { InferenceCondition, InferenceDegradationPolicy, InferenceReliabilityResult, InferenceRisk, InferenceSli, simulateInferenceReliability } from "./cloud/inference-reliability.mjs";
+import { DriftResolution, ExternalChange, InfrastructureCommand, InfrastructureIntent, InfrastructurePhase, InfrastructurePlan, InfrastructureShape, InfrastructureSnapshot, createInfrastructureEngine, infrastructureSnapshot, transitionInfrastructure } from "./cloud/infrastructure.mjs";
+import { DependencyState, SloIncidentResult, SloTarget, Telemetry, observeService } from "./cloud/observability.mjs";
+import { ClusterCapacity, ClusterFailure, OrchestrationResult, ReleaseState, reconcileWorkload } from "./cloud/orchestration.mjs";
+import { Incident, RecoveryResult, RecoveryStrategy, WriteLoad, evaluateRecovery } from "./cloud/recovery.mjs";
+import { CandidateHealth, DataCompatibility, ReleaseCommand, ReleasePlan, ReleaseSnapshot, ReleaseStatus, ReleaseStrategy, createReleaseEngine, releaseSnapshot, transitionRelease } from "./cloud/releases.mjs";
+import { BackendHealth, BackendResult, LoadRoutingPolicy, ServiceScalingResult, simulateServiceScaling } from "./cloud/scaling.mjs";
+import { ConsumerRefresh, RotationPhase, RotationTrigger, SecretRotationCommand, SecretRotationPlan, SecretRotationSnapshot, SecretStrategy, createSecretRotationEngine, secretRotationSnapshot, transitionSecretRotation } from "./cloud/secrets.mjs";
+import { DEPLOYMENT_STAGES, DeploymentFault, DeploymentScope, DeploymentStage, ServerDeploymentResult, ServerFrontEnd, deploymentStageState, simulateServerDeployment } from "./cloud/server-deployment.mjs";
+import { CloudStorage, CloudWorkload, StorageResult, evaluateCloudStorage } from "./cloud/storage.mjs";
+import { VpcDesign, VpcRouteResult, VpcScenario, VpcZone, planVpcRoute } from "./cloud/vpc.mjs";
+import { QueueResult, bottleneckQueue, queueAtTime } from "./queue.mjs";
+import { CertificateKind, DNS_HOPS, DnsCache, DnsHop, TLS_STEPS, certificateAccepted, dnsHops, dnsLookupMs, dnsPath, visibleOnWire } from "./protocols.mjs";
+import { EncodingResult, MediaKind, MediaQuality, ModulationResult, ModulationScheme, encodeMedia, modulate } from "./signals.mjs";
+import { ContentionResult, simulateContention } from "./wireless.mjs";
+import { BroadcastDeliveryResult, DeliveryMode, DeviceState, GroupDeliveryResult, LiveStreamResult, STREAM_STAGES, StreamStage, compareDelivery, deliverGroupMessage, simulateLiveStream } from "./delivery.mjs";
+import { AdaptationPolicy, BROADBAND_STAGES, BroadbandAccess, BroadbandFault, BroadbandJourneyResult, BroadbandStage, CALL_STAGES, CAPACITY_PATTERNS, CallCondition, CallJourneyResult, CallService, CallStage, CapacityPattern, ConversationKind, MESSAGE_STAGES, MessageJourneyResult, MessageNetwork, MessageStage, VIDEO_RATES, VideoCallTrace, VideoMoment, VideoTier, broadbandStageReached, callStageIndex, messageStageIndex, simulateBroadband, simulateCall, simulateMessage, simulateVideoCall } from "./journeys.mjs";
+import { Bit, SubnetInfo, bitsOf, describe, firstDifferingBit, intToIpv4, ipv4ToInt, maskFor, sameNetwork, widestSharedPrefix } from "./subnet.mjs";
+import { NetworkDevice, NetworkDeviceKind, NetworkDoc, NetworkEndpoint, NetworkEvent, NetworkInterface, NetworkLink, NetworkPacket, NetworkRoute, NetworkTrace, PacketLayer, PacketLayerKind } from "./topology/contract.mjs";
+import { cidrContains, longestPrefixMatch, parseCidr } from "./routing.mjs";
+import { DhcpClientState, DhcpLeaseOptions, DhcpLeaseResult, simulateDhcpLease } from "./addressing.mjs";
+import { Ipv6AddressMode, Ipv6HostOptions, Ipv6HostResult, configureIpv6Host } from "./ipv6.mjs";
+import { NatBehavior, NatTraversalOptions, NatTraversalResult, TraversalStrategy, simulateNatTraversal } from "./nat-traversal.mjs";
+import { TcpFeedback, TcpSenderOptions, TcpSenderResult, advanceTcpSender } from "./tcp-reliability.mjs";
+import { BgpCandidate, LearnedRoute, OspfLink, learnOspfRoute, selectBgpRoute } from "./route-learning.mjs";
+import { AirtimeResult, Client, ClientShare, HOUSEHOLD, PAYLOAD_BITS, TURN_OVERHEAD_US, rateFromRssi, shareAirtime, signalWord } from "./models/airtime.mjs";
+import { Blocker, EIRP_DBM, GENERATIONS, Generation, GenerationId, HANDSET_SENSITIVITY_DBM, MAX_PATH_LOSS_DB, TASKS, TERRAIN, Task, Terrain, TerrainSpec, blockedBy, canServe, cellAreaKm2, cellRadiusKm, firstGenerationFor, generationById, pathLossDb, rssiFromMast, towersFor } from "./models/cellular.mjs";
+import { DEFAULT_PATH, Encapsulation, EncapsulationSegment, HEADERS, Header, LayerKind, NodeKind, OVERHEAD_BYTES, PathNode, WireFrame, decapsulate, encapsulate, frameOn, journey, opensTo, segmentsOf } from "./models/encapsulation.mjs";
+import { DEFAULT_DRIVE, DRIVE_WINDOW, DROP_AFTER_KM, DriveOptions, DriveResult, DriveSample, HandoverEvent, MarginVerdict, Mast, TWO_MAST_ROAD, drive, judgeMargin } from "./models/handover.mjs";
+import { DEFAULT_RTO_MS, DROPS, DropSpec, DropWhich, HandshakeOptions, HandshakeResult, Side, TcpSegment, firstResponseMs, handshake } from "./models/handshake.mjs";
+import { MEDIA, Medium, MediumId, PAIRS, PINOUTS, PinoutCheck, PinoutStandard, SCENARIOS, Scenario, WIRE_INK, WIRE_LABEL, WireColor, cableKind, checkPinout, isSplitPair, isStriped, pairOf, pairPins, ruleOut } from "./models/media.mjs";
+import { C_KM_S, EARTH_AREA_KM2, EARTH_RADIUS_KM, MU_EARTH, ORBITS, Orbit, centralAngleRad, footprintAreaKm2, footprintRadiusKm, oneWayMs, orbitById, orbitalPeriodMin, passMinutes, roundTripMs, satellitesForCoverage } from "./models/satellite.mjs";
+import { C, PENETRATION, Penetration, PenetrationSpec, SPECTRUM, SpectrumBand, bandById, decades, humanFrequency, humanLength, logPosition, quarterWaveM, wavelengthM } from "./models/spectrum.mjs";
+import { FrameResult, MacEntry, SwitchDevice, SwitchEvent, SwitchPort, SwitchState, clearTable, linkUp, makeSwitch, sendFrame, setPortEnabled } from "./models/switch.mjs";
+import { BroadcastResult, DeliveryResult, Vlan, VlanPort, VlanState, broadcastFrom, domainCount, domainOf, isLive, makeVlanSwitch, sendBetween, setPortVlan, setRouting } from "./models/vlan.mjs";
+import { Field, OBSERVERS, Observer, ObserverId, Setup, Sighting, TUNNEL_OVERHEAD_BYTES, canReadContents, canSeeDestination, observe, observersFor, surveyOf, usableBytes } from "./models/vpn.mjs";
+import { ADVICE, Exposure, LISTENERS, Listener, PROTECTIONS, PrivacyVerdict, Protection, ProtectionSpec, Transport, judgePrivacy, linkReadable, whatTheySee } from "./models/wifi-privacy.mjs";
+import { BANDS, Band, BandSpec, FLOOR_PLANS, FloorPlan, GRADES, Grade, GradeSpec, MATERIALS, MaterialSpec, NOISE_FLOOR_DBM, PATH_LOSS_EXPONENT, Point, Reading, Room, RoomVerdict, Spot, TX_POWER_DBM, Wall, WallMaterial, bestPlacement, coverageGrid, coverageScore, grade, referenceLossDb, roomVerdicts, signalAt, throughputMbps, wallsBetween } from "./models/wifi.mjs";
+import { COMPANY_NETWORK, HOME_NETWORK } from "./topology/presets.mjs";
+import { createPacket, simulatePacket } from "./topology/simulation.mjs";
+export { ADVICE, AccessDesign, AccessIncident, AccessSnapshot, AdaptationPolicy, AirtimeResult, Artifact, BANDS, BROADBAND_STAGES, BackendHealth, BackendResult, Band, BandSpec, BatchSize, BgpCandidate, Bit, Blocker, BroadbandAccess, BroadbandFault, BroadbandJourneyResult, BroadbandStage, BroadcastDeliveryResult, BroadcastResult, C, CALL_STAGES, CAPACITY_PATTERNS, COMPANY_NETWORK, C_KM_S, CachePolicy, CallCondition, CallJourneyResult, CallService, CallStage, CandidateHealth, CapacityPattern, CertificateKind, Client, ClientShare, CloudResource, CloudStorage, CloudWorkload, ClusterCapacity, ClusterFailure, ConsumerRefresh, ContainerDeploymentResult, ContentionResult, ContextSize, ConversationKind, CustomerContext, DEFAULT_DRIVE, DEFAULT_PATH, DEFAULT_RTO_MS, DEPLOYMENT_STAGES, DNS_HOPS, DRIVE_WINDOW, DROPS, DROP_AFTER_KM, DataCompatibility, DataPlacement, DeliveryMode, DeliveryResult, DependencyState, DeploymentFault, DeploymentScope, DeploymentStage, DeviceState, DhcpClientState, DhcpLeaseOptions, DhcpLeaseResult, DistributedInferenceResult, DistributedStrategy, DnsCache, DnsHop, DriftResolution, DriveOptions, DriveResult, DriveSample, DropSpec, DropWhich, EARTH_AREA_KM2, EARTH_RADIUS_KM, EIRP_DBM, EdgeResult, Encapsulation, EncapsulationSegment, EncodingResult, Exposure, ExternalChange, FLOOR_PLANS, FailureDomainResult, FailureScope, Field, FloorPlan, FrameResult, GENERATIONS, GRADES, Generation, GenerationId, GeoMarketResult, GeoRoutingPolicy, GpuCount, GpuInterconnect, GpuMemory, Grade, GradeSpec, GroupDeliveryResult, HANDSET_SENSITIVITY_DBM, HEADERS, HOME_NETWORK, HOUSEHOLD, HandoverEvent, HandshakeOptions, HandshakeResult, Header, HostDrift, Incident, InferenceCapacityResult, InferenceCondition, InferenceDegradationPolicy, InferenceReliabilityResult, InferenceRequestResult, InferenceRisk, InferenceScheduler, InferenceSli, InferenceWorkloadMix, InfrastructureCommand, InfrastructureIntent, InfrastructurePhase, InfrastructurePlan, InfrastructureShape, InfrastructureSnapshot, Ipv6AddressMode, Ipv6HostOptions, Ipv6HostResult, LISTENERS, LayerKind, LearnedRoute, Listener, LiveStreamResult, LoadRoutingPolicy, MATERIALS, MAX_PATH_LOSS_DB, MEDIA, MESSAGE_STAGES, MU_EARTH, MacEntry, MarginVerdict, Mast, MaterialSpec, MediaKind, MediaQuality, Medium, MediumId, MessageJourneyResult, MessageNetwork, MessageStage, ModelRoutingPolicy, ModelRoutingResult, ModelSize, ModulationResult, ModulationScheme, NOISE_FLOOR_DBM, NatBehavior, NatTraversalOptions, NatTraversalResult, NetworkDevice, NetworkDeviceKind, NetworkDoc, NetworkEndpoint, NetworkEvent, NetworkInterface, NetworkLink, NetworkPacket, NetworkRoute, NetworkTrace, NodeKind, OBSERVERS, ORBITS, OVERHEAD_BYTES, Observer, ObserverId, Orbit, OrchestrationResult, OriginState, OspfLink, OutputTokens, PAIRS, PATH_LOSS_EXPONENT, PAYLOAD_BITS, PENETRATION, PINOUTS, PROTECTIONS, PacketLayer, PacketLayerKind, PathNode, Penetration, PenetrationSpec, Permission, PinoutCheck, PinoutStandard, Placement, Point, Precision, PrefixCacheResult, PrefixCacheScope, PrefixCacheState, PrefixRequester, PrefixTokens, PrivacyVerdict, PromptTokens, Protection, ProtectionSpec, QueueResult, Reading, RecoveryResult, RecoveryStrategy, ReleaseCommand, ReleasePlan, ReleaseSnapshot, ReleaseState, ReleaseStatus, ReleaseStrategy, ReplicaVersion, ResourceAccess, ResourceAction, ResponseQualityTarget, Room, RoomVerdict, RotationPhase, RotationTrigger, SCENARIOS, SPECTRUM, STREAM_STAGES, Scenario, SecretRotationCommand, SecretRotationPlan, SecretRotationSnapshot, SecretStrategy, ServerDeploymentResult, ServerFrontEnd, ServiceScalingResult, Setup, ShopperLocation, Side, Sighting, SloIncidentResult, SloTarget, SpectrumBand, Spot, StatePlacement, StorageResult, StreamStage, SubnetInfo, SwitchDevice, SwitchEvent, SwitchPort, SwitchState, TASKS, TERRAIN, TLS_STEPS, TUNNEL_OVERHEAD_BYTES, TURN_OVERHEAD_US, TWO_MAST_ROAD, TX_POWER_DBM, Task, TcpFeedback, TcpSegment, TcpSenderOptions, TcpSenderResult, Telemetry, Terrain, TerrainSpec, Transport, TraversalStrategy, UniquePromptTokens, VERSION_TEXT, VIDEO_RATES, VideoCallTrace, VideoMoment, VideoTier, Vlan, VlanPort, VlanState, VpcDesign, VpcRouteResult, VpcScenario, VpcZone, WIRE_INK, WIRE_LABEL, Wall, WallMaterial, WireColor, WireFrame, WorkloadKind, WriteLoad, advanceTcpSender, bandById, bestPlacement, bitsOf, blockedBy, bottleneckQueue, broadbandStageReached, broadcastFrom, cableKind, callStageIndex, canReadContents, canSeeDestination, canServe, cellAreaKm2, cellRadiusKm, centralAngleRad, certificateAccepted, checkPinout, cidrContains, clearTable, compareDelivery, configureIpv6Host, coverageGrid, coverageScore, createInfrastructureEngine, createPacket, createReleaseEngine, createSecretRotationEngine, decades, decapsulate, deliverGroupMessage, deploymentStageState, describe, dnsHops, dnsLookupMs, dnsPath, domainCount, domainOf, drive, encapsulate, encodeMedia, evaluateCloudStorage, evaluateContainerDeployment, evaluateRecovery, evaluateWorkloadAccess, firstDifferingBit, firstGenerationFor, firstResponseMs, footprintAreaKm2, footprintRadiusKm, frameOn, generationById, grade, handshake, humanFrequency, humanLength, infrastructureSnapshot, intToIpv4, ipv4ToInt, isLive, isSplitPair, isStriped, journey, judgeMargin, judgePrivacy, learnOspfRoute, linkReadable, linkUp, logPosition, longestPrefixMatch, makeSwitch, makeVlanSwitch, maskFor, messageStageIndex, modulate, observe, observeService, observersFor, oneWayMs, opensTo, orbitById, orbitalPeriodMin, pairOf, pairPins, parseCidr, passMinutes, pathLossDb, planInference, planVpcRoute, quarterWaveM, queueAtTime, rateFromRssi, reconcileWorkload, referenceLossDb, releaseSnapshot, resolveGeoMarket, roomVerdicts, roundTripMs, rssiFromMast, ruleOut, sameNetwork, satellitesForCoverage, secretRotationSnapshot, segmentsOf, selectBgpRoute, sendBetween, sendFrame, setPortEnabled, setPortVlan, setRouting, shareAirtime, signalAt, signalWord, simulateBroadband, simulateCall, simulateContention, simulateDhcpLease, simulateDistributedInference, simulateEdgeCache, simulateFailureDomains, simulateInferenceReliability, simulateInferenceRequest, simulateLiveStream, simulateMessage, simulateModelRouting, simulateNatTraversal, simulatePacket, simulatePrefixCache, simulateServerDeployment, simulateServiceScaling, simulateVideoCall, surveyOf, throughputMbps, towersFor, transitionInfrastructure, transitionRelease, transitionSecretRotation, usableBytes, visibleOnWire, wallsBetween, wavelengthM, whatTheySee, widestSharedPrefix };

package/dist/networking/index.mjs

@@ -0,0 +1,47 @@
+import { bottleneckQueue, queueAtTime } from "./queue.mjs";
+import { DNS_HOPS, TLS_STEPS, certificateAccepted, dnsHops, dnsLookupMs, dnsPath, visibleOnWire } from "./protocols.mjs";
+import { encodeMedia, modulate } from "./signals.mjs";
+import { simulateContention } from "./wireless.mjs";
+import { STREAM_STAGES, compareDelivery, deliverGroupMessage, simulateLiveStream } from "./delivery.mjs";
+import { BROADBAND_STAGES, CALL_STAGES, CAPACITY_PATTERNS, MESSAGE_STAGES, VIDEO_RATES, broadbandStageReached, callStageIndex, messageStageIndex, simulateBroadband, simulateCall, simulateMessage, simulateVideoCall } from "./journeys.mjs";
+import { bitsOf, describe, firstDifferingBit, intToIpv4, ipv4ToInt, maskFor, sameNetwork, widestSharedPrefix } from "./subnet.mjs";
+import { cidrContains, longestPrefixMatch, parseCidr } from "./routing.mjs";
+import { simulateDhcpLease } from "./addressing.mjs";
+import { configureIpv6Host } from "./ipv6.mjs";
+import { simulateNatTraversal } from "./nat-traversal.mjs";
+import { advanceTcpSender } from "./tcp-reliability.mjs";
+import { learnOspfRoute, selectBgpRoute } from "./route-learning.mjs";
+import { HOUSEHOLD, PAYLOAD_BITS, TURN_OVERHEAD_US, rateFromRssi, shareAirtime, signalWord } from "./models/airtime.mjs";
+import { EIRP_DBM, GENERATIONS, HANDSET_SENSITIVITY_DBM, MAX_PATH_LOSS_DB, TASKS, TERRAIN, blockedBy, canServe, cellAreaKm2, cellRadiusKm, firstGenerationFor, generationById, pathLossDb, rssiFromMast, towersFor } from "./models/cellular.mjs";
+import { DEFAULT_PATH, HEADERS, OVERHEAD_BYTES, decapsulate, encapsulate, frameOn, journey, opensTo, segmentsOf } from "./models/encapsulation.mjs";
+import { DEFAULT_DRIVE, DRIVE_WINDOW, DROP_AFTER_KM, TWO_MAST_ROAD, drive, judgeMargin } from "./models/handover.mjs";
+import { DEFAULT_RTO_MS, DROPS, firstResponseMs, handshake } from "./models/handshake.mjs";
+import { MEDIA, PAIRS, PINOUTS, SCENARIOS, WIRE_INK, WIRE_LABEL, cableKind, checkPinout, isSplitPair, isStriped, pairOf, pairPins, ruleOut } from "./models/media.mjs";
+import { C_KM_S, EARTH_AREA_KM2, EARTH_RADIUS_KM, MU_EARTH, ORBITS, centralAngleRad, footprintAreaKm2, footprintRadiusKm, oneWayMs, orbitById, orbitalPeriodMin, passMinutes, roundTripMs, satellitesForCoverage } from "./models/satellite.mjs";
+import { C, PENETRATION, SPECTRUM, bandById, decades, humanFrequency, humanLength, logPosition, quarterWaveM, wavelengthM } from "./models/spectrum.mjs";
+import { clearTable, linkUp, makeSwitch, sendFrame, setPortEnabled } from "./models/switch.mjs";
+import { broadcastFrom, domainCount, domainOf, isLive, makeVlanSwitch, sendBetween, setPortVlan, setRouting } from "./models/vlan.mjs";
+import { OBSERVERS, TUNNEL_OVERHEAD_BYTES, canReadContents, canSeeDestination, observe, observersFor, surveyOf, usableBytes } from "./models/vpn.mjs";
+import { ADVICE, LISTENERS, PROTECTIONS, judgePrivacy, linkReadable, whatTheySee } from "./models/wifi-privacy.mjs";
+import { BANDS, FLOOR_PLANS, GRADES, MATERIALS, NOISE_FLOOR_DBM, PATH_LOSS_EXPONENT, TX_POWER_DBM, bestPlacement, coverageGrid, coverageScore, grade, referenceLossDb, roomVerdicts, signalAt, throughputMbps, wallsBetween } from "./models/wifi.mjs";
+import { COMPANY_NETWORK, HOME_NETWORK } from "./topology/presets.mjs";
+import { createPacket, simulatePacket } from "./topology/simulation.mjs";
+import { evaluateWorkloadAccess } from "./cloud/access.mjs";
+import { VERSION_TEXT, evaluateContainerDeployment } from "./cloud/containers.mjs";
+import { simulateEdgeCache } from "./cloud/edge.mjs";
+import { simulateFailureDomains } from "./cloud/failure-domains.mjs";
+import { resolveGeoMarket } from "./cloud/geo-routing.mjs";
+import { planInference, simulateDistributedInference, simulateInferenceRequest, simulateModelRouting, simulatePrefixCache } from "./cloud/inference.mjs";
+import { simulateInferenceReliability } from "./cloud/inference-reliability.mjs";
+import { createInfrastructureEngine, infrastructureSnapshot, transitionInfrastructure } from "./cloud/infrastructure.mjs";
+import { observeService } from "./cloud/observability.mjs";
+import { reconcileWorkload } from "./cloud/orchestration.mjs";
+import { evaluateRecovery } from "./cloud/recovery.mjs";
+import { createReleaseEngine, releaseSnapshot, transitionRelease } from "./cloud/releases.mjs";
+import { simulateServiceScaling } from "./cloud/scaling.mjs";
+import { createSecretRotationEngine, secretRotationSnapshot, transitionSecretRotation } from "./cloud/secrets.mjs";
+import { DEPLOYMENT_STAGES, deploymentStageState, simulateServerDeployment } from "./cloud/server-deployment.mjs";
+import { evaluateCloudStorage } from "./cloud/storage.mjs";
+import { planVpcRoute } from "./cloud/vpc.mjs";
+
+export { ADVICE, BANDS, BROADBAND_STAGES, C, CALL_STAGES, CAPACITY_PATTERNS, COMPANY_NETWORK, C_KM_S, DEFAULT_DRIVE, DEFAULT_PATH, DEFAULT_RTO_MS, DEPLOYMENT_STAGES, DNS_HOPS, DRIVE_WINDOW, DROPS, DROP_AFTER_KM, EARTH_AREA_KM2, EARTH_RADIUS_KM, EIRP_DBM, FLOOR_PLANS, GENERATIONS, GRADES, HANDSET_SENSITIVITY_DBM, HEADERS, HOME_NETWORK, HOUSEHOLD, LISTENERS, MATERIALS, MAX_PATH_LOSS_DB, MEDIA, MESSAGE_STAGES, MU_EARTH, NOISE_FLOOR_DBM, OBSERVERS, ORBITS, OVERHEAD_BYTES, PAIRS, PATH_LOSS_EXPONENT, PAYLOAD_BITS, PENETRATION, PINOUTS, PROTECTIONS, SCENARIOS, SPECTRUM, STREAM_STAGES, TASKS, TERRAIN, TLS_STEPS, TUNNEL_OVERHEAD_BYTES, TURN_OVERHEAD_US, TWO_MAST_ROAD, TX_POWER_DBM, VERSION_TEXT, VIDEO_RATES, WIRE_INK, WIRE_LABEL, advanceTcpSender, bandById, bestPlacement, bitsOf, blockedBy, bottleneckQueue, broadbandStageReached, broadcastFrom, cableKind, callStageIndex, canReadContents, canSeeDestination, canServe, cellAreaKm2, cellRadiusKm, centralAngleRad, certificateAccepted, checkPinout, cidrContains, clearTable, compareDelivery, configureIpv6Host, coverageGrid, coverageScore, createInfrastructureEngine, createPacket, createReleaseEngine, createSecretRotationEngine, decades, decapsulate, deliverGroupMessage, deploymentStageState, describe, dnsHops, dnsLookupMs, dnsPath, domainCount, domainOf, drive, encapsulate, encodeMedia, evaluateCloudStorage, evaluateContainerDeployment, evaluateRecovery, evaluateWorkloadAccess, firstDifferingBit, firstGenerationFor, firstResponseMs, footprintAreaKm2, footprintRadiusKm, frameOn, generationById, grade, handshake, humanFrequency, humanLength, infrastructureSnapshot, intToIpv4, ipv4ToInt, isLive, isSplitPair, isStriped, journey, judgeMargin, judgePrivacy, learnOspfRoute, linkReadable, linkUp, logPosition, longestPrefixMatch, makeSwitch, makeVlanSwitch, maskFor, messageStageIndex, modulate, observe, observeService, observersFor, oneWayMs, opensTo, orbitById, orbitalPeriodMin, pairOf, pairPins, parseCidr, passMinutes, pathLossDb, planInference, planVpcRoute, quarterWaveM, queueAtTime, rateFromRssi, reconcileWorkload, referenceLossDb, releaseSnapshot, resolveGeoMarket, roomVerdicts, roundTripMs, rssiFromMast, ruleOut, sameNetwork, satellitesForCoverage, secretRotationSnapshot, segmentsOf, selectBgpRoute, sendBetween, sendFrame, setPortEnabled, setPortVlan, setRouting, shareAirtime, signalAt, signalWord, simulateBroadband, simulateCall, simulateContention, simulateDhcpLease, simulateDistributedInference, simulateEdgeCache, simulateFailureDomains, simulateInferenceReliability, simulateInferenceRequest, simulateLiveStream, simulateMessage, simulateModelRouting, simulateNatTraversal, simulatePacket, simulatePrefixCache, simulateServerDeployment, simulateServiceScaling, simulateVideoCall, surveyOf, throughputMbps, towersFor, transitionInfrastructure, transitionRelease, transitionSecretRotation, usableBytes, visibleOnWire, wallsBetween, wavelengthM, whatTheySee, widestSharedPrefix };

package/dist/networking/ipv6.d.mts

@@ -0,0 +1,28 @@
+//#region src/networking/ipv6.d.ts
+type Ipv6AddressMode = "slaac" | "dhcpv6" | "static";
+interface Ipv6HostOptions {
+  mode: Ipv6AddressMode;
+  routerAdvertisement: boolean;
+  dhcpv6Available?: boolean;
+  prefix?: string;
+  interfaceId?: string;
+  peer: "link-local" | "same-prefix" | "remote-prefix";
+}
+interface Ipv6HostResult {
+  linkLocalAddress: string;
+  globalAddress: string | null;
+  defaultRouter: boolean;
+  path: "neighbor-discovery" | "router" | "unreachable";
+  usesBroadcast: false;
+  explanation: string;
+}
+declare function configureIpv6Host({
+  mode,
+  routerAdvertisement,
+  dhcpv6Available,
+  prefix,
+  interfaceId,
+  peer
+}: Ipv6HostOptions): Ipv6HostResult;
+//#endregion
+export { Ipv6AddressMode, Ipv6HostOptions, Ipv6HostResult, configureIpv6Host };

package/dist/networking/ipv6.mjs

@@ -0,0 +1,17 @@
+//#region src/networking/ipv6.ts
+function configureIpv6Host({ mode, routerAdvertisement, dhcpv6Available = false, prefix = "2001:db8:1", interfaceId = "42", peer }) {
+	const globalAddress = mode === "static" || mode === "slaac" && routerAdvertisement || mode === "dhcpv6" && dhcpv6Available ? `${prefix}::${interfaceId}` : null;
+	const defaultRouter = routerAdvertisement;
+	const path = peer === "link-local" ? "neighbor-discovery" : peer === "same-prefix" && globalAddress ? "neighbor-discovery" : peer === "remote-prefix" && globalAddress && defaultRouter ? "router" : "unreachable";
+	return {
+		linkLocalAddress: `fe80::${interfaceId}`,
+		globalAddress,
+		defaultRouter,
+		path,
+		usesBroadcast: false,
+		explanation: path === "neighbor-discovery" ? "Resolve the neighbor with multicast, then send directly." : path === "router" ? "Send the packet to the default router learned from its advertisement." : "This host has no usable address or route for that peer."
+	};
+}
+
+//#endregion
+export { configureIpv6Host };

package/dist/networking/journeys.d.mts

@@ -0,0 +1,83 @@
+import { DnsCache } from "./protocols.mjs";
+import { MediaKind, MediaQuality } from "./signals.mjs";
+
+//#region src/networking/journeys.d.ts
+type AdaptationPolicy = "fixed" | "adaptive";
+type CapacityPattern = "steady" | "drop-recover";
+type VideoTier = "HD" | "SD" | "low";
+declare const VIDEO_RATES: Record<VideoTier, number>;
+declare const CAPACITY_PATTERNS: Record<CapacityPattern, readonly number[]>;
+interface VideoMoment {
+  readonly index: number;
+  readonly capacityKbps: number;
+  readonly bitrateKbps: number;
+  readonly tier: VideoTier;
+  readonly queued: number;
+  readonly dropped: number;
+  readonly delayMs: number;
+  readonly state: "clear" | "delayed" | "dropping";
+}
+interface VideoCallTrace {
+  readonly moments: readonly VideoMoment[];
+  readonly totalDropped: number;
+}
+declare function simulateVideoCall(policy: AdaptationPolicy, pattern: CapacityPattern): VideoCallTrace;
+type BroadbandAccess = "fibre" | "cable" | "mobile";
+type BroadbandFault = "none" | "wifi" | "access" | "dns";
+type BroadbandStage = "device" | "router" | "terminal" | "isp" | "dns" | "internet" | "server";
+declare const BROADBAND_STAGES: readonly BroadbandStage[];
+interface BroadbandJourneyResult {
+  readonly stages: readonly BroadbandStage[];
+  readonly terminal: string;
+  readonly medium: string;
+  readonly downMbps: number;
+  readonly latencyMs: number;
+  readonly stoppedAt: BroadbandStage | null;
+  readonly privateAddress: string;
+  readonly publicAddress: string;
+}
+declare function simulateBroadband(access: BroadbandAccess, fault: BroadbandFault): BroadbandJourneyResult;
+declare function broadbandStageReached(current: number, stage: BroadbandStage, stoppedAt: BroadbandStage | null): "idle" | "active" | "success" | "error";
+type ConversationKind = "direct" | "group";
+type MessageNetwork = "clear" | "congested";
+type MessageStage = "compose" | "resolve" | "secure" | "deliver" | "synchronize";
+declare const MESSAGE_STAGES: readonly MessageStage[];
+interface MessageJourneyResult {
+  readonly hostname: string;
+  readonly lookupMs: number;
+  readonly tlsAccepted: boolean;
+  readonly encrypted: true;
+  readonly recipients: number;
+  readonly copies: number;
+  readonly delivered: number;
+  readonly offline: number;
+  readonly networkDrops: number;
+  readonly queueDelayMs: number;
+  readonly totalMs: number;
+}
+declare function simulateMessage(conversation: ConversationKind, recipients: number, offlineDevices: number, cache: DnsCache, network: MessageNetwork, hostname?: string): MessageJourneyResult;
+declare const messageStageIndex: (stage: MessageStage) => number;
+type CallService = "carrier" | "app";
+type CallCondition = "strong" | "moving" | "congested";
+type CallStage = "capture" | "encode" | "radio" | "route" | "reconstruct";
+declare const CALL_STAGES: readonly CallStage[];
+interface CallJourneyResult {
+  readonly service: CallService;
+  readonly kind: MediaKind;
+  readonly quality: MediaQuality;
+  readonly condition: CallCondition;
+  readonly bitrateKbps: number;
+  readonly packets: number;
+  readonly received: number;
+  readonly lost: number;
+  readonly fidelity: number;
+  readonly latencyMs: number;
+  readonly handoffs: number;
+  readonly encrypted: true;
+  readonly routeLabel: string;
+  readonly recoveredBits: string;
+}
+declare function simulateCall(service: CallService, kind: MediaKind, quality: MediaQuality, condition: CallCondition): CallJourneyResult;
+declare const callStageIndex: (stage: CallStage) => number;
+//#endregion
+export { AdaptationPolicy, BROADBAND_STAGES, BroadbandAccess, BroadbandFault, BroadbandJourneyResult, BroadbandStage, CALL_STAGES, CAPACITY_PATTERNS, CallCondition, CallJourneyResult, CallService, CallStage, CapacityPattern, ConversationKind, MESSAGE_STAGES, MessageJourneyResult, MessageNetwork, MessageStage, VIDEO_RATES, VideoCallTrace, VideoMoment, VideoTier, broadbandStageReached, callStageIndex, messageStageIndex, simulateBroadband, simulateCall, simulateMessage, simulateVideoCall };

package/dist/networking/journeys.mjs

@@ -0,0 +1,161 @@
+import { queueAtTime } from "./queue.mjs";
+import { certificateAccepted, dnsLookupMs } from "./protocols.mjs";
+import { encodeMedia, modulate } from "./signals.mjs";
+import { deliverGroupMessage } from "./delivery.mjs";
+
+//#region src/networking/journeys.ts
+const VIDEO_RATES = {
+	HD: 2500,
+	SD: 1e3,
+	low: 350
+};
+const CAPACITY_PATTERNS = {
+	steady: [
+		3e3,
+		3e3,
+		3e3,
+		3e3,
+		3e3
+	],
+	"drop-recover": [
+		3e3,
+		1400,
+		500,
+		1400,
+		3e3
+	]
+};
+const adaptiveTier = (capacity) => capacity >= 2800 ? "HD" : capacity >= 1100 ? "SD" : "low";
+function simulateVideoCall(policy, pattern) {
+	const capacities = CAPACITY_PATTERNS[pattern];
+	let queued = 0;
+	let totalDropped = 0;
+	return {
+		moments: capacities.map((capacityKbps, index) => {
+			const observedCapacity = capacities[Math.max(0, index - 1)] ?? capacityKbps;
+			const tier = policy === "fixed" ? "HD" : adaptiveTier(observedCapacity);
+			const bitrateKbps = VIDEO_RATES[tier];
+			const service = capacityKbps / 100;
+			const offered = Math.max(0, queued + bitrateKbps / 100 - service);
+			const dropped = Math.max(0, offered - 20);
+			queued = Math.min(20, offered);
+			totalDropped += dropped;
+			return {
+				index,
+				capacityKbps,
+				bitrateKbps,
+				tier,
+				queued: Math.round(queued),
+				dropped: Math.round(dropped),
+				delayMs: service > 0 ? Math.round(queued / service * 1e3) : 0,
+				state: dropped > 0 ? "dropping" : queued > 0 ? "delayed" : "clear"
+			};
+		}),
+		totalDropped: Math.round(totalDropped)
+	};
+}
+const BROADBAND_STAGES = [
+	"device",
+	"router",
+	"terminal",
+	"isp",
+	"dns",
+	"internet",
+	"server"
+];
+const ACCESS = {
+	fibre: {
+		terminal: "ONT",
+		medium: "light in fibre",
+		downMbps: 500,
+		latencyMs: 7
+	},
+	cable: {
+		terminal: "Cable modem",
+		medium: "radio-frequency signal in coax",
+		downMbps: 200,
+		latencyMs: 14
+	},
+	mobile: {
+		terminal: "5G radio",
+		medium: "radio to a cell tower",
+		downMbps: 120,
+		latencyMs: 24
+	}
+};
+function simulateBroadband(access, fault) {
+	const stoppedAt = fault === "wifi" ? "router" : fault === "access" ? "isp" : fault === "dns" ? "dns" : null;
+	return {
+		stages: BROADBAND_STAGES,
+		...ACCESS[access],
+		stoppedAt,
+		privateAddress: "192.168.1.24",
+		publicAddress: "203.0.113.18"
+	};
+}
+function broadbandStageReached(current, stage, stoppedAt) {
+	const index = BROADBAND_STAGES.indexOf(stage);
+	const stop = stoppedAt ? BROADBAND_STAGES.indexOf(stoppedAt) : Infinity;
+	if (index === stop && current >= index) return "error";
+	if (index === current && index < stop) return "active";
+	if (index < current && index < stop) return "success";
+	return "idle";
+}
+const MESSAGE_STAGES = [
+	"compose",
+	"resolve",
+	"secure",
+	"deliver",
+	"synchronize"
+];
+function simulateMessage(conversation, recipients, offlineDevices, cache, network, hostname = "chat.example") {
+	const safeRecipients = conversation === "direct" ? 1 : Math.min(8, Math.max(2, recipients));
+	const delivery = deliverGroupMessage(safeRecipients, 2, offlineDevices);
+	const queue = network === "congested" ? queueAtTime(18, 8, 6, 1) : queueAtTime(5, 10, 6, 1);
+	const lookupMs = dnsLookupMs(cache, 20);
+	return {
+		hostname,
+		lookupMs,
+		tlsAccepted: certificateAccepted("trusted"),
+		encrypted: true,
+		recipients: safeRecipients,
+		copies: delivery.copies,
+		delivered: delivery.delivered,
+		offline: delivery.queued,
+		networkDrops: queue.dropped,
+		queueDelayMs: queue.delayMs,
+		totalMs: lookupMs + 45 + queue.delayMs
+	};
+}
+const messageStageIndex = (stage) => MESSAGE_STAGES.indexOf(stage);
+const CALL_STAGES = [
+	"capture",
+	"encode",
+	"radio",
+	"route",
+	"reconstruct"
+];
+function simulateCall(service, kind, quality, condition) {
+	const encoding = encodeMedia(kind, quality, condition === "congested" ? 25 : condition === "moving" ? 10 : 0);
+	const radio = modulate("10110010", "bpsk", condition === "strong" ? 0 : condition === "moving" ? 22 : 40);
+	return {
+		service,
+		kind,
+		quality,
+		condition,
+		bitrateKbps: encoding.bitrateKbps,
+		packets: encoding.packets,
+		received: encoding.received,
+		lost: encoding.lost,
+		fidelity: encoding.fidelity,
+		latencyMs: condition === "congested" ? 310 : condition === "moving" ? 145 : 55,
+		handoffs: condition === "moving" ? 1 : 0,
+		encrypted: true,
+		routeLabel: service === "app" ? "app service" : "mobile core",
+		recoveredBits: radio.recovered
+	};
+}
+const callStageIndex = (stage) => CALL_STAGES.indexOf(stage);
+
+//#endregion
+export { BROADBAND_STAGES, CALL_STAGES, CAPACITY_PATTERNS, MESSAGE_STAGES, VIDEO_RATES, broadbandStageReached, callStageIndex, messageStageIndex, simulateBroadband, simulateCall, simulateMessage, simulateVideoCall };

package/dist/networking/models/airtime.d.mts

@@ -0,0 +1,87 @@
+//#region src/networking/models/airtime.d.ts
+/**
+ * One channel, several devices, and the thing everyone is actually sharing.
+ *
+ * A switch gives every port its own wire. Wi-Fi gives everybody the same air, so devices take turns,
+ * and what they are taking turns at is TIME rather than bandwidth. That one substitution explains the
+ * most confusing thing about a home network: a laptop sitting beside the router, showing a perfect
+ * signal, can be slow because of a phone in a distant bedroom.
+ *
+ * The mechanism has a name, the 802.11 performance anomaly, and it is worth stating precisely because
+ * it is so counter-intuitive. The access point gives each device roughly the same number of turns.
+ * A device with a weak signal negotiates a low data rate, so ITS turn takes far longer to deliver the
+ * same bytes. While that turn runs, nobody else may transmit at all. With one device at 260 Mbps and
+ * one at 15 Mbps, the fast device does not get 260: both end up near 14, because the slow device is
+ * occupying the channel for most of every round.
+ *
+ * So chapter 1 is not finished when a room reaches a usable signal. A room that is merely usable
+ * drags down every other room, and the fix for a slow house is often to improve the WORST corner
+ * rather than to buy a faster router. That is the opposite of what the advertising suggests and it
+ * follows from one line of arithmetic.
+ */
+/**
+ * Bits carried in one transmission opportunity.
+ *
+ * Not one frame. Modern Wi-Fi aggregates dozens of frames into a single transmission, precisely
+ * because the fixed cost below would otherwise dominate at high rates. Modelling a lone 1500-byte
+ * frame would show a 300 Mbps link delivering 60 Mbps, which is what 802.11 looked like twenty years
+ * ago and would teach an efficiency problem that has since been solved.
+ */
+declare const PAYLOAD_BITS: number;
+/**
+ * Fixed cost of taking a turn, in microseconds.
+ *
+ * Contention, the gap before transmitting, the preamble and the acknowledgement. It is paid per turn
+ * regardless of how fast the device is, which is why it hurts fast devices most and why aggregation
+ * exists.
+ */
+declare const TURN_OVERHEAD_US = 200;
+interface Client {
+  id: string;
+  label: string;
+  /** Signal at the device, in dBm. The rate follows from it. */
+  rssiDbm: number;
+}
+interface ClientShare {
+  client: Client;
+  /** Rate this device negotiates from its signal, in Mbps. */
+  rateMbps: number;
+  /** Microseconds of channel time its turn consumes. */
+  turnUs: number;
+  /** Fraction of the channel's time this device occupies, 0 to 1. */
+  airtimeShare: number;
+  /** What it actually achieves once everyone is taking turns, in Mbps. */
+  effectiveMbps: number;
+}
+interface AirtimeResult {
+  shares: ClientShare[];
+  /** Everything the cell delivers, added up, in Mbps. */
+  totalMbps: number;
+  /** What the fastest device alone would have achieved, for comparison. */
+  aloneMbps: number;
+  /** Airtime taken by the single worst offender, 0 to 1. */
+  worstShare: number;
+}
+/**
+ * Data rate a device negotiates from its signal, in Mbps.
+ *
+ * A staircase rather than a curve, because rate selection is a ladder of modulation schemes and a
+ * device drops a whole rung at a time. The figures are for a two-stream client on a modern 5 GHz
+ * channel. The shape is what matters: rate holds up and then falls off a cliff, so a room that is
+ * merely "usable" is already several rungs down.
+ */
+declare function rateFromRssi(rssiDbm: number): number;
+/**
+ * Share the channel between devices that all want to send at once.
+ *
+ * Each device gets an equal number of turns, so a round is the sum of everyone's turn length, and
+ * every device delivers one payload per round. That is why the effective rates come out EQUAL: the
+ * arithmetic makes the fast device wait through the slow one's turn, every round, forever.
+ */
+declare function shareAirtime(clients: readonly Client[]): AirtimeResult;
+/** A device's signal placed into words, so a share can be read without decoding dBm. */
+declare function signalWord(rssiDbm: number): string;
+/** A household worth arguing about: three healthy devices and one in the corner that is not. */
+declare const HOUSEHOLD: Client[];
+//#endregion
+export { AirtimeResult, Client, ClientShare, HOUSEHOLD, PAYLOAD_BITS, TURN_OVERHEAD_US, rateFromRssi, shareAirtime, signalWord };