@gitkraken/milestones-tools 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/) and this project adheres to [Semantic Versioning](https://semver.org/).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-07-09
+
+### Added
+
+- Initial scaffold of `@gitkraken/milestones-tools`, the v1 client library for the milestone and demographic surface of identity-service.
+- `MilestoneClient` (via `createMilestoneClient`) - loads achieved milestones (cached through the injected `StoragePort`), observes host actions against the embedded manifest, enqueues newly-detected milestones, flushes them to identity-service, and fires `onConfirmed` callbacks on acceptance.
+- `DemographicClient` (via `createDemographicClient`) - reads and writes the user's demographic metadata and the enum sets that constrain each field.
+- `createMilestonesClient` - one-call factory that wires both clients to a shared `MilestonesSdkConfig`.
+- Embedded canonical manifest (the v1 event taxonomy: `commit_created`, `branch_created`, `pull_request_created`, `ai_feature_used`) with `eventForMilestone` / `eventByName` helpers, validated with zod at module load.
+- Request-function transport: the host injects a `request(options) => { body, status, headers }` function (the GitKraken house pattern, e.g. `@gitkraken/provider-apis` via `contextFreeMakeRequest`); when omitted, a default `fetch`-based requester is used. The transport attaches a fresh bearer token per request and maps non-2xx (or enveloped-error) responses to a typed `HttpError`. String bodies are JSON-coerced before envelope unwrapping.
+- Durable, at-least-once action queue persisted through the `StoragePort`, with linear backoff retries and drop-on-422 (the milestone is not active yet, so backfill covers it).
+- Transport unwraps the identity-service `{ data, error }` response envelope (surfacing a non-null `error` as `HttpError`); `loadMilestones` maps the returned milestone array into the achieved map. Verified end-to-end against the dev environment.
+
+### Fixed
+
+- Serialized the cache read-modify-write sections of `recordAchieved` and `loadMilestones` so a confirmation and a refresh can no longer interleave and drop one another's writes to the achieved-state key; `loadMilestones` now merges server rows into the cached state instead of overwriting it.
+- A failed send no longer maps back to `done` via its bare status: a thrown `HttpError` (including a 2xx whose envelope carried an `error`) is never recorded as achieved. Terminal statuses (the 422 gate and other 4xx) drop instead of retrying to exhaustion; only transient statuses (408, 429, 5xx) retry.

package/LICENSE

@@ -0,0 +1,19 @@
+Core Tools License
+
+Copyright (c) 2025-2026 Axosoft, LLC dba GitKraken ("GitKraken")
+
+This software and associated documentation files (the "Software") may be compiled as part of GitKraken software products, including the gitkraken/vscode-gitlens open source project (collectively, the "GitKraken Products"), to the extent the Software is a required component of the GitKraken Products; provided, however, that the Software and its functionality may only be used if you (and any entity that you represent) have agreed to, and are in compliance with, the GitKraken End User License Agreement, available at https://gitkraken.com/eula (the "EULA"), or other agreement governing the use of the Software, as agreed by you and GitKraken, and otherwise have a valid subscription for the correct number of user seats for the applicable version of the Software (e.g., GitLens Free+, GitLens Pro, GitLens Teams, and GitLens Enterprise).
+
+The Software is licensed, not sold. This license only gives you some rights to use the Software. GitKraken reserves all other rights. Unless applicable law gives you more rights despite this limitation, you may use the Software only as expressly permitted in this license. In doing so, you must comply with any technical limitations in the Software that only allow you to use it in certain ways. You may not (i) work around any technical limitations in the Software, (ii) reverse engineer, decompile or disassemble the Software, or otherwise attempt to derive the source code for the Software, except and to the extent required by third party licensing terms governing use of certain open source components that may be included with the Software, (iii) remove, minimize, block or modify any notices of GitKraken or its suppliers in the Software, (iv) use the software in any way that is against the law, (v) host, share, publish, rent or lease the Software; (vi) distribute the Software as a stand-alone or integrated offering or combine it with any of your applications for others to use, (vii) use the Software other than in connection with validly licensed GitKraken Products or (viii) use any portion of the Software to create software with the same or similar functionality.
+
+You agree that GitKraken and/or its licensors (as applicable) retain all right, title and interest in and to the Software and all modifications and/or patches thereto. You are not granted any other rights beyond what is expressly stated herein. Except as set forth above, it is forbidden to copy, merge, publish, distribute, sublicense, modify and/or sell the Software.
+
+If you give feedback about the Software to GitKraken, you give to GitKraken, without charge, the right to use, share and commercialize your feedback in any way and for any purpose. You will not give feedback that is subject to a license that requires GitKraken to license its software or documentation to third parties because we include your feedback in them. These rights survive this License.
+
+The full text of this Core Tools License shall be included in all copies or substantial portions of the Software.
+
+This License and the EULA, if applicable, are the entire agreement for the Software. You must comply with all domestic and international export laws and regulations that apply to the Software, which include restrictions on destinations, end users and end use. This License is governed and construed by the laws of the State of Arizona, United States without regard to any choice or conflict of law principles or rules.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL GITKRAKEN, THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+For all third party components incorporated into the Software, those components are licensed under the original license provided by the owner of the applicable component.

package/README.md

@@ -0,0 +1,118 @@
+# @gitkraken/milestones-tools
+
+Client library for GitKraken user milestones and demographic metadata, served by identity-service.
+
+## What it is
+
+This package wraps the v1 milestone and demographic surface of identity-service in a runtime-agnostic client. It does two things:
+
+- **Milestones** - detects when a user earns a milestone (first commit, first branch, first PR, first AI event) from actions the host already observes, queues each detection durably, and confirms it with identity-service. Detection runs against an embedded copy of the canonical event manifest, so the client and the server agree on the taxonomy without a round-trip.
+- **Demographics** - reads and writes the user's demographic metadata and the enum sets that constrain each field.
+
+The library never performs HTTP itself, never reads a token from ambient state, and never persists anything directly. The host injects all three: a `request` function (the same `{ body, status, headers }` shape GitKraken's other client SDKs use, e.g. `@gitkraken/provider-apis`), a token getter, and a storage port.
+
+## Install
+
+```bash
+pnpm add @gitkraken/milestones-tools
+```
+
+## Provide the ports
+
+Everything the library needs from the outside world is passed through `MilestonesSdkConfig`:
+
+```typescript
+import { createMilestonesClient } from '@gitkraken/milestones-tools';
+
+const client = createMilestonesClient({
+    baseUrl: 'https://api.gitkraken.dev',
+    // Identifies the host surface reporting milestones (e.g. 'gitlens').
+    sourceClient: 'gitlens',
+    // Injected request function - omit to use a default fetch-based requester.
+    // Plug in your own (e.g. GitKraken's contextFreeMakeRequest) to own the network.
+    // `headers` is a Web `Headers` instance (case-insensitive lookups). A fetch
+    // response already exposes one; wrap a plain object with `new Headers(obj)`.
+    request: async ({ method, url, headers, body }) => {
+        const response = await myHttp({ method, url, headers, body });
+        return { body: response.body, status: response.status, headers: new Headers(response.headers) };
+    },
+    // Called per request to supply a fresh bearer token.
+    getToken: async () => await myAuth.getAccessToken(),
+    // Durable key/value store - back it with disk, localStorage, etc.
+    storage: {
+        get: async (key) => myStore.get(key) ?? null,
+        set: async (key, value) => myStore.set(key, value),
+        delete: async (key) => myStore.delete(key),
+    },
+    // Optional - how long loadMilestones() trusts its cache (default 5 min).
+    cacheTtlMs: 5 * 60 * 1000,
+    // Optional structured logger.
+    logger: console,
+});
+```
+
+`StoragePort` is the only stateful dependency. The library uses it to cache milestone state and to persist the pending-action queue, so detections survive process restarts and are delivered at least once.
+
+## Milestones
+
+```typescript
+const { milestones } = client;
+
+// Load the user's achieved milestones (cached for cacheTtlMs).
+const state = await milestones.loadMilestones();
+console.log(Object.keys(state.achieved));
+
+// Get notified when a queued milestone is confirmed by the server.
+const unsubscribe = milestones.onConfirmed((milestoneId) => {
+    showCelebration(milestoneId);
+});
+
+// Feed actions the host already observes. The client maps each action to a
+// milestone via the embedded manifest, skips ones already achieved, enqueues
+// the rest, and flushes to identity-service.
+await milestones.observe({
+    type: 'commit_created',
+    at: new Date().toISOString(),
+    payload: { surface_name: 'gitlens', kind: 'create' },
+});
+
+// Cheap local check against the cached state.
+if (await milestones.isAchieved('first_commit')) {
+    hideFirstCommitHint();
+}
+
+unsubscribe();
+```
+
+A `commit_created` with `kind` of `cherrypick` or `revert` does not earn `first_commit` - the embedded manifest's `milestone_filter` only credits `create` and `amend`. Unknown action types are ignored.
+
+## Demographics
+
+```typescript
+const { demographic } = client;
+
+const enums = await demographic.getEnums();
+const current = await demographic.get();
+const updated = await demographic.set({ role: 'softwareEngineer', gitComfortLevel: 'very' });
+```
+
+## Canonical manifest
+
+The canonical v1 event taxonomy is embedded in the package and exported as `manifest`, alongside the `eventForMilestone(milestoneId)` and `eventByName(name)` helpers. It is validated with zod at module load, so a malformed manifest fails fast rather than producing silent mis-detections.
+
+```typescript
+import { manifest, eventForMilestone } from '@gitkraken/milestones-tools';
+
+console.log(manifest.events.map((event) => event.event_name));
+console.log(eventForMilestone('first_commit')?.event_name); // 'commit_created'
+```
+
+## Contributing
+
+This package follows the monorepo's standard tooling - see the root [CONTRIBUTING.md](../../CONTRIBUTING.md). Local commands:
+
+```bash
+pnpm --filter @gitkraken/milestones-tools build
+pnpm --filter @gitkraken/milestones-tools typecheck
+pnpm --filter @gitkraken/milestones-tools test
+```

package/dist/client.d.ts

@@ -0,0 +1,14 @@
+import { MilestonesSdkConfig } from "./config.js";
+import { DemographicClient } from "./demographic/demographic-client.js";
+import { MilestoneClient } from "./milestones/milestone-client.js";
+
+//#region src/client.d.ts
+/** The milestone and demographic clients, wired to one shared config. */
+interface MilestonesClient {
+  milestones: MilestoneClient;
+  demographic: DemographicClient;
+}
+/** Constructs both the milestone and demographic clients from one SDK config. */
+declare function createMilestonesClient(config: MilestonesSdkConfig): MilestonesClient;
+//#endregion
+export { MilestonesClient, createMilestonesClient };

package/dist/client.js

@@ -0,0 +1 @@
+import{createDemographicClient as e}from"./demographic/demographic-client.js";import{createMilestoneClient as t}from"./milestones/milestone-client.js";function n(n){return{milestones:t(n),demographic:e(n)}}export{n as createMilestonesClient};

package/dist/config.d.ts

@@ -0,0 +1,37 @@
+import { ApiClientConfig } from "@gitkraken/api-tools";
+
+//#region src/config.d.ts
+/**
+ * Durable key/value store the library uses to cache milestone state and hold
+ * the pending-action queue. Implemented by the host (e.g. backed by disk,
+ * `localStorage`, or an in-memory map for tests).
+ */
+interface StoragePort {
+  get(key: string): Promise<string | null>;
+  set(key: string, value: string): Promise<void>;
+  delete(key: string): Promise<void>;
+}
+/** The host surfaces identity-service accepts as a milestone `sourceClient`. */
+declare const SourceClient: {
+  readonly GitKrakenClient: "GitKraken Client";
+  readonly GitLens: "gitlens";
+  readonly GitKrakenCliV2: "GitKraken CLI V2";
+};
+type SourceClient = (typeof SourceClient)[keyof typeof SourceClient];
+/**
+ * Configuration for the milestones and demographic clients. Composes the
+ * transport config from `@gitkraken/api-tools` (`baseUrl`, `getToken`,
+ * optional `request`/`logger`) and adds the milestone-specific fields.
+ *
+ * `request` is injected so the host owns the network (proxies, on-prem hosts,
+ * custom TLS); when omitted the library uses a default `fetch`-based requester.
+ * `getToken` is called per request to supply a fresh bearer token.
+ */
+interface MilestonesSdkConfig extends ApiClientConfig {
+  /** Identifies the host surface reporting milestones (e.g. `'gitlens'`). */
+  sourceClient: SourceClient;
+  storage: StoragePort;
+  cacheTtlMs?: number;
+}
+//#endregion
+export { MilestonesSdkConfig, SourceClient, StoragePort };

package/dist/config.js

@@ -0,0 +1 @@
+const e={GitKrakenClient:`GitKraken Client`,GitLens:`gitlens`,GitKrakenCliV2:`GitKraken CLI V2`};export{e as SourceClient};

package/dist/demographic/demographic-client.d.ts

@@ -0,0 +1,22 @@
+import { MilestonesSdkConfig } from "../config.js";
+import { DemographicEnums, DemographicInput, UserDemographic } from "./types.js";
+
+//#region src/demographic/demographic-client.d.ts
+/**
+ * Client for the v1 demographic surface of identity-service.
+ *
+ * Reads and writes the user's demographic metadata and the enum sets that
+ * constrain each field. Every call carries a bearer token.
+ */
+declare class DemographicClient {
+  private readonly transport;
+  constructor(config: MilestonesSdkConfig);
+  getEnums(signal?: AbortSignal): Promise<DemographicEnums>;
+  get(signal?: AbortSignal): Promise<UserDemographic>;
+  set(input: DemographicInput, signal?: AbortSignal): Promise<UserDemographic>;
+  private requireBody;
+}
+/** Constructs a {@link DemographicClient} from the SDK config. */
+declare function createDemographicClient(config: MilestonesSdkConfig): DemographicClient;
+//#endregion
+export { DemographicClient, createDemographicClient };

package/dist/demographic/demographic-client.js

@@ -0,0 +1 @@
+import{demographicEnumsSchema as e,userDemographicSchema as t}from"./schemas.js";import{HttpError as n,Transport as r}from"@gitkraken/api-tools";var i=class{transport;constructor(e){this.transport=new r(e)}async getEnums(t){return this.requireBody({method:`GET`,path:`/v1/demographic/enums`,signal:t,parse:t=>e.parse(t)})}async get(e){return this.requireBody({method:`GET`,path:`/v1/demographic`,signal:e,parse:e=>t.parse(e)})}async set(e,n){return this.requireBody({method:`POST`,path:`/v1/demographic`,body:e,signal:n,parse:e=>t.parse(e)})}async requireBody(e){let{data:t,status:r,headers:i}=await this.transport.request(e);if(t===void 0)throw new n(r,null,i);return t}};function a(e){return new i(e)}export{i as DemographicClient,a as createDemographicClient};

package/dist/demographic/schemas.d.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+
+//#region src/demographic/schemas.d.ts
+declare const userDemographicSchema: z.ZodObject<{
+  userId: z.ZodString;
+  role: z.ZodOptional<z.ZodEnum<{
+    softwareEngineer: "softwareEngineer";
+    engineeringManager: "engineeringManager";
+    devOps: "devOps";
+    dataAi: "dataAi";
+    designer: "designer";
+    productManager: "productManager";
+    student: "student";
+    educator: "educator";
+    hobbyist: "hobbyist";
+    other: "other";
+    none: "none";
+  }>>;
+  roleUpdatedAt: z.ZodOptional<z.ZodString>;
+  gitComfortLevel: z.ZodOptional<z.ZodEnum<{
+    notAtAll: "notAtAll";
+    somewhat: "somewhat";
+    very: "very";
+    extremely: "extremely";
+  }>>;
+  gitComfortLevelUpdatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const demographicEnumsSchema: z.ZodObject<{
+  role: z.ZodArray<z.ZodEnum<{
+    softwareEngineer: "softwareEngineer";
+    engineeringManager: "engineeringManager";
+    devOps: "devOps";
+    dataAi: "dataAi";
+    designer: "designer";
+    productManager: "productManager";
+    student: "student";
+    educator: "educator";
+    hobbyist: "hobbyist";
+    other: "other";
+    none: "none";
+  }>>;
+  gitComfortLevel: z.ZodArray<z.ZodEnum<{
+    notAtAll: "notAtAll";
+    somewhat: "somewhat";
+    very: "very";
+    extremely: "extremely";
+  }>>;
+}, z.core.$strip>;
+//#endregion
+export { demographicEnumsSchema, userDemographicSchema };

package/dist/demographic/schemas.js

@@ -0,0 +1 @@
+import{GitComfortLevel as e,UserRole as t}from"./types.js";import{z as n}from"zod";const r=n.enum(Object.values(t)),i=n.enum(Object.values(e)),a=n.object({userId:n.string(),role:r.optional(),roleUpdatedAt:n.string().optional(),gitComfortLevel:i.optional(),gitComfortLevelUpdatedAt:n.string().optional()}),o=n.object({role:n.array(r),gitComfortLevel:n.array(i)});export{o as demographicEnumsSchema,a as userDemographicSchema};

package/dist/demographic/types.d.ts

@@ -0,0 +1,47 @@
+//#region src/demographic/types.d.ts
+/** The user's self-reported role, as constrained by identity-service. */
+declare const UserRole: {
+  readonly SoftwareEngineer: "softwareEngineer";
+  readonly EngineeringManager: "engineeringManager";
+  readonly DevOps: "devOps";
+  readonly DataAi: "dataAi";
+  readonly Designer: "designer";
+  readonly ProductManager: "productManager";
+  readonly Student: "student";
+  readonly Educator: "educator";
+  readonly Hobbyist: "hobbyist";
+  readonly Other: "other";
+  readonly None: "none";
+};
+type UserRole = (typeof UserRole)[keyof typeof UserRole];
+/** The user's self-reported comfort with Git, as constrained by identity-service. */
+declare const GitComfortLevel: {
+  readonly NotAtAll: "notAtAll";
+  readonly Somewhat: "somewhat";
+  readonly Very: "very";
+  readonly Extremely: "extremely";
+};
+type GitComfortLevel = (typeof GitComfortLevel)[keyof typeof GitComfortLevel];
+/** The user's stored demographic metadata. */
+interface UserDemographic {
+  userId: string;
+  role?: UserRole;
+  roleUpdatedAt?: string;
+  gitComfortLevel?: GitComfortLevel;
+  gitComfortLevelUpdatedAt?: string;
+}
+/**
+ * The writable subset of {@link UserDemographic} accepted by `set`. Passing
+ * `'skip'` for `gitComfortLevel` clears the stored value server-side.
+ */
+interface DemographicInput {
+  role?: UserRole;
+  gitComfortLevel?: GitComfortLevel | 'skip';
+}
+/** The allowed values for each demographic field, as served by identity-service. */
+interface DemographicEnums {
+  role: UserRole[];
+  gitComfortLevel: GitComfortLevel[];
+}
+//#endregion
+export { DemographicEnums, DemographicInput, GitComfortLevel, UserDemographic, UserRole };

package/dist/demographic/types.js

@@ -0,0 +1 @@
+const e={SoftwareEngineer:`softwareEngineer`,EngineeringManager:`engineeringManager`,DevOps:`devOps`,DataAi:`dataAi`,Designer:`designer`,ProductManager:`productManager`,Student:`student`,Educator:`educator`,Hobbyist:`hobbyist`,Other:`other`,None:`none`},t={NotAtAll:`notAtAll`,Somewhat:`somewhat`,Very:`very`,Extremely:`extremely`};export{t as GitComfortLevel,e as UserRole};

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { MilestonesSdkConfig, SourceClient, StoragePort } from "./config.js";
+import { DemographicEnums, DemographicInput, GitComfortLevel, UserDemographic, UserRole } from "./demographic/types.js";
+import { DemographicClient, createDemographicClient } from "./demographic/demographic-client.js";
+import { CanonicalEventName, ClientAction, DetectionMethod, MilestoneAchieved, MilestoneId, MilestoneState, Unsubscribe } from "./milestones/types.js";
+import { DropCallback, DropReason, DurableQueue, QueueItem, SendOutcome, outcomeForError, outcomeForStatus } from "./milestones/queue.js";
+import { ConfirmedCallback, DroppedCallback, MilestoneClient, createMilestoneClient } from "./milestones/milestone-client.js";
+import { MilestonesClient, createMilestonesClient } from "./client.js";
+import { CanonicalEvent, Manifest, PayloadSchema, Surface, eventByName, eventForMilestone, manifest } from "./manifest/manifest.js";
+import { detect } from "./milestones/detection.js";
+import { ApiClientConfig, ApiRequest, ApiRequest as MilestonesRequest, ApiRequestOptions, ApiRequestOptions as MilestonesRequestOptions, ApiResponse, ApiResponse as MilestonesResponse, HttpError, LoggerPort, RequestInput } from "@gitkraken/api-tools";
+export { type ApiClientConfig, type ApiRequest, type ApiRequestOptions, type ApiResponse, type CanonicalEvent, CanonicalEventName, type ClientAction, type ConfirmedCallback, DemographicClient, type DemographicEnums, type DemographicInput, DetectionMethod, type DropCallback, type DropReason, type DroppedCallback, DurableQueue, GitComfortLevel, HttpError, type LoggerPort, type Manifest, type MilestoneAchieved, MilestoneClient, MilestoneId, type MilestoneState, type MilestonesClient, type MilestonesRequest, type MilestonesRequestOptions, type MilestonesResponse, type MilestonesSdkConfig, type PayloadSchema, type QueueItem, type RequestInput, type SendOutcome, SourceClient, type StoragePort, type Surface, type Unsubscribe, type UserDemographic, UserRole, createDemographicClient, createMilestoneClient, createMilestonesClient, detect, eventByName, eventForMilestone, manifest, outcomeForError, outcomeForStatus };

package/dist/index.js

@@ -0,0 +1 @@
+import{GitComfortLevel as e,UserRole as t}from"./demographic/types.js";import{DemographicClient as n,createDemographicClient as r}from"./demographic/demographic-client.js";import{eventByName as i,eventForMilestone as a,manifest as o}from"./manifest/manifest.js";import{detect as s}from"./milestones/detection.js";import{DurableQueue as c,outcomeForError as l,outcomeForStatus as u}from"./milestones/queue.js";import{CanonicalEventName as d,DetectionMethod as f,MilestoneId as p}from"./milestones/types.js";import{MilestoneClient as m,createMilestoneClient as h}from"./milestones/milestone-client.js";import{createMilestonesClient as g}from"./client.js";import{SourceClient as _}from"./config.js";import{HttpError as v}from"@gitkraken/api-tools";export{d as CanonicalEventName,n as DemographicClient,f as DetectionMethod,c as DurableQueue,e as GitComfortLevel,v as HttpError,m as MilestoneClient,p as MilestoneId,_ as SourceClient,t as UserRole,r as createDemographicClient,h as createMilestoneClient,g as createMilestonesClient,s as detect,i as eventByName,a as eventForMilestone,o as manifest,l as outcomeForError,u as outcomeForStatus};

package/dist/manifest/manifest.d.ts

@@ -0,0 +1,43 @@
+import { CanonicalEventName, MilestoneId } from "../milestones/types.js";
+
+//#region src/manifest/manifest.d.ts
+/** A milestone-emitting surface (GitKraken Client, GitLens, CLI V2). */
+interface Surface {
+  id: string;
+  service_name: string;
+  source_client: string;
+}
+/** A JSON-Schema-ish payload contract for a canonical event. */
+interface PayloadSchema {
+  type: 'object';
+  required: string[];
+  additionalProperties: boolean;
+  properties: Record<string, unknown>;
+}
+/**
+ * One canonical event in the v1 milestone taxonomy. `milestone_filter`
+ * narrows which payloads count toward the milestone (e.g. only commit kinds
+ * `create`/`amend` earn `first_commit`).
+ */
+interface CanonicalEvent {
+  event_name: CanonicalEventName;
+  milestone: MilestoneId;
+  description: string;
+  payload_schema: PayloadSchema;
+  milestone_filter: Record<string, string[]> | null;
+}
+/** The canonical manifest the client uses for real-time milestone detection. */
+interface Manifest {
+  version: string;
+  description: string;
+  surfaces: Surface[];
+  events: CanonicalEvent[];
+}
+/** The validated canonical manifest. Shape is parsed at module load. */
+declare const manifest: Manifest;
+/** Returns the canonical event whose `milestone` matches `milestoneId`, or `undefined`. */
+declare function eventForMilestone(milestoneId: MilestoneId): CanonicalEvent | undefined;
+/** Returns the canonical event whose `event_name` matches `name`, or `undefined`. */
+declare function eventByName(name: string): CanonicalEvent | undefined;
+//#endregion
+export { CanonicalEvent, Manifest, PayloadSchema, Surface, eventByName, eventForMilestone, manifest };

package/dist/manifest/manifest.data.d.ts

@@ -0,0 +1,105 @@
+//#region src/manifest/manifest.data.d.ts
+declare const manifestData: {
+  version: string;
+  description: string;
+  surfaces: {
+    id: string;
+    service_name: string;
+    source_client: string;
+  }[];
+  events: ({
+    event_name: "commit_created";
+    milestone: "first_commit";
+    description: string;
+    payload_schema: {
+      type: "object";
+      required: string[];
+      additionalProperties: true;
+      properties: {
+        surface_name: {
+          type: string;
+          enum: string[];
+        };
+        kind: {
+          type: string;
+          enum: string[];
+        };
+        client_version: {
+          type: string;
+        };
+        feature?: undefined;
+      };
+    };
+    milestone_filter: {
+      kind: string[];
+    };
+  } | {
+    event_name: "branch_created";
+    milestone: "first_branch";
+    description: string;
+    payload_schema: {
+      type: "object";
+      required: string[];
+      additionalProperties: true;
+      properties: {
+        surface_name: {
+          type: string;
+          enum: string[];
+        };
+        client_version: {
+          type: string;
+        };
+        kind?: undefined;
+        feature?: undefined;
+      };
+    };
+    milestone_filter: null;
+  } | {
+    event_name: "pull_request_created";
+    milestone: "first_pr";
+    description: string;
+    payload_schema: {
+      type: "object";
+      required: string[];
+      additionalProperties: true;
+      properties: {
+        surface_name: {
+          type: string;
+          enum: string[];
+        };
+        client_version: {
+          type: string;
+        };
+        kind?: undefined;
+        feature?: undefined;
+      };
+    };
+    milestone_filter: null;
+  } | {
+    event_name: "ai_feature_used";
+    milestone: "first_ai_event";
+    description: string;
+    payload_schema: {
+      type: "object";
+      required: string[];
+      additionalProperties: true;
+      properties: {
+        surface_name: {
+          type: string;
+          enum: string[];
+        };
+        feature: {
+          type: string;
+          enum: string[];
+        };
+        client_version: {
+          type: string;
+        };
+        kind?: undefined;
+      };
+    };
+    milestone_filter: null;
+  })[];
+};
+//#endregion
+export { manifestData };

package/dist/manifest/manifest.data.js

@@ -0,0 +1 @@
+const e={version:`1`,description:`Canonical event taxonomy for the v1 user milestone system. Each event has one canonical name across all surfaces (GitKraken Client, GitLens, GitKraken CLI V2). Surface teams emit these events going forward; the per-surface legacy events used for historical backfill live in backfill_legacy.json and are not part of this contract. Consumed by client SDKs (real-time milestone detection) and by forward-going Airflow compute DAGs.`,surfaces:[{id:`GitKraken Client`,service_name:`GitKraken Client`,source_client:`GitKraken Client`},{id:`gitlens`,service_name:`gitlens`,source_client:`gitlens`},{id:`GitKraken CLI V2`,service_name:`GitKraken CLI V2`,source_client:`GitKraken CLI V2`}],events:[{event_name:`commit_created`,milestone:`first_commit`,description:`Fired when the user completes a commit in any GitKraken surface. All kinds (including cherrypick and revert) count toward the commits aggregate. The first_commit milestone only counts kinds create and amend.`,payload_schema:{type:`object`,required:[`surface_name`,`kind`],additionalProperties:!0,properties:{surface_name:{type:`string`,enum:[`GitKraken Client`,`gitlens`,`GitKraken CLI V2`]},kind:{type:`string`,enum:[`create`,`amend`,`cherrypick`,`revert`]},client_version:{type:`string`}}},milestone_filter:{kind:[`create`,`amend`]}},{event_name:`branch_created`,milestone:`first_branch`,description:`Fired when the user creates a branch in any GitKraken surface.`,payload_schema:{type:`object`,required:[`surface_name`],additionalProperties:!0,properties:{surface_name:{type:`string`,enum:[`GitKraken Client`,`gitlens`,`GitKraken CLI V2`]},client_version:{type:`string`}}},milestone_filter:null},{event_name:`pull_request_created`,milestone:`first_pr`,description:`Fired when the user creates a pull request in any GitKraken surface. Emitted whether or not an AI feature was used to author the PR; AI usage is reported in parallel via ai_feature_used and is orthogonal to artifact creation.`,payload_schema:{type:`object`,required:[`surface_name`],additionalProperties:!0,properties:{surface_name:{type:`string`,enum:[`GitKraken Client`,`gitlens`,`GitKraken CLI V2`]},client_version:{type:`string`}}},milestone_filter:null},{event_name:`ai_feature_used`,milestone:`first_ai_event`,description:`Fired when the user invokes a supported AI feature. Independent of whether an artifact (commit, PR, etc.) is ultimately produced; the AI invocation itself is the tracked signal. feature is an advisory classification with an other catch-all, not a gate: any non-empty feature earns the milestone and counts toward the aggregate.`,payload_schema:{type:`object`,required:[`surface_name`,`feature`],additionalProperties:!0,properties:{surface_name:{type:`string`,enum:[`GitKraken Client`,`gitlens`,`GitKraken CLI V2`]},feature:{type:`string`,enum:[`commit_message`,`pr_description`,`explain`,`conflict_resolve`,`feedback`,`agent_hook`,`other`]},client_version:{type:`string`}}},milestone_filter:null}]};export{e as manifestData};

package/dist/manifest/manifest.js

@@ -0,0 +1 @@
+import{manifestData as e}from"./manifest.data.js";import{z as t}from"zod";const n=t.object({type:t.literal(`object`),required:t.array(t.string()),additionalProperties:t.boolean(),properties:t.record(t.string(),t.unknown())}),r=t.object({event_name:t.enum([`commit_created`,`branch_created`,`pull_request_created`,`ai_feature_used`]),milestone:t.enum([`first_commit`,`first_branch`,`first_pr`,`first_ai_event`]),description:t.string(),payload_schema:n,milestone_filter:t.record(t.string(),t.array(t.string())).nullable()}),i=t.object({version:t.string(),description:t.string(),surfaces:t.array(t.object({id:t.string(),service_name:t.string(),source_client:t.string()})).min(1),events:t.array(r).min(1)}).parse(e);function a(e){return i.events.find(t=>t.milestone===e)}function o(e){return i.events.find(t=>t.event_name===e)}export{o as eventByName,a as eventForMilestone,i as manifest};

package/dist/milestones/detection.d.ts

@@ -0,0 +1,17 @@
+import { ClientAction, MilestoneId } from "./types.js";
+import { Manifest } from "../manifest/manifest.js";
+
+//#region src/milestones/detection.d.ts
+/**
+ * Maps an observed action to the milestone it earns, or `null` when it earns
+ * none.
+ *
+ * The action's `type` must match a canonical event's `event_name`. When that
+ * event declares a `milestone_filter`, every listed field in the action's
+ * payload must hold one of the allowed values; otherwise the action counts
+ * toward the aggregate but does not earn the milestone. An unknown action type
+ * yields `null`.
+ */
+declare function detect(action: ClientAction, manifest: Manifest): MilestoneId | null;
+//#endregion
+export { detect };

package/dist/milestones/detection.js

@@ -0,0 +1 @@
+function e(e,n){let r=n.events.find(t=>t.event_name===e.type);return!r||!t(r,e)?null:r.milestone}function t(e,t){let n=e.milestone_filter;if(!n)return!0;let r=t.payload??{};for(let[e,t]of Object.entries(n)){let n=r[e];if(typeof n!=`string`||!t.includes(n))return!1}return!0}export{e as detect};

package/dist/milestones/milestone-client.d.ts

@@ -0,0 +1,56 @@
+import { MilestonesSdkConfig } from "../config.js";
+import { ClientAction, MilestoneId, MilestoneState, Unsubscribe } from "./types.js";
+import { DropReason } from "./queue.js";
+
+//#region src/milestones/milestone-client.d.ts
+/** Fired when identity-service confirms a queued milestone. */
+type ConfirmedCallback = (milestoneId: MilestoneId) => void;
+/** Fired when the queue drops a milestone terminally (server rejection or exhausted retries). */
+type DroppedCallback = (milestoneId: MilestoneId, reason: DropReason) => void;
+/**
+ * High-level client for the v1 milestone surface of identity-service.
+ *
+ * `loadMilestones` reads the user's achieved milestones (cached through the
+ * {@link StoragePort} for `cacheTtlMs`). `observe` runs an action through the
+ * embedded manifest, skips milestones already achieved, enqueues the rest, and
+ * triggers a flush. `onConfirmed` fires once when a milestone is first accepted
+ * by the server; `onDropped` fires when the queue gives up on an item.
+ */
+declare class MilestoneClient {
+  private readonly config;
+  private readonly transport;
+  private readonly queue;
+  private readonly manifest;
+  private readonly cacheTtlMs;
+  private readonly confirmedCallbacks;
+  private readonly droppedCallbacks;
+  private cacheChain;
+  constructor(config: MilestonesSdkConfig);
+  loadMilestones(options?: {
+    force?: boolean;
+    signal?: AbortSignal;
+  }): Promise<MilestoneState>;
+  isAchieved(milestoneId: MilestoneId): Promise<boolean>;
+  observe(action: ClientAction): Promise<void>;
+  flush(signal?: AbortSignal): Promise<void>;
+  onConfirmed(cb: ConfirmedCallback): Unsubscribe;
+  onDropped(cb: DroppedCallback): Unsubscribe;
+  private send;
+  private recordAchieved;
+  private emitConfirmed;
+  private emitDropped;
+  private readCache;
+  private writeCache;
+  /**
+   * Serializes the cache read-modify-write sections of `recordAchieved` and
+   * `loadMilestones` against each other so a confirmation and a refresh cannot
+   * interleave and drop one another's writes to `STATE_KEY`. The network fetch
+   * in `loadMilestones` stays outside this chain; only its merge-and-write runs
+   * inside.
+   */
+  private serializeCache;
+}
+/** Constructs a {@link MilestoneClient} from the SDK config. */
+declare function createMilestoneClient(config: MilestonesSdkConfig): MilestoneClient;
+//#endregion
+export { ConfirmedCallback, DroppedCallback, MilestoneClient, createMilestoneClient };

package/dist/milestones/milestone-client.js

@@ -0,0 +1 @@
+import{manifest as e}from"../manifest/manifest.js";import{detect as t}from"./detection.js";import{DurableQueue as n,outcomeForError as r,outcomeForStatus as i}from"./queue.js";import{milestoneAchievedListSchema as a}from"./schemas.js";import{Transport as o}from"@gitkraken/api-tools";const s=`gk.milestones.state.v1`;var c=class{config;transport;queue;manifest;cacheTtlMs;confirmedCallbacks=new Set;droppedCallbacks=new Set;cacheChain=Promise.resolve();constructor(t){this.config=t,this.transport=new o(t),this.queue=new n(t.storage,t.logger),this.manifest=e,this.cacheTtlMs=t.cacheTtlMs??3e5}async loadMilestones(e){if(!e?.force){let e=await this.readCache();if(e&&Date.now()-e.fetchedAt<this.cacheTtlMs)return e.state}let{data:t}=await this.transport.request({method:`GET`,path:`/v1/milestones`,signal:e?.signal,parse:e=>a.parse(e)});return this.serializeCache(async()=>{let e={...(await this.readCache())?.state.achieved??{}};for(let n of t??[])e[n.milestoneId]=n;let n={achieved:e};return await this.writeCache(n),n})}async isAchieved(e){return!!(await this.readCache())?.state.achieved[e]}async observe(e){let n=t(e,this.manifest);n&&(await this.isAchieved(n)||(await this.queue.enqueue({id:crypto.randomUUID(),milestoneId:n,action:{type:e.type,at:e.at,payload:e.payload}}),await this.flush()))}async flush(e){await this.queue.flush(t=>this.send(t,e),{onDrop:(e,t)=>this.emitDropped(e,t)})}onConfirmed(e){return this.confirmedCallbacks.add(e),()=>{this.confirmedCallbacks.delete(e)}}onDropped(e){return this.droppedCallbacks.add(e),()=>{this.droppedCallbacks.delete(e)}}async send(e,t){let n;try{n=i((await this.transport.request({method:`POST`,path:`/v1/milestones`,body:{milestone:e.milestoneId,sourceClient:this.config.sourceClient},signal:t})).status)}catch(t){if(!l(t))return this.config.logger?.warn(`milestone send failed before response`,{id:e.id,milestoneId:e.milestoneId,error:t}),{kind:`retry`};n=r(t.status)}return n.kind===`done`&&await this.recordAchieved(e.milestoneId)&&this.emitConfirmed(e.milestoneId),n}async recordAchieved(e){return this.serializeCache(async()=>{let t=(await this.readCache())?.state??{achieved:{}};return t.achieved[e]?!1:(t.achieved[e]={milestoneId:e,achievedAt:new Date().toISOString(),sourceSurface:this.config.sourceClient,detectionMethod:`live`},await this.writeCache(t),!0)})}emitConfirmed(e){for(let t of this.confirmedCallbacks)try{t(e)}catch(e){this.config.logger?.error(`onConfirmed callback threw`,e)}}emitDropped(e,t){for(let n of this.droppedCallbacks)try{n(e,t)}catch(e){this.config.logger?.error(`onDropped callback threw`,e)}}async readCache(){let e=await this.config.storage.get(s);if(!e)return null;try{return JSON.parse(e)}catch{return null}}async writeCache(e){let t={fetchedAt:Date.now(),state:e};await this.config.storage.set(s,JSON.stringify(t))}serializeCache(e){let t=this.cacheChain.then(e,e);return this.cacheChain=t.catch(()=>void 0),t}};function l(e){return typeof e==`object`&&!!e&&typeof e.status==`number`}function u(e){return new c(e)}export{c as MilestoneClient,u as createMilestoneClient};

package/dist/milestones/queue.d.ts

@@ -0,0 +1,66 @@
+import { StoragePort } from "../config.js";
+import { ClientAction, MilestoneId } from "./types.js";
+import { LoggerPort } from "@gitkraken/api-tools";
+
+//#region src/milestones/queue.d.ts
+/** Why an item left the queue without being confirmed. */
+type DropReason = 'rejected' | 'exhausted';
+/** Reports a milestone item that the queue dropped terminally. */
+type DropCallback = (milestoneId: MilestoneId, reason: DropReason) => void;
+/** A queued milestone action awaiting confirmation by identity-service. */
+interface QueueItem {
+  id: string;
+  milestoneId: MilestoneId;
+  action: ClientAction;
+  attempts: number;
+  nextAttemptAt: number;
+}
+/** The result of attempting to send one item to identity-service. */
+type SendOutcome = {
+  kind: 'done';
+  status: number;
+} | {
+  kind: 'drop';
+  status: number;
+} | {
+  kind: 'retry';
+  status?: number;
+};
+/** Maps the status of a successfully-resolved send (a clean 2xx) to an outcome. */
+declare function outcomeForStatus(status: number): SendOutcome;
+/**
+ * Maps the status of a *thrown* send (a non-2xx, or a 2xx whose envelope carried
+ * an `error`) to an outcome. A thrown send is never a success, so this never
+ * returns `done`: transient statuses (408, 429, 5xx) retry; everything else
+ * (the 422 activation gate, other 4xx, and a 2xx-with-error) drops terminally,
+ * since retrying cannot recover them.
+ */
+declare function outcomeForError(status: number): SendOutcome;
+/**
+ * A durable, at-least-once queue persisted through the {@link StoragePort}.
+ *
+ * `flush` walks the queue oldest-first, calling `send` for each item whose
+ * backoff window has elapsed. A `done` outcome removes the item; `drop` (a 422:
+ * the milestone is not active yet) also removes it, since retrying cannot
+ * succeed before the cutover flag flips and backfill covers pre-cutover
+ * actions; `retry` schedules the next attempt with linear backoff until
+ * `MAX_ATTEMPTS`, after which the item is dropped. Reads,
+ * mutations, and writes are serialized through an in-instance promise chain so
+ * concurrent `enqueue`/`flush` calls cannot lose an item.
+ */
+declare class DurableQueue {
+  private readonly storage;
+  private readonly logger?;
+  private chain;
+  constructor(storage: StoragePort, logger?: LoggerPort);
+  enqueue(item: Omit<QueueItem, 'attempts' | 'nextAttemptAt'>): Promise<void>;
+  flush(send: (item: QueueItem) => Promise<SendOutcome>, options?: {
+    now?: number;
+    onDrop?: DropCallback;
+  }): Promise<void>;
+  read(): Promise<QueueItem[]>;
+  private write;
+  private serialize;
+}
+//#endregion
+export { DropCallback, DropReason, DurableQueue, QueueItem, SendOutcome, outcomeForError, outcomeForStatus };

package/dist/milestones/queue.js

@@ -0,0 +1 @@
+const e=`gk.milestones.queue.v1`,t=`${e}.corrupt`;function n(e){return e===200||e===201?{kind:`done`,status:e}:e===422?{kind:`drop`,status:e}:{kind:`retry`,status:e}}function r(e){return e===408||e===429||e>=500?{kind:`retry`,status:e}:{kind:`drop`,status:e}}var i=class{storage;logger;chain=Promise.resolve();constructor(e,t){this.storage=e,this.logger=t}async enqueue(e){await this.serialize(async()=>{let t=await this.read();t.push({...e,attempts:0,nextAttemptAt:0}),await this.write(t)})}async flush(e,t){let n=t?.now??Date.now();await this.serialize(async()=>{let r=await this.read();if(r.length===0)return;let i=[];for(let a of r){if(a.nextAttemptAt>n){i.push(a);continue}let r;try{r=await e(a)}catch(e){this.logger?.warn(`milestone queue send threw`,e),r={kind:`retry`}}if(r.kind===`done`)continue;if(r.kind===`drop`){this.logger?.warn(`milestone queue item rejected; dropping`,{id:a.id,milestoneId:a.milestoneId,status:r.status}),t?.onDrop?.(a.milestoneId,`rejected`);continue}let o=a.attempts+1;if(o>=6){this.logger?.error(`milestone queue item exhausted retries`,{id:a.id,milestoneId:a.milestoneId,attempts:o}),t?.onDrop?.(a.milestoneId,`exhausted`);continue}i.push({...a,attempts:o,nextAttemptAt:n+o*1e3})}await this.write(i)})}async read(){let n=await this.storage.get(e);if(!n)return[];try{let e=JSON.parse(n);return Array.isArray(e)?e:[]}catch(r){return await this.storage.set(t,n),this.logger?.error(`milestone queue storage was corrupt; quarantined and dropped`,{key:e,corruptKey:t,raw:n,error:r}),[]}}async write(t){if(t.length===0){await this.storage.delete(e);return}await this.storage.set(e,JSON.stringify(t))}serialize(e){let t=this.chain.then(e,e);return this.chain=t.catch(()=>void 0),t}};export{i as DurableQueue,r as outcomeForError,n as outcomeForStatus};

package/dist/milestones/schemas.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+
+//#region src/milestones/schemas.d.ts
+declare const milestoneAchievedSchema: z.ZodObject<{
+  milestoneId: z.ZodEnum<{
+    first_commit: "first_commit";
+    first_branch: "first_branch";
+    first_pr: "first_pr";
+    first_ai_event: "first_ai_event";
+  }>;
+  achievedAt: z.ZodString;
+  sourceSurface: z.ZodString;
+  detectionMethod: z.ZodEnum<{
+    live: "live";
+    backfill: "backfill";
+    backfill_corrected: "backfill_corrected";
+  }>;
+}, z.core.$strip>;
+declare const milestoneAchievedListSchema: z.ZodNullable<z.ZodArray<z.ZodObject<{
+  milestoneId: z.ZodEnum<{
+    first_commit: "first_commit";
+    first_branch: "first_branch";
+    first_pr: "first_pr";
+    first_ai_event: "first_ai_event";
+  }>;
+  achievedAt: z.ZodString;
+  sourceSurface: z.ZodString;
+  detectionMethod: z.ZodEnum<{
+    live: "live";
+    backfill: "backfill";
+    backfill_corrected: "backfill_corrected";
+  }>;
+}, z.core.$strip>>>;
+//#endregion
+export { milestoneAchievedListSchema, milestoneAchievedSchema };

package/dist/milestones/schemas.js

@@ -0,0 +1 @@
+import{DetectionMethod as e,MilestoneId as t}from"./types.js";import{z as n}from"zod";const r=n.enum(Object.values(t)),i=n.enum(Object.values(e)),a=n.object({milestoneId:r,achievedAt:n.string(),sourceSurface:n.string(),detectionMethod:i}),o=n.array(a).nullable();export{o as milestoneAchievedListSchema,a as milestoneAchievedSchema};

package/dist/milestones/types.d.ts

@@ -0,0 +1,49 @@
+//#region src/milestones/types.d.ts
+/** How a milestone achievement was detected, as recorded by identity-service. */
+declare const DetectionMethod: {
+  readonly Live: "live";
+  readonly Backfill: "backfill";
+  readonly BackfillCorrected: "backfill_corrected";
+};
+type DetectionMethod = (typeof DetectionMethod)[keyof typeof DetectionMethod];
+/** A canonical event name in the v1 milestone taxonomy. */
+declare const CanonicalEventName: {
+  readonly CommitCreated: "commit_created";
+  readonly BranchCreated: "branch_created";
+  readonly PullRequestCreated: "pull_request_created";
+  readonly AiFeatureUsed: "ai_feature_used";
+};
+type CanonicalEventName = (typeof CanonicalEventName)[keyof typeof CanonicalEventName];
+/** The closed set of milestones a client can earn in the v1 taxonomy. */
+declare const MilestoneId: {
+  readonly FirstCommit: "first_commit";
+  readonly FirstBranch: "first_branch";
+  readonly FirstPr: "first_pr";
+  readonly FirstAiEvent: "first_ai_event";
+};
+type MilestoneId = (typeof MilestoneId)[keyof typeof MilestoneId];
+/** A single achieved milestone as reported by identity-service. */
+interface MilestoneAchieved {
+  milestoneId: MilestoneId;
+  achievedAt: string;
+  sourceSurface: string;
+  detectionMethod: DetectionMethod;
+}
+/** The user's full milestone state: which milestones have been achieved. */
+interface MilestoneState {
+  achieved: Partial<Record<MilestoneId, MilestoneAchieved>>;
+}
+/**
+ * An action the host observed, passed to {@link MilestoneClient.observe}. The
+ * `type` matches a canonical event name (e.g. `commit_created`); `payload`
+ * carries the fields the manifest filters against (e.g. commit `kind`).
+ */
+interface ClientAction {
+  type: CanonicalEventName;
+  at: string;
+  payload?: Record<string, unknown>;
+}
+/** Cancels a subscription registered via `onConfirmed`. */
+type Unsubscribe = () => void;
+//#endregion
+export { CanonicalEventName, ClientAction, DetectionMethod, MilestoneAchieved, MilestoneId, MilestoneState, Unsubscribe };

package/dist/milestones/types.js

@@ -0,0 +1 @@
+const e={Live:`live`,Backfill:`backfill`,BackfillCorrected:`backfill_corrected`},t={CommitCreated:`commit_created`,BranchCreated:`branch_created`,PullRequestCreated:`pull_request_created`,AiFeatureUsed:`ai_feature_used`},n={FirstCommit:`first_commit`,FirstBranch:`first_branch`,FirstPr:`first_pr`,FirstAiEvent:`first_ai_event`};export{t as CanonicalEventName,e as DetectionMethod,n as MilestoneId};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@gitkraken/milestones-tools",
+  "version": "0.1.0",
+  "description": "Client library for GitKraken user milestones and demographic metadata (identity-service).",
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "Axosoft, LLC dba GitKraken",
+  "engines": {
+    "node": ">= 22"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "zod": "^4.3.6",
+    "@gitkraken/api-tools": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.1"
+  },
+  "scripts": {
+    "build": "tsdown --config-loader=unrun",
+    "build:dev": "tsdown --config tsdown.dev.config.ts --config-loader=unrun",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}