@hasna/skills 0.5.2 → 0.5.3

package/dist/lib/invitation-customer-action.d.ts

@@ -0,0 +1,14 @@
+import type { RemoteSkillsAuthClient } from "./remote-auth.js";
+import { type RemoteWorkspaceContext } from "./remote-workspace-selection.js";
+import { type InvitationAction, type InvitationInputs, type InvitationResults } from "./remote-invitations.js";
+/** A saved profile constrains explicit input; it never silently supplies another target. */
+export declare function invitationProfileContext(userId: string, membershipId: string, profile?: RemoteWorkspaceContext): Readonly<{
+    userId: string;
+    membershipId: string;
+}>;
+/** Surface adapters share this dispatch; the remote client owns validation and transport. */
+export declare function invokeFreshInvitation<A extends InvitationAction>(client: RemoteSkillsAuthClient, email: string, code: string, context: RemoteWorkspaceContext, action: A, input: InvitationInputs[A]): Promise<InvitationResults[A]>;
+export declare function invitationCustomerError(error: unknown): {
+    code: string;
+    error: string;
+};

package/dist/lib/invitation-recovery-target.d.ts

@@ -0,0 +1,5 @@
+/** Recovery requires an explicit environment URL. Never probe credentials or Keychain to choose its target. */
+export declare function prepareInvitationRecoveryTarget(source?: Record<string, string | undefined>): {
+    origin: string;
+    unchanged(): void;
+};

package/dist/lib/remote-auth.d.ts

@@ -1,3 +1,5 @@
+import { type RequestInvitationEmailChallenge, type AcceptInvitationEmailChallenge } from "./remote-invitation-recovery.js";
+import { type ListRemoteWorkspaceInvitations, type IssueRemoteWorkspaceInvitation, type ResendRemoteWorkspaceInvitation, type RevokeRemoteWorkspaceInvitation, type AcceptRemoteWorkspaceInvitation } from "./remote-invitations.js";
 import { type LeaveRemoteWorkspace } from "./remote-workspace-leave.js";
 import { type RemoteWorkspaceContext, type RemoteWorkspaceSession, type RemoteAccountWorkspaceDiscovery } from "./remote-workspace-selection.js";
 import { type RemoteWorkspaceMembersOptions } from "./remote-workspace.js";
@@ -21,6 +23,8 @@ export declare class HostedApiError extends Error {
 export declare class RemoteSkillsAuthClient {
     readonly apiOrigin: string;
     constructor(apiUrl: string);
+    requestInvitationEmailChallenge(input: RequestInvitationEmailChallenge): Promise<import("./remote-invitation-recovery.js").RemoteInvitationEmailChallenge>;
+    acceptInvitationEmailChallenge(input: AcceptInvitationEmailChallenge): Promise<import("./remote-invitation-recovery.js").RemoteInvitationEmailAcceptance>;
     requestCode(email: string): Promise<any>;
     verifyCode(email: string, code: string): Promise<any>;
     startDevice(): Promise<any>;
@@ -31,6 +35,14 @@ export declare class RemoteSkillsAuthClient {
     /** Contains a secret session token. Selection never creates or stores an API key. */
     switchWorkspace(email: string, code: string, context: RemoteWorkspaceContext): Promise<RemoteWorkspaceSession>;
     private workspaceLogin;
+    listWorkspaceInvitations(email: string, code: string, context: RemoteWorkspaceContext, options?: ListRemoteWorkspaceInvitations): Promise<import("./remote-invitations.js").RemoteWorkspaceInvitationsPage>;
+    getWorkspaceInvitation(email: string, code: string, context: RemoteWorkspaceContext, invitationId: string): Promise<{
+        invitation: import("./remote-invitations.js").RemoteWorkspaceInvitation;
+    }>;
+    issueWorkspaceInvitation(email: string, code: string, context: RemoteWorkspaceContext, input: IssueRemoteWorkspaceInvitation): Promise<import("./remote-invitations.js").RemoteWorkspaceInvitationResult>;
+    resendWorkspaceInvitation(email: string, code: string, context: RemoteWorkspaceContext, invitationId: string, input: ResendRemoteWorkspaceInvitation): Promise<import("./remote-invitations.js").RemoteWorkspaceInvitationResult>;
+    revokeWorkspaceInvitation(email: string, code: string, context: RemoteWorkspaceContext, invitationId: string, input: RevokeRemoteWorkspaceInvitation): Promise<import("./remote-invitations.js").RemoteWorkspaceInvitationResult>;
+    acceptWorkspaceInvitation(email: string, code: string, context: RemoteWorkspaceContext, invitationId: string, input: AcceptRemoteWorkspaceInvitation): Promise<import("./remote-invitations.js").RemoteWorkspaceInvitationAcceptance>;
     createApiKey(email: string, code: string, name: string, scopes?: string[], context?: RemoteWorkspaceContext): Promise<{
         [field: string]: unknown;
         key: string;

package/dist/lib/remote-client.d.ts

@@ -1,3 +1,4 @@
+import { type ListRemoteWorkspaceInvitations, type IssueRemoteWorkspaceInvitation, type ResendRemoteWorkspaceInvitation, type RevokeRemoteWorkspaceInvitation, type AcceptRemoteWorkspaceInvitation } from "./remote-invitations.js";
 import { type LeaveRemoteWorkspace, type RemoteWorkspaceLeaveResult } from "./remote-workspace-leave.js";
 import { type RemoteWorkspaceContext, type RemoteAccountWorkspaces, type RemoteWorkspaceSession, type RemoteWorkspaceSelectionErrorCode } from "./remote-workspace-selection.js";
 import { type RemoteWorkspaceMembersOptions, type RemoteWorkspaceMembersPage } from "./remote-workspace.js";
@@ -148,6 +149,17 @@ export declare class RemoteSkillsClient {
     private requestWorkspaceMember;
     /** Leave only the explicitly confirmed current incarnation, once. No credential writes or retries. */
     leaveWorkspace(context: RemoteWorkspaceContext, input: LeaveRemoteWorkspace): Promise<RemoteWorkspaceLeaveResult>;
+    listWorkspaceInvitations(context: RemoteWorkspaceContext, options?: ListRemoteWorkspaceInvitations): Promise<import("./remote-invitations.js").RemoteWorkspaceInvitationsPage>;
+    getWorkspaceInvitation(context: RemoteWorkspaceContext, invitationId: string): Promise<{
+        invitation: import("./remote-invitations.js").RemoteWorkspaceInvitation;
+    }>;
+    issueWorkspaceInvitation(context: RemoteWorkspaceContext, input: IssueRemoteWorkspaceInvitation): Promise<import("./remote-invitations.js").RemoteWorkspaceInvitationResult>;
+    resendWorkspaceInvitation(context: RemoteWorkspaceContext, invitationId: string, input: ResendRemoteWorkspaceInvitation): Promise<import("./remote-invitations.js").RemoteWorkspaceInvitationResult>;
+    revokeWorkspaceInvitation(context: RemoteWorkspaceContext, invitationId: string, input: RevokeRemoteWorkspaceInvitation): Promise<import("./remote-invitations.js").RemoteWorkspaceInvitationResult>;
+    acceptWorkspaceInvitation(context: RemoteWorkspaceContext, invitationId: string, input: AcceptRemoteWorkspaceInvitation): Promise<import("./remote-invitations.js").RemoteWorkspaceInvitationAcceptance>;
+    /** One bounded operation, bound to the observed current incarnation. No retries,
+     * key/session persistence or post-acceptance selection of another workspace. */
+    private requestWorkspaceInvitation;
     listApiKeys(): Promise<Record<string, unknown>[]>;
     createApiKey(name: string, scopes?: string[]): Promise<{
         key: string;

package/dist/lib/remote-invitation-recovery.d.ts

@@ -0,0 +1,62 @@
+export type RequestInvitationEmailChallenge = Readonly<{
+    invitationId: string;
+    token: string;
+    challengeId: string;
+    confirm: true;
+}>;
+export type AcceptInvitationEmailChallenge = RequestInvitationEmailChallenge & Readonly<{
+    code: string;
+}>;
+export type RemoteInvitationEmailChallenge = {
+    challengeId: string;
+    message: string;
+    expiresIn: 600;
+};
+export type RemoteInvitationEmailAcceptance = {
+    organizationId: string;
+    membershipId: string;
+    accepted: true;
+    changed: true;
+    signInRequired: true;
+};
+export declare class InvitationEmailInputError extends Error {
+    readonly code = "INVITATION_EMAIL_INPUT_INVALID";
+    constructor();
+}
+declare const refusals: {
+    readonly INVALID_REQUEST: readonly [400, "Invitation recovery parameters were refused."];
+    readonly ORIGIN_REQUIRED: readonly [403, "Invitation recovery requires the configured site origin."];
+    readonly INVITATION_PROOF_UNAVAILABLE: readonly [401, "Invitation proof is unavailable. Sign in or explicitly request another recovery code."];
+    readonly RATE_LIMITED: readonly [429, "Invitation verification is rate limited. Wait before another deliberate action."];
+    readonly INVITATION_BUSY: readonly [503, "Invitation is busy. Sign in to check membership before another deliberate action."];
+    readonly INVITATION_DELIVERY_UNAVAILABLE: readonly [503, "Invitation recovery is unavailable on this service."];
+};
+export type RemoteInvitationEmailErrorCode = keyof typeof refusals;
+export declare class RemoteInvitationEmailError extends Error {
+    readonly code: RemoteInvitationEmailErrorCode;
+    readonly status: number;
+    constructor(code: RemoteInvitationEmailErrorCode);
+}
+export declare class RemoteInvitationEmailUnconfirmedError extends Error {
+    readonly action: "challenge" | "accept";
+    readonly code = "INVITATION_EMAIL_UNCONFIRMED";
+    constructor(action: "challenge" | "accept");
+}
+export declare function invitationEmailIds(invitationId: unknown, challengeId: unknown): {
+    invitationId: string;
+    challengeId: string;
+};
+export declare function invitationEmailInput<A extends "challenge" | "accept">(action: A, input: A extends "accept" ? AcceptInvitationEmailChallenge : RequestInvitationEmailChallenge): {
+    code?: string | undefined;
+    token: string;
+    confirm: true;
+    invitationId: string;
+    challengeId: string;
+};
+/** Explicit anonymous protocol: no auth resolver, headers, session creation or persistence. */
+export declare function requestInvitationEmail<A extends "challenge" | "accept">(origin: string, action: A, input: A extends "accept" ? AcceptInvitationEmailChallenge : RequestInvitationEmailChallenge): Promise<A extends "accept" ? RemoteInvitationEmailAcceptance : RemoteInvitationEmailChallenge>;
+export declare function invitationEmailCustomerError(error: unknown): {
+    code: string;
+    error: string;
+};
+export {};

package/dist/lib/remote-invitations.d.ts

@@ -0,0 +1,128 @@
+import type { RemoteCustomerRole } from "./remote-profile.js";
+export type RemoteWorkspaceInvitation = {
+    id: string;
+    organizationId: string;
+    email: string;
+    role: RemoteCustomerRole;
+    generation: number;
+    status: "pending" | "expired" | "accepted" | "revoked";
+    expiresAt: string;
+    createdAt: string;
+    delivery: {
+        state: "queued" | "sending" | "uncertain" | "provider_accepted" | "failed" | "cancelled";
+        attempts: number;
+    };
+};
+export type RemoteWorkspaceInvitationsPage = {
+    organizationId: string;
+    invitations: RemoteWorkspaceInvitation[];
+    nextCursor: string | null;
+};
+export type RemoteWorkspaceInvitationResult = {
+    invitation: RemoteWorkspaceInvitation;
+    changed: boolean;
+};
+export type RemoteWorkspaceInvitationAcceptance = {
+    organizationId: string;
+    membershipId: string;
+    accepted: true;
+    changed: boolean;
+};
+export type ListRemoteWorkspaceInvitations = Readonly<{
+    after?: string;
+}>;
+export type IssueRemoteWorkspaceInvitation = Readonly<{
+    email: string;
+    role: RemoteCustomerRole;
+    idempotencyKey: string;
+    confirm: true;
+}>;
+export type ResendRemoteWorkspaceInvitation = Readonly<{
+    expectedGeneration: number;
+    idempotencyKey: string;
+    confirm: true;
+}>;
+export type RevokeRemoteWorkspaceInvitation = Readonly<{
+    expectedGeneration: number;
+    confirm: true;
+}>;
+/** Secret input, never returned or persisted by the client. Acceptance does not select the new membership. */
+export type AcceptRemoteWorkspaceInvitation = Readonly<{
+    token: string;
+    confirm: true;
+}>;
+export declare class WorkspaceInvitationInputError extends Error {
+    readonly code = "INVITATION_INPUT_INVALID";
+    constructor();
+}
+export declare const invitationFailures: {
+    readonly INVALID_REQUEST: readonly [400, "Invitation parameters were refused."];
+    readonly ACCOUNT_UNAVAILABLE: readonly [403, "Account is unavailable."];
+    readonly INTERACTIVE_SESSION_REQUIRED: readonly [403, "Fresh interactive sign-in is required."];
+    readonly WORKSPACE_ADMIN_REQUIRED: readonly [403, "A current workspace owner or admin is required."];
+    readonly INVITATION_FORBIDDEN: readonly [403, "Your current role cannot manage this invitation."];
+    readonly INVITATION_UNAVAILABLE: readonly [404, "Invitation is unavailable for this account."];
+    readonly INVITATION_CHANGED: readonly [409, "Invitation changed. Read its current generation before another action."];
+    readonly INVITATION_EXISTS: readonly [409, "A pending invitation already exists. Read current invitations."];
+    readonly ALREADY_MEMBER: readonly [409, "An active membership already exists. An invitation cannot change its role."];
+    readonly IDEMPOTENCY_CONFLICT: readonly [409, "This request key was used for different invitation parameters. Reconcile the original request."];
+    readonly INVITATION_LIMIT: readonly [429, "Invitation limit reached. Wait before issuing or resending."];
+    readonly INVITATION_BUSY: readonly [503, "Invitation is busy. Read its state before another action."];
+    readonly INVITATION_DELIVERY_UNAVAILABLE: readonly [503, "Invitation email delivery is unavailable."];
+};
+export type RemoteWorkspaceInvitationErrorCode = keyof typeof invitationFailures;
+export declare class RemoteWorkspaceInvitationError extends Error {
+    readonly code: RemoteWorkspaceInvitationErrorCode;
+    readonly status: number;
+    constructor(code: RemoteWorkspaceInvitationErrorCode);
+}
+export declare class RemoteWorkspaceInvitationUnconfirmedError extends Error {
+    readonly code = "INVITATION_UNCONFIRMED";
+    constructor();
+}
+export declare class RemoteWorkspaceInvitationReadError extends Error {
+    readonly code = "INVITATION_READ_FAILED";
+    constructor();
+}
+export declare function invitationFailure(value: unknown, status: number): "INVALID_REQUEST" | "ACCOUNT_UNAVAILABLE" | "INTERACTIVE_SESSION_REQUIRED" | "WORKSPACE_ADMIN_REQUIRED" | "INVITATION_FORBIDDEN" | "INVITATION_UNAVAILABLE" | "INVITATION_CHANGED" | "INVITATION_EXISTS" | "ALREADY_MEMBER" | "IDEMPOTENCY_CONFLICT" | "INVITATION_LIMIT" | "INVITATION_BUSY" | "INVITATION_DELIVERY_UNAVAILABLE" | null;
+export type InvitationAction = "list" | "get" | "issue" | "resend" | "revoke" | "accept";
+export type InvitationInputs = {
+    list: ListRemoteWorkspaceInvitations;
+    get: Readonly<{
+        invitationId: string;
+    }>;
+    issue: IssueRemoteWorkspaceInvitation;
+    resend: ResendRemoteWorkspaceInvitation & Readonly<{
+        invitationId: string;
+    }>;
+    revoke: RevokeRemoteWorkspaceInvitation & Readonly<{
+        invitationId: string;
+    }>;
+    accept: AcceptRemoteWorkspaceInvitation & Readonly<{
+        invitationId: string;
+    }>;
+};
+export type InvitationResults = {
+    list: RemoteWorkspaceInvitationsPage;
+    get: {
+        invitation: RemoteWorkspaceInvitation;
+    };
+    issue: RemoteWorkspaceInvitationResult;
+    resend: RemoteWorkspaceInvitationResult;
+    revoke: RemoteWorkspaceInvitationResult;
+    accept: RemoteWorkspaceInvitationAcceptance;
+};
+export declare function invitationId(value: unknown): string;
+/** Capture and validate all caller values before authentication or other awaits. */
+export declare function invitationInput<A extends InvitationAction>(action: A, input: InvitationInputs[A]): InvitationInputs[A];
+export declare function invitationRequest<A extends InvitationAction>(action: A, input: InvitationInputs[A]): {
+    path: string;
+    method: string;
+    body?: undefined;
+} | {
+    path: string;
+    method: string;
+    body: string;
+};
+/** Project only validated contract fields; never surface arbitrary response metadata. */
+export declare function parseInvitationResult<A extends InvitationAction>(action: A, value: unknown, input: InvitationInputs[A], organizationId: string): InvitationResults[A];

package/dist/lib/skill-bundle.d.ts

@@ -33,5 +33,58 @@ export declare function sha256Hex(bytes: Uint8Array): string;
 /** Collect the files a bundle would contain, in archive order. */
 export declare function collectSkillBundleEntries(dir: string): SkillBundleEntry[];
 export declare function packSkillBundle(dir: string, options?: PackSkillBundleOptions): PackedSkillBundle;
-/** Inverse of packSkillBundle. Used by the round-trip tests and by any future `pull`. */
+/** Legacy synchronous reader for trusted inputs. Unbounded; use inspectSkillBundle for uploads. */
 export declare function unpackSkillBundle(bundle: Uint8Array): SkillBundleEntry[];
+/** Hard ceilings. Callers may tighten these limits, never disable or raise them. */
+export interface SkillBundleInspectionLimits {
+    compressedBytes: number;
+    decompressedBytes: number;
+    entries: number;
+    fileBytes: number;
+    pathBytes: number;
+    timeoutMs: number;
+}
+export declare const SKILL_BUNDLE_INSPECTION_LIMITS: Readonly<SkillBundleInspectionLimits>;
+export interface InspectSkillBundleOptions {
+    limits?: Partial<SkillBundleInspectionLimits>;
+    signal?: AbortSignal;
+}
+export interface InspectedSkillBundle {
+    /** Each body has its own buffer. No path has been written or executed. */
+    entries: SkillBundleEntry[];
+    /** Hash of the complete owned compressed snapshot, not of extracted files. */
+    sha256: string;
+    compressedByteSize: number;
+    /** Includes headers, body padding, terminators and trailing zero padding. */
+    decompressedByteSize: number;
+    unpackedByteSize: number;
+    fileCount: number;
+}
+export type SkillBundleInspectionErrorCode = "BUNDLE_INVALID" | "BUNDLE_LIMIT" | "BUNDLE_ABORTED" | "BUNDLE_TIMEOUT";
+export declare class SkillBundleInspectionError extends Error {
+    readonly code: SkillBundleInspectionErrorCode;
+    constructor(code: SkillBundleInspectionErrorCode, message: string);
+}
+/**
+ * Inspect a bounded gzipped ustar bundle without filesystem writes or execution.
+ * Resolves only after the entire gzip stream and tar structure validate. Returned
+ * entries are NOT permission to execute code or safely extract through existing
+ * filesystem symlinks; consumers still own storage, authorization and isolation.
+ *
+ * Only regular files, canonical relative slash paths (100 UTF-8 bytes maximum),
+ * no prefix/extension/link records, and modes without special bits are supported.
+ * Paths are unique under NFC + lowercase and cannot collide with a file ancestor.
+ * Noncanonical dot/empty/backslash segments are refused, not silently rewritten.
+ * Two zero tar blocks are required, followed only by complete zero padding blocks.
+ * Gzip members are decoded as one stream: an empty extra member is harmless, but
+ * a second nonempty archive after the tar terminator is rejected.
+ *
+ * The decoder has bounded stream buffers; decompressed bytes are counted before
+ * parsing or retaining each chunk, so expansion is stopped during decompression.
+ * Memory is bounded by the compressed snapshot, accepted file bodies, and stream
+ * buffers. The deadline covers copying, hashing, decoding and parsing, with both
+ * a timer and monotonic checks. Decoding yields to timers every 256 KiB so Bun's
+ * stream microtasks cannot starve a caller's scheduled abort. No partial entries
+ * escape on any failure.
+ */
+export declare function inspectSkillBundle(bundle: Uint8Array, options?: InspectSkillBundleOptions): Promise<InspectedSkillBundle>;

package/dist/lib/skill-entry-path.d.ts

@@ -0,0 +1,6 @@
+/** Internal shared path policy for ordinary in-memory regular-file entries. */
+export declare class SkillEntryPaths {
+    private readonly files;
+    private readonly directories;
+    add(path: string, maxBytes: number, invalid: (message: string) => never, limit: () => never): void;
+}

package/dist/lib/skill-hash.d.ts

@@ -1,4 +1,5 @@
 import type { PortableSkillManifest } from "./portable-skills-types.js";
+import type { SkillBundleEntry } from "./skill-bundle.js";
 /**
  * Canonical content hashing for the hasna.skill.v1 portable bundle.
  *
@@ -49,6 +50,38 @@ export interface ContentHashVerification {
     /** The recomputed hash over the current bundle. */
     computedHash?: string;
 }
+export interface ContentHashLimits {
+    entries: number;
+    rawBytes: number;
+    normalizedBytes: number;
+    fileBytes: number;
+    normalizedFileBytes: number;
+    pathBytes: number;
+    manifestBytes: number;
+    manifestDepth: number;
+    timeoutMs: number;
+}
+/** Hard ceilings for the entry API. Callers may tighten these, never disable them. */
+export declare const CONTENT_HASH_LIMITS: Readonly<ContentHashLimits>;
+export interface ContentHashOptions {
+    limits?: Partial<ContentHashLimits>;
+    signal?: AbortSignal;
+}
+export type ContentHashInputErrorCode = "CONTENT_HASH_INVALID" | "CONTENT_HASH_LIMIT" | "CONTENT_HASH_ABORTED" | "CONTENT_HASH_TIMEOUT";
+export declare class ContentHashInputError extends Error {
+    readonly code: ContentHashInputErrorCode;
+    constructor(code: ContentHashInputErrorCode, message: string);
+}
+/**
+ * Hash bounded ordinary regular-file entries without filesystem access or extraction.
+ * Entries are revalidated and copied, even if supplied by inspectSkillBundle. This is
+ * content identity, not manifest validity, permission to execute, or a JS sandbox.
+ * Text uses the directory oracle's nonfatal UTF-8/LF normalization. Excluded paths
+ * still count toward input limits and collision checks. Inputs are never mutated.
+ */
+export declare function computeContentHashFromEntries(entries: readonly SkillBundleEntry[], options?: ContentHashOptions): Promise<string>;
+/** Verify only the declaration in the same owned skill.json, never a second manifest. */
+export declare function verifyContentHashFromEntries(entries: readonly SkillBundleEntry[], options?: ContentHashOptions): Promise<ContentHashVerification>;
 /**
  * Verify a skill folder's declared content_hash against the recomputed
  * canonical hash of the current bundle. A missing declaration or a mismatch

package/dist/mcp/index.d.ts

@@ -34,4 +34,3 @@ export declare function assertSkillsMcpConfigured(env?: Record<string, string |
  * stdio server (BUG e3997558).
  */
 export declare function startMcpStdio(): Promise<void>;
-export { buildServer } from "./server.js";

package/dist/mcp/invitation-recovery.d.ts

@@ -0,0 +1,2 @@
+/** Dedicated anonymous proof surface. Ordinary tools and credential resolution are not initialized. */
+export declare function startInvitationRecoveryMcp(args: string[], env?: Record<string, string | undefined>): Promise<void>;

package/dist/mcp/remote-invitation-tools.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerRemoteInvitationTools(server: McpServer): void;

package/dist/sdk/index.d.ts

@@ -42,3 +42,6 @@ export { WorkspaceContextInputError, WorkspaceIdentityMismatchError } from "../l
 export { RemoteWorkspaceSelectionError } from "../lib/remote-client.js";
 export type { LeaveRemoteWorkspace, RemoteWorkspaceLeaveResult, RemoteWorkspaceLeaveErrorCode } from "../lib/remote-workspace-leave.js";
 export { WorkspaceLeaveInputError, RemoteWorkspaceLeaveError, RemoteWorkspaceLeaveUnconfirmedError } from "../lib/remote-workspace-leave.js";
+export type { RemoteWorkspaceInvitation, RemoteWorkspaceInvitationsPage, RemoteWorkspaceInvitationResult, RemoteWorkspaceInvitationAcceptance, ListRemoteWorkspaceInvitations, IssueRemoteWorkspaceInvitation, ResendRemoteWorkspaceInvitation, RevokeRemoteWorkspaceInvitation, AcceptRemoteWorkspaceInvitation, RemoteWorkspaceInvitationErrorCode } from "../lib/remote-invitations.js";
+export { WorkspaceInvitationInputError, RemoteWorkspaceInvitationError, RemoteWorkspaceInvitationUnconfirmedError, RemoteWorkspaceInvitationReadError } from "../lib/remote-invitations.js";
+export { InvitationEmailInputError, RemoteInvitationEmailError, RemoteInvitationEmailUnconfirmedError, type RequestInvitationEmailChallenge, type AcceptInvitationEmailChallenge, type RemoteInvitationEmailChallenge, type RemoteInvitationEmailAcceptance, type RemoteInvitationEmailErrorCode } from "../lib/remote-invitation-recovery.js";