@neontechspace/fluxerly 1000.0.0-nightly.12

package/dist/api/default/roles.d.ts

@@ -0,0 +1,119 @@
+import type { ResultAsync } from "neverthrow";
+import type { GuildRole, RoleReference, RolePosition, RoleHoistPosition, RoleCreate, RoleEdit, GuildOperationFailure, DefaultGuildOperationOptions, DefaultGuildAuditOperationOptions } from "#sdk/guilds";
+import type { CancelledError, ConfigurationError } from "#sdk/errors";
+/**
+ * Create, edit, order and delete community roles, or read their current or cached data.
+ * Shared Guilds request limits, deadlines and read retries apply.
+ * Fluxer enforces permissions and hierarchy.
+ * No local permission prediction is performed
+ *
+ * Writes retry only confirmed HTTP 429 rejection.
+ * Abort waits for request cleanup but cannot undo a dispatched write
+ *
+ * Expected failures return GuildOperationError or ClientClosedError.
+ * Unexpected failures reject with SdkDefect.
+ * Inputs are copied when called.
+ * Results are snapshots, not gateway acknowledgement.
+ * Role permissions use bigint, which requires explicit conversion before JSON serialization.
+ * Every remote role mutation accepts DefaultGuildAuditOperationOptions. The fetchAll method rejects auditReason
+ *
+ * @category Roles and permissions
+ */
+export interface Roles {
+    /**
+     * Look up a role by decimal guildId and id in the enabled cache, including the everyone role.
+     * No request is made.
+     * The cache misses, stale-snapshot warnings, misuse and recency rules of guilds.get apply
+     *
+     * @remarks
+     * Returns the value synchronously.
+     * Unexpected failures throw SdkDefect
+     */
+    get(role: RoleReference): GuildRole | undefined;
+    /**
+     * Fetch the community's current role list, including everyone, in server order.
+     * This always reads remotely, without pagination or background refresh
+     */
+    fetchAll(guildId: string, options?: DefaultGuildOperationOptions): ResultAsync<readonly GuildRole[], GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Create a role with a name, optional color and permission flags.
+     * The permissions input defaults to 0n, rather than copying the everyone role's grants.
+     * Supplied permissions must be from 0n through 9_223_372_036_854_775_807n.
+     * Explicit permissions use Fluxer's feature opt-in for ViewChannelMembers.
+     * The result reports the actual server grants, which can differ from the request.
+     * Use a separate edit to change hoist or mentionable settings.
+     * The application manages the created role afterward.
+     * After an unknown outcome, use fetchAll before deciding whether to create again
+     *
+     * @example
+     * ```ts
+     * import { Permissions, type Client } from "@neontechspace/fluxerly"
+     * export async function createRoleExample(client: Client, guildId: string) {
+     *     const result = await client.roles.create(guildId, {
+     *         name: "Readers",
+     *         permissions: Permissions.ViewChannel | Permissions.ReadMessageHistory,
+     *     })
+     *     if (result.isErr()) throw result.error
+     *     return result.value
+     * }
+     * ```
+     */
+    create(guildId: string, input: RoleCreate, options?: DefaultGuildAuditOperationOptions): ResultAsync<GuildRole, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Change only supplied role fields and return the server's snapshot.
+     * Empty inputs and unknown fields fail locally.
+     * The permissions input replaces all raw grants rather than adding flags, and can set or clear ViewChannelMembers.
+     * The replacement must be from 0n through 9_223_372_036_854_775_807n, and larger received masks cannot be written unchanged.
+     * The everyone role accepts only color and permissions.
+     * Other supplied fields fail, even in a mixed input
+     */
+    edit(role: RoleReference, input: RoleEdit, options?: DefaultGuildAuditOperationOptions): ResultAsync<GuildRole, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Delete a role and remove its member assignments in Fluxer.
+     * The everyone role cannot be deleted.
+     * Fluxer removes the role from each member in separate writes before it deletes the role, and does not roll them back.
+     * A failure can leave the role in place after some members already lost it, so fetch the role and the affected members again before retrying.
+     * HTTP 204 succeeds with no value, without proving member-event delivery.
+     * Snapshots already returned to the caller remain unchanged
+     */
+    delete(role: RoleReference, options?: DefaultGuildAuditOperationOptions): ResultAsync<void, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Change role hierarchy positions using distinct role IDs and nonnegative safe-integer positions.
+     * The everyone role cannot move.
+     * HTTP 204 succeeds with no value and no new role list.
+     * Fluxer normalizes manageable positions, so use fetchAll if final order matters.
+     * This is not a transaction.
+     * A failure can leave partial changes, requiring a fresh read before recovery
+     */
+    reorder(guildId: string, positions: readonly RolePosition[], options?: DefaultGuildAuditOperationOptions): ResultAsync<void, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Set roles' display positions without changing their permission hierarchy or enabling hoist.
+     * Pass a nonempty list of distinct role IDs with integer hoistPosition values from -2,147,483,648 through 2,147,483,647.
+     * The everyone role is excluded.
+     * Fluxer checks ManageRoles and hierarchy.
+     * HTTP 204 succeeds with no value, not a role list.
+     * Successful writes and writes with unknown outcomes invalidate cached guild roles and conflicting pending reads.
+     * Failure or cancellation can leave partial changes.
+     * Refetch before deciding to replay
+     *
+     * @example
+     * ```ts
+     * import { type Client } from "@neontechspace/fluxerly"
+     * export function orderRoleDisplay(client: Client, guildId: string, roleId: string) {
+     *     return client.roles.setHoistPositions(guildId, [{ id: roleId, hoistPosition: 0 }])
+     * }
+     * ```
+     */
+    setHoistPositions(guildId: string, positions: readonly RoleHoistPosition[], options?: DefaultGuildAuditOperationOptions): ResultAsync<void, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Clear display-position assignments across the community, including roles above the bot.
+     * Fluxer requires ManageRoles.
+     * Permission hierarchy and hoist flags remain unchanged.
+     * HTTP 204 succeeds with no value, not a role list.
+     * Changes are not transactional and a failure can be partial.
+     * Successful writes and writes with unknown outcomes invalidate cached guild roles.
+     * Refetch to resolve an unknown outcome
+     */
+    resetHoistPositions(guildId: string, options?: DefaultGuildAuditOperationOptions): ResultAsync<void, GuildOperationFailure | CancelledError | ConfigurationError>;
+}
+//# sourceMappingURL=roles.d.ts.map

package/dist/api/default/roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roles.d.ts","sourceRoot":"","sources":["../../../src/api/default/roles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAC7C,OAAO,KAAK,EACR,SAAS,EACT,aAAa,EACb,YAAY,EACZ,iBAAiB,EACjB,UAAU,EACV,QAAQ,EACR,qBAAqB,EACrB,4BAA4B,EAC5B,iCAAiC,EACpC,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAErE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,KAAK;IAClB;;;;;;;;OAQG;IACH,GAAG,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,GAAG,SAAS,CAAA;IAC/C;;;OAGG;IACH,QAAQ,CACJ,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,4BAA4B,GACvC,WAAW,CAAC,SAAS,SAAS,EAAE,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IACjG;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CACF,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,UAAU,EACjB,OAAO,CAAC,EAAE,iCAAiC,GAC5C,WAAW,CAAC,SAAS,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IACtF;;;;;;;OAOG;IACH,IAAI,CACA,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,QAAQ,EACf,OAAO,CAAC,EAAE,iCAAiC,GAC5C,WAAW,CAAC,SAAS,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IACtF;;;;;;;OAOG;IACH,MAAM,CACF,IAAI,EAAE,aAAa,EACnB,OAAO,CAAC,EAAE,iCAAiC,GAC5C,WAAW,CAAC,IAAI,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IACjF;;;;;;;OAOG;IACH,OAAO,CACH,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,SAAS,YAAY,EAAE,EAClC,OAAO,CAAC,EAAE,iCAAiC,GAC5C,WAAW,CAAC,IAAI,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IACjF;;;;;;;;;;;;;;;;;OAiBG;IACH,iBAAiB,CACb,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,SAAS,iBAAiB,EAAE,EACvC,OAAO,CAAC,EAAE,iCAAiC,GAC5C,WAAW,CAAC,IAAI,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IACjF;;;;;;;;OAQG;IACH,mBAAmB,CACf,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,iCAAiC,GAC5C,WAAW,CAAC,IAAI,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;CACpF"}

package/dist/api/default/roles.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=roles.js.map

package/dist/api/default/roles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"roles.js","sourceRoot":"","sources":["../../../src/api/default/roles.ts"],"names":[],"mappings":""}

package/dist/api/default/stickers.d.ts

@@ -0,0 +1,92 @@
+import type { GuildSticker, ExpressionReference, ExpressionMetadata, ExpressionSourceGuild, StickerCreate, StickerEdit, ExpressionBatch, DefaultExpressionDeleteOptions } from "#sdk/expressions";
+import type { ResultAsync } from "neverthrow";
+import type { GuildOperationFailure, DefaultGuildOperationOptions, DefaultModerationOptions } from "#sdk/guilds";
+import type { CancelledError, ConfigurationError } from "#sdk/errors";
+/**
+ * Create, list, copy, edit and delete community stickers.
+ * Use get for an optional local cache lookup, or fetchAll, fetchMetadata and fetchSource for remote reads.
+ * Shared guild request limits, deadlines and read retries apply.
+ * Writes retry only confirmed HTTP 429 rejections.
+ * Input, permission, not-found and malformed-response errors are not retried.
+ * A lost response can leave a write applied.
+ * Results are frozen snapshots, not gateway acknowledgement
+ *
+ * Expected failures return GuildOperationError or ClientClosedError.
+ * Abort returns CancelledError after cleanup.
+ * Unexpected failures reject with SdkDefect
+ *
+ * @category Emoji and stickers
+ */
+export interface Stickers {
+    /**
+     * Replace a sticker's name, description and tags without changing its image or fetching it first.
+     * A fetched sticker can be spread into input if its identity matches the target.
+     * Unknown fields fail locally.
+     * An empty or null description clears it, and [] clears tags.
+     * The namespace's write, failure and cancellation rules apply
+     */
+    edit(target: ExpressionReference, input: StickerEdit, options?: DefaultModerationOptions): ResultAsync<GuildSticker, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Look up cached sticker metadata using decimal guildId and id, without an HTTP request.
+     * The result is undefined when caching is disabled or the entry is absent, expired or invalidated by a conflicting change.
+     * A hit becomes more recently used without extending expiry.
+     * An invalid ID is misuse: The default API throws GuildOperationError with reason input and the native API dies with it.
+     * A closing or closed client has no cache, so the result is undefined
+     *
+     * @remarks
+     * Returns the value synchronously.
+     * Unexpected failures throw SdkDefect
+     */
+    get(target: ExpressionReference): GuildSticker | undefined;
+    /**
+     * Fetch a community's sticker list in Fluxer's order, without pagination.
+     * The list can change after the response and is not an ongoing completeness guarantee.
+     * An enabled metadata cache can retain results, but not image bytes or creator accounts
+     */
+    fetchAll(guildId: string, options?: DefaultGuildOperationOptions): ResultAsync<readonly GuildSticker[], GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Fetch minimal sticker metadata by decimal ID, without requiring source-community membership.
+     * This read does not populate the cache
+     */
+    fetchMetadata(id: string, options?: DefaultGuildOperationOptions): ResultAsync<ExpressionMetadata, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Fetch the public presentation of the community that owns a custom sticker with this decimal ID: Its ID, name, icon hash and badges.
+     * Fluxer answers when the source community is discoverable or the bot is a member of it.
+     * A private source community the bot is not in, an unavailable community or an unknown sticker fails with GuildOperationError
+     * whose apiError.code is unknownResource, without revealing which case applies.
+     * This read does not populate the cache, and the result does not update when the community changes
+     */
+    fetchSource(id: string, options?: DefaultGuildOperationOptions): ResultAsync<ExpressionSourceGuild, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Upload one community sticker and return its metadata.
+     * Inputs are copied when execution starts.
+     * No image URL is fetched automatically.
+     * Fluxer checks image format, dimensions, permissions and capacity.
+     * A write with an unknown outcome is not replayed
+     */
+    create(guildId: string, input: StickerCreate, options?: DefaultModerationOptions): ResultAsync<GuildSticker, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Upload 1–50 community stickers in one batch and return separate successes and failures.
+     * The input array is copied by index, then its entries are copied when execution starts.
+     * Some uploads can succeed while others fail.
+     * No rollback or automatic chunking is performed.
+     * Failures named by duplicate sticker names cannot be matched reliably to input positions.
+     * After an unknown outcome, fetch fresh remote data rather than blindly replaying the batch
+     */
+    createMany(guildId: string, input: readonly StickerCreate[], options?: DefaultModerationOptions): ResultAsync<ExpressionBatch<GuildSticker>, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Copy a sticker into a community by its source ID, using Fluxer's server-side copy.
+     * Source metadata is preserved.
+     * Fluxer enforces source copying restrictions
+     */
+    clone(guildId: string, sourceId: string, options?: DefaultModerationOptions): ResultAsync<GuildSticker, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Remove a sticker, succeeding with no value after HTTP 204.
+     * Retained metadata is invalidated.
+     * A missing target is an error, not proof of an earlier deletion.
+     * The purge option defaults to false.
+     * Setting it to true also queues irreversible media removal, subject to Fluxer's restrictions
+     */
+    delete(target: ExpressionReference, options?: DefaultExpressionDeleteOptions): ResultAsync<void, GuildOperationFailure | CancelledError | ConfigurationError>;
+}
+//# sourceMappingURL=stickers.d.ts.map

package/dist/api/default/stickers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stickers.d.ts","sourceRoot":"","sources":["../../../src/api/default/stickers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,YAAY,EACZ,mBAAmB,EACnB,kBAAkB,EAClB,qBAAqB,EACrB,aAAa,EACb,WAAW,EACX,eAAe,EACf,8BAA8B,EACjC,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAC7C,OAAO,KAAK,EAAE,qBAAqB,EAAE,4BAA4B,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AAChH,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAErE;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,QAAQ;IACrB;;;;;;OAMG;IACH,IAAI,CACA,MAAM,EAAE,mBAAmB,EAC3B,KAAK,EAAE,WAAW,EAClB,OAAO,CAAC,EAAE,wBAAwB,GACnC,WAAW,CAAC,YAAY,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IACzF;;;;;;;;;;OAUG;IACH,GAAG,CAAC,MAAM,EAAE,mBAAmB,GAAG,YAAY,GAAG,SAAS,CAAA;IAC1D;;;;OAIG;IACH,QAAQ,CACJ,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,4BAA4B,GACvC,WAAW,CAAC,SAAS,YAAY,EAAE,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IACpG;;;OAGG;IACH,aAAa,CACT,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE,4BAA4B,GACvC,WAAW,CAAC,kBAAkB,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IAC/F;;;;;;OAMG;IACH,WAAW,CACP,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE,4BAA4B,GACvC,WAAW,CAAC,qBAAqB,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IAClG;;;;;;OAMG;IACH,MAAM,CACF,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,aAAa,EACpB,OAAO,CAAC,EAAE,wBAAwB,GACnC,WAAW,CAAC,YAAY,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IACzF;;;;;;;OAOG;IACH,UAAU,CACN,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,OAAO,CAAC,EAAE,wBAAwB,GACnC,WAAW,CAAC,eAAe,CAAC,YAAY,CAAC,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IAC1G;;;;OAIG;IACH,KAAK,CACD,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,wBAAwB,GACnC,WAAW,CAAC,YAAY,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IACzF;;;;;;OAMG;IACH,MAAM,CACF,MAAM,EAAE,mBAAmB,EAC3B,OAAO,CAAC,EAAE,8BAA8B,GACzC,WAAW,CAAC,IAAI,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;CACpF"}

package/dist/api/default/stickers.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stickers.js.map

package/dist/api/default/stickers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stickers.js","sourceRoot":"","sources":["../../../src/api/default/stickers.ts"],"names":[],"mappings":""}

package/dist/api/default/supervisor.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Run a fixed group of local Node.js child processes, each with its own client and assigned shards.
+ * Use create to validate the assignments, then start to launch the children.
+ * Each child entry module must call supervisor.child.run to create and run its client
+ *
+ * @remarks
+ * The start method waits for assignment and configuration acknowledgements, not gateway READY.
+ * Use waitForReady for all-child READY, and waitForClose to wait until this supervisor's children have exited.
+ * The status method returns a frozen local report with the latest gateway state received from each current child.
+ * Those states are separate observations, not an atomic health check across processes
+ *
+ * Fresh gateway Identify sends require a parent permit and are spaced by at least one second, unless identify.coordinator paces them.
+ * Identify authenticates a new session, while Resume reuses an earlier gateway session.
+ * Session Resume sends do not need a permit.
+ * A permit stays outstanding until the child confirms the send or cancels before sending.
+ * A stalled child is stopped and must exit before another permit is issued, after a full spacing interval.
+ * The child helper receives a stop signal.
+ * A parent stop does not wait for an uncooperative configure promise or start its client afterward
+ *
+ * The parent can forcibly terminate only children it started after the graceful deadline, and still waits for their exit.
+ * No process signal handlers are installed.
+ * Child output follows childOutput: Lines are forwarded with a child label by default, and inherit or ignore can be chosen instead.
+ * A crashed child restarts by default, up to three times in a row with exponentially increasing delays. Set restart to false to turn this off.
+ * The childEnvironment, args and execArgv options affect child launch but are omitted from status and failures.
+ * With totalShards "auto" and processes or shardsPerProcess, the plan is sized at start. Each child sends its client diagnostics, which status includes.
+ * Children keep resumable sessions through clientOptions.sharding.sessions.
+ * The children share Fluxer's limits per bot account through the parent. When one child is rate-limited globally, the parent
+ * holds the other children's REST requests until the same time. Member requests from all children share one count of 12 in
+ * any 11 seconds, and a members.iterateChunks request past it fails at once with reason rateLimit and retryAfterMs.
+ * A child that gets no answer from the parent within one second counts only its own member requests and logs
+ * supervisor.memberRequestsLocal once. Per-route REST rate limits stay per child, and other processes using the same
+ * token are not counted
+ *
+ * @example
+ * ```ts
+ * import { supervisor } from "@neontechspace/fluxerly"
+ *
+ * export const workers = supervisor.create({
+ *     entry: "/srv/bot-worker.js",
+ *     totalShards: 2,
+ *     assignments: [
+ *         { id: "one", shardIds: [0] },
+ *         { id: "two", shardIds: [1] },
+ *     ],
+ * })
+ * ```
+ *
+ * @category Sharding and supervision
+ */
+export declare const supervisor: import("#sdk/default-supervisor").DefaultSupervisorTools;
+//# sourceMappingURL=supervisor.d.ts.map

package/dist/api/default/supervisor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supervisor.d.ts","sourceRoot":"","sources":["../../../src/api/default/supervisor.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,UAAU,EAAE,OAAO,yBAAyB,EAAE,sBAA4D,CAAA"}

package/dist/api/default/supervisor.js

@@ -0,0 +1,53 @@
+import { makeDefaultSupervisor } from "#sdk/default-supervisor";
+import { createClient } from "./client.js";
+/**
+ * Run a fixed group of local Node.js child processes, each with its own client and assigned shards.
+ * Use create to validate the assignments, then start to launch the children.
+ * Each child entry module must call supervisor.child.run to create and run its client
+ *
+ * @remarks
+ * The start method waits for assignment and configuration acknowledgements, not gateway READY.
+ * Use waitForReady for all-child READY, and waitForClose to wait until this supervisor's children have exited.
+ * The status method returns a frozen local report with the latest gateway state received from each current child.
+ * Those states are separate observations, not an atomic health check across processes
+ *
+ * Fresh gateway Identify sends require a parent permit and are spaced by at least one second, unless identify.coordinator paces them.
+ * Identify authenticates a new session, while Resume reuses an earlier gateway session.
+ * Session Resume sends do not need a permit.
+ * A permit stays outstanding until the child confirms the send or cancels before sending.
+ * A stalled child is stopped and must exit before another permit is issued, after a full spacing interval.
+ * The child helper receives a stop signal.
+ * A parent stop does not wait for an uncooperative configure promise or start its client afterward
+ *
+ * The parent can forcibly terminate only children it started after the graceful deadline, and still waits for their exit.
+ * No process signal handlers are installed.
+ * Child output follows childOutput: Lines are forwarded with a child label by default, and inherit or ignore can be chosen instead.
+ * A crashed child restarts by default, up to three times in a row with exponentially increasing delays. Set restart to false to turn this off.
+ * The childEnvironment, args and execArgv options affect child launch but are omitted from status and failures.
+ * With totalShards "auto" and processes or shardsPerProcess, the plan is sized at start. Each child sends its client diagnostics, which status includes.
+ * Children keep resumable sessions through clientOptions.sharding.sessions.
+ * The children share Fluxer's limits per bot account through the parent. When one child is rate-limited globally, the parent
+ * holds the other children's REST requests until the same time. Member requests from all children share one count of 12 in
+ * any 11 seconds, and a members.iterateChunks request past it fails at once with reason rateLimit and retryAfterMs.
+ * A child that gets no answer from the parent within one second counts only its own member requests and logs
+ * supervisor.memberRequestsLocal once. Per-route REST rate limits stay per child, and other processes using the same
+ * token are not counted
+ *
+ * @example
+ * ```ts
+ * import { supervisor } from "@neontechspace/fluxerly"
+ *
+ * export const workers = supervisor.create({
+ *     entry: "/srv/bot-worker.js",
+ *     totalShards: 2,
+ *     assignments: [
+ *         { id: "one", shardIds: [0] },
+ *         { id: "two", shardIds: [1] },
+ *     ],
+ * })
+ * ```
+ *
+ * @category Sharding and supervision
+ */
+export const supervisor = makeDefaultSupervisor(createClient);
+//# sourceMappingURL=supervisor.js.map

package/dist/api/default/supervisor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"supervisor.js","sourceRoot":"","sources":["../../../src/api/default/supervisor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAA;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,MAAM,CAAC,MAAM,UAAU,GAA6D,qBAAqB,CAAC,YAAY,CAAC,CAAA"}

package/dist/api/default/threads.d.ts

@@ -0,0 +1,158 @@
+import type { ResultAsync, Result } from "neverthrow";
+import type { GuildThreadChannel, ThreadMember, ChannelOperationFailure, DefaultChannelOperationOptions, DefaultChannelAuditOperationOptions } from "#sdk/channels";
+import type { CancelledError, ConfigurationError } from "#sdk/errors";
+import type { Message, MessageCore, MessageReference } from "#sdk/messages";
+import type { PaginationError } from "#sdk/pagination";
+import type { ArchivedThreadPage, ArchivedThreadQuery, ForumPost, ForumPostCreate, ThreadCreate, ThreadEdit, ThreadFromMessageCreate, ThreadMemberIterationQuery, ThreadMemberPageQuery, ThreadMemberQuery, ThreadSearchPage, ThreadSearchQuery } from "#sdk/threads";
+/**
+ * Create threads and forum posts, change, list and search threads, and manage thread members.
+ * Every method uses HTTP without a gateway connection and starts immediately.
+ * Bots can use threads in every community where Fluxer enables them, without a capability setting.
+ * Read a thread with channels.fetch, delete it with channels.delete and send to it with messages.send and its ID
+ *
+ * @remarks
+ * Supply decimal IDs. Requests share the client's REST slots and queue limits.
+ * The default deadline, rest.defaultTimeoutMs (30,000 ms unless configured), includes capacity, rate-limit and retry waits.
+ * Eligible reads retry transport and HTTP 500, 502, 503 or 504 failures at most twice.
+ * Writes retry only confirmed HTTP 429 rejection, and no write is followed by an automatic confirmation fetch.
+ * Manage Threads is an elevated permission.
+ * In a community whose mfaLevel is GuildMfaLevels.Elevated, an action that needs it fails with apiError.code twoFactorRequired, unless the bot owns the community or its application owner has two-factor authentication enabled.
+ * The create, createFromMessage, createPost and edit methods accept a raw audit reason through
+ * DefaultChannelAuditOperationOptions, and the other methods reject auditReason.
+ * The fetchActive list enters the enabled channel cache, while archived pages, search results, forum posts and member
+ * reads do not.
+ * The edit, join, leave, addMember and removeMember methods remove their thread from the enabled channel cache.
+ * Inputs are copied when called.
+ * Expected failures return ChannelOperationError, whose operation names the threads method, or ClientClosedError.
+ * Abort returns CancelledError after cleanup.
+ * Unexpected failures reject with SdkDefect
+ *
+ * @category Channels
+ */
+export interface Threads<M extends MessageCore = Message> {
+    /**
+     * Create a thread that is not attached to a message in a text or announcement channel, and return its frozen
+     * snapshot. The bot becomes the thread's first member, and Fluxer posts a ThreadCreated notice in the parent channel
+     * for a public or announcement thread.
+     * Fluxer requires Create Public Threads, or Create Private Threads for a private thread.
+     * Use createPost in a forum or media channel.
+     * A lost response can leave the thread created, and the SDK never resends it
+     *
+     * @example
+     * ```ts
+     * import { ChannelType, ThreadAutoArchiveMinutes, type Client } from "@neontechspace/fluxerly"
+     * export async function threadExample(client: Client, channelId: string) {
+     *     const thread = await client.threads.create(channelId, {
+     *         name: "Release planning",
+     *         type: ChannelType.PrivateThread,
+     *         autoArchiveMinutes: ThreadAutoArchiveMinutes.OneDay,
+     *     })
+     *     if (thread.isErr()) throw thread.error
+     *     return client.messages.send(thread.value.id, "Planning starts here")
+     * }
+     * ```
+     */
+    create(channelId: string, input: ThreadCreate, options?: DefaultChannelAuditOperationOptions): ResultAsync<GuildThreadChannel, ChannelOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Start a public thread on an existing message and return its frozen snapshot.
+     * The thread takes the message's ID, and the message gains MessageFlags.HasThread.
+     * Only a default message or a reply in a text or announcement channel can start a thread, and only one.
+     * In an announcement channel the thread is an announcement thread.
+     * Fluxer posts a ThreadCreated notice in the parent channel unless the message is among its five newest messages.
+     * Fluxer requires Create Public Threads and Read Message History.
+     * A lost response can leave the thread created, and the SDK never resends it.
+     * After an unknown outcome, channels.fetch(message.id) shows whether the thread exists
+     */
+    createFromMessage(message: MessageReference, input: ThreadFromMessageCreate, options?: DefaultChannelAuditOperationOptions): ResultAsync<GuildThreadChannel, ChannelOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Create a post in a forum or media channel, a public thread with its first message, and return both frozen.
+     * Files in the message are sent inline as multipart form data in the same request, never through presigned uploads,
+     * under messages.send's attachment rules and the client's upload budget.
+     * Fluxer requires Send Messages in the channel plus the permissions the message content needs, and applies the
+     * channel's tag rules. When the first message fails, Fluxer removes the new post again.
+     * A lost response can leave the post created, and the SDK never resends it
+     */
+    createPost(channelId: string, input: ForumPostCreate, options?: DefaultChannelAuditOperationOptions): ResultAsync<ForumPost<M>, ChannelOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Change only the supplied thread settings and return the frozen thread.
+     * It uses the route and rate limit of channels.edit. ThreadEdit describes which changes the thread's creator may
+     * make and which need Manage Threads
+     */
+    edit(threadId: string, input: ThreadEdit, options?: DefaultChannelAuditOperationOptions): ResultAsync<GuildThreadChannel, ChannelOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Fetch every active thread the bot can view in a community, newest first, as one frozen list.
+     * A private thread appears when the bot joined it or can manage threads in its parent channel.
+     * Each thread the bot joined has membership set
+     */
+    fetchActive(guildId: string, options?: DefaultChannelOperationOptions): ResultAsync<readonly GuildThreadChannel[], ChannelOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Fetch one frozen page of archived threads of a text, announcement, forum or media channel, as ArchivedThreadQuery
+     * selects. Scopes "public" and "private" list the most recently archived first, and "joinedPrivate" lists the newest
+     * threads first. Each thread the bot joined has membership set.
+     * Fluxer requires Read Message History, plus Manage Threads for scope "private"
+     */
+    fetchArchived(channelId: string, query?: ArchivedThreadQuery, options?: DefaultChannelOperationOptions): ResultAsync<ArchivedThreadPage, ChannelOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Search the threads of a text, announcement, forum or media channel by name, tags and state, and return one frozen
+     * page. Fluxer requires Read Message History.
+     * While Fluxer builds the community's search index it answers HTTP 202 with code SEARCH_INDEX_NOT_READY, which this
+     * method returns as an indexing page without retrying. Any other HTTP 202 answer fails with reason response.
+     * While Fluxer's search service is turned off, the call fails with reason rejected and apiError.providerCode
+     * FEATURE_TEMPORARILY_DISABLED
+     */
+    search(channelId: string, query?: ThreadSearchQuery, options?: DefaultChannelOperationOptions): ResultAsync<ThreadSearchPage<M>, ChannelOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Add the bot to a thread, succeeding with no value after HTTP 204. Joining a thread the bot already belongs to also
+     * succeeds. An archived thread cannot be joined, and a locked one needs Manage Threads
+     */
+    join(threadId: string, options?: DefaultChannelOperationOptions): ResultAsync<void, ChannelOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Remove the bot from a thread, succeeding with no value after HTTP 204.
+     * An archived thread cannot be left, and Fluxer rejects a bot that is not a member with UNKNOWN_THREAD_MEMBER
+     */
+    leave(threadId: string, options?: DefaultChannelOperationOptions): ResultAsync<void, ChannelOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Add a community member who can view the parent channel to a thread, succeeding with no value after HTTP 204.
+     * Adding a current member also succeeds, and otherwise Fluxer posts a RecipientAdd notice in the thread.
+     * Fluxer requires Send Messages In Threads, plus Manage Threads in a locked thread and in a private thread that is
+     * not invitable, unless the added member can manage threads. An archived thread accepts no new members
+     */
+    addMember(threadId: string, userId: string, options?: DefaultChannelOperationOptions): ResultAsync<void, ChannelOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Remove a member from a thread, succeeding with no value after HTTP 204, and Fluxer posts a RecipientRemove notice
+     * in the thread. Removing the bot's own ID works like leave.
+     * Fluxer requires Manage Threads unless the bot created the private thread. A user who is not a member fails with
+     * UNKNOWN_THREAD_MEMBER, and an archived thread cannot change
+     */
+    removeMember(threadId: string, userId: string, options?: DefaultChannelOperationOptions): ResultAsync<void, ChannelOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Fetch one thread member as a frozen ThreadMember. A user who is not a member fails with UNKNOWN_THREAD_MEMBER.
+     * With withMember, member holds the user's community membership while the user has one. Its community comes from
+     * the channel cache when the thread is cached there, otherwise from one extra channel read that shares the deadline
+     * and whose failure fails this call
+     */
+    fetchMember(threadId: string, userId: string, query?: ThreadMemberQuery, options?: DefaultChannelOperationOptions): ResultAsync<ThreadMember, ChannelOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Fetch one page of thread members in ascending user ID order, as frozen ThreadMember values.
+     * With withMember, each member holds the user's community membership while the user has one, with the community
+     * resolved as fetchMember describes
+     */
+    fetchMembers(threadId: string, query?: ThreadMemberPageQuery, options?: DefaultChannelOperationOptions): ResultAsync<readonly ThreadMember[], ChannelOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Read thread members in ascending user ID order, buffering one page and never prefetching.
+     * The maxItems option is required. The pageSize option defaults to 100 and accepts 1–100, maxPages defaults to 100,
+     * and timeoutMs applies to each page. An empty page or maxItems ends the scan.
+     * Invalid traversal input, a stalled cursor or reaching the page budget fails with PaginationError, and remote
+     * failures keep threads.fetchMembers's errors.
+     * With withMember, one consumption resolves the thread's community once, as fetchMember describes.
+     * Each consumption is independent, and client closure releases the page and fails the next pull
+     *
+     * @remarks
+     * Consume the iterable with a for await loop, which starts the first request.
+     * An expected failure yields one Err and ends iteration.
+     * Breaking the loop releases the buffered page.
+     * Abort interrupts pending request work and waits for cleanup
+     */
+    iterateMembers(threadId: string, query: ThreadMemberIterationQuery, options?: DefaultChannelOperationOptions): AsyncIterable<Result<ThreadMember, ChannelOperationFailure | PaginationError | CancelledError | ConfigurationError>>;
+}
+//# sourceMappingURL=threads.d.ts.map

package/dist/api/default/threads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"threads.d.ts","sourceRoot":"","sources":["../../../src/api/default/threads.ts"],"names":[],"mappings":"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"}

package/dist/api/default/threads.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=threads.js.map

package/dist/api/default/threads.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"threads.js","sourceRoot":"","sources":["../../../src/api/default/threads.ts"],"names":[],"mappings":""}

package/dist/api/default/users.d.ts

@@ -0,0 +1,73 @@
+import type { User, UserProfile, UserProfileQuery, UserOperationFailure, DefaultUserOperationOptions } from "#sdk/users";
+import type { ResultAsync } from "neverthrow";
+import type { CancelledError, ConfigurationError } from "#sdk/errors";
+/**
+ * Read public user account and profile data, without connecting the gateway.
+ * Use get for an explicitly enabled local account cache, or fetch for a remote read.
+ * HTTP calls start immediately with the client's default deadline (rest.defaultTimeoutMs, 30,000 ms unless configured) and bounded eligible read retries.
+ * Any writes retry only confirmed rate-limit rejection, not an uncertain outcome.
+ * Abort waits for cleanup and returns CancelledError.
+ * Unexpected failures reject with SdkDefect
+ *
+ * @category Users and DMs
+ */
+export interface Users {
+    /**
+     * Look up a public account in the optional cache using its decimal ID, without a request.
+     * A hit may be stale and becomes more recently used without extending its age.
+     * A miss produces undefined.
+     * An invalid ID is misuse: The default API throws UserOperationError with reason input and the native API dies with it.
+     * A closing or closed client has no cache, so the result is undefined
+     *
+     * @remarks
+     * Returns the value synchronously.
+     * Unexpected failures throw SdkDefect
+     */
+    get(id: string): User | undefined;
+    /**
+     * Look up the bot's own public account as the gateway's READY reported it, without a request.
+     * The result is undefined until this client's first READY, and also while no READY has carried a complete public account.
+     * A later READY with a complete public account, such as for a new session, replaces it, while an incomplete one keeps the previous account.
+     * Other user updates and fetchSelf results do not change it, so its username or avatar can be stale.
+     * The value remains available after the client stops.
+     * This lookup never fails. Use fetchSelf for a current remote snapshot
+     *
+     * @remarks
+     * Returns the value synchronously
+     */
+    getSelf(): User | undefined;
+    /**
+     * Fetch a public account snapshot by decimal user ID.
+     * An unknown user fails with reason notFound rather than an empty result.
+     * With the user cache enabled, a concurrent fetch of another user ID does not keep this result from being stored, unless more than 256 user IDs are being read at once
+     */
+    fetch(id: string, options?: DefaultUserOperationOptions): ResultAsync<User, UserOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Fetch a user's privacy-filtered profile, optionally for the community specified in query.guildId.
+     * The frozen result includes only documented identity and profile fields.
+     * The isLimited field reports Fluxer's privacy restriction, not missing community membership.
+     * A guildProfile of null means no contextual profile was supplied, not proof the user is outside the community.
+     * No gateway connection, hidden member fetch or account or profile cache use is performed, and each call issues a separate read.
+     * Users' shared deadlines and eligible read retries apply.
+     * Fluxer may clear expired premium state while serving this GET.
+     * Invalid input, denied access or a malformed response fails with UserOperationError for users.fetchProfile.
+     * Cancellation affects this request only and waits for cleanup
+     *
+     * @example
+     * ```ts
+     * import type { Client } from "@neontechspace/fluxerly"
+     * export function profileExample(client: Client, userId: string, guildId: string) {
+     *     return client.users.fetchProfile(userId, { guildId })
+     * }
+     * ```
+     */
+    fetchProfile(id: string, query?: UserProfileQuery, options?: DefaultUserOperationOptions): ResultAsync<UserProfile, UserOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Fetch the authenticated bot's public account data remotely.
+     * Private account fields are excluded.
+     * With the user cache enabled, the bot's ID is unknown until the response arrives, so some concurrent user cache changes keep the result out of the cache.
+     * Examples are another users.fetch or users.fetchSelf call, a user update event and a lost gateway connection
+     */
+    fetchSelf(options?: DefaultUserOperationOptions): ResultAsync<User, UserOperationFailure | CancelledError | ConfigurationError>;
+}
+//# sourceMappingURL=users.d.ts.map

package/dist/api/default/users.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"users.d.ts","sourceRoot":"","sources":["../../../src/api/default/users.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAA;AACxH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAErE;;;;;;;;;GASG;AACH,MAAM,WAAW,KAAK;IAClB;;;;;;;;;;OAUG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;IACjC;;;;;;;;;;OAUG;IACH,OAAO,IAAI,IAAI,GAAG,SAAS,CAAA;IAC3B;;;;OAIG;IACH,KAAK,CACD,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE,2BAA2B,GACtC,WAAW,CAAC,IAAI,EAAE,oBAAoB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IAChF;;;;;;;;;;;;;;;;;;OAkBG;IACH,YAAY,CACR,EAAE,EAAE,MAAM,EACV,KAAK,CAAC,EAAE,gBAAgB,EACxB,OAAO,CAAC,EAAE,2BAA2B,GACtC,WAAW,CAAC,WAAW,EAAE,oBAAoB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IACvF;;;;;OAKG;IACH,SAAS,CACL,OAAO,CAAC,EAAE,2BAA2B,GACtC,WAAW,CAAC,IAAI,EAAE,oBAAoB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;CACnF"}

package/dist/api/default/users.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=users.js.map

package/dist/api/default/users.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"users.js","sourceRoot":"","sources":["../../../src/api/default/users.ts"],"names":[],"mappings":""}