@learncard/network-brain-service 3.19.0 → 4.0.0

package/src/helpers/share-link-maintenance/scheduler.ts

@@ -0,0 +1,126 @@
+import { safeLogMaintenance } from './telemetry';
+import type { ShareLinkMaintenanceLogger, ShareLinkMaintenanceRunSummary } from './types';
+
+export type ShareLinkMaintenanceSchedulerDependencies = {
+    runOnce: (options?: { remainingTimeMs?: number }) => Promise<unknown>;
+    intervalMs: number;
+    logger: ShareLinkMaintenanceLogger;
+    setTimeoutFn?: (handler: () => void, timeoutMs: number) => unknown;
+    clearTimeoutFn?: (handle: unknown) => void;
+};
+
+export type ShareLinkMaintenanceScheduler = {
+    /** Idempotent; schedules the first bounded pass one interval from now. */
+    start: () => void;
+    /** Stops scheduling and drains an in-flight pass. */
+    stop: () => Promise<void>;
+    /** Runs one pass now, coalescing with an in-flight pass (no overlap). */
+    trigger: () => Promise<void>;
+    isRunning: () => boolean;
+};
+
+const defaultSetTimeout = (handler: () => void, timeoutMs: number): unknown =>
+    setTimeout(handler, timeoutMs);
+
+const defaultClearTimeout = (handle: unknown): void => {
+    clearTimeout(handle as ReturnType<typeof setTimeout>);
+};
+
+const fixedFailureSummary = (intervalMs: number): ShareLinkMaintenanceRunSummary => ({
+    status: 'failed',
+    durationMs: 0,
+    budgetMs: intervalMs,
+    recovery: null,
+    cleanup: null,
+    receiptPrune: null,
+    categories: { share_link_maintenance_pass_failed: 1 },
+});
+
+/**
+ * Non-overlapping maintenance loop.
+ *
+ * The next tick is scheduled only *after* the awaited pass settles, so a slow
+ * pass can never stack timers. `trigger` coalesces with an in-flight pass, which
+ * is the per-process overlap guard; other processes are fenced by the durable
+ * repository claims. `stop` is terminal: it clears the pending tick, awaits the
+ * in-flight pass, and rejects any later explicit trigger or already-queued timer
+ * callback. Nothing here registers a timer at module import, and a logger failure
+ * cannot corrupt the loop state.
+ */
+export const createShareLinkMaintenanceScheduler = (
+    dependencies: ShareLinkMaintenanceSchedulerDependencies
+): ShareLinkMaintenanceScheduler => {
+    const setTimeoutFn = dependencies.setTimeoutFn ?? defaultSetTimeout;
+    const clearTimeoutFn = dependencies.clearTimeoutFn ?? defaultClearTimeout;
+
+    let started = false;
+    let stopped = false;
+    let timer: unknown = null;
+    let inFlight: Promise<void> | null = null;
+
+    const scheduleNext = (): void => {
+        if (stopped || !started) return;
+
+        timer = setTimeoutFn(() => {
+            void tick();
+        }, dependencies.intervalMs);
+    };
+
+    const tick = async (): Promise<void> => {
+        await trigger();
+        scheduleNext();
+    };
+
+    const trigger = (): Promise<void> => {
+        // Stop is terminal: nothing, including an explicit trigger or an already
+        // queued timer callback, may start work after `stop()`.
+        if (stopped) return Promise.resolve();
+
+        if (inFlight) return inFlight;
+
+        // An `async` wrapper converts a synchronous `runOnce` throw into a
+        // rejected promise, and `.finally` always settles on a microtask, so the
+        // assignment below can never race the clearing callback and leave
+        // `inFlight` stuck on an already-settled promise.
+        const run = async (): Promise<void> => {
+            try {
+                await dependencies.runOnce();
+            } catch {
+                safeLogMaintenance(
+                    dependencies.logger,
+                    fixedFailureSummary(dependencies.intervalMs)
+                );
+            }
+        };
+
+        const pass = run().finally(() => {
+            if (inFlight === pass) inFlight = null;
+        });
+
+        inFlight = pass;
+
+        return pass;
+    };
+
+    return {
+        start: () => {
+            if (started || stopped) return;
+
+            started = true;
+            scheduleNext();
+        },
+        stop: async () => {
+            stopped = true;
+            started = false;
+
+            if (timer !== null) {
+                clearTimeoutFn(timer);
+                timer = null;
+            }
+
+            if (inFlight) await inFlight;
+        },
+        trigger,
+        isRunning: () => inFlight !== null,
+    };
+};

package/src/helpers/share-link-maintenance/telemetry.ts

@@ -0,0 +1,73 @@
+import type { CleanupRunSummary, ShareRecoveryRunSummary } from '../share-link-coordinator';
+import type {
+    ShareLinkMaintenanceLogEvent,
+    ShareLinkMaintenanceLogger,
+    ShareLinkMaintenanceRunSummary,
+} from './types';
+
+/**
+ * Fixed, allowlisted aggregate counters. This is the ONLY surface a maintenance
+ * log may contain: no object ref, share id, owner id, namespace value, title,
+ * note, URL, fragment, key, ciphertext, recovery blob or exception object.
+ */
+const recoveryCounts = (recovery: ShareRecoveryRunSummary | null): Record<string, number> => ({
+    recoveryDiscovered: recovery?.discovered ?? 0,
+    recoveryClaimed: recovery?.claimed ?? 0,
+    recoveryFinalized: recovery?.finalized ?? 0,
+    recoveryAbandoned: recovery?.abandoned ?? 0,
+    recoveryDeferred: recovery?.deferred ?? 0,
+    recoveryClaimLost: recovery?.claimLost ?? 0,
+    recoveryAnomalies: recovery?.anomalies ?? 0,
+});
+
+const cleanupCounts = (cleanup: CleanupRunSummary | null): Record<string, number> => ({
+    cleanupClaimed: cleanup?.claimed ?? 0,
+    cleanupCompleted: cleanup?.completed ?? 0,
+    cleanupRetried: cleanup?.retried ?? 0,
+    cleanupClaimLost: cleanup?.claimLost ?? 0,
+    cleanupSkipped: cleanup?.skipped ?? 0,
+});
+
+export const toMaintenanceLogEvent = (
+    summary: ShareLinkMaintenanceRunSummary
+): ShareLinkMaintenanceLogEvent => ({
+    event: 'share_link_maintenance',
+    status: summary.status,
+    durationMs: Math.max(0, Math.trunc(summary.durationMs)),
+    budgetMs: Math.max(0, Math.trunc(summary.budgetMs)),
+    counts: {
+        ...recoveryCounts(summary.recovery),
+        ...cleanupCounts(summary.cleanup),
+        receiptsPruned: summary.receiptPrune?.pruned ?? 0,
+        ...(summary.attachmentStages
+            ? { attachmentStagesQueued: summary.attachmentStages.queued }
+            : {}),
+    },
+    categories: {
+        ...(summary.recovery?.categories ?? {}),
+        ...(summary.cleanup?.categories ?? {}),
+        ...summary.categories,
+    },
+});
+
+/**
+ * Emit one allowlisted event. A throwing logger is swallowed: telemetry must
+ * never corrupt lifecycle state or turn a completed pass into a failure.
+ */
+export const safeLogMaintenance = (
+    logger: ShareLinkMaintenanceLogger,
+    summary: ShareLinkMaintenanceRunSummary
+): void => {
+    try {
+        const event = toMaintenanceLogEvent(summary);
+        if (summary.status === 'failed') logger.error(event);
+        else logger.info(event);
+    } catch {
+        // Intentionally ignored: lifecycle state is authoritative.
+    }
+};
+
+export const createConsoleMaintenanceLogger = (): ShareLinkMaintenanceLogger => ({
+    info: event => console.log('[share-link-maintenance]', event),
+    error: event => console.error('[share-link-maintenance]', event),
+});

package/src/helpers/share-link-maintenance/types.ts

@@ -0,0 +1,91 @@
+import type { ShareRecoveryRunSummary, CleanupRunSummary } from '../share-link-coordinator';
+
+/**
+ * LC-2187 share-link maintenance (scheduling + cleanup integration).
+ *
+ * This module owns the automatically configured, namespace-scoped maintenance pass. It
+ * is deliberately separate from the coordinator barrel so unit tests never load
+ * the Neo4j `@instance` or the LearnCard signing graph.
+ */
+
+/** A fully validated, enabled maintenance configuration. */
+export type ShareLinkMaintenanceConfig = {
+    namespace: string;
+    origin: string;
+    audience: string;
+    allowInsecureLoopback: boolean;
+    claimant: string;
+    recoveryLimit: number;
+    cleanupLimit: number;
+    receiptPruneLimit: number;
+    leaseMs: number;
+    claimMs: number;
+    budgetMs: number;
+    intervalMs: number;
+    requestTimeoutMs: number;
+    finalizeReserveMs: number;
+    graphTimeoutMs: number;
+};
+
+/**
+ * Fixed, non-sensitive configuration outcome. `invalid` never carries the bad
+ * value or an exception, so it is safe to log verbatim.
+ */
+export type ShareLinkMaintenanceConfigResolution =
+    | { status: 'enabled'; config: ShareLinkMaintenanceConfig }
+    | { status: 'disabled' }
+    | { status: 'invalid'; category: 'share_link_maintenance_configuration_invalid' };
+
+/** Fixed pass status. Never carries request/record data. */
+export type ShareLinkMaintenanceStatus =
+    | 'disabled'
+    | 'invalid_configuration'
+    | 'initialization_failed'
+    | 'completed'
+    | 'deadline_exhausted'
+    | 'failed';
+
+/** Fixed failure categories allowed in a maintenance summary/log. */
+export type ShareLinkMaintenanceFailureCategory =
+    | 'share_link_maintenance_pass_failed'
+    | 'share_link_maintenance_recovery_failed'
+    | 'share_link_maintenance_cleanup_failed'
+    | 'share_link_maintenance_attachment_stage_failed'
+    | 'share_link_maintenance_receipt_prune_failed'
+    | 'share_link_maintenance_initialization_failed'
+    | 'share_link_maintenance_configuration_invalid';
+
+/**
+ * Aggregate-only result of one maintenance invocation. It contains counts,
+ * durations and fixed categories; it never contains object/share/owner ids,
+ * URLs, keys, ciphertext, recovery, titles, notes or exception objects.
+ */
+export type ShareLinkMaintenanceRunSummary = {
+    status: ShareLinkMaintenanceStatus;
+    durationMs: number;
+    budgetMs: number;
+    recovery: ShareRecoveryRunSummary | null;
+    cleanup: CleanupRunSummary | null;
+    /** Namespace-scoped expired/consumed receipt nodes deleted this pass. */
+    receiptPrune: { pruned: number } | null;
+    attachmentStages?: { queued: number } | null;
+    categories: Partial<Record<ShareLinkMaintenanceFailureCategory, number>>;
+};
+
+/**
+ * Allowlisted log event shape. The logger is called with this object only; a
+ * throwing logger must never corrupt lifecycle state.
+ */
+export type ShareLinkMaintenanceLogEvent = {
+    event: 'share_link_maintenance';
+    status: ShareLinkMaintenanceStatus;
+    durationMs: number;
+    budgetMs: number;
+    counts: Record<string, number>;
+    categories: Record<string, number>;
+};
+
+export type ShareLinkMaintenanceLogger = {
+    info: (event: ShareLinkMaintenanceLogEvent) => void;
+    error: (event: ShareLinkMaintenanceLogEvent) => void;
+};

package/src/helpers/share-link-owner/config.ts

@@ -0,0 +1,48 @@
+import {
+    hasShareLinkServiceTransportConfig,
+    resolveShareLinkServiceTransportConfig,
+} from '../share-link-maintenance/config';
+
+/**
+ * Available automatically once trusted service configuration is complete.
+ * Namespace, origin and audience come only from server configuration. Missing
+ * wiring is inactive; partial or invalid wiring fails closed.
+ */
+
+export const SHARE_LINK_OWNER_API_ENV = {
+    NAMESPACE: 'SHARE_LINK_OWNER_API_NAMESPACE',
+} as const;
+
+export type ShareLinkOwnerApiConfigResolution =
+    | { status: 'disabled' }
+    | { status: 'invalid' }
+    | {
+          status: 'enabled';
+          namespace: string;
+          origin: string;
+          audience: string;
+          allowInsecureLoopback: boolean;
+      };
+
+export const resolveShareLinkOwnerApiConfig = (raw: unknown): ShareLinkOwnerApiConfigResolution => {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) return { status: 'invalid' };
+
+    const source = raw as Record<string, unknown>;
+    if (!hasShareLinkServiceTransportConfig(source)) return { status: 'disabled' };
+
+    const transport = resolveShareLinkServiceTransportConfig(source);
+    if (transport.status !== 'enabled') return { status: 'invalid' };
+
+    const ownerNamespace = source[SHARE_LINK_OWNER_API_ENV.NAMESPACE];
+    if (ownerNamespace !== undefined && ownerNamespace !== transport.config.namespace) {
+        return { status: 'invalid' };
+    }
+
+    return {
+        status: 'enabled',
+        namespace: transport.config.namespace,
+        origin: transport.config.origin,
+        audience: transport.config.audience,
+        allowInsecureLoopback: transport.config.allowInsecureLoopback,
+    };
+};

package/src/helpers/share-link-owner/diagnostics.ts

@@ -0,0 +1,89 @@
+/**
+ * Bounded, sanitized diagnostics for share-link service composition.
+ *
+ * The owner and public APIs fail closed for two states that are otherwise
+ * indistinguishable to an operator:
+ *
+ * - intentionally absent configuration (`status: 'disabled'`) is silent and
+ *   inert; it is a supported deployment;
+ * - malformed/partial service wiring (`status: 'invalid'`) or a failed
+ *   dependency build emits one fixed category so a misconfiguration is
+ *   distinguishable from an unconfigured deployment.
+ *
+ * The reporter is bounded per process: each category is emitted at most once,
+ * so a flood of requests against a misconfigured deployment cannot flood logs.
+ * The event carries only a fixed allowlisted category string: never an
+ * environment value, URL, request body, DID key, title, note or ciphertext.
+ */
+
+export const SHARE_LINK_COMPOSITION_DIAGNOSTIC = {
+    OWNER_CONFIGURATION_INVALID: 'share_link_owner_configuration_invalid',
+    OWNER_INITIALIZATION_FAILED: 'share_link_owner_initialization_failed',
+    PUBLIC_CONFIGURATION_INVALID: 'share_link_public_configuration_invalid',
+    PUBLIC_INITIALIZATION_FAILED: 'share_link_public_initialization_failed',
+} as const;
+
+export type ShareLinkCompositionDiagnosticCategory =
+    (typeof SHARE_LINK_COMPOSITION_DIAGNOSTIC)[keyof typeof SHARE_LINK_COMPOSITION_DIAGNOSTIC];
+
+export type ShareLinkDiagnosticSink = (category: ShareLinkCompositionDiagnosticCategory) => void;
+
+/** Aggregate-only sink matching the existing route reporting convention. */
+export const defaultShareLinkDiagnosticSink: ShareLinkDiagnosticSink = category => {
+    console.warn('share_link_composition_diagnostic', { category });
+};
+
+/** Wrap a sink so each category is emitted at most once per process. */
+export const createBoundedShareLinkDiagnosticReporter = (
+    sink: ShareLinkDiagnosticSink = defaultShareLinkDiagnosticSink
+): ShareLinkDiagnosticSink => {
+    const reported = new Set<ShareLinkCompositionDiagnosticCategory>();
+
+    return category => {
+        if (reported.has(category)) return;
+        reported.add(category);
+        sink(category);
+    };
+};
+
+type ShareLinkConfigStatus = { status: 'disabled' } | { status: 'invalid' } | { status: 'enabled' };
+
+/**
+ * Compose the lazy getter a share-link router uses around a pure config
+ * resolution and a retryable initializer.
+ *
+ * Disabled configuration returns `null` silently. Invalid configuration reports
+ * a single sanitized diagnostic and returns `null`, preserving the anonymous
+ * not_found behavior. An enabled but failing build reports a single sanitized
+ * diagnostic and rethrows so the caller maps it to a generic error while the
+ * retryable initializer clears the failed attempt cache.
+ */
+export const createShareLinkDependencyResolver = <TDependencies>(options: {
+    readonly resolveConfig: () => ShareLinkConfigStatus;
+    readonly initializeDependencies: () => Promise<TDependencies>;
+    readonly reportDiagnostic: ShareLinkDiagnosticSink;
+    readonly configurationInvalidCategory: ShareLinkCompositionDiagnosticCategory;
+    readonly initializationFailedCategory: ShareLinkCompositionDiagnosticCategory;
+}): (() => Promise<TDependencies | null>) => {
+    return async () => {
+        const config = options.resolveConfig();
+
+        // Intentionally absent configuration: inert and silent.
+        if (config.status === 'disabled') return null;
+
+        // Malformed/partial wiring: one bounded diagnostic, still fail closed.
+        if (config.status === 'invalid') {
+            options.reportDiagnostic(options.configurationInvalidCategory);
+            return null;
+        }
+
+        try {
+            return await options.initializeDependencies();
+        } catch (error) {
+            // The initializer has already cleared its failed attempt; report the
+            // category once and let the caller surface a sanitized error.
+            options.reportDiagnostic(options.initializationFailedCategory);
+            throw error;
+        }
+    };
+};

package/src/helpers/share-link-owner/lazy-initializer.ts

@@ -0,0 +1,29 @@
+/**
+ * Retryable lazy initialization for the owner share-link runtime.
+ *
+ * Successful and in-flight builds are shared across concurrent callers. A
+ * *failed* build must never be cached: a transient constraint/graph/signer
+ * failure would otherwise poison the owner API until the process restarts
+ * (the same defect previously corrected for the C7 setup cache). Only the
+ * failed attempt is cleared, so a later request retries while any other
+ * in-flight attempt keeps its own shared promise.
+ */
+export const createRetryableLazyInitializer = <T>(build: () => Promise<T>): (() => Promise<T>) => {
+    let cached: Promise<T> | null = null;
+
+    return () => {
+        if (cached) return cached;
+
+        const attempt = build();
+        cached = attempt;
+
+        // Preserve the rejection for the awaiting caller, but detach it from the
+        // cache so the next call rebuilds. `catch` also prevents an unhandled
+        // rejection when nobody is awaiting this particular attempt.
+        attempt.catch(() => {
+            if (cached === attempt) cached = null;
+        });
+
+        return attempt;
+    };
+};

package/src/helpers/share-link-owner-projection.ts

@@ -0,0 +1,54 @@
+import type { ShareLink } from '@learncard/types';
+
+import type { ShareLinkRecord } from '../models/ShareLink';
+
+/**
+ * Explicit owner projection of a `ShareLinkRecord`.
+ *
+ * This is a deliberate field-by-field mapping, never a spread: the raw record
+ * carries internal object refs, operation ids, leases, hashes, byte counts and
+ * ciphertext bindings that must never reach a caller. `contentUrl` is
+ * intentionally omitted here — the public resolve/content routes own the guarded
+ * relative URL, and a LearnCloud object URL (or a fabricated decryption key)
+ * must never be exposed.
+ *
+ * `viewCountingEnabled` is the FRESHLY re-resolved authoritative eligibility for
+ * the owner (never the stale `minorPolicyViewCountingEnabled` snapshot alone and
+ * never a caller field). When it is not exactly `true`, `viewCount` is omitted
+ * and `lastViewedAt` is nulled so a formerly eligible owner's historical counts
+ * stop leaking through get/mutation/status/retry.
+ */
+export const toOwnerShareLink = (
+    record: ShareLinkRecord,
+    viewCountingEnabled?: boolean
+): ShareLink => {
+    const countingEnabled = viewCountingEnabled === true;
+
+    return {
+        id: record.id,
+        title: record.title,
+        ...(record.note === null ? {} : { note: record.note }),
+        selectedCount: record.selectedCount,
+        version: record.version,
+        contentVersion: record.contentVersion,
+        attachmentId: record.attachmentId ?? null,
+        attachmentChunkCount: record.attachmentChunkCount ?? null,
+        status: record.status,
+        contentState: record.contentState,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+        expiresAt: record.expiresAt,
+        stoppedAt: record.stoppedAt,
+        ...(countingEnabled
+            ? { lastViewedAt: record.lastViewedAt, viewCount: record.viewCount }
+            : { lastViewedAt: null }),
+        passcodeProtected: record.passcodeHash != null,
+        notifyOnView: record.notifyOnView === true,
+        minorPolicy: {
+            isMinor: record.minorPolicyIsMinor,
+            policyResolved: record.minorPolicyResolved,
+            defaultExpiryDays: record.minorPolicyDefaultExpiryDays === 365 ? 365 : 30,
+            viewCountingEnabled: record.minorPolicyViewCountingEnabled,
+        },
+    };
+};

package/src/helpers/share-link-passcode-abuse.ts

@@ -0,0 +1,36 @@
+import cache from '@cache';
+import { environment } from '@environment';
+
+// The short shared window limits distributed guessing while bounding the time
+// an attacker can deny access to a legitimate recipient. Per-source limits
+// preserve capacity for other recipients until the shared budget is exhausted.
+const WINDOW_SECONDS = 60;
+// A successful recipient view checks the passcode at resolve and content, so
+// it spends two attempts. Keep that in mind before lowering these budgets.
+const SHARE_ATTEMPT_LIMIT = 24;
+const SOURCE_ATTEMPT_LIMIT = 6;
+
+const keys = (namespace: string, shareId: string, sourceIp?: string): [string, string] => [
+    `share-link-passcode-attempt:${namespace}:${shareId}`,
+    `share-link-passcode-attempt-source:${namespace}:${shareId}:${sourceIp ?? 'unknown'}`,
+];
+
+export const reserveSharePasscodeAttempt = async (
+    namespace: string,
+    shareId: string,
+    sourceIp?: string
+): Promise<boolean> => {
+    // Process-local fallback counters cannot stop rotated-IP guesses across
+    // production workers. Protected access requires the shared Redis counter.
+    if (environment.NODE_ENV === 'production' && !cache.redis) return false;
+    const [shareKey, sourceKey] = keys(namespace, shareId, sourceIp);
+    // Reserve before Argon2. Redis INCR is atomic across Lambda instances, so
+    // simultaneous guesses cannot all read a stale budget. Count successful
+    // attempts too; no cross-key refund race and no stored submitted value.
+    const sourceCount = await cache.incr(sourceKey, WINDOW_SECONDS);
+    if (sourceCount === undefined || sourceCount > SOURCE_ATTEMPT_LIMIT) return false;
+    // Rejected requests from this source never consume another recipient's
+    // share-wide budget. Both reservations still precede Argon2.
+    const shareCount = await cache.incr(shareKey, WINDOW_SECONDS);
+    return shareCount !== undefined && shareCount <= SHARE_ATTEMPT_LIMIT;
+};

package/src/helpers/share-link-passcode.ts

@@ -0,0 +1,47 @@
+import { randomBytes } from 'node:crypto';
+
+import { argon2id, argon2Verify } from 'hash-wasm';
+
+const ARGON2_MEMORY_KIB = 19_456;
+const ARGON2_ITERATIONS = 2;
+const ARGON2_PARALLELISM = 1;
+const ARGON2_HASH_BYTES = 32;
+const MAX_CONCURRENT_VERIFICATIONS = 4;
+let activeVerifications = 0;
+
+export class SharePasscodeCapacityError extends Error {
+    constructor() {
+        super('share passcode verification capacity exhausted');
+        this.name = 'SharePasscodeCapacityError';
+    }
+}
+
+/** Hash a share passcode as an Argon2id PHC string with a fresh 128-bit salt. */
+export const hashSharePasscode = async (passcode: string): Promise<string> =>
+    argon2id({
+        password: passcode,
+        salt: randomBytes(16),
+        iterations: ARGON2_ITERATIONS,
+        memorySize: ARGON2_MEMORY_KIB,
+        parallelism: ARGON2_PARALLELISM,
+        hashLength: ARGON2_HASH_BYTES,
+        outputType: 'encoded',
+    });
+
+/** Verify without ever logging, returning, or persisting the plaintext passcode. */
+export const verifySharePasscode = async (
+    passcodeHash: string,
+    passcode: string
+): Promise<boolean> => {
+    // Local defense for long-lived workers; Lambda's cross-instance budget is
+    // reserved in Redis before this function runs. Capacity is not a wrong code.
+    if (activeVerifications >= MAX_CONCURRENT_VERIFICATIONS) throw new SharePasscodeCapacityError();
+    activeVerifications += 1;
+    try {
+        return await argon2Verify({ password: passcode, hash: passcodeHash });
+    } catch {
+        return false;
+    } finally {
+        activeVerifications -= 1;
+    }
+};

package/src/helpers/share-link-policy/index.ts

@@ -0,0 +1,7 @@
+export * from './types';
+export {
+    composeShareLinkPolicy,
+    createShareLinkPolicyResolver,
+    resolveShareLinkExpiry,
+} from './resolver';
+export { createProductionShareLinkPolicySource } from './production';