@lastshotlabs/bunshot 0.0.20 → 0.0.25

package/dist/adapters/localStorage.d.ts

@@ -0,0 +1,6 @@
+import type { StorageAdapter } from "../lib/storageAdapter";
+export interface LocalStorageConfig {
+    directory: string;
+    baseUrl?: string;
+}
+export declare const localStorage: (config: LocalStorageConfig) => StorageAdapter;

package/dist/adapters/localStorage.js

@@ -0,0 +1,44 @@
+import { unlink } from "node:fs/promises";
+import { join } from "node:path";
+export const localStorage = (config) => ({
+    async put(key, data, _meta) {
+        const filePath = join(config.directory, key);
+        // Ensure parent directory exists
+        const dir = filePath.substring(0, filePath.lastIndexOf("/"));
+        if (dir) {
+            const { mkdir } = await import("node:fs/promises");
+            await mkdir(dir, { recursive: true });
+        }
+        if (data instanceof Blob) {
+            await Bun.write(filePath, data);
+        }
+        else if (data instanceof ReadableStream) {
+            const response = new Response(data);
+            const blob = await response.blob();
+            await Bun.write(filePath, blob);
+        }
+        else {
+            await Bun.write(filePath, data);
+        }
+        const url = config.baseUrl ? `${config.baseUrl.replace(/\/$/, "")}/${key}` : undefined;
+        return { ...(url !== undefined ? { url } : {}) };
+    },
+    async get(key) {
+        const filePath = join(config.directory, key);
+        const file = Bun.file(filePath);
+        const exists = await file.exists();
+        if (!exists)
+            return null;
+        const stream = file.stream();
+        return { stream, size: file.size };
+    },
+    async delete(key) {
+        const filePath = join(config.directory, key);
+        try {
+            await unlink(filePath);
+        }
+        catch {
+            // File doesn't exist — ignore
+        }
+    },
+});

package/dist/adapters/memoryAuth.d.ts

@@ -10,6 +10,8 @@ export declare const memoryGetUserSessions: (userId: string) => SessionInfo[];
 export declare const memoryGetActiveSessionCount: (userId: string) => number;
 export declare const memoryEvictOldestSession: (userId: string) => void;
 export declare const memoryUpdateSessionLastActive: (sessionId: string) => void;
+export declare const memoryGetSessionFingerprint: (sessionId: string) => string | null;
+export declare const memorySetSessionFingerprint: (sessionId: string, fingerprint: string) => void;
 export declare const memorySetRefreshToken: (sessionId: string, refreshToken: string) => void;
 import type { RefreshResult } from "../lib/session";
 export declare const memoryGetSessionByRefreshToken: (refreshToken: string) => RefreshResult | null;
@@ -37,3 +39,8 @@ export declare const memoryConsumeResetToken: (hash: string) => {
 import type { OAuthCodePayload } from "../lib/oauthCode";
 export declare const memoryStoreOAuthCode: (hash: string, payload: OAuthCodePayload, ttlSeconds: number) => void;
 export declare const memoryConsumeOAuthCode: (hash: string) => OAuthCodePayload | null;
+export declare const memoryCreateDeletionCancelToken: (token: string, userId: string, jobId: string, ttlSeconds: number) => void;
+export declare const memoryConsumeDeletionCancelToken: (hash: string) => {
+    userId: string;
+    jobId: string;
+} | null;

package/dist/adapters/memoryAuth.js

@@ -2,6 +2,11 @@ import { HttpError } from "../lib/HttpError";
 import { getPersistSessionMetadata, getIncludeInactiveSessions } from "../lib/appConfig";
 import { clearMemoryRateLimitStore } from "../lib/authRateLimit";
 import { clearMemoryMfaChallenges } from "../lib/mfaChallenge";
+import { clearAuditLogMemoryStore } from "../lib/auditLog";
+import { clearPresenceStore } from "../lib/wsPresence";
+import { clearWsMessageMemoryStore } from "../lib/wsMessages";
+import { clearHeartbeatState } from "../lib/wsHeartbeat";
+import { clearMemoryUploadStore } from "./memoryStorage";
 const _users = new Map();
 const _byEmail = new Map();
 const _sessions = new Map(); // sessionId → session
@@ -11,8 +16,11 @@ const _oauthStates = new Map();
 const _cache = new Map();
 const _verificationTokens = new Map();
 const _resetTokens = new Map();
+const _cancelTokens = new Map();
 const _oauthCodes = new Map();
 const _tenantRoles = new Map(); // "userId:tenantId" → roles
+const _groups = new Map(); // groupId → GroupRecord
+const _groupMemberships = new Map();
 /** Reset all in-memory state. Useful for test isolation. */
 export const clearMemoryStore = () => {
     _users.clear();
@@ -21,13 +29,21 @@ export const clearMemoryStore = () => {
     _userSessionIds.clear();
     _refreshTokenIndex.clear();
     _tenantRoles.clear();
+    _groups.clear();
+    _groupMemberships.clear();
     _oauthStates.clear();
     _oauthCodes.clear();
     _cache.clear();
     _verificationTokens.clear();
     _resetTokens.clear();
+    _cancelTokens.clear();
     clearMemoryRateLimitStore();
     clearMemoryMfaChallenges();
+    clearAuditLogMemoryStore();
+    clearPresenceStore();
+    clearWsMessageMemoryStore();
+    clearHeartbeatState();
+    clearMemoryUploadStore();
 };
 // ---------------------------------------------------------------------------
 // Auth adapter
@@ -242,6 +258,106 @@ export const memoryAuthAdapter = {
             _tenantRoles.set(key, current.filter((r) => r !== role));
         }
     },
+    // ---------------------------------------------------------------------------
+    // Groups
+    // ---------------------------------------------------------------------------
+    async createGroup(group) {
+        // Enforce name uniqueness within scope (null = app-wide, string = tenant-scoped)
+        for (const g of _groups.values()) {
+            if (g.name === group.name && g.tenantId === group.tenantId) {
+                throw new HttpError(409, "A group with this name already exists in this scope");
+            }
+        }
+        const id = crypto.randomUUID();
+        const now = Date.now();
+        _groups.set(id, { ...group, id, createdAt: now, updatedAt: now });
+        return { id };
+    },
+    async deleteGroup(groupId) {
+        _groups.delete(groupId);
+        // Cascade: remove all memberships for this group
+        for (const [userId, memberships] of _groupMemberships) {
+            const filtered = memberships.filter((m) => m.groupId !== groupId);
+            if (filtered.length !== memberships.length) {
+                _groupMemberships.set(userId, filtered);
+            }
+        }
+    },
+    async getGroup(groupId) {
+        return _groups.get(groupId) ?? null;
+    },
+    async listGroups(tenantId, opts) {
+        const limit = Math.min(opts?.limit ?? 50, 200);
+        const offset = opts?.offset ?? 0;
+        const all = [..._groups.values()].filter((g) => g.tenantId === tenantId);
+        return { items: all.slice(offset, offset + limit), total: all.length, limit, offset };
+    },
+    async updateGroup(groupId, updates) {
+        const group = _groups.get(groupId);
+        if (!group)
+            return;
+        const now = Date.now();
+        _groups.set(groupId, { ...group, ...updates, id: group.id, tenantId: group.tenantId, createdAt: group.createdAt, updatedAt: now });
+    },
+    async addGroupMember(groupId, userId, roles = []) {
+        const group = _groups.get(groupId);
+        if (!group)
+            throw new HttpError(404, "Group not found");
+        const existing = _groupMemberships.get(userId) ?? [];
+        if (existing.some((m) => m.groupId === groupId)) {
+            throw new HttpError(409, "User is already a member of this group");
+        }
+        _groupMemberships.set(userId, [...existing, {
+                groupId, roles: [...roles], tenantId: group.tenantId, createdAt: Date.now(),
+            }]);
+    },
+    async updateGroupMembership(groupId, userId, roles) {
+        const memberships = _groupMemberships.get(userId);
+        if (!memberships)
+            return;
+        const idx = memberships.findIndex((m) => m.groupId === groupId);
+        if (idx === -1)
+            return;
+        memberships[idx] = { ...memberships[idx], roles: [...roles] };
+    },
+    async removeGroupMember(groupId, userId) {
+        const memberships = _groupMemberships.get(userId);
+        if (!memberships)
+            return;
+        _groupMemberships.set(userId, memberships.filter((m) => m.groupId !== groupId));
+    },
+    async getGroupMembers(groupId, opts) {
+        const limit = Math.min(opts?.limit ?? 50, 200);
+        const offset = opts?.offset ?? 0;
+        const all = [];
+        for (const [userId, memberships] of _groupMemberships) {
+            const m = memberships.find((m) => m.groupId === groupId);
+            if (m)
+                all.push({ userId, roles: [...m.roles] });
+        }
+        return { items: all.slice(offset, offset + limit), total: all.length, limit, offset };
+    },
+    async getUserGroups(userId, tenantId) {
+        const memberships = (_groupMemberships.get(userId) ?? []).filter((m) => m.tenantId === tenantId);
+        const result = [];
+        for (const m of memberships) {
+            const group = _groups.get(m.groupId);
+            if (group)
+                result.push({ group: { ...group }, membershipRoles: [...m.roles] });
+        }
+        return result;
+    },
+    async getEffectiveRoles(userId, tenantId) {
+        const direct = tenantId
+            ? (_tenantRoles.get(`${userId}:${tenantId}`) ?? [])
+            : (_users.get(userId)?.roles ?? []);
+        const memberships = (_groupMemberships.get(userId) ?? []).filter((m) => m.tenantId === tenantId);
+        const groupRoles = memberships.flatMap((m) => [
+            ...(_groups.get(m.groupId)?.roles ?? []),
+            ...m.roles,
+        ]);
+        return [...new Set([...direct, ...groupRoles])];
+    },
 };
 // ---------------------------------------------------------------------------
 // Session helpers (used by src/lib/session.ts)
@@ -349,6 +465,14 @@ export const memoryUpdateSessionLastActive = (sessionId) => {
     if (entry)
         entry.lastActiveAt = Date.now();
 };
+export const memoryGetSessionFingerprint = (sessionId) => {
+    return _sessions.get(sessionId)?.fingerprint ?? null;
+};
+export const memorySetSessionFingerprint = (sessionId, fingerprint) => {
+    const entry = _sessions.get(sessionId);
+    if (entry)
+        entry.fingerprint = fingerprint;
+};
 export const memorySetRefreshToken = (sessionId, refreshToken) => {
     const entry = _sessions.get(sessionId);
     if (!entry)
@@ -488,3 +612,23 @@ export const memoryConsumeOAuthCode = (hash) => {
     _oauthCodes.delete(hash);
     return { token: entry.token, userId: entry.userId, email: entry.email, refreshToken: entry.refreshToken };
 };
+// ---------------------------------------------------------------------------
+// Account deletion cancel token helpers (used by src/lib/deletionCancelToken.ts)
+// ---------------------------------------------------------------------------
+export const memoryCreateDeletionCancelToken = (token, userId, jobId, ttlSeconds) => {
+    const now = Date.now();
+    for (const [k, v] of _cancelTokens) {
+        if (v.expiresAt <= now)
+            _cancelTokens.delete(k);
+    }
+    _cancelTokens.set(token, { userId, jobId, expiresAt: now + ttlSeconds * 1000 });
+};
+export const memoryConsumeDeletionCancelToken = (hash) => {
+    const entry = _cancelTokens.get(hash);
+    if (!entry || entry.expiresAt <= Date.now()) {
+        _cancelTokens.delete(hash);
+        return null;
+    }
+    _cancelTokens.delete(hash);
+    return { userId: entry.userId, jobId: entry.jobId };
+};

package/dist/adapters/memoryStorage.d.ts

@@ -0,0 +1,3 @@
+import type { StorageAdapter } from "../lib/storageAdapter";
+export declare const clearMemoryUploadStore: () => void;
+export declare const memoryStorage: () => StorageAdapter;

package/dist/adapters/memoryStorage.js

@@ -0,0 +1,44 @@
+const _store = new Map();
+export const clearMemoryUploadStore = () => {
+    _store.clear();
+};
+export const memoryStorage = () => ({
+    async put(key, data, meta) {
+        let buf;
+        if (data instanceof Blob) {
+            buf = Buffer.from(await data.arrayBuffer());
+        }
+        else if (data instanceof ReadableStream) {
+            const chunks = [];
+            const reader = data.getReader();
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (value)
+                    chunks.push(value);
+            }
+            buf = Buffer.concat(chunks);
+        }
+        else {
+            buf = data;
+        }
+        _store.set(key, { data: buf, mimeType: meta.mimeType, size: meta.size });
+        return {};
+    },
+    async get(key) {
+        const entry = _store.get(key);
+        if (!entry)
+            return null;
+        const stream = new ReadableStream({
+            start(controller) {
+                controller.enqueue(entry.data);
+                controller.close();
+            },
+        });
+        return { stream, mimeType: entry.mimeType, size: entry.size };
+    },
+    async delete(key) {
+        _store.delete(key);
+    },
+});

package/dist/adapters/mongoAuth.js

@@ -1,5 +1,7 @@
 import { AuthUser } from "../models/AuthUser";
 import { TenantRole } from "../models/TenantRole";
+import { Group } from "../models/Group";
+import { GroupMembership } from "../models/GroupMembership";
 import { HttpError } from "../lib/HttpError";
 export const mongoAuthAdapter = {
     async findByEmail(email) {
@@ -184,4 +186,122 @@ export const mongoAuthAdapter = {
     async removeTenantRole(userId, tenantId, role) {
         await TenantRole.findOneAndUpdate({ userId, tenantId }, { $pull: { roles: role } });
     },
+    // ---------------------------------------------------------------------------
+    // Groups
+    // ---------------------------------------------------------------------------
+    async createGroup(group) {
+        try {
+            const doc = await Group.create(group);
+            return { id: String(doc._id) };
+        }
+        catch (err) {
+            if (err?.code === 11000)
+                throw new HttpError(409, "A group with this name already exists in this scope");
+            throw err;
+        }
+    },
+    async deleteGroup(groupId) {
+        await Group.findByIdAndDelete(groupId);
+        // Explicit cascade (Mongoose middleware hooks are intentionally avoided for visibility)
+        await GroupMembership.deleteMany({ groupId });
+    },
+    async getGroup(groupId) {
+        const doc = await Group.findById(groupId).lean();
+        if (!doc)
+            return null;
+        return mongoGroupToRecord(doc);
+    },
+    async listGroups(tenantId, opts) {
+        const limit = Math.min(opts?.limit ?? 50, 200);
+        const offset = opts?.offset ?? 0;
+        const filter = { tenantId: tenantId ?? null };
+        const [docs, total] = await Promise.all([
+            Group.find(filter).skip(offset).limit(limit).lean(),
+            Group.countDocuments(filter),
+        ]);
+        return { items: docs.map(mongoGroupToRecord), total, limit, offset };
+    },
+    async updateGroup(groupId, updates) {
+        await Group.findByIdAndUpdate(groupId, { $set: updates });
+    },
+    async addGroupMember(groupId, userId, roles = []) {
+        // Look up group to get tenantId for denormalization
+        const group = await Group.findById(groupId, "tenantId").lean();
+        if (!group)
+            throw new HttpError(404, "Group not found");
+        try {
+            await GroupMembership.create({ groupId, userId, roles, tenantId: group.tenantId ?? null });
+        }
+        catch (err) {
+            if (err?.code === 11000)
+                throw new HttpError(409, "User is already a member of this group");
+            throw err;
+        }
+    },
+    async updateGroupMembership(groupId, userId, roles) {
+        await GroupMembership.findOneAndUpdate({ groupId, userId }, { $set: { roles } });
+    },
+    async removeGroupMember(groupId, userId) {
+        await GroupMembership.deleteOne({ groupId, userId });
+    },
+    async getGroupMembers(groupId, opts) {
+        const limit = Math.min(opts?.limit ?? 50, 200);
+        const offset = opts?.offset ?? 0;
+        const [docs, total] = await Promise.all([
+            GroupMembership.find({ groupId }, "userId roles").skip(offset).limit(limit).lean(),
+            GroupMembership.countDocuments({ groupId }),
+        ]);
+        return {
+            items: docs.map((d) => ({ userId: d.userId, roles: d.roles ?? [] })),
+            total, limit, offset,
+        };
+    },
+    async getUserGroups(userId, tenantId) {
+        const memberships = await GroupMembership.find({ userId, tenantId: tenantId ?? null }, "groupId roles").lean();
+        if (memberships.length === 0)
+            return [];
+        const groupIds = memberships.map((m) => m.groupId);
+        const groups = await Group.find({ _id: { $in: groupIds } }).lean();
+        const groupMap = new Map(groups.map((g) => [String(g._id), g]));
+        return memberships.map((m) => ({
+            group: mongoGroupToRecord(groupMap.get(m.groupId)),
+            membershipRoles: m.roles ?? [],
+        })).filter((r) => r.group);
+    },
+    async getEffectiveRoles(userId, tenantId) {
+        // Direct roles
+        let direct = [];
+        if (tenantId) {
+            const doc = await TenantRole.findOne({ userId, tenantId }, "roles").lean();
+            direct = doc?.roles ?? [];
+        }
+        else {
+            const user = await AuthUser.findById(userId, "roles").lean();
+            direct = user?.roles ?? [];
+        }
+        // Group roles via memberships
+        const memberships = await GroupMembership.find({ userId, tenantId: tenantId ?? null }, "groupId roles").lean();
+        if (memberships.length === 0)
+            return [...new Set(direct)];
+        const groupIds = memberships.map((m) => m.groupId);
+        const groups = await Group.find({ _id: { $in: groupIds } }, "roles").lean();
+        const groupMap = new Map(groups.map((g) => [String(g._id), g.roles ?? []]));
+        const groupRoles = memberships.flatMap((m) => [
+            ...(groupMap.get(m.groupId) ?? []),
+            ...(m.roles ?? []),
+        ]);
+        return [...new Set([...direct, ...groupRoles])];
+    },
 };
+function mongoGroupToRecord(doc) {
+    return {
+        id: String(doc._id),
+        name: doc.name,
+        displayName: doc.displayName,
+        description: doc.description,
+        roles: doc.roles ?? [],
+        tenantId: doc.tenantId ?? null,
+        createdAt: doc.createdAt instanceof Date ? doc.createdAt.getTime() : doc.createdAt,
+        updatedAt: doc.updatedAt instanceof Date ? doc.updatedAt.getTime() : doc.updatedAt,
+    };
+}

package/dist/adapters/s3Storage.d.ts

@@ -0,0 +1,14 @@
+import type { StorageAdapter } from "../lib/storageAdapter";
+export interface S3StorageConfig {
+    bucket: string;
+    region?: string;
+    endpoint?: string;
+    credentials?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+    };
+    publicUrl?: string;
+    forcePathStyle?: boolean;
+    streaming?: boolean;
+}
+export declare const s3Storage: (config: S3StorageConfig) => StorageAdapter;

package/dist/adapters/s3Storage.js

@@ -0,0 +1,126 @@
+function requireS3Client() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        return require("@aws-sdk/client-s3");
+    }
+    catch {
+        throw new Error("@aws-sdk/client-s3 is not installed. Run: bun add @aws-sdk/client-s3");
+    }
+}
+function requirePresigner() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        return require("@aws-sdk/s3-request-presigner");
+    }
+    catch {
+        throw new Error("@aws-sdk/s3-request-presigner is not installed. Run: bun add @aws-sdk/s3-request-presigner");
+    }
+}
+function requireLibStorage() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        return require("@aws-sdk/lib-storage");
+    }
+    catch {
+        throw new Error("@aws-sdk/lib-storage is not installed. Run: bun add @aws-sdk/lib-storage");
+    }
+}
+export const s3Storage = (config) => {
+    let _client = null;
+    const getClient = () => {
+        if (!_client) {
+            const { S3Client } = requireS3Client();
+            _client = new S3Client({
+                region: config.region ?? "us-east-1",
+                ...(config.endpoint ? { endpoint: config.endpoint } : {}),
+                ...(config.credentials ? { credentials: config.credentials } : {}),
+                ...(config.forcePathStyle !== undefined ? { forcePathStyle: config.forcePathStyle } : {}),
+            });
+        }
+        return _client;
+    };
+    return {
+        async put(key, data, meta) {
+            const bucket = meta.bucket ?? config.bucket;
+            const client = getClient();
+            if (config.streaming && data instanceof ReadableStream) {
+                const { Upload } = requireLibStorage();
+                const upload = new Upload({
+                    client,
+                    params: {
+                        Bucket: bucket,
+                        Key: key,
+                        Body: data,
+                        ContentType: meta.mimeType,
+                    },
+                });
+                await upload.done();
+            }
+            else {
+                const { PutObjectCommand } = requireS3Client();
+                let body;
+                if (data instanceof ReadableStream) {
+                    const response = new Response(data);
+                    body = Buffer.from(await response.arrayBuffer());
+                }
+                else if (data instanceof Blob) {
+                    body = Buffer.from(await data.arrayBuffer());
+                }
+                else {
+                    body = data;
+                }
+                await client.send(new PutObjectCommand({
+                    Bucket: bucket,
+                    Key: key,
+                    Body: body,
+                    ContentType: meta.mimeType,
+                    ContentLength: meta.size,
+                }));
+            }
+            const url = config.publicUrl
+                ? `${config.publicUrl.replace(/\/$/, "")}/${key}`
+                : undefined;
+            return { ...(url !== undefined ? { url } : {}) };
+        },
+        async get(key) {
+            const { GetObjectCommand } = requireS3Client();
+            const client = getClient();
+            const bucket = config.bucket;
+            try {
+                const result = await client.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+                return {
+                    stream: result.Body,
+                    mimeType: result.ContentType,
+                    size: result.ContentLength,
+                };
+            }
+            catch (err) {
+                if (err?.name === "NoSuchKey" || err?.$metadata?.httpStatusCode === 404)
+                    return null;
+                throw err;
+            }
+        },
+        async delete(key) {
+            const { DeleteObjectCommand } = requireS3Client();
+            const client = getClient();
+            await client.send(new DeleteObjectCommand({ Bucket: config.bucket, Key: key }));
+        },
+        async presignPut(key, opts) {
+            const { PutObjectCommand } = requireS3Client();
+            const { getSignedUrl } = requirePresigner();
+            const client = getClient();
+            const params = {
+                Bucket: config.bucket,
+                Key: key,
+                ...(opts.mimeType ? { ContentType: opts.mimeType } : {}),
+            };
+            return getSignedUrl(client, new PutObjectCommand(params), { expiresIn: opts.expirySeconds });
+        },
+        async presignGet(key, opts) {
+            const { GetObjectCommand } = requireS3Client();
+            const { getSignedUrl } = requirePresigner();
+            const client = getClient();
+            return getSignedUrl(client, new GetObjectCommand({ Bucket: config.bucket, Key: key }), { expiresIn: opts.expirySeconds });
+        },
+    };
+};

package/dist/adapters/sqliteAuth.d.ts

@@ -15,6 +15,8 @@ import type { RefreshResult } from "../lib/session";
 export declare const sqliteSetRefreshToken: (sessionId: string, refreshToken: string) => void;
 export declare const sqliteGetSessionByRefreshToken: (refreshToken: string) => RefreshResult | null;
 export declare const sqliteRotateRefreshToken: (sessionId: string, newRefreshToken: string, newAccessToken: string) => void;
+export declare const sqliteGetSessionFingerprint: (sessionId: string) => string | null;
+export declare const sqliteSetSessionFingerprint: (sessionId: string, fingerprint: string) => void;
 export declare const sqliteStoreOAuthState: (state: string, codeVerifier?: string, linkUserId?: string) => void;
 export declare const sqliteConsumeOAuthState: (state: string) => {
     codeVerifier?: string;
@@ -36,6 +38,11 @@ export declare const sqliteConsumeResetToken: (hash: string) => {
     userId: string;
     email: string;
 } | null;
+export declare const sqliteCreateDeletionCancelToken: (token: string, userId: string, jobId: string, ttlSeconds: number) => void;
+export declare const sqliteConsumeDeletionCancelToken: (hash: string) => {
+    userId: string;
+    jobId: string;
+} | null;
 import type { OAuthCodePayload } from "../lib/oauthCode";
 export declare const sqliteStoreOAuthCode: (hash: string, payload: OAuthCodePayload, ttlSeconds: number) => void;
 export declare const sqliteConsumeOAuthCode: (hash: string) => OAuthCodePayload | null;