@tileflow/react-native 0.0.0-bootstrap.0 → 0.1.0-alpha.0

package/ios/TileflowNativeDocuments.mm

@@ -0,0 +1,105 @@
+#import "TileflowNativeDocuments.h"
+#import "TileflowNativeAdmission.h"
+#import "TFNativeDocumentRegistry.h"
+#import "TFAdmissionNetwork.h"
+#import <React/RCTBridge.h>
+#import <UIKit/UIKit.h>
+#import <atomic>
+#import <cmath>
+
+@interface TileflowNativeDocuments () {
+	std::atomic_bool _invalidated;
+}
+@property (nonatomic, strong, nullable) TFNativeDocumentRegistry *registry;
+@property (nonatomic, strong, nullable) TFAdmissionURLSessionNetwork *network;
+@end
+
+@implementation TileflowNativeDocuments
+RCT_EXPORT_MODULE(TileflowNativeDocuments)
+@synthesize bridge = _bridge;
++ (BOOL)requiresMainQueueSetup { return YES; }
+- (dispatch_queue_t)methodQueue { return dispatch_get_main_queue(); }
+- (instancetype)init {
+	if ((self = [super init])) {
+		_invalidated.store(false);
+		NSNotificationCenter *center = NSNotificationCenter.defaultCenter;
+		[center addObserver:self selector:@selector(background:) name:UIApplicationWillResignActiveNotification object:nil];
+		[center addObserver:self selector:@selector(foreground:) name:UIApplicationDidBecomeActiveNotification object:nil];
+	}
+	return self;
+}
+- (void)dealloc { [NSNotificationCenter.defaultCenter removeObserver:self]; }
+- (TFNativeDocumentRegistry *)ensureRegistry {
+	if (_invalidated.load()) [self invalid];
+	if (!self.registry) {
+		NSURLSessionConfiguration *configuration = NSURLSessionConfiguration.ephemeralSessionConfiguration;
+		configuration.protocolClasses = @[];
+		configuration.URLCache = nil;
+		configuration.HTTPCookieStorage = nil;
+		configuration.URLCredentialStorage = nil;
+		configuration.HTTPShouldSetCookies = NO;
+		configuration.HTTPAdditionalHeaders = nil;
+		configuration.requestCachePolicy = NSURLRequestReloadIgnoringLocalCacheData;
+		TFAdmissionURLSessionNetwork *network = [[TFAdmissionURLSessionNetwork alloc] initWithConfiguration:configuration followsRedirects:NO responseByteLimit:8388608 queueDepth:16 concurrency:4];
+		self.network = network;
+		self.registry = [[TFNativeDocumentRegistry alloc] initWithScheduler:[TFContinuousAdmissionScheduler new] load:^id<TFAdmissionCancel>(NSURLRequest *request, TFNativeDocumentScope *scope, TFAdmissionStartGuard guard, TFAdmissionNetworkCompletion completion) {
+			if (scope) return scope.load(request, completion);
+			return [network start:request mayStart:guard completion:completion];
+		}];
+		[self.registry lifecycle:UIApplication.sharedApplication.applicationState == UIApplicationStateActive];
+	}
+	return self.registry;
+}
+RCT_REMAP_METHOD(openDocument, openDocumentURL:(NSString *)url maximumBytes:(double)maximumBytes installation:(NSString *)installation context:(NSString *)context developmentOrigin:(NSString *)developmentOrigin resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	@try {
+		if (_invalidated.load() || !std::isfinite(maximumBytes) || std::floor(maximumBytes) != maximumBytes || maximumBytes < 1 || maximumBytes > 8388608 ||
+			(installation == nil) != (context == nil)) [self invalid];
+		TFNativeDocumentScope *scope = nil;
+		if (installation) {
+			if (!TFAdmissionValidToken(installation) || !TFAdmissionValidToken(context)) [self invalid];
+			TileflowNativeAdmission *admission = [self.bridge moduleForClass:TileflowNativeAdmission.class];
+			if (!admission) [self invalid];
+			scope = [admission documentScopeForInstallation:installation context:context documents:self];
+			if (!scope) [self invalid];
+		}
+		NSURLRequest *request = [NSURLRequest requestWithURL:[NSURL URLWithString:url]];
+		NSString *identifier = [[self ensureRegistry] open:request maximumBytes:(NSUInteger)maximumBytes scope:scope developmentOrigin:developmentOrigin];
+		resolve(@{@"document": identifier});
+	} @catch (NSException *exception) { [self reject:reject]; }
+}
+RCT_REMAP_METHOD(documentResponse, responseDocument:(NSString *)document resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	@try {
+		if (_invalidated.load() || !TFAdmissionValidToken(document) || !self.registry) [self invalid];
+		[self.registry response:document completion:^(NSDictionary *header) {
+			if (!header || self->_invalidated.load()) [self reject:reject];
+			else resolve(header);
+		}];
+	} @catch (NSException *exception) { [self reject:reject]; }
+}
+RCT_REMAP_METHOD(documentChunk, chunkDocument:(NSString *)document maximumBytes:(double)maximumBytes resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	@try {
+		if (_invalidated.load() || !TFAdmissionValidToken(document) || !self.registry || !std::isfinite(maximumBytes) ||
+			std::floor(maximumBytes) != maximumBytes || maximumBytes < 1 || maximumBytes > 65536) [self invalid];
+		resolve([self.registry chunk:document maximumBytes:(NSUInteger)maximumBytes]);
+	} @catch (NSException *exception) { [self reject:reject]; }
+}
+RCT_REMAP_METHOD(cancelDocument, cancelDocumentID:(NSString *)document resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	@try {
+		if (!TFAdmissionValidToken(document)) [self invalid];
+		[self.registry cancel:document];
+		resolve(@{@"cancelled": @YES});
+	} @catch (NSException *exception) { [self reject:reject]; }
+}
+- (void)retireNativeContext:(NSString *)context { [self.registry retireContext:context]; }
+- (void)retireProtectedDocuments { [self.registry retireProtected]; }
+- (void)background:(NSNotification *)notification { [self.registry lifecycle:NO]; }
+- (void)foreground:(NSNotification *)notification { if (!_invalidated.load()) [self.registry lifecycle:YES]; }
+- (void)invalidate {
+	_invalidated.store(true);
+	[NSNotificationCenter.defaultCenter removeObserver:self];
+	dispatch_async(dispatch_get_main_queue(), ^{ [self.registry close]; [self.network close]; });
+}
+- (void)reject:(RCTPromiseRejectBlock)reject { reject(@"NATIVE_DOCUMENT_UNAVAILABLE", @"Native document acquisition failed.", nil); }
+- (void)invalid { @throw [NSException exceptionWithName:@"TFNativeDocumentInvalid" reason:@"Native document acquisition failed." userInfo:nil]; }
+- (NSString *)description { return @"TileflowNativeDocuments(redacted)"; }
+@end

package/ios/TileflowNativeSurface.mm

@@ -0,0 +1,403 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTInvalidating.h>
+#import <MapLibre/MapLibre.h>
+#import <MapLibreReactNative/MLRNMapView.h>
+#import <MapLibreReactNative/MLRNCamera.h>
+#import <QuartzCore/QuartzCore.h>
+#import "TFAdmissionEngine.h"
+#import "TFNativeSurfaceState.h"
+#import <cmath>
+
+static void TFSurfaceInvalid(void) {
+	@throw [NSException exceptionWithName:@"TFNativeSurfaceInvalid" reason:@"Native surface operation failed." userInfo:nil];
+}
+static void TFSurfaceReject(RCTPromiseRejectBlock reject) { reject(@"NATIVE_SURFACE_UNAVAILABLE", @"Native surface operation failed.", nil); }
+static NSUInteger TFSurfaceInteger(id value) {
+	if (![value isKindOfClass:NSNumber.class] || CFGetTypeID((__bridge CFTypeRef)value) == CFBooleanGetTypeID()) TFSurfaceInvalid();
+	double number = [value doubleValue];
+	if (!std::isfinite(number) || number < 1 || number > 9007199254740991.0 || std::floor(number) != number) TFSurfaceInvalid();
+	return (NSUInteger)number;
+}
+static double TFSurfaceNumber(id value, double minimum, double maximum) {
+	if (![value isKindOfClass:NSNumber.class] || CFGetTypeID((__bridge CFTypeRef)value) == CFBooleanGetTypeID()) TFSurfaceInvalid();
+	double number = [value doubleValue];
+	if (!std::isfinite(number) || number < minimum || number > maximum) TFSurfaceInvalid();
+	return number;
+}
+static NSDictionary *TFSurfaceView(id value) {
+	if (![value isKindOfClass:NSDictionary.class] || [value count] != 4) TFSurfaceInvalid();
+	for (id key in value) if (![@[@"center", @"zoom", @"bearing", @"pitch"] containsObject:key]) TFSurfaceInvalid();
+	id center = value[@"center"];
+	if (![center isKindOfClass:NSArray.class] || [center count] != 2) TFSurfaceInvalid();
+	return @{@"center": @[@(TFSurfaceNumber(center[0], -180, 180)), @(TFSurfaceNumber(center[1], -90, 90))],
+		@"zoom": @(TFSurfaceNumber(value[@"zoom"], 0, 24)), @"bearing": @(TFSurfaceNumber(value[@"bearing"], -180, 180)),
+		@"pitch": @(TFSurfaceNumber(value[@"pitch"], 0, 85))};
+}
+static MLRNMapView *TFSurfaceMap(UIView *root) {
+	NSMutableArray<UIView *> *queue = [NSMutableArray arrayWithObject:root];
+	MLRNMapView *found = nil; NSUInteger visited = 0;
+	while (queue.count) {
+		if (++visited > 1024) TFSurfaceInvalid();
+		UIView *view = queue.firstObject; [queue removeObjectAtIndex:0];
+		if ([view isKindOfClass:MLRNMapView.class]) {
+			if (found) TFSurfaceInvalid(); found = (MLRNMapView *)view;
+		} else {
+			if (queue.count + view.subviews.count > 1024) TFSurfaceInvalid();
+			[queue addObjectsFromArray:view.subviews];
+		}
+	}
+	if (!found) TFSurfaceInvalid();
+	return found;
+}
+static MLRNCamera *TFSurfaceCamera(UIView *root, MLRNMapView *map) {
+	NSMutableArray<UIView *> *queue = [NSMutableArray arrayWithObject:root];
+	MLRNCamera *found = nil; NSUInteger visited = 0;
+	while (queue.count) {
+		if (++visited > 1024) TFSurfaceInvalid();
+		UIView *view = queue.firstObject; [queue removeObjectAtIndex:0];
+		if ([view isKindOfClass:MLRNCamera.class]) {
+			if (found) TFSurfaceInvalid(); found = (MLRNCamera *)view;
+		}
+		if (queue.count + view.subviews.count > 1024) TFSurfaceInvalid();
+		[queue addObjectsFromArray:view.subviews];
+	}
+	id registered = map.reactCamera;
+	if (!found || ![registered isKindOfClass:MLRNCamera.class] || registered != found || ((MLRNCamera *)registered).map != map) TFSurfaceInvalid();
+	return found;
+}
+
+@interface TFSurfaceLayoutProbe : UIView
+@property (nonatomic, copy) dispatch_block_t changed;
+@end
+@implementation TFSurfaceLayoutProbe
+- (void)layoutSubviews { [super layoutSubviews]; if (self.changed) self.changed(); }
+- (void)didMoveToWindow { [super didMoveToWindow]; if (self.changed) self.changed(); }
+@end
+
+@interface TFSurfaceAttachment : NSObject <MLNMapViewDelegate>
+@property (nonatomic, copy) NSString *identifier;
+@property (nonatomic, strong) UIView *root;
+@property (nonatomic, strong) MLRNMapView *map;
+@property (nonatomic, weak) id<MLNMapViewDelegate> previous;
+@property (nonatomic, strong) TFSurfaceLayoutProbe *probe;
+@property (nonatomic, strong) TFNativeSurfaceState *state;
+@property (nonatomic, copy) NSString *token;
+@property (nonatomic, strong, nullable) NSArray *layoutSnapshot;
+@property (nonatomic, strong) NSMutableArray<dispatch_block_t> *detached;
+@property (nonatomic, copy, nullable) dispatch_block_t deadline;
+@property (nonatomic, copy, nullable) dispatch_block_t layoutCancel;
+@property (nonatomic) BOOL retiring;
+@property (nonatomic) BOOL foreground;
+@property (nonatomic) BOOL observing;
+- (void)attach;
+- (void)retire;
+- (BOOL)owns;
+- (MLNStyle *)style;
+- (NSDictionary *)view;
+- (void)sampleLayout;
+@end
+
+@implementation TFSurfaceAttachment
+- (BOOL)owns {
+	if (self.retiring || self.map.delegate != self) return NO;
+	@try { return TFSurfaceMap(self.root) == self.map; }
+	@catch (__unused NSException *exception) { return NO; }
+}
+- (NSString *)marker { return [@"__tileflow_native_style_" stringByAppendingString:self.token ?: @""]; }
+- (MLNStyle *)style { MLNStyle *style = self.map.style; return [style layerWithIdentifier:self.marker] ? style : nil; }
+- (NSDictionary *)view {
+	CLLocationCoordinate2D center = self.map.centerCoordinate;
+	double longitude = std::fmod(center.longitude + 540, 360) - 180;
+	double bearing = std::fmod(self.map.direction + 540, 360) - 180;
+	return @{@"center": @[@(longitude), @(center.latitude)], @"zoom": @(self.map.zoomLevel), @"bearing": @(bearing), @"pitch": @(self.map.camera.pitch)};
+}
+- (void)attach {
+	self.token = @""; self.detached = [NSMutableArray array]; self.previous = self.map.delegate;
+	if ([self.previous isKindOfClass:TFSurfaceAttachment.class]) TFSurfaceInvalid();
+	self.map.delegate = self;
+	[self.map addObserver:self forKeyPath:@"delegate" options:0 context:(__bridge void *)self]; self.observing = YES;
+	TFSurfaceLayoutProbe *probe = [[TFSurfaceLayoutProbe alloc] initWithFrame:self.root.bounds];
+	probe.userInteractionEnabled = NO; probe.accessibilityElementsHidden = YES; probe.alpha = 0;
+	probe.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+	__weak TFSurfaceAttachment *weakSelf = self;
+	probe.changed = ^{
+		TFSurfaceAttachment *owner = weakSelf;
+		if (!owner) return;
+		if (owner.retiring && !owner.root.window) {
+			NSArray *callbacks = [owner.detached copy]; [owner.detached removeAllObjects];
+			owner.probe.changed = nil; [owner.probe removeFromSuperview];
+			for (dispatch_block_t callback in callbacks) callback();
+		} else [owner sampleLayout];
+	};
+	self.probe = probe; [self.root addSubview:probe]; [self sampleLayout];
+}
+- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context {
+	if (context == (__bridge void *)self && object == self.map) {
+		if (!self.retiring && self.map.delegate != self) [self.state fail];
+		return;
+	}
+	[super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
+}
+- (void)sampleLayout {
+	if (self.retiring) return;
+	NSArray *snapshot = @[@(self.root.bounds.size.width), @(self.root.bounds.size.height), @(self.map.bounds.size.width), @(self.map.bounds.size.height),
+		@(self.root.frame.origin.x), @(self.root.frame.origin.y), @(self.root.window && self.map.window && self.foreground)];
+	if ([snapshot isEqual:self.layoutSnapshot]) return;
+	self.layoutSnapshot = snapshot;
+	BOOL visible = [snapshot.lastObject boolValue];
+	for (NSUInteger index = 0; index < 4; index++) visible = visible && [snapshot[index] doubleValue] > 0;
+	[self.state layout:visible];
+}
+- (void)retire {
+	if (self.retiring) return;
+	self.retiring = YES; [self.state close];
+	if (self.deadline) dispatch_block_cancel(self.deadline); self.deadline = nil;
+	if (self.layoutCancel) self.layoutCancel(); self.layoutCancel = nil;
+	if (self.observing) { [self.map removeObserver:self forKeyPath:@"delegate" context:(__bridge void *)self]; self.observing = NO; }
+	if (self.map.delegate == self) self.map.delegate = self.previous;
+	if (!self.root.window && self.probe.changed) self.probe.changed();
+}
+- (BOOL)respondsToSelector:(SEL)selector { return [super respondsToSelector:selector] || [self.previous respondsToSelector:selector]; }
+- (id)forwardingTargetForSelector:(SEL)selector { return [self.previous respondsToSelector:selector] ? self.previous : [super forwardingTargetForSelector:selector]; }
+- (void)mapView:(MLNMapView *)mapView didFinishLoadingStyle:(MLNStyle *)style {
+	if ([self owns] && style == self.style) [self.state loaded:self.token identity:style];
+	if ([self.previous respondsToSelector:_cmd]) [self.previous mapView:mapView didFinishLoadingStyle:style];
+}
+- (void)mapViewWillStartRenderingFrame:(MLNMapView *)mapView {
+	if ([self owns]) { [self sampleLayout]; [self.state frameStart:self.style]; }
+	if ([self.previous respondsToSelector:_cmd]) [self.previous mapViewWillStartRenderingFrame:mapView];
+}
+- (void)mapViewDidFinishRenderingMap:(MLNMapView *)mapView fullyRendered:(BOOL)fully {
+	if ([self.previous respondsToSelector:_cmd]) [self.previous mapViewDidFinishRenderingMap:mapView fullyRendered:fully];
+}
+- (void)mapViewDidFinishRenderingFrame:(MLNMapView *)mapView fullyRendered:(BOOL)fully {
+	if ([self owns]) [self.state frameEnd:self.style fully:fully];
+	if ([self.previous respondsToSelector:_cmd]) [self.previous mapViewDidFinishRenderingFrame:mapView fullyRendered:fully];
+}
+- (void)mapViewDidFinishRenderingFrame:(MLNMapView *)mapView fullyRendered:(BOOL)fully frameEncodingTime:(double)encoding frameRenderingTime:(double)rendering {
+	if ([self owns]) [self.state frameEnd:self.style fully:fully];
+	if ([self.previous respondsToSelector:_cmd]) [self.previous mapViewDidFinishRenderingFrame:mapView fullyRendered:fully frameEncodingTime:encoding frameRenderingTime:rendering];
+	else if ([self.previous respondsToSelector:@selector(mapViewDidFinishRenderingFrame:fullyRendered:)]) [self.previous mapViewDidFinishRenderingFrame:mapView fullyRendered:fully];
+}
+- (void)mapViewDidFinishRenderingFrame:(MLNMapView *)mapView fullyRendered:(BOOL)fully renderingStats:(MLNRenderingStats *)stats {
+	if ([self owns]) [self.state frameEnd:self.style fully:fully];
+	if ([self.previous respondsToSelector:_cmd]) [self.previous mapViewDidFinishRenderingFrame:mapView fullyRendered:fully renderingStats:stats];
+	else if ([self.previous respondsToSelector:@selector(mapViewDidFinishRenderingFrame:fullyRendered:)]) [self.previous mapViewDidFinishRenderingFrame:mapView fullyRendered:fully];
+}
+- (void)mapView:(MLNMapView *)mapView regionWillChangeWithReason:(MLNCameraChangeReason)reason animated:(BOOL)animated {
+	MLNCameraChangeReason gestures = MLNCameraChangeReasonResetNorth | MLNCameraChangeReasonGesturePan | MLNCameraChangeReasonGesturePinch |
+		MLNCameraChangeReasonGestureRotate | MLNCameraChangeReasonGestureZoomIn | MLNCameraChangeReasonGestureZoomOut |
+		MLNCameraChangeReasonGestureOneFingerZoom | MLNCameraChangeReasonGestureTilt;
+	if ([self owns]) { if (reason & gestures) [self.state gestureStart:self.view]; else [self.state gestureEnd:self.view]; }
+	if ([self.previous respondsToSelector:_cmd]) [self.previous mapView:mapView regionWillChangeWithReason:reason animated:animated];
+	else if ([self.previous respondsToSelector:@selector(mapView:regionWillChangeAnimated:)]) [self.previous mapView:mapView regionWillChangeAnimated:animated];
+}
+- (void)mapView:(MLNMapView *)mapView regionIsChangingWithReason:(MLNCameraChangeReason)reason {
+	if ([self owns]) [self.state gestureChange:self.view];
+	if ([self.previous respondsToSelector:_cmd]) [self.previous mapView:mapView regionIsChangingWithReason:reason];
+	else if ([self.previous respondsToSelector:@selector(mapViewRegionIsChanging:)]) [self.previous mapViewRegionIsChanging:mapView];
+}
+- (void)mapView:(MLNMapView *)mapView regionDidChangeWithReason:(MLNCameraChangeReason)reason animated:(BOOL)animated {
+	if ([self owns]) [self.state gestureEnd:self.view];
+	if ([self.previous respondsToSelector:_cmd]) [self.previous mapView:mapView regionDidChangeWithReason:reason animated:animated];
+	else if ([self.previous respondsToSelector:@selector(mapView:regionDidChangeAnimated:)]) [self.previous mapView:mapView regionDidChangeAnimated:animated];
+}
+- (NSString *)description { return @"TFSurfaceAttachment"; }
+@end
+
+@interface TileflowNativeSurface : RCTEventEmitter <RCTBridgeModule, RCTInvalidating>
+@property (nonatomic, strong) NSMutableDictionary<NSString *, TFSurfaceAttachment *> *surfaces;
+@property (nonatomic, strong) NSMutableDictionary<NSNumber *, TFSurfaceLayoutProbe *> *rootRetirements;
+@property (nonatomic) BOOL invalidated;
+@property (nonatomic) BOOL observing;
+@end
+@implementation TileflowNativeSurface
+RCT_EXPORT_MODULE(TileflowNativeSurface)
+@synthesize viewRegistry_DEPRECATED = _viewRegistry_DEPRECATED;
++ (BOOL)requiresMainQueueSetup { return YES; }
+- (dispatch_queue_t)methodQueue { return dispatch_get_main_queue(); }
+- (NSArray<NSString *> *)supportedEvents { return @[@"TileflowNativeSurfaceEvent"]; }
+- (void)startObserving { self.observing = YES; }
+- (void)stopObserving { self.observing = NO; }
+- (instancetype)init {
+	if ((self = [super init])) {
+		_surfaces = [NSMutableDictionary dictionary]; _rootRetirements = [NSMutableDictionary dictionary];
+		[NSNotificationCenter.defaultCenter addObserver:self selector:@selector(background:) name:UIApplicationWillResignActiveNotification object:nil];
+		[NSNotificationCenter.defaultCenter addObserver:self selector:@selector(foreground:) name:UIApplicationDidBecomeActiveNotification object:nil];
+	}
+	return self;
+}
+- (void)dealloc { [NSNotificationCenter.defaultCenter removeObserver:self]; }
+- (TFSurfaceAttachment *)current:(NSString *)identifier allowFailed:(BOOL)allowFailed {
+	TFSurfaceAttachment *surface = self.surfaces[identifier];
+	if (self.invalidated || !surface || ![surface owns] || (!allowFailed && !surface.state.active)) TFSurfaceInvalid();
+	return surface;
+}
+RCT_REMAP_METHOD(attachSurface, attachSurfaceWithTag:(NSNumber *)tag resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	@try {
+		TFSurfaceInteger(tag);
+		if (self.invalidated || !self.observing || !self.viewRegistry_DEPRECATED) TFSurfaceInvalid();
+		[self.viewRegistry_DEPRECATED addUIBlock:^(RCTViewRegistry *registry) {
+			@try {
+				if (self.invalidated || self.surfaces.count >= 16) TFSurfaceInvalid();
+				UIView *root = [registry viewForReactTag:tag];
+				if (!root || !root.window) TFSurfaceInvalid();
+				MLRNMapView *map = TFSurfaceMap(root);
+				for (TFSurfaceAttachment *existing in self.surfaces.allValues) if (existing.map == map) TFSurfaceInvalid();
+				TFSurfaceAttachment *surface = [TFSurfaceAttachment new];
+				surface.identifier = NSUUID.UUID.UUIDString; surface.root = root; surface.map = map;
+				surface.foreground = UIApplication.sharedApplication.applicationState == UIApplicationStateActive;
+				__weak TileflowNativeSurface *weakSelf = self;
+				__weak TFSurfaceAttachment *weakSurface = surface;
+				surface.state = [[TFNativeSurfaceState alloc] initWithSurface:surface.identifier emit:^(NSDictionary *event) {
+					TileflowNativeSurface *owner = weakSelf; TFSurfaceAttachment *attachment = weakSurface;
+					if (!attachment) return;
+					if ([event[@"kind"] isEqual:@"render"] && attachment.deadline) { dispatch_block_cancel(attachment.deadline); attachment.deadline = nil; }
+					if (!owner || owner.invalidated || !owner.observing) { [attachment.state close]; return; }
+					[owner sendEventWithName:@"TileflowNativeSurfaceEvent" body:event];
+				}];
+				self.surfaces[surface.identifier] = surface;
+				@try { [surface attach]; } @catch (NSException *exception) { [surface retire]; @throw; }
+				resolve(@{@"surface": surface.identifier});
+			} @catch (NSException *exception) { TFSurfaceReject(reject); }
+		}];
+	} @catch (NSException *exception) { TFSurfaceReject(reject); }
+}
+RCT_REMAP_METHOD(expectStyle, expectSurface:(NSString *)identifier style:(NSString *)token resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	@try {
+		TFSurfaceAttachment *surface = [self current:identifier allowFailed:YES];
+		[surface.state expect:token]; surface.token = token;
+		if (surface.deadline) dispatch_block_cancel(surface.deadline);
+		__weak TFSurfaceAttachment *weakSurface = surface;
+		dispatch_block_t deadline = dispatch_block_create((dispatch_block_flags_t)0, ^{
+			TFSurfaceAttachment *current = weakSurface;
+			if (current && !current.retiring && [current.token isEqual:token]) [current.state fail];
+		});
+		surface.deadline = deadline;
+		dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 30 * NSEC_PER_SEC), dispatch_get_main_queue(), deadline);
+		resolve(@{@"accepted": @YES});
+	} @catch (NSException *exception) { TFSurfaceReject(reject); }
+}
+RCT_REMAP_METHOD(acknowledgeSurface, acknowledgeSurface:(NSString *)identifier sequence:(NSNumber *)sequence resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	@try { if (!TFAdmissionValidToken(identifier)) TFSurfaceInvalid(); [self.surfaces[identifier].state acknowledge:TFSurfaceInteger(sequence)]; resolve(@{@"acknowledged": @YES}); }
+	@catch (NSException *exception) { TFSurfaceReject(reject); }
+}
+RCT_REMAP_METHOD(commitLayout, commitSurface:(NSString *)identifier style:(NSString *)token resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	@try {
+		TFSurfaceAttachment *surface = [self current:identifier allowFailed:NO];
+		if (surface.layoutCancel) TFSurfaceInvalid();
+		__block BOOL finished = NO;
+		void (^complete)(BOOL) = ^(BOOL success) {
+			if (finished) return; finished = YES; surface.layoutCancel = nil;
+			@try {
+				if (!success || [self current:identifier allowFailed:NO] != surface || ![surface.token isEqual:token]) TFSurfaceInvalid();
+				[surface sampleLayout]; resolve(@{@"layout": @([surface.state commit:token])});
+			} @catch (NSException *exception) { TFSurfaceReject(reject); }
+		};
+		surface.layoutCancel = ^{ complete(NO); };
+		[CATransaction begin];
+		[CATransaction setCompletionBlock:^{ complete(YES); }];
+		[surface.root setNeedsLayout]; [surface.root layoutIfNeeded];
+		[CATransaction commit];
+	} @catch (NSException *exception) { TFSurfaceReject(reject); }
+}
+RCT_REMAP_METHOD(requestFrame, requestFrameForSurface:(NSString *)identifier style:(NSString *)token resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	@try {
+		TFSurfaceAttachment *surface = [self current:identifier allowFailed:NO];
+		if (![surface.token isEqual:token]) TFSurfaceInvalid();
+		if (!surface.style) TFSurfaceInvalid();
+		[surface.state request:token];
+		[surface.map triggerRepaint];
+		resolve(@{@"requested": @YES});
+	} @catch (NSException *exception) { TFSurfaceReject(reject); }
+}
+RCT_REMAP_METHOD(applyCamera, applyCameraForSurface:(NSString *)identifier sequence:(NSNumber *)sequence view:(NSDictionary *)input resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	@try {
+		TFSurfaceAttachment *surface = [self current:identifier allowFailed:NO];
+		NSDictionary *target = TFSurfaceView(input); NSUInteger command = TFSurfaceInteger(sequence);
+		NSUInteger invalidation = [surface.state beginCommand:command];
+		if (!invalidation) TFSurfaceInvalid();
+		MLRNCamera *camera = TFSurfaceCamera(surface.root, surface.map);
+		// The pinned iOS CameraUpdateItem computes altitude before applying a changed pitch.
+		// Apply center/bearing/pitch first, then compute the exact zoom at that pitch.
+		NSMutableDictionary *pitchStop = [target mutableCopy];
+		[pitchStop removeObjectForKey:@"zoom"]; pitchStop[@"duration"] = @0;
+		[camera handleImperativeStop:pitchStop];
+		NSMutableDictionary *stop = [target mutableCopy]; stop[@"duration"] = @0;
+		[camera handleImperativeStop:stop];
+		NSDictionary *actual = surface.view;
+		for (NSString *key in @[@"zoom", @"pitch"]) if (std::abs([actual[key] doubleValue] - [target[key] doubleValue]) > 0.000001) TFSurfaceInvalid();
+		for (NSString *key in @[@"bearing"]) if (std::abs(std::fmod([actual[key] doubleValue] - [target[key] doubleValue] + 540, 360) - 180) > 0.000001) TFSurfaceInvalid();
+		if (std::abs(std::fmod([actual[@"center"][0] doubleValue] - [target[@"center"][0] doubleValue] + 540, 360) - 180) > 0.000001 ||
+			std::abs([actual[@"center"][1] doubleValue] - [target[@"center"][1] doubleValue]) > 0.000001 || [self current:identifier allowFailed:NO] != surface) TFSurfaceInvalid();
+		resolve(@{@"command": @(command), @"invalidation": @(invalidation), @"view": target});
+	} @catch (NSException *exception) { TFSurfaceReject(reject); }
+}
+RCT_REMAP_METHOD(cancelCamera, cancelCameraForSurface:(NSString *)identifier sequence:(NSNumber *)sequence resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	@try { if (!TFAdmissionValidToken(identifier)) TFSurfaceInvalid(); [self.surfaces[identifier].state cancelCommand:TFSurfaceInteger(sequence)]; resolve(@{@"cancelled": @YES}); }
+	@catch (NSException *exception) { TFSurfaceReject(reject); }
+}
+- (void)retire:(TFSurfaceAttachment *)surface resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
+	[surface retire];
+	if (!surface.root.window) { [self.surfaces removeObjectForKey:surface.identifier]; resolve(@{@"detached": @YES}); return; }
+	if (surface.detached.count >= 16) TFSurfaceInvalid();
+	__block BOOL completed = NO;
+	NSString *identifier = [surface.identifier copy];
+	__weak TileflowNativeSurface *weakSelf = self;
+	__weak TFSurfaceAttachment *weakSurface = surface;
+	[surface.detached addObject:^{
+		TileflowNativeSurface *owner = weakSelf;
+		TFSurfaceAttachment *attachment = weakSurface;
+		if (!owner || !attachment) return;
+		TFSurfaceAttachment *registered = owner.surfaces[identifier];
+		if (registered && registered != attachment) return;
+		if (registered == attachment) [owner.surfaces removeObjectForKey:identifier];
+		if (!completed) { completed = YES; resolve(@{@"detached": @YES}); }
+	}];
+	dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 30 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
+		if (!completed) { completed = YES; TFSurfaceReject(reject); }
+	});
+}
+RCT_REMAP_METHOD(retireSurface, retireSurfaceWithIdentifier:(NSString *)identifier resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	@try {
+		if (!TFAdmissionValidToken(identifier)) TFSurfaceInvalid();
+		TFSurfaceAttachment *surface = self.surfaces[identifier];
+		if (!surface) { resolve(@{@"detached": @YES}); return; }
+		[self retire:surface resolver:resolve rejecter:reject];
+	} @catch (NSException *exception) { TFSurfaceReject(reject); }
+}
+RCT_REMAP_METHOD(retireRoot, retireRootWithTag:(NSNumber *)tag resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	@try {
+		TFSurfaceInteger(tag);
+		if (!self.viewRegistry_DEPRECATED) TFSurfaceInvalid();
+		[self.viewRegistry_DEPRECATED addUIBlock:^(RCTViewRegistry *registry) {
+			@try {
+				UIView *root = [registry viewForReactTag:tag];
+				if (!root || !root.window) { resolve(@{@"detached": @YES}); return; }
+				for (TFSurfaceAttachment *surface in self.surfaces.allValues) if (surface.root == root) { [self retire:surface resolver:resolve rejecter:reject]; return; }
+				if (self.rootRetirements.count >= 16 || self.rootRetirements[tag]) TFSurfaceInvalid();
+				TFSurfaceLayoutProbe *probe = [[TFSurfaceLayoutProbe alloc] initWithFrame:CGRectZero];
+				probe.userInteractionEnabled = NO; probe.alpha = 0;
+				__block BOOL completed = NO;
+				__weak TileflowNativeSurface *weakSelf = self;
+				__weak TFSurfaceLayoutProbe *weakProbe = probe;
+				probe.changed = ^{
+					if (root.window) return;
+					[weakSelf.rootRetirements removeObjectForKey:tag]; weakProbe.changed = nil; [weakProbe removeFromSuperview];
+					if (!completed) { completed = YES; resolve(@{@"detached": @YES}); }
+				};
+				self.rootRetirements[tag] = probe; [root addSubview:probe];
+				dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 30 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{ if (!completed) { completed = YES; TFSurfaceReject(reject); } });
+			} @catch (NSException *exception) { TFSurfaceReject(reject); }
+		}];
+	} @catch (NSException *exception) { TFSurfaceReject(reject); }
+}
+- (void)background:(NSNotification *)notification { for (TFSurfaceAttachment *surface in self.surfaces.allValues) { surface.foreground = NO; [surface sampleLayout]; } }
+- (void)foreground:(NSNotification *)notification { for (TFSurfaceAttachment *surface in self.surfaces.allValues) { surface.foreground = YES; [surface sampleLayout]; } }
+- (void)invalidate {
+	[NSNotificationCenter.defaultCenter removeObserver:self];
+	dispatch_async(dispatch_get_main_queue(), ^{ self.invalidated = YES; for (TFSurfaceAttachment *surface in self.surfaces.allValues) [surface retire]; });
+	[super invalidate];
+}
+@end

package/ios/tileflow_native_admission.rb

@@ -0,0 +1,45 @@
+# Call after $MLRN.post_install(installer) in the existing local Podfile.
+# This only links the already configured pinned SPM product to this pod and
+# its local test targets. It never installs a shell phase or changes a pin.
+def tileflow_native_admission_post_install(installer)
+	project = installer.pods_project
+	url = 'https://github.com/maplibre/maplibre-gl-native-distribution'
+	version = '6.26.0'
+	refs = project.root_object.package_references.select do |reference|
+		reference.respond_to?(:repositoryURL) && reference.repositoryURL == url
+	end
+	raise 'Run MapLibre React Native post_install before Tileflow native admission' unless refs.length == 1
+	reference = refs.first
+	requirement = reference.requirement.transform_keys(&:to_s)
+	unless requirement == { 'kind' => 'exactVersion', 'version' => version }
+		raise 'Tileflow native admission requires the exact MapLibre Native 6.26.0 SPM product'
+	end
+	if defined?($MLRN_NATIVE_VERSION) && $MLRN_NATIVE_VERSION.to_s != version
+		raise 'Conflicting MapLibre Native version for Tileflow native admission'
+	end
+
+	targets = project.targets.select do |target|
+		target.is_a?(Xcodeproj::Project::Object::PBXNativeTarget) &&
+			(target.name == 'TileflowNativeAdmission' || target.name.start_with?('TileflowNativeAdmission-', 'AppHost-TileflowNativeAdmission-'))
+	end
+	raise 'TileflowNativeAdmission pod target is missing' unless targets.any? { |target| target.name == 'TileflowNativeAdmission' }
+	targets.each do |target|
+		products = target.package_product_dependencies.select { |product| product.product_name == 'MapLibre' }
+		if products.any? { |product| product.package != reference } || products.length > 1
+			raise 'Conflicting MapLibre product on Tileflow native admission target'
+		end
+		product = products.first
+		unless product
+			product = project.new(Xcodeproj::Project::Object::XCSwiftPackageProductDependency)
+			product.package = reference
+			product.product_name = 'MapLibre'
+			target.package_product_dependencies << product
+		end
+		phase = target.frameworks_build_phase
+		unless phase.files.any? { |file| file.respond_to?(:product_ref) && file.product_ref == product }
+			file = project.new(Xcodeproj::Project::Object::PBXBuildFile)
+			file.product_ref = product
+			phase.files << file
+		end
+	end
+end

package/package.json

@@ -1,19 +1,63 @@
 {
   "name": "@tileflow/react-native",
-  "version": "0.0.0-bootstrap.0",
-  "description": "Package registration for Tileflow React Native. Runtime releases use the alpha tag.",
+  "version": "0.1.0-alpha.0",
   "license": "Apache-2.0",
+  "description": "Tileflow maps, camera control and semantic interactions for React Native.",
+  "type": "module",
+  "sideEffects": false,
   "homepage": "https://tileflow.dev",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/tileflow/tileflow-sdk.git"
+    "url": "git+https://github.com/tileflow/tileflow-sdk.git",
+    "directory": "packages/react-native"
   },
   "bugs": {
     "url": "https://github.com/tileflow/tileflow-sdk/issues"
   },
-  "files": ["README.md", "LICENSE"],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "docs",
+    "android/build.gradle",
+    "android/src/main",
+    "ios/*.h",
+    "ios/*.mm",
+    "ios/*.rb",
+    "TileflowNativeAdmission.podspec",
+    "react-native.config.cjs",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@tileflow/core": ">=0.1.0-alpha.27 <0.1.0-beta.0",
+    "@tileflow/interactions": ">=0.1.0-alpha.4 <0.1.0-beta.0"
+  },
+  "peerDependencies": {
+    "@maplibre/maplibre-react-native": "11.3.10",
+    "react": "19.2.0",
+    "react-native": "0.83.10"
+  },
+  "devDependencies": {
+    "@maplibre/maplibre-react-native": "11.3.10",
+    "@types/react": "^19.2.17",
+    "react": "19.2.0",
+    "react-native": "0.83.10"
+  },
   "publishConfig": {
-    "access": "public",
-    "tag": "bootstrap"
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "tsx --test test/*.test.ts",
+    "verify": "pnpm run build && pnpm run typecheck && pnpm run test",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.contract.json",
+    "lint": "tsc -p tsconfig.json --noEmit"
   }
-}
+}

package/react-native.config.cjs

@@ -0,0 +1,13 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        sourceDir: 'android',
+        packageImportPath: 'import dev.tileflow.reactnative.TileflowNativeAdmissionPackage;',
+        packageInstance: 'new TileflowNativeAdmissionPackage()',
+      },
+      // The CLI discovers the sole podspec at the package root.
+      ios: {},
+    },
+  },
+};