@knowledge-medium/agent-cli 0.1.0

package/dist/kernel-types/src/plugins/geo/LocationPropertyEditor.d.ts

@@ -0,0 +1,14 @@
+/** Property editor for the `location` reference.
+ *
+ *  Surfaces three actions:
+ *    1. Search — typeahead bundling local Places + Google Places. Pick
+ *       any result, route through `createOrFindPlace`, and write the
+ *       resolved Place id into `location`.
+ *    2. Drop pin — opens a small map for free-form coordinate pick;
+ *       creates an unnamed Place at those coords.
+ *    3. Clear — sets the property back to undefined.
+ *
+ *  The "Use current location" button is wired in Phase F. */
+import { type PropertyEditorProps } from '@/data/api';
+export declare const LocationPropertyEditor: ({ value, onChange, }: PropertyEditorProps<string | undefined>) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=LocationPropertyEditor.d.ts.map

package/dist/kernel-types/src/plugins/geo/LocationPropertyEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocationPropertyEditor.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/geo/LocationPropertyEditor.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;6DAU6D;AAU7D,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAwCrD,eAAO,MAAM,sBAAsB,GAAI,sBAGpC,mBAAmB,CAAC,MAAM,GAAG,SAAS,CAAC,4CA4LzC,CAAA"}

package/dist/kernel-types/src/plugins/geo/MapView.d.ts

@@ -0,0 +1,29 @@
+/** Map view component — renders pins for blocks under a root.
+ *
+ *  Single component, used both inline (over any block subtree, e.g. a
+ *  Place page's own mini-map) and globally (rooted at the Locations
+ *  page). The `placesUnderBlock` query handles both shapes uniformly —
+ *  Place blocks pin at their own coords, non-Place blocks with
+ *  `location` pin at the referenced Place's coords.
+ *
+ *  Click a marker → opens an InfoWindow with the place name, address,
+ *  and an "Open" button that navigates to the source block. This
+ *  preview-on-click pattern lets the user scan a busy map without
+ *  losing the map context.
+ *
+ *  Renders a graceful placeholder when the Google Maps API key is
+ *  missing — the picker UX in Phases C / E still works, the map just
+ *  doesn't render. */
+export interface MapViewProps {
+    rootBlockId: string;
+    /** Override the default sizing — pass e.g. `h-full w-full` for fill. */
+    className?: string;
+    /** Initial map zoom. Defaults to 11 (city-level) which suits the
+     *  global Locations map; per-Place mini-maps should pass ~15. */
+    defaultZoom?: number;
+}
+export declare function MapView(props: MapViewProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace MapView {
+    var displayName: string;
+}
+//# sourceMappingURL=MapView.d.ts.map

package/dist/kernel-types/src/plugins/geo/MapView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapView.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/geo/MapView.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;sBAesB;AAiBtB,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAA;IACnB,wEAAwE;IACxE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;qEACiE;IACjE,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AA+GD,wBAAgB,OAAO,CAAC,KAAK,EAAE,YAAY,2CAc1C;yBAde,OAAO"}

package/dist/kernel-types/src/plugins/geo/blockTypes.d.ts

@@ -0,0 +1,15 @@
+/** Geo-plugin block types. `PLACE_TYPE` blocks hold a single physical-
+ *  world location (Google POI or ad-hoc coord pin). `MAP_TYPE` is a
+ *  generic, user-applicable tag: any block carrying it gets a map of
+ *  the places under it via `geoContentDecorator`. The Locations page
+ *  ships with this type, but it is not special — the same tag added
+ *  to a trip page, an event, or any other block produces an inline
+ *  map rooted at that block.
+ *
+ *  Type id strings must match `PLACE_TYPE_ID` in `./properties.ts` —
+ *  duplicated as a literal there to break the import cycle. */
+import { type TypeContribution } from '@/data/api';
+export declare const PLACE_TYPE = "place";
+export declare const MAP_TYPE = "map";
+export declare const GEO_TYPE_CONTRIBUTIONS: readonly TypeContribution[];
+//# sourceMappingURL=blockTypes.d.ts.map

package/dist/kernel-types/src/plugins/geo/blockTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockTypes.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/geo/blockTypes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;+DAS+D;AAE/D,OAAO,EAAmB,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAInE,eAAO,MAAM,UAAU,UAAU,CAAA;AACjC,eAAO,MAAM,QAAQ,QAAQ,CAAA;AAE7B,eAAO,MAAM,sBAAsB,EAAE,SAAS,gBAAgB,EAiB7D,CAAA"}

package/dist/kernel-types/src/plugins/geo/codeMirrorExtensions.d.ts

@@ -0,0 +1,17 @@
+/** CodeMirror surface for the geo plugin: autocomplete theme + `@`
+ *  completion source contributed via `EditorState.languageData`. The
+ *  single central `autocompletion()` call (in
+ *  `src/extensions/editorAutocomplete.ts`) walks language data and
+ *  picks the source up.
+ *
+ *  Current-location flow: picking the sentinel does NOT auto-resolve —
+ *  it fetches geolocation + nearby POIs and re-opens the autocomplete
+ *  with that list plus "Drop pin at exact coords" and "Create named
+ *  place here…" fallbacks. The picker stage rides the same CM dropdown
+ *  via `startCompletion(view)` after stashing the candidates in the
+ *  closure. The session token, Google client, and resolver all live in
+ *  that closure (created per editor mount), so the billing session
+ *  boundary still matches "one `@` press' worth of interactions". */
+import type { CodeMirrorExtensionContribution } from '@/extensions/editor.js';
+export declare const geoCodeMirrorExtensions: CodeMirrorExtensionContribution;
+//# sourceMappingURL=codeMirrorExtensions.d.ts.map

package/dist/kernel-types/src/plugins/geo/codeMirrorExtensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeMirrorExtensions.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/geo/codeMirrorExtensions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;qEAaqE;AAMrE,OAAO,KAAK,EAEV,+BAA+B,EAChC,MAAM,wBAAwB,CAAA;AAkT/B,eAAO,MAAM,uBAAuB,EAAE,+BAMrC,CAAA"}

package/dist/kernel-types/src/plugins/geo/codecs.d.ts

@@ -0,0 +1,16 @@
+/** Plugin-local optional ref codec. Core's `codecs.ref` is non-optional
+ *  (`Codec<string>`); this is the absence-aware sibling, modeled on
+ *  `codecs.optionalString`. Kept inside the geo plugin until a second
+ *  consumer emerges — at which point promoting it to `codecs.optionalRef`
+ *  in [src/data/api/codecs.ts](../../data/api/codecs.ts) is a trivial
+ *  follow-up.
+ *
+ *  Carries the same `targetTypes` array as a regular `RefCodec` so the
+ *  property-panel ref-picker can constrain its candidate list. */
+import { type Codec, type RefCodecOptions } from '@/data/api/codecs';
+export interface OptionalRefCodec extends Codec<string | undefined> {
+    readonly type: 'ref';
+    readonly targetTypes: readonly string[];
+}
+export declare const optionalRefCodec: (options?: RefCodecOptions) => OptionalRefCodec;
+//# sourceMappingURL=codecs.d.ts.map

package/dist/kernel-types/src/plugins/geo/codecs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/geo/codecs.ts"],"names":[],"mappings":"AAAA;;;;;;;;kEAQkE;AAElE,OAAO,EAAc,KAAK,KAAK,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAEhF,MAAM,WAAW,gBAAiB,SAAQ,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC;IACjE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;CACxC;AAED,eAAO,MAAM,gBAAgB,GAAI,UAAU,eAAe,KAAG,gBAS3D,CAAA"}

package/dist/kernel-types/src/plugins/geo/createOrFindPlace.d.ts

@@ -0,0 +1,36 @@
+/** `createOrFindPlace` — alias-based dedup + Place block creation.
+ *  Single entry point used by the `@` autocomplete (Phase C), the
+ *  property editor (Phase E), and the current-location flow (Phase F).
+ *
+ *  Dedup rules:
+ *    - Google POI: aliases = [name, `place:<googlePlaceId>`]. The
+ *      machine-form alias is what we look up by — names drift, ids
+ *      don't.
+ *    - Ad-hoc coordinate pin: aliases = [`geo:<lat>,<lng>`] with lat/lng
+ *      rounded to 5 decimals (~1m precision). Two pins dropped at the
+ *      same spot dedup; exact-float dedup is brittle and an unwanted
+ *      strictness.
+ *
+ *  Locations page is bootstrapped lazily on first call. */
+import type { Block } from '@/data/block';
+import type { Repo } from '@/data/repo';
+/** Normalised candidate shape. `lat` / `lng` are always present —
+ *  callers without coords have no business invoking this. */
+export interface PlaceCandidate {
+    /** Display name. For ad-hoc pins this may be empty — caller-supplied
+     *  label if any, otherwise we fall back to the geo: alias as content
+     *  so the block still renders. */
+    name: string;
+    lat: number;
+    lng: number;
+    address?: string;
+    googlePlaceId?: string;
+    googleMapsUrl?: string;
+    website?: string;
+    phone?: string;
+    categories?: readonly string[];
+}
+/** Public for test access — same machine alias the lookup uses. */
+export declare const placeMachineAlias: (candidate: Pick<PlaceCandidate, "googlePlaceId" | "lat" | "lng">) => string;
+export declare const createOrFindPlace: (repo: Repo, workspaceId: string, candidate: PlaceCandidate) => Promise<Block>;
+//# sourceMappingURL=createOrFindPlace.d.ts.map

package/dist/kernel-types/src/plugins/geo/createOrFindPlace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createOrFindPlace.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/geo/createOrFindPlace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;2DAa2D;AAI3D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAiBvC;6DAC6D;AAC7D,MAAM,WAAW,cAAc;IAC7B;;sCAEkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/B;AAMD,mEAAmE;AACnE,eAAO,MAAM,iBAAiB,GAAI,WAAW,IAAI,CAAC,cAAc,EAAE,eAAe,GAAG,KAAK,GAAG,KAAK,CAAC,KAAG,MAGhC,CAAA;AAarE,eAAO,MAAM,iBAAiB,GAC5B,MAAM,IAAI,EACV,aAAa,MAAM,EACnB,WAAW,cAAc,KACxB,OAAO,CAAC,KAAK,CAsDf,CAAA"}

package/dist/kernel-types/src/plugins/geo/currentLocation.d.ts

@@ -0,0 +1,34 @@
+/** Browser-geolocation wrapper for the geo plugin.
+ *
+ *  Wraps `navigator.geolocation.getCurrentPosition` with three
+ *  improvements over the raw API:
+ *    - Promise-shaped instead of callback.
+ *    - Distinct error kinds (`'denied' | 'unavailable' | 'timeout'`)
+ *      via a typed `CurrentLocationError`, so callers can branch on
+ *      kind for the right UX message instead of pattern-matching on
+ *      the upstream error code enum.
+ *    - Optional `navigator` injection for tests — defaults to the
+ *      browser global. No app-side permission storage; the browser is
+ *      the source of truth.
+ *
+ *  We do NOT cache coords here. Phase F UX wants a fresh fix per pick
+ *  session (user might have moved); caching a stale fix would silently
+ *  pin to the wrong spot. */
+export interface CurrentLocation {
+    lat: number;
+    lng: number;
+    /** Accuracy radius in meters at 68% confidence (per the W3C spec). */
+    accuracy: number;
+}
+export type CurrentLocationErrorKind = 'denied' | 'unavailable' | 'timeout' | 'unsupported';
+export declare class CurrentLocationError extends Error {
+    readonly kind: CurrentLocationErrorKind;
+    constructor(kind: CurrentLocationErrorKind, message: string);
+}
+export interface GetCurrentPositionOptions {
+    timeoutMs?: number;
+    /** Override `navigator` (for tests). Defaults to the global. */
+    navigator?: Partial<Navigator>;
+}
+export declare const getCurrentPosition: (options?: GetCurrentPositionOptions) => Promise<CurrentLocation>;
+//# sourceMappingURL=currentLocation.d.ts.map

package/dist/kernel-types/src/plugins/geo/currentLocation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"currentLocation.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/geo/currentLocation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;6BAe6B;AAI7B,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,MAAM,wBAAwB,GAChC,QAAQ,GACR,aAAa,GACb,SAAS,GACT,aAAa,CAAA;AAEjB,qBAAa,oBAAqB,SAAQ,KAAK;aACjB,IAAI,EAAE,wBAAwB;gBAA9B,IAAI,EAAE,wBAAwB,EAAE,OAAO,EAAE,MAAM;CAI5E;AAED,MAAM,WAAW,yBAAyB;IACxC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,gEAAgE;IAChE,SAAS,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,CAAA;CAC/B;AAUD,eAAO,MAAM,kBAAkB,GAC7B,UAAS,yBAA8B,KACtC,OAAO,CAAC,eAAe,CA0BzB,CAAA"}

package/dist/kernel-types/src/plugins/geo/dataExtension.d.ts

@@ -0,0 +1,7 @@
+/** Data-layer contributions for the geo plugin — types, property
+ *  schemas, queries, and the CodeMirror surface (theme + `@`
+ *  completion source via languageData). Composed into the user-facing
+ *  `geoPlugin` in `./index.ts`. */
+import type { AppExtension } from '@/extensions/facet';
+export declare const geoDataExtension: AppExtension;
+//# sourceMappingURL=dataExtension.d.ts.map

package/dist/kernel-types/src/plugins/geo/dataExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataExtension.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/geo/dataExtension.ts"],"names":[],"mappings":"AAAA;;;mCAGmC;AAQnC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAMtD,eAAO,MAAM,gBAAgB,EAAE,YAK9B,CAAA"}

package/dist/kernel-types/src/plugins/geo/geoContentDecorator.d.ts

@@ -0,0 +1,18 @@
+/** Block content decorator that wraps any Place block or any block
+ *  tagged `MAP_TYPE` with the corresponding MapView. Replaces the
+ *  earlier `blockRenderersFacet`-based per-type renderer overrides: a
+ *  decorator composes with the default content renderer rather than
+ *  displacing it, so any future renderer the user picks for these
+ *  blocks still works and the map just rides on top.
+ *
+ *  `MAP_TYPE` is generic — users can add it to any block (a trip page,
+ *  an event, …) to get an inline map of every place in that subtree.
+ *  The shipping Locations page is just the default home for it.
+ *
+ *  Cached per inner renderer (and per kind) so React keeps a stable
+ *  component identity across re-renders — required by
+ *  `blockContentDecoratorsFacet` to avoid unmounting the inner subtree
+ *  on every parent render. */
+import { type BlockContentDecoratorContribution } from '@/extensions/blockInteraction.js';
+export declare const geoContentDecoratorContribution: BlockContentDecoratorContribution;
+//# sourceMappingURL=geoContentDecorator.d.ts.map

package/dist/kernel-types/src/plugins/geo/geoContentDecorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geoContentDecorator.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/geo/geoContentDecorator.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;8BAc8B;AAG9B,OAAO,EAEL,KAAK,iCAAiC,EACvC,MAAM,kCAAkC,CAAA;AAoDzC,eAAO,MAAM,+BAA+B,EAAE,iCAM7C,CAAA"}

package/dist/kernel-types/src/plugins/geo/googlePlacesClient.d.ts

@@ -0,0 +1,102 @@
+/** Thin wrapper around the Google Places API (New) for the geo plugin.
+ *  Exposes three operations:
+ *
+ *    - `autocomplete(input, ctx)`  — text-search suggestions for the `@`
+ *      and property-editor pickers.
+ *    - `getDetails(placeId, ctx)`  — full POI details for the user's
+ *      selection. Reuses the same `sessionToken` as the prior
+ *      autocomplete call so Google bills the pair as one unit.
+ *    - `searchNearby({lat, lng, radiusM}, ctx)` — distance-ranked POIs
+ *      near a coordinate. Drives the current-location picker (Phase F).
+ *
+ *  The client is stateless w.r.t. session tokens — callers create one
+ *  via `newSessionToken()` at the start of a picker session and pass it
+ *  through. That keeps the `@` autocomplete (one session per `@` press)
+ *  and the property editor (one session per editor open) independently
+ *  governed without coupling them through hidden client state.
+ *
+ *  Network access goes through an injected `fetch` impl (defaults to
+ *  the global `fetch`) so tests can mock at the module boundary without
+ *  monkey-patching `globalThis`. */
+export type FetchFn = typeof fetch;
+export interface GooglePlacesClientOptions {
+    apiKey: string;
+    fetchImpl?: FetchFn;
+}
+export interface AutocompleteContext {
+    sessionToken: string;
+    /** Optional bias — when set, results are ranked higher if they're
+     *  near `{lat, lng}` within `radiusM`. Used by the property editor
+     *  when the user has already dropped a pin. */
+    bias?: {
+        lat: number;
+        lng: number;
+        radiusM?: number;
+    };
+}
+export interface AutocompleteSuggestion {
+    placeId: string;
+    /** Primary label for the dropdown row. */
+    primary: string;
+    /** Secondary line — address / locality for disambiguation. */
+    secondary?: string;
+}
+export interface PlaceDetails {
+    placeId: string;
+    name: string;
+    lat: number;
+    lng: number;
+    address?: string;
+    googleMapsUrl?: string;
+    website?: string;
+    phone?: string;
+    categories: readonly string[];
+}
+export interface NearbyOptions {
+    lat: number;
+    lng: number;
+    /** Radius in meters; clamped to Google's accepted range [0, 50000]. */
+    radiusM?: number;
+    /** Max results; Google caps at 20 for nearby search. */
+    maxResults?: number;
+}
+export type NearbyCandidate = AutocompleteSuggestion & {
+    lat: number;
+    lng: number;
+    /** Distance from the query coordinate in meters; populated for
+     *  ranking and for "±18m" surfacing in the picker. */
+    distanceM: number;
+    googleMapsUrl?: string;
+    categories: readonly string[];
+};
+export declare class GooglePlacesError extends Error {
+    readonly kind: 'http' | 'network' | 'invalid-response';
+    readonly status: number | null;
+    constructor(kind: 'http' | 'network' | 'invalid-response', status: number | null, message: string);
+}
+/** Haversine distance, meters. Pure helper — exported for the
+ *  `searchNearby` post-process and for any future caller that wants to
+ *  surface accuracy bands. */
+export declare const haversineMeters: (a: {
+    lat: number;
+    lng: number;
+}, b: {
+    lat: number;
+    lng: number;
+}) => number;
+export interface GooglePlacesClient {
+    autocomplete(input: string, ctx: AutocompleteContext): Promise<AutocompleteSuggestion[]>;
+    getDetails(placeId: string, ctx: {
+        sessionToken?: string;
+    }): Promise<PlaceDetails>;
+    searchNearby(opts: NearbyOptions): Promise<NearbyCandidate[]>;
+}
+/** Per-session token. Google requires a UUID-shaped string; the actual
+ *  bytes are opaque — we just use the runtime's randomUUID. */
+export declare const newSessionToken: () => string;
+export declare const createGooglePlacesClient: (options: GooglePlacesClientOptions) => GooglePlacesClient;
+/** Resolve the Google Maps API key from the Vite env. Returns `null`
+ *  when missing — callers gate the autocomplete entirely (no Google
+ *  results, only local Place matches) rather than throwing. */
+export declare const resolveApiKey: () => string | null;
+//# sourceMappingURL=googlePlacesClient.d.ts.map

package/dist/kernel-types/src/plugins/geo/googlePlacesClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"googlePlacesClient.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/geo/googlePlacesClient.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;oCAmBoC;AA8BpC,MAAM,MAAM,OAAO,GAAG,OAAO,KAAK,CAAA;AAElC,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,MAAM,CAAA;IACpB;;mDAE+C;IAC/C,IAAI,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CACtD;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAA;IACf,0CAA0C;IAC1C,OAAO,EAAE,MAAM,CAAA;IACf,8DAA8D;IAC9D,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,SAAS,MAAM,EAAE,CAAA;CAC9B;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,uEAAuE;IACvE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,wDAAwD;IACxD,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,MAAM,eAAe,GAAG,sBAAsB,GAAG;IACrD,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX;0DACsD;IACtD,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,SAAS,MAAM,EAAE,CAAA;CAC9B,CAAA;AAED,qBAAa,iBAAkB,SAAQ,KAAK;aAExB,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,kBAAkB;aAC7C,MAAM,EAAE,MAAM,GAAG,IAAI;gBADrB,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,kBAAkB,EAC7C,MAAM,EAAE,MAAM,GAAG,IAAI,EACrC,OAAO,EAAE,MAAM;CAKlB;AASD;;8BAE8B;AAC9B,eAAO,MAAM,eAAe,GAC1B,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EAC/B,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,KAC9B,MAUF,CAAA;AA4BD,MAAM,WAAW,kBAAkB;IACjC,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAAA;IACxF,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE;QAAE,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,YAAY,CAAC,CAAA;IAClF,YAAY,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAAA;CAC9D;AAED;+DAC+D;AAC/D,eAAO,MAAM,eAAe,QAAO,MAOlC,CAAA;AAED,eAAO,MAAM,wBAAwB,GACnC,SAAS,yBAAyB,KACjC,kBAyIF,CAAA;AAED;;+DAE+D;AAC/D,eAAO,MAAM,aAAa,QAAO,MAAM,GAAG,IAGzC,CAAA"}

package/dist/kernel-types/src/plugins/geo/index.d.ts

@@ -0,0 +1,11 @@
+/** Geo plugin — physical-world location references. See the project
+ *  plan at [.claude/plans/compiled-wobbling-kahan.md] for the full
+ *  design.
+ *
+ *  Composes its dependencies (currently `referencesPlugin`) directly
+ *  into its `AppExtension` array. Facet-level dedup means listing the
+ *  same dependency in `staticAppExtensions` is harmless — order is
+ *  irrelevant. */
+import type { AppExtension } from '@/extensions/facet';
+export declare const geoPlugin: AppExtension;
+//# sourceMappingURL=index.d.ts.map

package/dist/kernel-types/src/plugins/geo/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/geo/index.ts"],"names":[],"mappings":"AAAA;;;;;;;kBAOkB;AAIlB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAOtD,eAAO,MAAM,SAAS,EAAE,YAYtB,CAAA"}

package/dist/kernel-types/src/plugins/geo/locationsPage.d.ts

@@ -0,0 +1,11 @@
+/** Locations-page bootstrap — singleton per workspace, lazy. Each Place
+ *  block lives as a child of this page. Created on demand by
+ *  `createOrFindPlace` (Phase C), never at workspace init — mirrors the
+ *  daily-notes lazy pattern rather than the kernel's
+ *  PROPERTIES_PAGE/TYPES_PAGE which are bootstrapped from the data
+ *  extension. */
+import type { Block } from '@/data/block';
+import type { Repo } from '@/data/repo';
+export declare const locationsPageBlockId: (workspaceId: string) => string;
+export declare const getOrCreateLocationsPage: (repo: Repo, workspaceId: string) => Promise<Block>;
+//# sourceMappingURL=locationsPage.d.ts.map

package/dist/kernel-types/src/plugins/geo/locationsPage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locationsPage.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/geo/locationsPage.ts"],"names":[],"mappings":"AAAA;;;;;iBAKiB;AAEjB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAUvC,eAAO,MAAM,oBAAoB,GAAI,aAAa,MAAM,KAAG,MACR,CAAA;AAEnD,eAAO,MAAM,wBAAwB,GAAI,MAAM,IAAI,EAAE,aAAa,MAAM,KAAG,OAAO,CAAC,KAAK,CAUpF,CAAA"}

package/dist/kernel-types/src/plugins/geo/pickCurrentLocation.d.ts

@@ -0,0 +1,23 @@
+/** Shared "use my current location" flow — used by both the `@`
+ *  autocomplete sentinel and the property editor's button.
+ *
+ *  v1 strategy: get a browser geolocation fix, run a nearby-POI search,
+ *  pick the closest candidate within 50m (so a casual fix doesn't snap
+ *  to a 200m-away coffee shop), fall back to an ad-hoc coord pin. The
+ *  full Embark-style "show a picker" UI is a follow-up.
+ *
+ *  Returns the resolved Place block, or `null` if the user denied
+ *  permission / no fix was obtained. */
+import type { Block } from '@/data/block';
+import type { Repo } from '@/data/repo';
+export interface PickCurrentLocationResult {
+    block: Block;
+    /** Accuracy radius from the browser fix in meters — surface this in
+     *  the UI as "±18m" so the user knows when to second-guess the snap. */
+    accuracyM: number;
+    /** True when we snapped to a Google POI; false when we dropped an
+     *  ad-hoc coord pin. */
+    snappedToPOI: boolean;
+}
+export declare const pickCurrentLocation: (repo: Repo, workspaceId: string) => Promise<PickCurrentLocationResult | null>;
+//# sourceMappingURL=pickCurrentLocation.d.ts.map

package/dist/kernel-types/src/plugins/geo/pickCurrentLocation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pickCurrentLocation.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/geo/pickCurrentLocation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;wCASwC;AAExC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAkBvC,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,KAAK,CAAA;IACZ;4EACwE;IACxE,SAAS,EAAE,MAAM,CAAA;IACjB;4BACwB;IACxB,YAAY,EAAE,OAAO,CAAA;CACtB;AAED,eAAO,MAAM,mBAAmB,GAC9B,MAAM,IAAI,EACV,aAAa,MAAM,KAClB,OAAO,CAAC,yBAAyB,GAAG,IAAI,CAsD1C,CAAA"}

package/dist/kernel-types/src/plugins/geo/placeAutocomplete.d.ts

@@ -0,0 +1,103 @@
+/** CodeMirror CompletionSource for the `@` place trigger.
+ *
+ *  Trigger shape: `@<query>` at start of line or after whitespace, with
+ *  no `[` in the query (so we don't fire inside `[[`) and no preceding
+ *  word character (so we don't fire mid-email `a@b`). The query may be
+ *  empty — that's the moment to surface the "Use current location"
+ *  sentinel (Phase F).
+ *
+ *  On select: the caller-supplied `resolvePlace` returns a
+ *  `PlaceResolveResult`. Two kinds:
+ *    - `{kind: 'insert', name}` → we replace the trigger span with
+ *      `[[<name>]]` (the references plugin picks up the wikilink).
+ *    - `{kind: 'handled'}` → the resolver dispatched its own change /
+ *      opened a follow-up picker; the source stays out of the way.
+ *  Returning `null` cancels the insertion (user dismissed a sub-prompt).
+ *
+ *  Follow-up pickers (Phase F current-location list) re-enter the
+ *  source via `consumePendingCandidates`: a one-shot stash of
+ *  candidates + span that the caller pushes from a candidate's apply
+ *  handler, then triggers `startCompletion(view)` so CM re-opens the
+ *  dropdown with the new list — no second UI to maintain.
+ *
+ *  The source is *pure* w.r.t. data access — it takes already-resolved
+ *  candidates and a `resolvePlace` callback. Wiring to the repo, the
+ *  Google client, and `createOrFindPlace` happens in the geo plugin's
+ *  CodeMirror extension. */
+import type { EditorView } from '@codemirror/view';
+import type { CompletionSource } from '@codemirror/autocomplete';
+export type PlaceCandidateSource = 'local' | 'google' | 'sentinel:current-location' | 'drop-pin' | 'create-named';
+export interface PlaceAutocompleteCandidate {
+    /** Stable id used for de-dup across sources and for picking. For local
+     *  candidates, the block id; for Google, the placeId; for sentinels, a
+     *  fixed string; for picker-stage candidates, includes the coords. */
+    id: string;
+    source: PlaceCandidateSource;
+    /** Display label for the dropdown row. */
+    label: string;
+    /** Optional secondary text (address, distance, etc.). */
+    detail?: string;
+    /** Final wikilink text to insert. For Google candidates this is set
+     *  during pick (after getDetails resolves the canonical name); for
+     *  local matches it's the existing block's name. */
+    insertText: string;
+    /** Coords stashed on picker-stage candidates (drop-pin, create-named)
+     *  so resolution can create the Place without re-fetching geolocation. */
+    coords?: {
+        lat: number;
+        lng: number;
+    };
+}
+export type PlaceResolveResult = {
+    kind: 'insert';
+    name: string;
+}
+/** Resolver handled the change itself (e.g. opened a follow-up
+ *  picker). Source skips the default `[[...]]` insertion. */
+ | {
+    kind: 'handled';
+} | null;
+export interface PlaceResolveContext {
+    view: EditorView;
+    /** Trigger span in the doc — same range CM passes to the apply
+     *  callback. Resolvers that re-open the dropdown should re-use this
+     *  span for the follow-up so the user's `@here` text stays in place. */
+    from: number;
+    to: number;
+}
+export interface PlaceAutocompleteOptions {
+    /** Callback to fetch candidates for the current query. Returns a list
+     *  in display order. Implementations bundle: local alias scan,
+     *  optionally Google autocomplete (gated by query length and API key),
+     *  and the current-location sentinel when appropriate. */
+    getCandidates: (query: string) => Promise<PlaceAutocompleteCandidate[]>;
+    /** Called when the user selects a candidate. Returns either an insert
+     *  spec, `{kind:'handled'}` if the resolver took ownership of the
+     *  change, or `null` to cancel. */
+    resolvePlace: (candidate: PlaceAutocompleteCandidate, ctx: PlaceResolveContext) => Promise<PlaceResolveResult>;
+    /** Optional one-shot stash drained at the top of every source call.
+     *  Used by follow-up pickers: a candidate's resolver stashes the next
+     *  round of candidates (with their target span) and calls
+     *  `startCompletion(view)`. The next invocation returns them
+     *  verbatim, bypassing `@` trigger detection. */
+    consumePendingCandidates?: () => {
+        span: {
+            from: number;
+            to: number;
+        };
+        candidates: PlaceAutocompleteCandidate[];
+    } | null;
+}
+interface TriggerMatch {
+    /** Character position in the doc where the `@` itself sits. The
+     *  inserted text replaces from here (so the `@` is removed). */
+    from: number;
+    /** The text typed after `@`, possibly empty. */
+    query: string;
+}
+/** Pure trigger-detection helper. Exported for direct testing — the
+ *  CompletionSource glue just adapts to CodeMirror's call shape. */
+export declare const matchAtTrigger: (text: string, pos: number) => TriggerMatch | null;
+export declare const placeCompletionSource: (options: PlaceAutocompleteOptions) => CompletionSource;
+export {};
+//# sourceMappingURL=placeAutocomplete.d.ts.map

package/dist/kernel-types/src/plugins/geo/placeAutocomplete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"placeAutocomplete.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/geo/placeAutocomplete.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;4BAyB4B;AAG5B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EAIV,gBAAgB,EACjB,MAAM,0BAA0B,CAAA;AAEjC,MAAM,MAAM,oBAAoB,GAC5B,OAAO,GACP,QAAQ,GACR,2BAA2B,GAC3B,UAAU,GACV,cAAc,CAAA;AAElB,MAAM,WAAW,0BAA0B;IACzC;;0EAEsE;IACtE,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,oBAAoB,CAAA;IAC5B,0CAA0C;IAC1C,KAAK,EAAE,MAAM,CAAA;IACb,yDAAyD;IACzD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;wDAEoD;IACpD,UAAU,EAAE,MAAM,CAAA;IAClB;8EAC0E;IAC1E,MAAM,CAAC,EAAE;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAC,CAAA;CACpC;AAED,MAAM,MAAM,kBAAkB,GAC1B;IAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC;AAChC;6DAC6D;GAC3D;IAAC,IAAI,EAAE,SAAS,CAAA;CAAC,GACjB,IAAI,CAAA;AAER,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,UAAU,CAAA;IAChB;;4EAEwE;IACxE,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;CACX;AAED,MAAM,WAAW,wBAAwB;IACvC;;;8DAG0D;IAC1D,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,0BAA0B,EAAE,CAAC,CAAA;IACvE;;uCAEmC;IACnC,YAAY,EAAE,CACZ,SAAS,EAAE,0BAA0B,EACrC,GAAG,EAAE,mBAAmB,KACrB,OAAO,CAAC,kBAAkB,CAAC,CAAA;IAChC;;;;qDAIiD;IACjD,wBAAwB,CAAC,EAAE,MAAM;QAC/B,IAAI,EAAE;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,EAAE,EAAE,MAAM,CAAA;SAAC,CAAA;QAChC,UAAU,EAAE,0BAA0B,EAAE,CAAA;KACzC,GAAG,IAAI,CAAA;CACT;AAED,UAAU,YAAY;IACpB;oEACgE;IAChE,IAAI,EAAE,MAAM,CAAA;IACZ,gDAAgD;IAChD,KAAK,EAAE,MAAM,CAAA;CACd;AAiBD;oEACoE;AACpE,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,EAAE,KAAK,MAAM,KAAG,YAAY,GAAG,IAwBzE,CAAA;AAyBD,eAAO,MAAM,qBAAqB,GAChC,SAAS,wBAAwB,KAChC,gBAsCF,CAAA"}

package/dist/kernel-types/src/plugins/geo/properties.d.ts

@@ -0,0 +1,33 @@
+/** Geo-plugin property schemas. All `place:*` fields live on Place
+ *  blocks (Google POIs and ad-hoc coordinate pins alike); `location` is
+ *  the typed reference property that any block can set to point at a
+ *  Place.
+ *
+ *  Storage rationale:
+ *    - `lat` / `lng` are stored as scalar numbers, not a `{lat, lng}`
+ *      blob. The `where` capability lives on primitive codecs only;
+ *      keeping coords scalar lets the map-view query stay on the typed-
+ *      query path instead of synthesising a json_extract clause.
+ *    - `googlePlaceId` and `googleMapsUrl` are both optional. Google POIs
+ *      created via the `@` autocomplete have the `ChIJ…` id; Roam
+ *      imports carry only the legacy `?cid=…` URL; ad-hoc pins have
+ *      neither.
+ *    - `categories` mirrors Google's `types[]` and Roam's `isa`. List of
+ *      strings for v1; promote to references to Category blocks if/when
+ *      a category tree is wanted.
+ */
+import { type PropertySchema } from '@/data/api';
+export declare const placeLatProp: PropertySchema<number | undefined>;
+export declare const placeLngProp: PropertySchema<number | undefined>;
+export declare const placeAddressProp: PropertySchema<string | undefined>;
+export declare const placeGooglePlaceIdProp: PropertySchema<string | undefined>;
+export declare const placeGoogleMapsUrlProp: PropertySchema<string | undefined>;
+export declare const placeWebsiteProp: PropertySchema<string | undefined>;
+export declare const placePhoneProp: PropertySchema<string | undefined>;
+export declare const placeCategoriesProp: PropertySchema<readonly string[]>;
+/** Reference from any block to a Place. Single ref for v1 — promote to
+ *  refList if multi-location-per-block becomes a real need. */
+export declare const locationProp: PropertySchema<string | undefined>;
+export declare const PLACE_PROPERTY_SCHEMAS: ReadonlyArray<PropertySchema<unknown>>;
+export declare const GEO_PROPERTY_SCHEMAS: ReadonlyArray<PropertySchema<unknown>>;
+//# sourceMappingURL=properties.d.ts.map

package/dist/kernel-types/src/plugins/geo/properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"properties.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/geo/properties.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAuC,KAAK,cAAc,EAAE,MAAM,YAAY,CAAA;AASrF,eAAO,MAAM,YAAY,oCAIvB,CAAA;AAEF,eAAO,MAAM,YAAY,oCAIvB,CAAA;AAEF,eAAO,MAAM,gBAAgB,oCAI3B,CAAA;AAEF,eAAO,MAAM,sBAAsB,oCAIjC,CAAA;AAEF,eAAO,MAAM,sBAAsB,oCAIjC,CAAA;AAEF,eAAO,MAAM,gBAAgB,oCAI3B,CAAA;AAEF,eAAO,MAAM,cAAc,oCAIzB,CAAA;AAEF,eAAO,MAAM,mBAAmB,mCAI9B,CAAA;AAEF;+DAC+D;AAC/D,eAAO,MAAM,YAAY,oCAIvB,CAAA;AAEF,eAAO,MAAM,sBAAsB,EAAE,aAAa,CAAC,cAAc,CAAC,OAAO,CAAC,CAS/B,CAAA;AAE3C,eAAO,MAAM,oBAAoB,EAAE,aAAa,CAAC,cAAc,CAAC,OAAO,CAAC,CAGvE,CAAA"}

package/dist/kernel-types/src/plugins/geo/propertyEditorOverrides.d.ts

@@ -0,0 +1,6 @@
+/** Per-name property editor overrides exposed by the geo plugin. Only
+ *  the `location` property needs one — the codec-based default editor
+ *  for refs (`RefPropertyEditor`) doesn't know how to call out to
+ *  Google Places. */
+export declare const locationPropertyEditorOverride: import("@/data/api").PropertyEditorOverride<string | undefined>;
+//# sourceMappingURL=propertyEditorOverrides.d.ts.map

package/dist/kernel-types/src/plugins/geo/propertyEditorOverrides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propertyEditorOverrides.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/geo/propertyEditorOverrides.ts"],"names":[],"mappings":"AAAA;;;qBAGqB;AAMrB,eAAO,MAAM,8BAA8B,iEAIzC,CAAA"}

package/dist/kernel-types/src/plugins/geo/query.d.ts

@@ -0,0 +1,48 @@
+/** Queries for the geo plugin.
+ *
+ *  `placesUnderBlock` — drives the map view. Given a root block id,
+ *  returns one pin per "block → Place" pairing found in the subtree:
+ *    - Place blocks (PLACE_TYPE) pin at their own lat/lng — so a map
+ *      rooted at the Locations page shows every Place.
+ *    - Non-Place blocks with `location` set pin at their referenced
+ *      Place's lat/lng — so a map rooted at a trip block shows every
+ *      activity that has a location.
+ *    - Non-Place blocks whose body content references a Place via a
+ *      wikilink or block-ref (`[[Dandelion]]`, `((uuid))`) pin at
+ *      that Place's lat/lng — so a casual mention of a place in a note
+ *      surfaces on the map without having to set the `location` prop.
+ *      Only body refs (`sourceField === ''`) participate; refs
+ *      projected from typed properties go through their own path.
+ *
+ *  A block that mentions the same place via both its `location` prop
+ *  and a body wikilink yields one pin (dedupped by target Place id).
+ *
+ *  Dependencies are declared per-row (catches descendant content,
+ *  property, and reference changes) + per-referenced-Place so the
+ *  query re-resolves whenever a descendant changes, a referenced Place
+ *  moves, or a block's `location` / body refs change. */
+export declare const PLACES_UNDER_BLOCK_QUERY = "geo.placesUnderBlock";
+export interface MapPin {
+    /** Source block (the thing being pinned — may be a Place or any
+     *  block that has a `location` ref). */
+    blockId: string;
+    /** The Place block whose coords we used. Same as `blockId` for
+     *  Place-typed sources, the referenced Place otherwise. */
+    placeId: string;
+    /** Display name — the Place's content, used as the marker label. */
+    name: string;
+    lat: number;
+    lng: number;
+    /** Formatted address from the referenced Place — used in marker
+     *  callouts. Undefined for ad-hoc coord pins. */
+    address?: string;
+}
+export declare const placesUnderBlockQuery: import("@/data/api").Query<{
+    rootBlockId: string;
+}, MapPin[]>;
+declare module '@/data/api' {
+    interface QueryRegistry {
+        [PLACES_UNDER_BLOCK_QUERY]: typeof placesUnderBlockQuery;
+    }
+}
+//# sourceMappingURL=query.d.ts.map

package/dist/kernel-types/src/plugins/geo/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/geo/query.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;yDAsByD;AAiBzD,eAAO,MAAM,wBAAwB,yBAAyB,CAAA;AAE9D,MAAM,WAAW,MAAM;IACrB;4CACwC;IACxC,OAAO,EAAE,MAAM,CAAA;IACf;+DAC2D;IAC3D,OAAO,EAAE,MAAM,CAAA;IACf,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX;qDACiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AA2CD,eAAO,MAAM,qBAAqB;iBAA6B,MAAM;YAqEnE,CAAA;AAEF,OAAO,QAAQ,YAAY,CAAC;IAC1B,UAAU,aAAa;QACrB,CAAC,wBAAwB,CAAC,EAAE,OAAO,qBAAqB,CAAA;KACzD;CACF"}