@volter/twin-googlemaps 0.1.0

package/src/googlemaps-perform-harness.ts

@@ -0,0 +1,17 @@
+// A MINIATURE OF THE HEAD, for this pack's own claims and suites (protocol 2). Not on the serve path.
+import { confirmAction, deployableEntries, worldNow } from '@volter/world-core';
+import { pushGoogleMapsAction, type GoogleMapsExecute } from './googlemaps-connector.ts';
+
+export async function performPending(execute: GoogleMapsExecute, opts: { root?: string; occurredAt?: string } = {}): Promise<number> {
+  let pushed = 0;
+  for (const entry of deployableEntries('googlemaps', opts.root)) {
+    if (!(await pushGoogleMapsAction(entry, execute))) continue;
+    confirmAction({
+      service: 'googlemaps', actionId: entry.id, subject: entry.subject, fields: entry.fields ?? {},
+      occurredAt: opts.occurredAt ?? worldNow(), receipt: { status: 'deployed' },
+      ...(opts.root !== undefined ? { root: opts.root } : {}),
+    });
+    pushed += 1;
+  }
+  return pushed;
+}

package/src/googlemaps-server.ts

@@ -0,0 +1,33 @@
+// Google Maps twin HTTP server — serve the full Google Maps Platform twin handler over HTTP so
+// the real clients (pointed at this base URL) work unmodified.
+//
+// FETCH-FIRST (runtime contract R12b): the pack's whole HTTP surface is the plain fetch below,
+// built from the kernel's ONE adaptation (`createTwinFetchFromHandler` — manifest door, body
+// read, header map, worldNow() stamp, JSON reply). This file contributes only VALUES. The
+// server is one line of Bun.serve around that same closure, so the standalone (R1) and hosted
+// lanes execute identical serving bytes.
+import { serveHttp } from '@volter/world-core';
+import { handleGoogleMapsTwinRequest } from './googlemaps-twin.ts';
+import { createTwinFetchFromHandler, statefulTwinManifest } from '@volter/world-core';
+
+/** Options every Google Maps-twin HTTP surface needs, independent of who owns the socket. */
+export interface GoogleMapsTwinFetchOptions {
+  root?: string;
+  readOnly?: boolean;
+}
+
+export function createGoogleMapsTwinFetch(options: GoogleMapsTwinFetchOptions = {}): (request: Request) => Promise<Response> {
+  return createTwinFetchFromHandler(handleGoogleMapsTwinRequest, {
+    ...options,
+    manifest: statefulTwinManifest({ vendor: 'googlemaps', twinOf: 'the Google Maps Platform web services', stores: 'deterministic geocoding/places/roads answers derived from the request' }),
+  });
+}
+
+export async function createGoogleMapsTwinServer(options: { root?: string; port?: number; readOnly?: boolean } = {}): Promise<{ port: number; stop: () => void }> {
+  const server = await serveHttp({
+    port: options.port ?? 0,
+    idleTimeout: 60,
+    fetch: createGoogleMapsTwinFetch(options),
+  });
+  return { port: server.port ?? options.port ?? 0, stop: () => server.stop(true) };
+}