@nlabs/reaktor 1.17.0 → 1.19.0

package/lib/organizations/signup.js

@@ -0,0 +1,169 @@
+import { createHash, createPassword, parsePassword } from '@nlabs/utils/parsers/strings';
+import { createHmac, randomBytes } from 'node:crypto';
+import { organizationUserId } from './authorization.js';
+import { encodeOrganizationMail, organizationMailKey } from './mail.js';
+import { newOrganizationId, organizationKey, organizationStoreFor, requireIdentifier } from './store.js';
+export const queueOrganizationVerification = async (tx, registration, previous)=>{
+    const now = Date.now();
+    const token = randomBytes(32).toString('base64url');
+    const withinHour = previous && now - previous.resendWindow < 3600000;
+    const verification = {
+        attemptWindow: previous?.attemptWindow || now,
+        attempts: previous?.attempts || 0,
+        expiresAt: now + 24 * 3600000,
+        lastSent: now,
+        resendCount: withinHour ? previous.resendCount + 1 : 1,
+        resendWindow: withinHour ? previous.resendWindow : now,
+        tokenHash: organizationKey(token),
+        used: false,
+        userId: registration.userId
+    };
+    await tx.put('organizationVerificationTokens', registration.registrationId, verification, previous);
+    const jobId = newOrganizationId();
+    const job = {
+        attempts: 0,
+        desired: {
+            ciphertext: encodeOrganizationMail({
+                email: registration.email,
+                registrationId: registration.registrationId,
+                token
+            })
+        },
+        effectiveAt: now,
+        jobId,
+        kind: 'mail',
+        leaseExpires: 0,
+        organizationId: registration.organizationId,
+        owner: '',
+        priceVersion: '2026-10-v1',
+        sequence: -now,
+        status: 'pending'
+    };
+    await tx.put('organizationBillingJobs', jobId, job);
+};
+const insertOrganization = async (tx, name, userId)=>{
+    const now = Date.now();
+    const organization = {
+        createdAt: now,
+        name,
+        organizationId: newOrganizationId(),
+        ownerUserId: userId,
+        revision: 0,
+        updatedAt: now
+    };
+    const membership = {
+        createdAt: now,
+        organizationId: organization.organizationId,
+        revision: 0,
+        role: 'admin',
+        status: 'active',
+        updatedAt: now,
+        userId
+    };
+    await tx.put('organizations', organization.organizationId, organization);
+    await tx.put('organizationMemberships', organizationKey(organization.organizationId, userId), membership);
+    return organization;
+};
+export const registerOrganization = async (input, controlContext)=>{
+    if (!input || Object.keys(input).some((key)=>![
+            'email',
+            'organizationName',
+            'password',
+            'requestId'
+        ].includes(key)) || typeof input.email !== 'string' || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(input.email) || input.email.length > 254 || typeof input.password !== 'string' || input.password.length < 12 || input.password.length > 128 || typeof input.organizationName !== 'string' || !input.organizationName.trim() || input.organizationName.length > 160) {
+        throw new Error('invalid_signup');
+    }
+    requireIdentifier(input.requestId);
+    const email = input.email.trim().toLowerCase();
+    const fingerprint = createHmac('sha256', organizationMailKey()).update(JSON.stringify({
+        ...input,
+        email
+    })).digest('hex');
+    const registrationId = organizationKey('registration', email, input.requestId);
+    return organizationStoreFor(controlContext).transaction(async (tx)=>{
+        const previous = await tx.get('organizationRegistrations', registrationId);
+        if (previous) {
+            if (previous.fingerprint !== fingerprint) {
+                throw new Error('registration_conflict');
+            }
+            return {
+                registrationId,
+                verificationRequired: true
+            };
+        }
+        const users = await tx.find('users', {
+            email
+        });
+        const userId = createHash(email);
+        const collision = await tx.get('users', userId);
+        const existing = users.length > 0 || Boolean(collision);
+        let organizationId = '';
+        if (!existing) {
+            const salt = randomBytes(32).toString('hex');
+            await tx.put('users', userId, {
+                active: true,
+                added: Date.now(),
+                email,
+                locale: 'en',
+                organizationAccount: true,
+                password: createPassword(parsePassword(input.password), salt),
+                salt,
+                type: 'user',
+                userAccess: 0,
+                username: email,
+                verifiedEmail: false
+            });
+            ({ organizationId } = await insertOrganization(tx, input.organizationName.trim(), userId));
+        }
+        const registration = {
+            email,
+            fingerprint,
+            organizationId,
+            registrationId,
+            requestId: input.requestId,
+            userId: existing ? '' : userId
+        };
+        await tx.put('organizationRegistrations', registrationId, registration);
+        if (!existing) {
+            await queueOrganizationVerification(tx, registration);
+        }
+        return {
+            registrationId,
+            verificationRequired: true
+        };
+    });
+};
+export const createOrganization = (context, name, requestId)=>organizationStoreFor(context).transaction(async (tx)=>{
+        const userId = organizationUserId(context);
+        const user = await tx.get('users', userId);
+        if (!user?.active || !user.verifiedEmail) {
+            throw new Error('email_verification_required');
+        }
+        if (typeof name !== 'string' || !name.trim() || name.length > 160) {
+            throw new Error('invalid_organization_name');
+        }
+        const key = organizationKey('authenticated-organization', userId, requireIdentifier(requestId));
+        const previous = await tx.get('organizationRegistrations', key);
+        if (previous) {
+            if (previous.name !== name.trim()) {
+                throw new Error('registration_conflict');
+            }
+            const existing = await tx.get('organizations', previous.organizationId);
+            const { _key, _rev, ...organization } = existing;
+            return organization;
+        }
+        const org = await insertOrganization(tx, name.trim(), userId);
+        await tx.put('organizationRegistrations', key, {
+            name: name.trim(),
+            organizationId: org.organizationId,
+            requestId: key,
+            userId
+        });
+        await tx.put('users', userId, {
+            ...user,
+            organizationAccount: true
+        }, user);
+        return org;
+    });
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/private/tmp/vault-reaktor-completion/packages/reaktor/src/organizations/signup.ts"],"sourcesContent":["import {createHash, createPassword, parsePassword} from '@nlabs/utils/parsers/strings';\nimport {createHmac, randomBytes} from 'node:crypto';\n\nimport {organizationUserId} from './authorization.js';\nimport {encodeOrganizationMail, organizationMailKey} from './mail.js';\nimport {\n  newOrganizationId,\n  organizationKey,\n  organizationStoreFor,\n  requireIdentifier,\n  type OrganizationTransaction\n} from './store.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {BillingJob, Organization, OrganizationMembership, SignupInput, SignupResult} from './types.js';\n\nexport type Registration = {\n  email: string;\n  fingerprint: string;\n  organizationId: string;\n  registrationId: string;\n  requestId: string;\n  userId: string;\n};\nexport type Verification = {\n  attempts: number;\n  attemptWindow: number;\n  expiresAt: number;\n  lastSent: number;\n  resendCount: number;\n  resendWindow: number;\n  tokenHash: string;\n  used: boolean;\n  userId: string;\n};\nexport const queueOrganizationVerification = async (\n  tx: OrganizationTransaction,\n  registration: Registration,\n  previous?: import('./store.js').Stored<Verification> | null\n): Promise<void> => {\n  const now = Date.now();\n  const token = randomBytes(32).toString('base64url');\n  const withinHour = previous && now - previous.resendWindow < 3600000;\n  const verification: Verification = {\n    attemptWindow: previous?.attemptWindow || now,\n    attempts: previous?.attempts || 0,\n    expiresAt: now + (24 * 3600000),\n    lastSent: now,\n    resendCount: withinHour ? previous.resendCount + 1 : 1,\n    resendWindow: withinHour ? previous.resendWindow : now,\n    tokenHash: organizationKey(token),\n    used: false,\n    userId: registration.userId\n  };\n  await tx.put('organizationVerificationTokens', registration.registrationId, verification, previous);\n  const jobId = newOrganizationId();\n  const job: BillingJob = {\n    attempts: 0,\n    desired: {\n      ciphertext: encodeOrganizationMail({\n        email: registration.email,\n        registrationId: registration.registrationId,\n        token\n      })\n    },\n    effectiveAt: now,\n    jobId,\n    kind: 'mail',\n    leaseExpires: 0,\n    organizationId: registration.organizationId,\n    owner: '',\n    priceVersion: '2026-10-v1',\n    sequence: -now,\n    status: 'pending'\n  };\n  await tx.put('organizationBillingJobs', jobId, job);\n};\n\nconst insertOrganization = async (\n  tx: OrganizationTransaction,\n  name: string,\n  userId: string\n): Promise<Organization> => {\n  const now = Date.now();\n  const organization: Organization = {\n    createdAt: now,\n    name,\n    organizationId: newOrganizationId(),\n    ownerUserId: userId,\n    revision: 0,\n    updatedAt: now\n  };\n  const membership: OrganizationMembership = {\n    createdAt: now,\n    organizationId: organization.organizationId,\n    revision: 0,\n    role: 'admin',\n    status: 'active',\n    updatedAt: now,\n    userId\n  };\n  await tx.put('organizations', organization.organizationId, organization);\n  await tx.put('organizationMemberships', organizationKey(organization.organizationId, userId), membership);\n  return organization;\n};\n\nexport const registerOrganization = async (\n  input: SignupInput,\n  controlContext: ApiContext\n): Promise<SignupResult> => {\n  if(\n    !input ||\n    Object.keys(input).some((key) => !['email', 'organizationName', 'password', 'requestId'].includes(key)) ||\n    typeof input.email !== 'string' ||\n    !/^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(input.email) ||\n    input.email.length > 254 ||\n    typeof input.password !== 'string' ||\n    input.password.length < 12 ||\n    input.password.length > 128 ||\n    typeof input.organizationName !== 'string' ||\n    !input.organizationName.trim() ||\n    input.organizationName.length > 160\n  ) {\n    throw new Error('invalid_signup');\n  }\n  requireIdentifier(input.requestId);\n  const email = input.email.trim().toLowerCase();\n  const fingerprint = createHmac('sha256', organizationMailKey())\n    .update(JSON.stringify({...input, email}))\n    .digest('hex');\n  const registrationId = organizationKey('registration', email, input.requestId);\n  return organizationStoreFor(controlContext).transaction(async (tx) => {\n    const previous = await tx.get<Registration>('organizationRegistrations', registrationId);\n    if(previous) {\n      if(previous.fingerprint !== fingerprint) {\n        throw new Error('registration_conflict');\n      }\n      return {registrationId, verificationRequired: true};\n    }\n    const users = await tx.find('users', {email});\n    const userId = createHash(email);\n    const collision = await tx.get('users', userId);\n    const existing = users.length > 0 || Boolean(collision);\n    let organizationId = '';\n    if(!existing) {\n      const salt = randomBytes(32).toString('hex');\n      await tx.put('users', userId, {\n        active: true,\n        added: Date.now(),\n        email,\n        locale: 'en',\n        organizationAccount: true,\n        password: createPassword(parsePassword(input.password), salt),\n        salt,\n        type: 'user',\n        userAccess: 0,\n        username: email,\n        verifiedEmail: false\n      });\n      ({organizationId} = await insertOrganization(tx, input.organizationName.trim(), userId));\n    }\n    const registration: Registration = {\n      email,\n      fingerprint,\n      organizationId,\n      registrationId,\n      requestId: input.requestId,\n      userId: existing ? '' : userId\n    };\n    await tx.put('organizationRegistrations', registrationId, registration);\n    if(!existing) {\n      await queueOrganizationVerification(tx, registration);\n    }\n    return {registrationId, verificationRequired: true};\n  });\n};\n\nexport const createOrganization = (\n  context: ApiContext,\n  name: string,\n  requestId: string\n): Promise<Organization> =>\n  organizationStoreFor(context).transaction(async (tx) => {\n    const userId = organizationUserId(context);\n    const user = await tx.get<{active: boolean; verifiedEmail: boolean}>('users', userId);\n    if(!user?.active || !user.verifiedEmail) {\n      throw new Error('email_verification_required');\n    }\n    if(typeof name !== 'string' || !name.trim() || name.length > 160) {\n      throw new Error('invalid_organization_name');\n    }\n    const key = organizationKey('authenticated-organization', userId, requireIdentifier(requestId));\n    const previous = await tx.get<{name: string; organizationId: string}>('organizationRegistrations', key);\n    if(previous) {\n      if(previous.name !== name.trim()) {\n        throw new Error('registration_conflict');\n      }\n      const existing = (await tx.get<Organization>('organizations', previous.organizationId))!;\n      const {_key, _rev, ...organization} = existing;\n      return organization;\n    }\n    const org = await insertOrganization(tx, name.trim(), userId);\n    await tx.put('organizationRegistrations', key, {\n      name: name.trim(),\n      organizationId: org.organizationId,\n      requestId: key,\n      userId\n    });\n    await tx.put('users', userId, {...user, organizationAccount: true}, user);\n    return org;\n  });\n"],"names":["createHash","createPassword","parsePassword","createHmac","randomBytes","organizationUserId","encodeOrganizationMail","organizationMailKey","newOrganizationId","organizationKey","organizationStoreFor","requireIdentifier","queueOrganizationVerification","tx","registration","previous","now","Date","token","toString","withinHour","resendWindow","verification","attemptWindow","attempts","expiresAt","lastSent","resendCount","tokenHash","used","userId","put","registrationId","jobId","job","desired","ciphertext","email","effectiveAt","kind","leaseExpires","organizationId","owner","priceVersion","sequence","status","insertOrganization","name","organization","createdAt","ownerUserId","revision","updatedAt","membership","role","registerOrganization","input","controlContext","Object","keys","some","key","includes","test","length","password","organizationName","trim","Error","requestId","toLowerCase","fingerprint","update","JSON","stringify","digest","transaction","get","verificationRequired","users","find","collision","existing","Boolean","salt","active","added","locale","organizationAccount","type","userAccess","username","verifiedEmail","createOrganization","context","user","_key","_rev","org"],"mappings":"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"}

package/lib/organizations/store.d.ts

@@ -0,0 +1,25 @@
+import { type Database } from 'arangojs';
+import type { ApiContext } from '../types/auth.types.js';
+export declare const organizationCollections: readonly ['organizations', 'organizationMemberships', 'organizationApps', 'organizationRegistrations', 'organizationVerificationTokens', 'organizationInvitations', 'organizationOwnerTransfers', 'organizationBilling', 'organizationBillingJobs', 'organizationBillingEvents', 'organizationBillingPeriods', 'organizationBillingQuotes'];
+export declare const organizationEdgeCollections: readonly ("hasConnection" | "hasConversation" | "hasCustomerNotification" | "hasCustomerOrder" | "hasFile" | "hasLocation" | "hasMailingList" | "hasMedia" | "hasPayment" | "hasPersona" | "hasPurchasedProduct" | "hasReaction" | "hasSupportTicket" | "hasSupportTicketEvent" | "hasSupportTicketMessage" | "isPosted" | "isTagged")[];
+export type OrganizationCollection = (typeof organizationCollections)[number] | (typeof organizationEdgeCollections)[number] | 'users';
+export type Stored<T> = T & {
+    _key: string;
+    _rev?: string;
+};
+export type OrganizationTransaction = Readonly<{
+    find: <T>(collection: OrganizationCollection, filter: Readonly<Record<string, unknown>>) => Promise<Stored<T>[]>;
+    get: <T>(collection: OrganizationCollection, key: string) => Promise<Stored<T> | null>;
+    put: <T extends object>(collection: OrganizationCollection, key: string, document: T, previous?: Stored<object> | null) => Promise<void>;
+    remove: (collection: OrganizationCollection, document: Stored<object>) => Promise<void>;
+}>;
+export type OrganizationStore = Readonly<{
+    initialize: () => Promise<void>;
+    transaction: <T>(action: (tx: OrganizationTransaction) => Promise<T>) => Promise<T>;
+}>;
+export declare const organizationKey: (...parts: string[]) => string;
+export declare const newOrganizationId: () => string;
+export declare const requireIdentifier: (value: unknown) => string;
+export declare const controlDatabaseName: () => string;
+export declare const organizationStoreFor: (_context: ApiContext) => OrganizationStore;
+export declare const createOrganizationStore: (controlName: string, database?: Database) => OrganizationStore;

package/lib/organizations/store.js

@@ -0,0 +1,167 @@
+/* Stream-transaction steps and ordered retry assertions must execute sequentially. */ /* eslint-disable no-await-in-loop */ import { aql } from 'arangojs';
+import { createHash, randomUUID } from 'node:crypto';
+import { DEFAULT_EDGE_COLLECTIONS } from '../constants/collections.js';
+import { useDb } from '../utils/arangodbUtils.js';
+export const organizationCollections = [
+    'organizations',
+    'organizationMemberships',
+    'organizationApps',
+    'organizationRegistrations',
+    'organizationVerificationTokens',
+    'organizationInvitations',
+    'organizationOwnerTransfers',
+    'organizationBilling',
+    'organizationBillingJobs',
+    'organizationBillingEvents',
+    'organizationBillingPeriods',
+    'organizationBillingQuotes'
+];
+export const organizationEdgeCollections = DEFAULT_EDGE_COLLECTIONS;
+export const organizationKey = (...parts)=>createHash('sha256').update(JSON.stringify(parts)).digest('hex');
+export const newOrganizationId = ()=>randomUUID();
+export const requireIdentifier = (value)=>{
+    if (typeof value !== 'string' || !/^[a-zA-Z0-9_-]{1,128}$/.test(value)) {
+        throw new Error('invalid_identifier');
+    }
+    return value;
+};
+export const controlDatabaseName = ()=>{
+    const name = process.env.ARANGODB_DATABASE;
+    if (!name || !/^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/.test(name) || name === '_system') {
+        throw new Error('organization_control_database_required');
+    }
+    return name;
+};
+export const organizationStoreFor = (_context)=>createOrganizationStore(controlDatabaseName());
+const indexes = {
+    organizationApps: [
+        [
+            'appId'
+        ]
+    ],
+    organizationBilling: [
+        [
+            'organizationId'
+        ]
+    ],
+    organizationBillingEvents: [
+        [
+            'eventId'
+        ]
+    ],
+    organizationBillingJobs: [
+        [
+            'organizationId',
+            'sequence'
+        ]
+    ],
+    organizationMemberships: [
+        [
+            'organizationId',
+            'userId'
+        ]
+    ],
+    organizations: [
+        [
+            'organizationId'
+        ]
+    ]
+};
+export const createOrganizationStore = (controlName, database = useDb(controlName))=>{
+    if (!controlName || controlName === '_system' || !/^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/.test(controlName)) {
+        throw new Error('organization_control_database_required');
+    }
+    let initialized = false;
+    const initialize = async ()=>{
+        if (initialized) {
+            return;
+        }
+        for (const name of [
+            ...organizationCollections,
+            'users',
+            ...organizationEdgeCollections
+        ]){
+            const collection = database.collection(name);
+            if (!await collection.exists()) {
+                try {
+                    await collection.create(organizationEdgeCollections.includes(name) ? {
+                        type: 3
+                    } : {});
+                } catch (error) {
+                    if (error.errorNum !== 1207) {
+                        throw error;
+                    }
+                }
+            }
+            for (const fields of indexes[name] || []){
+                await collection.ensureIndex({
+                    fields,
+                    type: 'persistent',
+                    unique: true
+                });
+            }
+        }
+        initialized = true;
+    };
+    const transaction = async (action)=>{
+        await initialize();
+        const trx = await database.beginTransaction({
+            exclusive: [
+                ...organizationCollections,
+                'users',
+                ...organizationEdgeCollections
+            ]
+        }, {
+            lockTimeout: 10
+        });
+        const tx = {
+            find: async (name, filter)=>{
+                const cursor = await trx.step(()=>database.query(aql`FOR doc IN ${database.collection(name)} FILTER MATCHES(doc, ${filter}) RETURN doc`));
+                return await cursor.all();
+            },
+            get: async (name, key)=>{
+                const cursor = await trx.step(()=>database.query(aql`RETURN DOCUMENT(${name}, ${requireIdentifier(key)})`));
+                return await cursor.next();
+            },
+            put: async (name, key, document, previous)=>{
+                const collection = database.collection(name);
+                const { _id, _key, _rev, ...safe } = document;
+                if (previous) {
+                    await trx.step(()=>collection.replace({
+                            _key: requireIdentifier(key),
+                            _rev: previous._rev
+                        }, safe, {
+                            ignoreRevs: false
+                        }));
+                } else {
+                    await trx.step(()=>collection.save({
+                            ...safe,
+                            _key: requireIdentifier(key)
+                        }));
+                }
+            },
+            remove: async (name, document)=>{
+                await trx.step(()=>database.collection(name).remove({
+                        _key: document._key,
+                        _rev: document._rev
+                    }, {
+                        ignoreRevs: false
+                    }));
+            }
+        };
+        try {
+            const result = await action(tx);
+            await trx.commit();
+            return result;
+        } catch (error) {
+            await trx.abort().catch(()=>undefined);
+            throw error;
+        }
+    };
+    return {
+        initialize,
+        transaction
+    };
+}; /* Stream-transaction steps and ordered retry assertions must execute sequentially. */  /* ArangoDB document metadata uses these reserved field names. */  /* eslint no-underscore-dangle: ["warn", {"allow": ["_key", "_rev", "_id"]}] */ 
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/private/tmp/vault-reaktor-completion/packages/reaktor/src/organizations/store.ts"],"sourcesContent":["/* Stream-transaction steps and ordered retry assertions must execute sequentially. */\n/* eslint-disable no-await-in-loop */\nimport {aql, type Database} from 'arangojs';\nimport {createHash, randomUUID} from 'node:crypto';\n\nimport {DEFAULT_EDGE_COLLECTIONS} from '../constants/collections.js';\nimport {useDb} from '../utils/arangodbUtils.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\n\nexport const organizationCollections = [\n  'organizations',\n  'organizationMemberships',\n  'organizationApps',\n  'organizationRegistrations',\n  'organizationVerificationTokens',\n  'organizationInvitations',\n  'organizationOwnerTransfers',\n  'organizationBilling',\n  'organizationBillingJobs',\n  'organizationBillingEvents',\n  'organizationBillingPeriods',\n  'organizationBillingQuotes'\n] as const;\nexport const organizationEdgeCollections = DEFAULT_EDGE_COLLECTIONS;\nexport type OrganizationCollection =\n  (typeof organizationCollections)[number] | (typeof organizationEdgeCollections)[number] | 'users';\nexport type Stored<T> = T & {_key: string; _rev?: string};\nexport type OrganizationTransaction = Readonly<{\n  find: <T>(\n    collection: OrganizationCollection,\n    filter: Readonly<Record<string, unknown>>\n  ) => Promise<Stored<T>[]>;\n  get: <T>(collection: OrganizationCollection, key: string) => Promise<Stored<T> | null>;\n  put: <T extends object>(\n    collection: OrganizationCollection,\n    key: string,\n    document: T,\n    previous?: Stored<object> | null\n  ) => Promise<void>;\n  remove: (collection: OrganizationCollection, document: Stored<object>) => Promise<void>;\n}>;\nexport type OrganizationStore = Readonly<{\n  initialize: () => Promise<void>;\n  transaction: <T>(action: (tx: OrganizationTransaction) => Promise<T>) => Promise<T>;\n}>;\nexport const organizationKey = (...parts: string[]): string =>\n  createHash('sha256').update(JSON.stringify(parts)).digest('hex');\nexport const newOrganizationId = (): string => randomUUID();\nexport const requireIdentifier = (value: unknown): string => {\n  if(typeof value !== 'string' || !/^[a-zA-Z0-9_-]{1,128}$/.test(value)) {\n    throw new Error('invalid_identifier');\n  }\n  return value;\n};\nexport const controlDatabaseName = (): string => {\n  const name = process.env.ARANGODB_DATABASE;\n  if(!name || !/^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/.test(name) || name === '_system') {\n    throw new Error('organization_control_database_required');\n  }\n  return name;\n};\nexport const organizationStoreFor = (_context: ApiContext): OrganizationStore =>\n  createOrganizationStore(controlDatabaseName());\n\nconst indexes: Partial<Record<OrganizationCollection, string[][]>> = {\n  organizationApps: [['appId']],\n  organizationBilling: [['organizationId']],\n  organizationBillingEvents: [['eventId']],\n  organizationBillingJobs: [['organizationId', 'sequence']],\n  organizationMemberships: [['organizationId', 'userId']],\n  organizations: [['organizationId']]\n};\n\nexport const createOrganizationStore = (\n  controlName: string,\n  database: Database = useDb(controlName)\n): OrganizationStore => {\n  if(!controlName || controlName === '_system' || !/^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/.test(controlName)) {\n    throw new Error('organization_control_database_required');\n  }\n  let initialized = false;\n  const initialize = async (): Promise<void> => {\n    if(initialized) {\n      return;\n    }\n    for(const name of [\n      ...organizationCollections,\n      'users',\n      ...organizationEdgeCollections\n    ] as OrganizationCollection[]) {\n      const collection = database.collection(name);\n      if(!(await collection.exists())) {\n        try {\n          await collection.create(\n            organizationEdgeCollections.includes(name as (typeof organizationEdgeCollections)[number])\n              ? {type: 3}\n              : {}\n          );\n        } catch(error) {\n          if((error as {errorNum?: number}).errorNum !== 1207) {\n            throw error;\n          }\n        }\n      }\n      for(const fields of indexes[name] || []) {\n        await collection.ensureIndex({fields, type: 'persistent', unique: true});\n      }\n    }\n    initialized = true;\n  };\n  const transaction = async <T>(action: (tx: OrganizationTransaction) => Promise<T>): Promise<T> => {\n    await initialize();\n    const trx = await database.beginTransaction(\n      {exclusive: [...organizationCollections, 'users', ...organizationEdgeCollections]},\n      {lockTimeout: 10}\n    );\n    const tx: OrganizationTransaction = {\n      find: async <D>(name: OrganizationCollection, filter: Readonly<Record<string, unknown>>) => {\n        const cursor = await trx.step(() =>\n          database.query(\n            aql`FOR doc IN ${database.collection(name)} FILTER MATCHES(doc, ${filter}) RETURN doc`\n          )\n        );\n        return (await cursor.all()) as Stored<D>[];\n      },\n      get: async <D>(name: OrganizationCollection, key: string) => {\n        const cursor = await trx.step(() =>\n          database.query(aql`RETURN DOCUMENT(${name}, ${requireIdentifier(key)})`)\n        );\n        return (await cursor.next()) as Stored<D> | null;\n      },\n      put: async <D extends object>(\n        name: OrganizationCollection,\n        key: string,\n        document: D,\n        previous?: Stored<object> | null\n      ) => {\n        const collection = database.collection(name);\n        const {_id, _key, _rev, ...safe} = document as D & {_id?: string; _key?: string; _rev?: string};\n        if(previous) {\n          await trx.step(() =>\n            collection.replace({_key: requireIdentifier(key), _rev: previous._rev}, safe, {ignoreRevs: false})\n          );\n        } else {\n          await trx.step(() => collection.save({...safe, _key: requireIdentifier(key)}));\n        }\n      },\n      remove: async (name, document) => {\n        await trx.step(() =>\n          database.collection(name).remove({_key: document._key, _rev: document._rev}, {ignoreRevs: false})\n        );\n      }\n    };\n    try {\n      const result = await action(tx);\n      await trx.commit();\n      return result;\n    } catch(error) {\n      await trx.abort().catch(() => undefined);\n      throw error;\n    }\n  };\n  return {initialize, transaction};\n};\n/* Stream-transaction steps and ordered retry assertions must execute sequentially. */\n\n/* ArangoDB document metadata uses these reserved field names. */\n/* eslint no-underscore-dangle: [\"warn\", {\"allow\": [\"_key\", \"_rev\", \"_id\"]}] */\n"],"names":["aql","createHash","randomUUID","DEFAULT_EDGE_COLLECTIONS","useDb","organizationCollections","organizationEdgeCollections","organizationKey","parts","update","JSON","stringify","digest","newOrganizationId","requireIdentifier","value","test","Error","controlDatabaseName","name","process","env","ARANGODB_DATABASE","organizationStoreFor","_context","createOrganizationStore","indexes","organizationApps","organizationBilling","organizationBillingEvents","organizationBillingJobs","organizationMemberships","organizations","controlName","database","initialized","initialize","collection","exists","create","includes","type","error","errorNum","fields","ensureIndex","unique","transaction","action","trx","beginTransaction","exclusive","lockTimeout","tx","find","filter","cursor","step","query","all","get","key","next","put","document","previous","_id","_key","_rev","safe","replace","ignoreRevs","save","remove","result","commit","abort","catch","undefined"],"mappings":"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"}

package/lib/organizations/types.d.ts

@@ -0,0 +1,138 @@
+import type { ApiContext } from '../types/auth.types.js';
+export type PlanKey = 'starter' | 'pro';
+export type BillingMode = 'disabled' | 'test';
+export type MembershipRole = 'admin' | 'member';
+export type MembershipStatus = 'pending' | 'active' | 'deactivated';
+export type Organization = Readonly<{
+    createdAt: number;
+    name: string;
+    organizationId: string;
+    ownerUserId: string;
+    revision: number;
+    updatedAt: number;
+}>;
+export type OrganizationMembership = Readonly<{
+    createdAt: number;
+    organizationId: string;
+    revision: number;
+    role: MembershipRole;
+    status: MembershipStatus;
+    updatedAt: number;
+    userId: string;
+}>;
+export type OrganizationAccess = Readonly<{
+    membership: OrganizationMembership;
+    organization: Organization;
+    userId: string;
+}>;
+export type OrganizationPlan = Readonly<{
+    additionalSeatCents: number;
+    baseCents: number;
+    currency: 'usd';
+    includedSeats: 10;
+    interval: 'month';
+    key: PlanKey;
+    version: '2026-10-v1';
+}>;
+export type OveragePreference = Readonly<{
+    enabled: boolean;
+    monthlyCapCents: number;
+    revision: number;
+}>;
+export type SubscriptionSummary = Readonly<{
+    activeMembers: number;
+    billingMode: BillingMode;
+    canManage: boolean;
+    estimatedMonthlyCents: number;
+    extraSeats: number;
+    metersEnabled: false;
+    organizationId: string;
+    overage: OveragePreference;
+    pendingChange: string | null;
+    periodEnd: number | null;
+    plan: PlanKey | null;
+    reconciliationPending: boolean;
+    status: string;
+}>;
+export type MembershipChange = Readonly<{
+    confirmedQuoteId?: string;
+    expectedRevision: number;
+    role: MembershipRole;
+    status: MembershipStatus;
+    userId: string;
+}>;
+export type SeatChangeQuote = Readonly<{
+    currency: 'usd';
+    expiresAt: number;
+    organizationRevision: number;
+    prorationCents: number;
+    quantity: number;
+    quoteId: string;
+}>;
+export type SignupInput = Readonly<{
+    email: string;
+    organizationName: string;
+    password: string;
+    requestId: string;
+}>;
+export type SignupResult = Readonly<{
+    registrationId: string;
+    verificationRequired: true;
+}>;
+export type BillingJob = Readonly<{
+    attempts: number;
+    desired: Record<string, unknown>;
+    effectiveAt: number;
+    jobId: string;
+    kind: 'cancel' | 'mail' | 'plan' | 'reconcile' | 'seats';
+    leaseExpires: number;
+    organizationId: string;
+    owner: string;
+    priceVersion: '2026-10-v1';
+    sequence: number;
+    status: 'complete' | 'pending';
+}>;
+export type ProviderSubscription = Readonly<{
+    cancelAtPeriodEnd?: boolean;
+    baseItemId: string;
+    customerId: string;
+    extraSeats: number;
+    id: string;
+    lastJobId?: string;
+    pendingPlan?: PlanKey | null;
+    periodEnd: number;
+    periodStart: number;
+    plan: PlanKey;
+    seatItemId: string;
+    status: string;
+    startedAt?: number;
+}>;
+export type CheckoutResult = Readonly<{
+    expiresAt: number;
+    id: string;
+    url: string;
+}>;
+export type VerifiedBillingEvent = Readonly<{
+    customerId: string;
+    eventId: string;
+    type: string;
+}>;
+export type BillingAdjustment = Readonly<{
+    amountCents: number;
+    periodEnd: number;
+    periodStart: number;
+    providerId: string;
+}>;
+export type BillingUpdateResult = Readonly<{
+    adjustments: readonly BillingAdjustment[];
+}>;
+export type BillingProvider = Readonly<{
+    checkout: (customerId: string, plan: PlanKey, extraSeats: number, key: string) => Promise<CheckoutResult>;
+    customer: (organizationId: string, email: string) => Promise<string>;
+    portal: (customerId: string) => Promise<string>;
+    preview: (subscription: ProviderSubscription, plan: PlanKey, seats: number, effectiveAt: number) => Promise<number>;
+    retrieve: (customerId: string, subscriptionId?: string) => Promise<ProviderSubscription | null>;
+    update: (subscription: ProviderSubscription, job: BillingJob, fence: () => Promise<void>) => Promise<BillingUpdateResult>;
+    verify: (body: string | Buffer, signature: string) => VerifiedBillingEvent;
+}>;
+export type OrganizationContext = ApiContext;

package/lib/organizations/types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9wcml2YXRlL3RtcC92YXVsdC1yZWFrdG9yLWNvbXBsZXRpb24vcGFja2FnZXMvcmVha3Rvci9zcmMvb3JnYW5pemF0aW9ucy90eXBlcy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7QXBpQ29udGV4dH0gZnJvbSAnLi4vdHlwZXMvYXV0aC50eXBlcy5qcyc7XG5cbmV4cG9ydCB0eXBlIFBsYW5LZXkgPSAnc3RhcnRlcicgfCAncHJvJztcbmV4cG9ydCB0eXBlIEJpbGxpbmdNb2RlID0gJ2Rpc2FibGVkJyB8ICd0ZXN0JztcbmV4cG9ydCB0eXBlIE1lbWJlcnNoaXBSb2xlID0gJ2FkbWluJyB8ICdtZW1iZXInO1xuZXhwb3J0IHR5cGUgTWVtYmVyc2hpcFN0YXR1cyA9ICdwZW5kaW5nJyB8ICdhY3RpdmUnIHwgJ2RlYWN0aXZhdGVkJztcbmV4cG9ydCB0eXBlIE9yZ2FuaXphdGlvbiA9IFJlYWRvbmx5PHtcbiAgY3JlYXRlZEF0OiBudW1iZXI7XG4gIG5hbWU6IHN0cmluZztcbiAgb3JnYW5pemF0aW9uSWQ6IHN0cmluZztcbiAgb3duZXJVc2VySWQ6IHN0cmluZztcbiAgcmV2aXNpb246IG51bWJlcjtcbiAgdXBkYXRlZEF0OiBudW1iZXI7XG59PjtcbmV4cG9ydCB0eXBlIE9yZ2FuaXphdGlvbk1lbWJlcnNoaXAgPSBSZWFkb25seTx7XG4gIGNyZWF0ZWRBdDogbnVtYmVyO1xuICBvcmdhbml6YXRpb25JZDogc3RyaW5nO1xuICByZXZpc2lvbjogbnVtYmVyO1xuICByb2xlOiBNZW1iZXJzaGlwUm9sZTtcbiAgc3RhdHVzOiBNZW1iZXJzaGlwU3RhdHVzO1xuICB1cGRhdGVkQXQ6IG51bWJlcjtcbiAgdXNlcklkOiBzdHJpbmc7XG59PjtcbmV4cG9ydCB0eXBlIE9yZ2FuaXphdGlvbkFjY2VzcyA9IFJlYWRvbmx5PHtcbiAgbWVtYmVyc2hpcDogT3JnYW5pemF0aW9uTWVtYmVyc2hpcDtcbiAgb3JnYW5pemF0aW9uOiBPcmdhbml6YXRpb247XG4gIHVzZXJJZDogc3RyaW5nO1xufT47XG5leHBvcnQgdHlwZSBPcmdhbml6YXRpb25QbGFuID0gUmVhZG9ubHk8e1xuICBhZGRpdGlvbmFsU2VhdENlbnRzOiBudW1iZXI7XG4gIGJhc2VDZW50czogbnVtYmVyO1xuICBjdXJyZW5jeTogJ3VzZCc7XG4gIGluY2x1ZGVkU2VhdHM6IDEwO1xuICBpbnRlcnZhbDogJ21vbnRoJztcbiAga2V5OiBQbGFuS2V5O1xuICB2ZXJzaW9uOiAnMjAyNi0xMC12MSc7XG59PjtcbmV4cG9ydCB0eXBlIE92ZXJhZ2VQcmVmZXJlbmNlID0gUmVhZG9ubHk8e2VuYWJsZWQ6IGJvb2xlYW47IG1vbnRobHlDYXBDZW50czogbnVtYmVyOyByZXZpc2lvbjogbnVtYmVyfT47XG5leHBvcnQgdHlwZSBTdWJzY3JpcHRpb25TdW1tYXJ5ID0gUmVhZG9ubHk8e1xuICBhY3RpdmVNZW1iZXJzOiBudW1iZXI7XG4gIGJpbGxpbmdNb2RlOiBCaWxsaW5nTW9kZTtcbiAgY2FuTWFuYWdlOiBib29sZWFuO1xuICBlc3RpbWF0ZWRNb250aGx5Q2VudHM6IG51bWJlcjtcbiAgZXh0cmFTZWF0czogbnVtYmVyO1xuICBtZXRlcnNFbmFibGVkOiBmYWxzZTtcbiAgb3JnYW5pemF0aW9uSWQ6IHN0cmluZztcbiAgb3ZlcmFnZTogT3ZlcmFnZVByZWZlcmVuY2U7XG4gIHBlbmRpbmdDaGFuZ2U6IHN0cmluZyB8IG51bGw7XG4gIHBlcmlvZEVuZDogbnVtYmVyIHwgbnVsbDtcbiAgcGxhbjogUGxhbktleSB8IG51bGw7XG4gIHJlY29uY2lsaWF0aW9uUGVuZGluZzogYm9vbGVhbjtcbiAgc3RhdHVzOiBzdHJpbmc7XG59PjtcbmV4cG9ydCB0eXBlIE1lbWJlcnNoaXBDaGFuZ2UgPSBSZWFkb25seTx7XG4gIGNvbmZpcm1lZFF1b3RlSWQ/OiBzdHJpbmc7XG4gIGV4cGVjdGVkUmV2aXNpb246IG51bWJlcjtcbiAgcm9sZTogTWVtYmVyc2hpcFJvbGU7XG4gIHN0YXR1czogTWVtYmVyc2hpcFN0YXR1cztcbiAgdXNlcklkOiBzdHJpbmc7XG59PjtcbmV4cG9ydCB0eXBlIFNlYXRDaGFuZ2VRdW90ZSA9IFJlYWRvbmx5PHtcbiAgY3VycmVuY3k6ICd1c2QnO1xuICBleHBpcmVzQXQ6IG51bWJlcjtcbiAgb3JnYW5pemF0aW9uUmV2aXNpb246IG51bWJlcjtcbiAgcHJvcmF0aW9uQ2VudHM6IG51bWJlcjtcbiAgcXVhbnRpdHk6IG51bWJlcjtcbiAgcXVvdGVJZDogc3RyaW5nO1xufT47XG5leHBvcnQgdHlwZSBTaWdudXBJbnB1dCA9IFJlYWRvbmx5PHtcbiAgZW1haWw6IHN0cmluZztcbiAgb3JnYW5pemF0aW9uTmFtZTogc3RyaW5nO1xuICBwYXNzd29yZDogc3RyaW5nO1xuICByZXF1ZXN0SWQ6IHN0cmluZztcbn0+O1xuZXhwb3J0IHR5cGUgU2lnbnVwUmVzdWx0ID0gUmVhZG9ubHk8e3JlZ2lzdHJhdGlvbklkOiBzdHJpbmc7IHZlcmlmaWNhdGlvblJlcXVpcmVkOiB0cnVlfT47XG5leHBvcnQgdHlwZSBCaWxsaW5nSm9iID0gUmVhZG9ubHk8e1xuICBhdHRlbXB0czogbnVtYmVyO1xuICBkZXNpcmVkOiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPjtcbiAgZWZmZWN0aXZlQXQ6IG51bWJlcjtcbiAgam9iSWQ6IHN0cmluZztcbiAga2luZDogJ2NhbmNlbCcgfCAnbWFpbCcgfCAncGxhbicgfCAncmVjb25jaWxlJyB8ICdzZWF0cyc7XG4gIGxlYXNlRXhwaXJlczogbnVtYmVyO1xuICBvcmdhbml6YXRpb25JZDogc3RyaW5nO1xuICBvd25lcjogc3RyaW5nO1xuICBwcmljZVZlcnNpb246ICcyMDI2LTEwLXYxJztcbiAgc2VxdWVuY2U6IG51bWJlcjtcbiAgc3RhdHVzOiAnY29tcGxldGUnIHwgJ3BlbmRpbmcnO1xufT47XG5leHBvcnQgdHlwZSBQcm92aWRlclN1YnNjcmlwdGlvbiA9IFJlYWRvbmx5PHtcbiAgY2FuY2VsQXRQZXJpb2RFbmQ/OiBib29sZWFuO1xuICBiYXNlSXRlbUlkOiBzdHJpbmc7XG4gIGN1c3RvbWVySWQ6IHN0cmluZztcbiAgZXh0cmFTZWF0czogbnVtYmVyO1xuICBpZDogc3RyaW5nO1xuICBsYXN0Sm9iSWQ/OiBzdHJpbmc7XG4gIHBlbmRpbmdQbGFuPzogUGxhbktleSB8IG51bGw7XG4gIHBlcmlvZEVuZDogbnVtYmVyO1xuICBwZXJpb2RTdGFydDogbnVtYmVyO1xuICBwbGFuOiBQbGFuS2V5O1xuICBzZWF0SXRlbUlkOiBzdHJpbmc7XG4gIHN0YXR1czogc3RyaW5nO1xuICBzdGFydGVkQXQ/OiBudW1iZXI7XG59PjtcbmV4cG9ydCB0eXBlIENoZWNrb3V0UmVzdWx0ID0gUmVhZG9ubHk8e2V4cGlyZXNBdDogbnVtYmVyOyBpZDogc3RyaW5nOyB1cmw6IHN0cmluZ30+O1xuZXhwb3J0IHR5cGUgVmVyaWZpZWRCaWxsaW5nRXZlbnQgPSBSZWFkb25seTx7Y3VzdG9tZXJJZDogc3RyaW5nOyBldmVudElkOiBzdHJpbmc7IHR5cGU6IHN0cmluZ30+O1xuZXhwb3J0IHR5cGUgQmlsbGluZ0FkanVzdG1lbnQgPSBSZWFkb25seTx7XG4gIGFtb3VudENlbnRzOiBudW1iZXI7XG4gIHBlcmlvZEVuZDogbnVtYmVyO1xuICBwZXJpb2RTdGFydDogbnVtYmVyO1xuICBwcm92aWRlcklkOiBzdHJpbmc7XG59PjtcbmV4cG9ydCB0eXBlIEJpbGxpbmdVcGRhdGVSZXN1bHQgPSBSZWFkb25seTx7YWRqdXN0bWVudHM6IHJlYWRvbmx5IEJpbGxpbmdBZGp1c3RtZW50W119PjtcbmV4cG9ydCB0eXBlIEJpbGxpbmdQcm92aWRlciA9IFJlYWRvbmx5PHtcbiAgY2hlY2tvdXQ6IChjdXN0b21lcklkOiBzdHJpbmcsIHBsYW46IFBsYW5LZXksIGV4dHJhU2VhdHM6IG51bWJlciwga2V5OiBzdHJpbmcpID0+IFByb21pc2U8Q2hlY2tvdXRSZXN1bHQ+O1xuICBjdXN0b21lcjogKG9yZ2FuaXphdGlvbklkOiBzdHJpbmcsIGVtYWlsOiBzdHJpbmcpID0+IFByb21pc2U8c3RyaW5nPjtcbiAgcG9ydGFsOiAoY3VzdG9tZXJJZDogc3RyaW5nKSA9PiBQcm9taXNlPHN0cmluZz47XG4gIHByZXZpZXc6IChcbiAgICBzdWJzY3JpcHRpb246IFByb3ZpZGVyU3Vic2NyaXB0aW9uLFxuICAgIHBsYW46IFBsYW5LZXksXG4gICAgc2VhdHM6IG51bWJlcixcbiAgICBlZmZlY3RpdmVBdDogbnVtYmVyXG4gICkgPT4gUHJvbWlzZTxudW1iZXI+O1xuICByZXRyaWV2ZTogKGN1c3RvbWVySWQ6IHN0cmluZywgc3Vic2NyaXB0aW9uSWQ/OiBzdHJpbmcpID0+IFByb21pc2U8UHJvdmlkZXJTdWJzY3JpcHRpb24gfCBudWxsPjtcbiAgdXBkYXRlOiAoXG4gICAgc3Vic2NyaXB0aW9uOiBQcm92aWRlclN1YnNjcmlwdGlvbixcbiAgICBqb2I6IEJpbGxpbmdKb2IsXG4gICAgZmVuY2U6ICgpID0+IFByb21pc2U8dm9pZD5cbiAgKSA9PiBQcm9taXNlPEJpbGxpbmdVcGRhdGVSZXN1bHQ+O1xuICB2ZXJpZnk6IChib2R5OiBzdHJpbmcgfCBCdWZmZXIsIHNpZ25hdHVyZTogc3RyaW5nKSA9PiBWZXJpZmllZEJpbGxpbmdFdmVudDtcbn0+O1xuZXhwb3J0IHR5cGUgT3JnYW5pemF0aW9uQ29udGV4dCA9IEFwaUNvbnRleHQ7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBa0lBLFdBQTZDIn0=

package/lib/organizations/verification.d.ts

@@ -0,0 +1,3 @@
+import type { ApiContext } from '../types/auth.types.js';
+export declare const verifyOrganizationEmail: (registrationId: string, token: string, context: ApiContext) => Promise<void>;
+export declare const resendOrganizationVerification: (registrationId: string, context: ApiContext) => Promise<void>;

package/lib/organizations/verification.js

@@ -0,0 +1,51 @@
+import { queueOrganizationVerification } from './signup.js';
+import { organizationKey, organizationStoreFor, requireIdentifier } from './store.js';
+export const verifyOrganizationEmail = async (registrationId, token, context)=>{
+    const error = await organizationStoreFor(context).transaction(async (tx)=>{
+        const previous = await tx.get('organizationVerificationTokens', requireIdentifier(registrationId));
+        if (!previous || previous.used || previous.expiresAt <= Date.now()) {
+            return 'invalid_verification';
+        }
+        const now = Date.now();
+        const attempts = now - previous.attemptWindow < 3600000 ? previous.attempts : 0;
+        if (attempts >= 10) {
+            return 'verification_rate_limited';
+        }
+        const valid = typeof token === 'string' && token.length <= 128 && previous.tokenHash === organizationKey(token);
+        await tx.put('organizationVerificationTokens', registrationId, {
+            ...previous,
+            attemptWindow: attempts ? previous.attemptWindow : now,
+            attempts: attempts + 1,
+            used: valid
+        }, previous);
+        if (!valid) {
+            return 'invalid_verification';
+        }
+        const user = await tx.get('users', previous.userId);
+        if (!user) {
+            throw new Error('invalid_verification');
+        }
+        await tx.put('users', previous.userId, {
+            ...user,
+            verifiedEmail: true
+        }, user);
+        return '';
+    });
+    if (error) {
+        throw new Error(error);
+    }
+};
+export const resendOrganizationVerification = (registrationId, context)=>organizationStoreFor(context).transaction(async (tx)=>{
+        const registration = await tx.get('organizationRegistrations', requireIdentifier(registrationId));
+        const previous = await tx.get('organizationVerificationTokens', registrationId);
+        if (!registration?.userId || !previous || previous.used) {
+            return;
+        }
+        const now = Date.now();
+        if (now - previous.lastSent < 60000 || now - previous.resendWindow < 3600000 && previous.resendCount >= 5) {
+            throw new Error('verification_rate_limited');
+        }
+        await queueOrganizationVerification(tx, registration, previous);
+    });
+
+//# sourceMappingURL=data:application/json;base64,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