@ankhorage/contracts 25.0.1 → 25.2.0

package/src/auth.ts

@@ -1,4 +1,5 @@
 import type { ValueMap } from './collections';
+import type { DataSchema } from './data/schemas';
 import type { AppDeployTargetId } from './deploy';
 import type { AppEnvironmentId } from './environments';
 import type { SecretRef } from './secrets';
@@ -237,6 +238,171 @@ export interface VerifyOtpInput {
   metadata?: Record<string, unknown>;
 }
 
+/**
+ * Portable schema sources for the provider-neutral auth/session values and operation payloads.
+ *
+ * They describe the existing serializable contracts only. Auth execution, capability catalogs,
+ * adapter ports, and provider-specific configuration remain outside Contracts.
+ */
+export const AUTH_IDENTIFIER_SCHEMA = {
+  type: 'object',
+  required: ['kind', 'value'],
+  properties: {
+    kind: { type: 'string', enum: AUTH_IDENTIFIER_KINDS },
+    value: { type: 'string' },
+  },
+} as const satisfies DataSchema;
+
+export const AUTH_USER_SCHEMA = {
+  type: 'object',
+  required: ['id'],
+  properties: {
+    id: { type: 'string' },
+    email: { type: 'string' },
+    phone: { type: 'string' },
+    username: { type: 'string' },
+    displayName: { type: 'string' },
+    avatarUrl: { type: 'string' },
+    metadata: { type: 'object', additionalProperties: {} },
+  },
+} as const satisfies DataSchema;
+
+export const AUTH_SESSION_SCHEMA = {
+  type: 'object',
+  required: ['accessToken', 'user'],
+  properties: {
+    accessToken: { type: 'string' },
+    refreshToken: { type: 'string' },
+    expiresAt: { type: 'number' },
+    tokenType: { type: 'string' },
+    user: AUTH_USER_SCHEMA,
+  },
+} as const satisfies DataSchema;
+
+export const AUTH_ADAPTER_ERROR_SCHEMA = {
+  type: 'object',
+  required: ['code', 'message'],
+  properties: {
+    code: { type: 'string' },
+    message: { type: 'string' },
+    cause: {},
+  },
+} as const satisfies DataSchema;
+
+export const SIGN_IN_INPUT_SCHEMA = {
+  type: 'object',
+  required: ['identifier'],
+  properties: {
+    identifier: AUTH_IDENTIFIER_SCHEMA,
+    password: { type: 'string' },
+    otp: { type: 'string' },
+    redirectTo: { type: 'string' },
+    metadata: { type: 'object', additionalProperties: {} },
+  },
+} as const satisfies DataSchema;
+
+export const SIGN_UP_INPUT_SCHEMA = {
+  type: 'object',
+  required: ['identifier'],
+  properties: {
+    identifier: AUTH_IDENTIFIER_SCHEMA,
+    password: { type: 'string' },
+    profile: { type: 'object', additionalProperties: {} },
+    redirectTo: { type: 'string' },
+    metadata: { type: 'object', additionalProperties: {} },
+  },
+} as const satisfies DataSchema;
+
+export const SIGN_OUT_INPUT_SCHEMA = {
+  type: 'object',
+  properties: { allDevices: { type: 'boolean' } },
+} as const satisfies DataSchema;
+
+export const PASSWORD_RESET_INPUT_SCHEMA = {
+  type: 'object',
+  required: ['identifier'],
+  properties: {
+    identifier: AUTH_IDENTIFIER_SCHEMA,
+    redirectTo: { type: 'string' },
+  },
+} as const satisfies DataSchema;
+
+export const VERIFY_OTP_INPUT_SCHEMA = {
+  type: 'object',
+  required: ['identifier', 'token'],
+  properties: {
+    identifier: AUTH_IDENTIFIER_SCHEMA,
+    token: { type: 'string' },
+    redirectTo: { type: 'string' },
+    metadata: { type: 'object', additionalProperties: {} },
+  },
+} as const satisfies DataSchema;
+
+export const AUTH_SUCCESS_SCHEMA = {
+  type: 'object',
+  required: ['ok'],
+  properties: { ok: { const: true } },
+} as const satisfies DataSchema;
+
+export const AUTH_ERROR_RESULT_SCHEMA = {
+  type: 'object',
+  required: ['ok', 'error'],
+  properties: {
+    ok: { const: false },
+    error: AUTH_ADAPTER_ERROR_SCHEMA,
+  },
+} as const satisfies DataSchema;
+
+export const SIGN_IN_RESULT_SCHEMA = {
+  oneOf: [
+    {
+      ...AUTH_SUCCESS_SCHEMA,
+      properties: { ...AUTH_SUCCESS_SCHEMA.properties, data: AUTH_SESSION_SCHEMA },
+    },
+    AUTH_ERROR_RESULT_SCHEMA,
+  ],
+} as const satisfies DataSchema;
+
+export const SIGN_UP_RESULT_SCHEMA = {
+  oneOf: [
+    {
+      ...AUTH_SUCCESS_SCHEMA,
+      properties: {
+        ...AUTH_SUCCESS_SCHEMA.properties,
+        data: { oneOf: [AUTH_SESSION_SCHEMA, AUTH_USER_SCHEMA] },
+      },
+    },
+    AUTH_ERROR_RESULT_SCHEMA,
+  ],
+} as const satisfies DataSchema;
+
+export const AUTH_VOID_RESULT_SCHEMA = {
+  oneOf: [AUTH_SUCCESS_SCHEMA, AUTH_ERROR_RESULT_SCHEMA],
+} as const satisfies DataSchema;
+
+export const AUTH_SESSION_RESULT_SCHEMA = {
+  oneOf: [
+    {
+      ...AUTH_SUCCESS_SCHEMA,
+      properties: { ...AUTH_SUCCESS_SCHEMA.properties, data: AUTH_SESSION_SCHEMA },
+    },
+    AUTH_ERROR_RESULT_SCHEMA,
+  ],
+} as const satisfies DataSchema;
+
+export const AUTH_NULLABLE_SESSION_RESULT_SCHEMA = {
+  oneOf: [
+    {
+      ...AUTH_SUCCESS_SCHEMA,
+      properties: {
+        ...AUTH_SUCCESS_SCHEMA.properties,
+        data: { oneOf: [AUTH_SESSION_SCHEMA, { type: 'null' }] },
+      },
+    },
+    AUTH_ERROR_RESULT_SCHEMA,
+  ],
+} as const satisfies DataSchema;
+
 export const AUTH_OAUTH_ERROR_STAGES = [
   'start',
   'transport',
@@ -341,6 +507,143 @@ export interface CompleteOAuthAuthorizationInput {
   response: AuthOAuthAuthorizationResponse;
 }
 
+export const AUTH_EMPTY_INPUT_SCHEMA = {
+  type: 'object',
+} as const satisfies DataSchema;
+
+export const START_OAUTH_AUTHORIZATION_INPUT_SCHEMA = {
+  type: 'object',
+  required: ['provider', 'redirectUri'],
+  properties: {
+    provider: { type: 'string' },
+    redirectUri: { type: 'string' },
+    scopes: { type: 'array', items: { type: 'string' } },
+    queryParams: { type: 'object', additionalProperties: { type: 'string' } },
+  },
+} as const satisfies DataSchema;
+
+export const AUTH_OAUTH_AUTHORIZATION_REQUEST_SCHEMA = {
+  type: 'object',
+  required: ['attemptId', 'provider', 'authorizationUrl', 'redirectUri'],
+  properties: {
+    attemptId: { type: 'string' },
+    provider: { type: 'string' },
+    authorizationUrl: { type: 'string' },
+    redirectUri: { type: 'string' },
+  },
+} as const satisfies DataSchema;
+
+export const AUTH_OAUTH_ERROR_SCHEMA = {
+  type: 'object',
+  required: ['code', 'message', 'stage', 'recoverable'],
+  properties: {
+    code: { type: 'string', enum: AUTH_OAUTH_ERROR_CODES },
+    message: { type: 'string' },
+    cause: {},
+    stage: { type: 'string', enum: AUTH_OAUTH_ERROR_STAGES },
+    provider: { type: 'string' },
+    recoverable: { type: 'boolean' },
+  },
+} as const satisfies DataSchema;
+
+export const AUTH_OAUTH_START_RESULT_SCHEMA = {
+  oneOf: [
+    {
+      type: 'object',
+      required: ['ok', 'data'],
+      properties: {
+        ok: { const: true },
+        data: AUTH_OAUTH_AUTHORIZATION_REQUEST_SCHEMA,
+      },
+    },
+    {
+      type: 'object',
+      required: ['ok', 'error'],
+      properties: {
+        ok: { const: false },
+        error: AUTH_OAUTH_ERROR_SCHEMA,
+      },
+    },
+  ],
+} as const satisfies DataSchema;
+
+export const AUTH_OAUTH_AUTHORIZATION_RESPONSE_SCHEMA = {
+  oneOf: [
+    {
+      type: 'object',
+      required: ['type', 'url'],
+      properties: { type: { const: 'callback' }, url: { type: 'string' } },
+    },
+    {
+      type: 'object',
+      required: ['type', 'reason'],
+      properties: {
+        type: { const: 'cancelled' },
+        reason: { type: 'string', enum: AUTH_OAUTH_TRANSPORT_CANCELLATION_REASONS },
+      },
+    },
+    {
+      type: 'object',
+      required: ['type', 'error'],
+      properties: {
+        type: { const: 'error' },
+        error: {
+          type: 'object',
+          required: ['code', 'message'],
+          properties: {
+            code: { type: 'string', enum: AUTH_OAUTH_TRANSPORT_ERROR_CODES },
+            message: { type: 'string' },
+            cause: {},
+          },
+        },
+      },
+    },
+  ],
+} as const satisfies DataSchema;
+
+export const COMPLETE_OAUTH_AUTHORIZATION_INPUT_SCHEMA = {
+  type: 'object',
+  required: ['attemptId', 'response'],
+  properties: {
+    attemptId: { type: 'string' },
+    response: AUTH_OAUTH_AUTHORIZATION_RESPONSE_SCHEMA,
+  },
+} as const satisfies DataSchema;
+
+export const AUTH_OAUTH_COMPLETION_RESULT_SCHEMA = {
+  oneOf: [
+    {
+      type: 'object',
+      required: ['ok', 'status', 'provider', 'session'],
+      properties: {
+        ok: { const: true },
+        status: { const: 'authenticated' },
+        provider: { type: 'string' },
+        session: AUTH_SESSION_SCHEMA,
+      },
+    },
+    {
+      type: 'object',
+      required: ['ok', 'status', 'provider', 'reason'],
+      properties: {
+        ok: { const: false },
+        status: { const: 'cancelled' },
+        provider: { type: 'string' },
+        reason: { type: 'string', enum: AUTH_OAUTH_CANCELLATION_REASONS },
+      },
+    },
+    {
+      type: 'object',
+      required: ['ok', 'status', 'error'],
+      properties: {
+        ok: { const: false },
+        status: { const: 'error' },
+        error: AUTH_OAUTH_ERROR_SCHEMA,
+      },
+    },
+  ],
+} as const satisfies DataSchema;
+
 export type AuthOAuthCompletionResult =
   | {
       ok: true;

package/src/storage-schemas.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, it } from 'bun:test';
+
+import { isDataSchema } from './data';
+import {
+  STORAGE_ADAPTER_ERROR_SCHEMA,
+  STORAGE_ASSET_REFERENCE_SCHEMA,
+  STORAGE_BYTES_SCHEMA,
+  STORAGE_ERROR_RESULT_SCHEMA,
+  STORAGE_IDENTITY_SCHEMA,
+  STORAGE_LIST_INPUT_SCHEMA,
+  STORAGE_LIST_OPERATION_RESULT_SCHEMA,
+  STORAGE_LIST_RESULT_SCHEMA,
+  STORAGE_OBJECT_METADATA_SCHEMA,
+  STORAGE_PUBLIC_URL_INPUT_SCHEMA,
+  STORAGE_PUBLIC_URL_OPERATION_RESULT_SCHEMA,
+  STORAGE_PUBLIC_URL_RESULT_SCHEMA,
+  STORAGE_REMOVE_INPUT_SCHEMA,
+  STORAGE_RESOLVE_INPUT_SCHEMA,
+  STORAGE_RESOLVE_OPERATION_RESULT_SCHEMA,
+  STORAGE_RESOLVE_RESULT_SCHEMA,
+  STORAGE_RESOLVED_ASSET_SCHEMA,
+  STORAGE_SUCCESS_SCHEMA,
+  STORAGE_UPLOAD_INPUT_SCHEMA,
+  STORAGE_UPLOAD_OPERATION_RESULT_SCHEMA,
+  STORAGE_UPLOAD_RESULT_SCHEMA,
+  STORAGE_VOID_RESULT_SCHEMA,
+} from './storage';
+
+const STORAGE_SCHEMAS = [
+  STORAGE_BYTES_SCHEMA,
+  STORAGE_IDENTITY_SCHEMA,
+  STORAGE_ASSET_REFERENCE_SCHEMA,
+  STORAGE_OBJECT_METADATA_SCHEMA,
+  STORAGE_UPLOAD_INPUT_SCHEMA,
+  STORAGE_UPLOAD_RESULT_SCHEMA,
+  STORAGE_REMOVE_INPUT_SCHEMA,
+  STORAGE_PUBLIC_URL_INPUT_SCHEMA,
+  STORAGE_PUBLIC_URL_RESULT_SCHEMA,
+  STORAGE_LIST_INPUT_SCHEMA,
+  STORAGE_LIST_RESULT_SCHEMA,
+  STORAGE_RESOLVE_INPUT_SCHEMA,
+  STORAGE_RESOLVED_ASSET_SCHEMA,
+  STORAGE_RESOLVE_RESULT_SCHEMA,
+  STORAGE_ADAPTER_ERROR_SCHEMA,
+  STORAGE_SUCCESS_SCHEMA,
+  STORAGE_ERROR_RESULT_SCHEMA,
+  STORAGE_VOID_RESULT_SCHEMA,
+  STORAGE_UPLOAD_OPERATION_RESULT_SCHEMA,
+  STORAGE_PUBLIC_URL_OPERATION_RESULT_SCHEMA,
+  STORAGE_LIST_OPERATION_RESULT_SCHEMA,
+  STORAGE_RESOLVE_OPERATION_RESULT_SCHEMA,
+] as const;
+
+describe('storage capability schemas', () => {
+  it('publishes valid, serializable schema sources for every storage operation and value', () => {
+    expect(STORAGE_SCHEMAS.every(isDataSchema)).toBe(true);
+    expect(JSON.parse(JSON.stringify(STORAGE_SCHEMAS))).toEqual(STORAGE_SCHEMAS);
+  });
+
+  it('serializes upload bytes as standard Base64 without changing the adapter input contract', () => {
+    expect(STORAGE_UPLOAD_INPUT_SCHEMA.required).toEqual(['bucket', 'path', 'body']);
+    expect(STORAGE_UPLOAD_INPUT_SCHEMA.properties.body).toEqual({
+      type: 'string',
+      format: 'base64',
+    });
+  });
+
+  it('keeps public and signed resolution under the existing access selection', () => {
+    expect(STORAGE_RESOLVE_INPUT_SCHEMA.properties.access).toEqual({
+      type: 'string',
+      enum: ['public', 'signed'],
+    });
+    expect(STORAGE_RESOLVED_ASSET_SCHEMA.properties.access).toEqual({
+      type: 'string',
+      enum: ['public', 'signed'],
+    });
+  });
+
+  it('requires result data for non-void operations and keeps errors portable', () => {
+    expect(STORAGE_UPLOAD_OPERATION_RESULT_SCHEMA.oneOf[0].required).toEqual(['ok', 'data']);
+    expect(STORAGE_PUBLIC_URL_OPERATION_RESULT_SCHEMA.oneOf[0].required).toEqual(['ok', 'data']);
+    expect(STORAGE_LIST_OPERATION_RESULT_SCHEMA.oneOf[0].required).toEqual(['ok', 'data']);
+    expect(STORAGE_RESOLVE_OPERATION_RESULT_SCHEMA.oneOf[0].required).toEqual(['ok', 'data']);
+    expect(STORAGE_ADAPTER_ERROR_SCHEMA.properties).not.toHaveProperty('cause');
+  });
+});

package/src/storage.ts

@@ -1,3 +1,5 @@
+import type { DataSchema } from './data/schemas.js';
+
 export interface StorageAdapterError {
   code: string;
   message: string;
@@ -154,3 +156,198 @@ export interface StorageResolveAdapter {
  */
 export interface MediaStorageAdapter
   extends StorageAdapter, StorageListAdapter, StorageResolveAdapter {}
+
+/**
+ * Portable schema sources for provider-neutral storage values and operations.
+ *
+ * Upload bytes use a standard Base64 string. The source `StorageUploadInput` remains a
+ * `Uint8Array` at the adapter boundary; catalogs serialize its `body` with this schema and
+ * reconstruct the bytes before invoking an adapter.
+ */
+export const STORAGE_BYTES_SCHEMA = {
+  type: 'string',
+  format: 'base64',
+} as const satisfies DataSchema;
+
+export const STORAGE_IDENTITY_SCHEMA = {
+  type: 'object',
+  required: ['bucket', 'path'],
+  properties: {
+    storageId: { type: 'string' },
+    bucket: { type: 'string' },
+    path: { type: 'string' },
+  },
+} as const satisfies DataSchema;
+
+export const STORAGE_ASSET_REFERENCE_SCHEMA = {
+  ...STORAGE_IDENTITY_SCHEMA,
+  properties: {
+    ...STORAGE_IDENTITY_SCHEMA.properties,
+    publicUrl: { type: 'string' },
+  },
+} as const satisfies DataSchema;
+
+export const STORAGE_OBJECT_METADATA_SCHEMA = {
+  ...STORAGE_IDENTITY_SCHEMA,
+  properties: {
+    ...STORAGE_IDENTITY_SCHEMA.properties,
+    contentType: { type: 'string' },
+    sizeBytes: { type: 'integer' },
+    createdAt: { type: 'string' },
+    updatedAt: { type: 'string' },
+    etag: { type: 'string' },
+  },
+} as const satisfies DataSchema;
+
+export const STORAGE_UPLOAD_INPUT_SCHEMA = {
+  ...STORAGE_IDENTITY_SCHEMA,
+  required: ['bucket', 'path', 'body'],
+  properties: {
+    ...STORAGE_IDENTITY_SCHEMA.properties,
+    body: STORAGE_BYTES_SCHEMA,
+    contentType: { type: 'string' },
+    cacheControl: { type: 'string' },
+    upsert: { type: 'boolean' },
+  },
+} as const satisfies DataSchema;
+
+export const STORAGE_UPLOAD_RESULT_SCHEMA = {
+  type: 'object',
+  required: ['asset'],
+  properties: { asset: STORAGE_ASSET_REFERENCE_SCHEMA },
+} as const satisfies DataSchema;
+
+export const STORAGE_REMOVE_INPUT_SCHEMA = {
+  ...STORAGE_IDENTITY_SCHEMA,
+  description: 'Identifies the stored object to remove.',
+} as const satisfies DataSchema;
+
+export const STORAGE_PUBLIC_URL_INPUT_SCHEMA = {
+  ...STORAGE_IDENTITY_SCHEMA,
+  description: 'Identifies the stored object whose public URL is requested.',
+} as const satisfies DataSchema;
+
+export const STORAGE_PUBLIC_URL_RESULT_SCHEMA = {
+  type: 'object',
+  required: ['publicUrl'],
+  properties: { publicUrl: { type: 'string' } },
+} as const satisfies DataSchema;
+
+export const STORAGE_LIST_INPUT_SCHEMA = {
+  type: 'object',
+  required: ['bucket'],
+  properties: {
+    storageId: { type: 'string' },
+    bucket: { type: 'string' },
+    prefix: { type: 'string' },
+    cursor: { type: 'string' },
+    limit: { type: 'integer' },
+  },
+} as const satisfies DataSchema;
+
+export const STORAGE_LIST_RESULT_SCHEMA = {
+  type: 'object',
+  required: ['objects'],
+  properties: {
+    objects: { type: 'array', items: STORAGE_OBJECT_METADATA_SCHEMA },
+    nextCursor: { type: 'string' },
+  },
+} as const satisfies DataSchema;
+
+export const STORAGE_RESOLVE_INPUT_SCHEMA = {
+  ...STORAGE_IDENTITY_SCHEMA,
+  properties: {
+    ...STORAGE_IDENTITY_SCHEMA.properties,
+    access: { type: 'string', enum: ['public', 'signed'] },
+    expiresInSeconds: { type: 'integer' },
+  },
+} as const satisfies DataSchema;
+
+export const STORAGE_RESOLVED_ASSET_SCHEMA = {
+  ...STORAGE_IDENTITY_SCHEMA,
+  required: ['bucket', 'path', 'url', 'access'],
+  properties: {
+    ...STORAGE_IDENTITY_SCHEMA.properties,
+    url: { type: 'string' },
+    access: { type: 'string', enum: ['public', 'signed'] },
+    expiresAt: { type: 'string' },
+  },
+} as const satisfies DataSchema;
+
+export const STORAGE_RESOLVE_RESULT_SCHEMA = {
+  type: 'object',
+  required: ['asset'],
+  properties: { asset: STORAGE_RESOLVED_ASSET_SCHEMA },
+} as const satisfies DataSchema;
+
+export const STORAGE_ADAPTER_ERROR_SCHEMA = {
+  type: 'object',
+  required: ['code', 'message'],
+  properties: {
+    code: { type: 'string' },
+    message: { type: 'string' },
+  },
+} as const satisfies DataSchema;
+
+export const STORAGE_SUCCESS_SCHEMA = {
+  type: 'object',
+  required: ['ok'],
+  properties: { ok: { const: true } },
+} as const satisfies DataSchema;
+
+export const STORAGE_ERROR_RESULT_SCHEMA = {
+  type: 'object',
+  required: ['ok', 'error'],
+  properties: {
+    ok: { const: false },
+    error: STORAGE_ADAPTER_ERROR_SCHEMA,
+  },
+} as const satisfies DataSchema;
+
+export const STORAGE_VOID_RESULT_SCHEMA = {
+  oneOf: [STORAGE_SUCCESS_SCHEMA, STORAGE_ERROR_RESULT_SCHEMA],
+} as const satisfies DataSchema;
+
+export const STORAGE_UPLOAD_OPERATION_RESULT_SCHEMA = {
+  oneOf: [
+    {
+      ...STORAGE_SUCCESS_SCHEMA,
+      required: ['ok', 'data'],
+      properties: { ...STORAGE_SUCCESS_SCHEMA.properties, data: STORAGE_UPLOAD_RESULT_SCHEMA },
+    },
+    STORAGE_ERROR_RESULT_SCHEMA,
+  ],
+} as const satisfies DataSchema;
+
+export const STORAGE_PUBLIC_URL_OPERATION_RESULT_SCHEMA = {
+  oneOf: [
+    {
+      ...STORAGE_SUCCESS_SCHEMA,
+      required: ['ok', 'data'],
+      properties: { ...STORAGE_SUCCESS_SCHEMA.properties, data: STORAGE_PUBLIC_URL_RESULT_SCHEMA },
+    },
+    STORAGE_ERROR_RESULT_SCHEMA,
+  ],
+} as const satisfies DataSchema;
+
+export const STORAGE_LIST_OPERATION_RESULT_SCHEMA = {
+  oneOf: [
+    {
+      ...STORAGE_SUCCESS_SCHEMA,
+      required: ['ok', 'data'],
+      properties: { ...STORAGE_SUCCESS_SCHEMA.properties, data: STORAGE_LIST_RESULT_SCHEMA },
+    },
+    STORAGE_ERROR_RESULT_SCHEMA,
+  ],
+} as const satisfies DataSchema;
+
+export const STORAGE_RESOLVE_OPERATION_RESULT_SCHEMA = {
+  oneOf: [
+    {
+      ...STORAGE_SUCCESS_SCHEMA,
+      required: ['ok', 'data'],
+      properties: { ...STORAGE_SUCCESS_SCHEMA.properties, data: STORAGE_RESOLVE_RESULT_SCHEMA },
+    },
+    STORAGE_ERROR_RESULT_SCHEMA,
+  ],
+} as const satisfies DataSchema;

package/src/structure/generated.ts

@@ -2,12 +2,12 @@
 import type { StructureDescriptorDocument } from '@ankhorage/contracts/structure';
 
 export const STRUCTURE_DESCRIPTOR_COMPILER_VERSION = '6.0.3';
-export const STRUCTURE_DESCRIPTOR_FINGERPRINT = 'sha256:d500087154a2536754e4dd4946fb40b6e84be31bebfc0ed5df114a5aad2f70f3';
+export const STRUCTURE_DESCRIPTOR_FINGERPRINT = 'sha256:e6117f029e0a0fde13ed1d08fe1a39d7e06a9f83a0d32198865446501875e27d';
 
 export const STRUCTURE_DESCRIPTOR = {
   "protocolVersion": 1,
   "packageName": "@ankhorage/contracts",
-  "packageVersion": "25.0.1",
+  "packageVersion": "25.2.0",
   "roots": {
     "auth-flow": "AuthFlowConfig",
     "auth-profile": "AuthProfileSpec",