@classytic/social 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,65 @@
+# Changelog
+
+All notable changes to `@classytic/social` will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+While the package is on `0.x.y`, minor bumps may include breaking changes;
+patch bumps are always backwards-compatible. We'll bump to `1.0.0` once the
+public surface stabilizes.
+
+## [0.1.0] — 2026-05-09
+
+Initial public release. Unified social media SDK for 9 platforms — YouTube,
+TikTok, Instagram, Facebook, LinkedIn, Telegram, WhatsApp, Twitter/X, Reddit.
+
+### Features
+
+- **`SocialClient` unified façade** — credential-bound wrapper exposing each
+  provider as a typed sub-client (`client.twitter`, `client.facebook`, …) plus
+  multi-platform `post()` / `upload()` / `message()` fan-out.
+- **`fromEnv()` auto-config** — instantiate from `process.env` using standard
+  `<PLATFORM>_*` variable names. Only platforms with required vars are enabled.
+- **9 provider classes** — direct, low-level access to each platform's full
+  surface (OAuth, CRUD, upload, messaging, analytics where supported).
+- **Factory `createRegistry({ port })`** — dynamic dispatch by provider name
+  for advanced multi-tenant scenarios.
+
+### Subpath exports
+
+- `@classytic/social` — main entrypoint (client, providers, errors)
+- `@classytic/social/client` — just the unified client + sub-clients
+- `@classytic/social/schemas` — zod v4 schemas + `allCapabilities` map +
+  `providersWithCapability(key)` for consumers (e.g. `@classytic/arc`) that
+  generate APIs / OpenAPI specs / MCP tools from schemas
+- `@classytic/social/common` — shared helpers exposed publicly:
+  - `httpRequest<T>()` — fetch wrapper with timeout, exponential-backoff retry,
+    `Retry-After` honoring, structured `SocialError` throwing
+  - `oauth2ExchangeCode` / `oauth2RefreshToken` / `buildAuthUrl` — RFC 6749
+  - `metaExchangeLongLived` / `metaRefreshLongLived*` — Meta two-step flow
+  - `PkceStore` / `generateCodeVerifier` / `generateCodeChallenge` — PKCE
+  - `paginate()` — generic cursor pagination → `AsyncIterable` with `.toArray()` / `.take(n)`
+  - `pollUntilComplete()` — poll-with-timeout for async jobs
+  - `assertPublicHttpUrl()` — SSRF guard for user-supplied URLs
+  - `redactSecrets()` — safe object-tree logging
+- `@classytic/social/<provider>` — direct access to one provider class
+
+### Cross-cutting
+
+- **`SocialError`** — uniform error class with `provider`, `statusCode`,
+  `errorCode`, `hint`, `retryable`, `retryAfter`, `originalError`. Every provider
+  populates these consistently via the shared HTTP layer.
+- **Capability declarations** per provider via `*Capabilities` constants
+  (auth type, posting, upload, messaging, scheduling, deletion, listing,
+  analytics, environments, PKCE).
+- **Per-provider rate-limit / file-size metadata** via `*Info` constants
+  in the schemas subpath.
+- **Tree-shakeable** — `sideEffects: false`, per-provider subpath exports.
+- **325 tests, build-validated with `attw` + `publint`.**
+
+### Examples
+
+5 runnable scripts under [`examples/`](./examples/) covering multi-platform
+posting, Express OAuth flow, Vercel AI SDK tool composition (composed at the
+call site — no package adapters), scheduled posts, and Telegram bot flow.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Classytic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,368 @@
+# @classytic/social
+
+> One TypeScript SDK for nine social platforms. OAuth, posting, video upload, messaging — with batteries included for AI agents.
+
+[![Node](https://img.shields.io/badge/node-%3E%3D20-green)](https://nodejs.org)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+**Platforms:** YouTube · TikTok · Instagram · Facebook · LinkedIn · Telegram · WhatsApp · Twitter/X · Reddit
+
+---
+
+## Why this package
+
+- **One client, every platform.** Configure once, post anywhere.
+- **AI-ready.** One import → typed tool definitions for OpenAI, Anthropic, MCP, and the Vercel AI SDK.
+- **Type-safe end-to-end.** Zod v4 schemas double as runtime validators, JSON Schema, and form descriptors.
+- **Production-grade.** Shared HTTP client with timeouts, retry, rate-limit handling, and SSRF guards.
+- **Tree-shakeable.** Per-provider subpath imports — only ship what you use.
+
+---
+
+## Install
+
+```bash
+npm install @classytic/social
+# YouTube provider needs googleapis as a peer dep:
+npm install googleapis
+```
+
+---
+
+## Three-line quickstart
+
+```ts
+import { fromEnv } from '@classytic/social';
+
+const client = fromEnv();                       // reads TWITTER_*, FACEBOOK_*, etc.
+await client.post({ text: 'Hello, internet!' }); // fans out to every configured platform
+```
+
+That's it. Configure credentials via env vars, call `post()`, and the SDK handles auth, rate limits, retries, and platform quirks.
+
+---
+
+## Configure explicitly
+
+```ts
+import { SocialClient } from '@classytic/social';
+
+const client = SocialClient.create({
+  twitter:  { clientId, clientSecret, tokens: { access_token } },
+  linkedin: { clientId, clientSecret, tokens: { access_token }, authorUrn: 'urn:li:person:abc' },
+  facebook: { appId, appSecret, tokens: { access_token }, pageId, pageAccessToken },
+  telegram: { botToken: '123:abc', chatId: '@my-channel' },
+});
+
+// Fan out to all configured platforms
+const result = await client.post({
+  text: 'Hello world',
+  media: [{ type: 'image', url: 'https://cdn.example.com/banner.png' }],
+  link: 'https://example.com/launch',
+});
+
+console.log(result.allOk, result.results); // per-platform pass/fail breakdown
+```
+
+### Per-platform calls
+
+```ts
+await client.twitter!.post({ text: 'Just a tweet' });
+await client.telegram!.send('Hi from the bot');
+await client.linkedin!.post({ text: 'Long-form content...' });
+await client.youtube!.upload({ videoUrl: '...', title: 'Launch!' });
+```
+
+### Video upload to multiple platforms
+
+```ts
+await client.upload({
+  platforms: ['youtube', 'tiktok'],
+  videoUrl: 'https://cdn.example.com/clip.mp4',
+  title: 'Launch trailer',
+  description: 'Out now.',
+  privacy: 'public',
+});
+```
+
+### Direct messaging
+
+```ts
+await client.message({ platform: 'telegram', text: 'Build deployed' });
+await client.message({ platform: 'whatsapp', to: '+15551234567', text: 'Verification code: 1234' });
+```
+
+---
+
+## AI agents — compose tools yourself
+
+This package deliberately doesn't ship LLM-SDK-specific tool adapters. Tool format is an application concern that varies per stack and changes between SDK versions. Compose tools at the call site using primitives the package gives you: typed `SocialClient` methods + zod schemas from `@classytic/social/schemas`.
+
+### Vercel AI SDK v5
+
+```ts
+import { tool } from 'ai';
+import { z } from 'zod';
+import { SocialClient } from '@classytic/social';
+
+const client = SocialClient.create({ /* ... */ });
+
+export const tools = {
+  twitter_post: tool({
+    description: 'Post a tweet (≤280 characters)',
+    inputSchema: z.object({
+      text: z.string().max(280),
+      replyToTweetId: z.string().optional(),
+    }),
+    execute: ({ text, replyToTweetId }) => client.twitter!.post({
+      text,
+      perPlatform: { twitter: { replyTo: replyToTweetId } },
+    }),
+  }),
+  telegram_send: tool({
+    description: 'Send a message via the configured Telegram bot',
+    inputSchema: z.object({ text: z.string().min(1).max(4096) }),
+    execute: ({ text }) => client.telegram!.send(text),
+  }),
+};
+```
+
+### OpenAI / Anthropic / MCP
+
+Generate JSON Schema from any zod schema with `z.toJSONSchema()` (zod v4 builtin):
+
+```ts
+import { z } from 'zod';
+
+const twitterPostInput = z.object({
+  text: z.string().max(280),
+  replyToTweetId: z.string().optional(),
+});
+
+// OpenAI Chat Completions
+const openaiTool = {
+  type: 'function' as const,
+  function: {
+    name: 'twitter_post',
+    description: 'Post a tweet',
+    parameters: z.toJSONSchema(twitterPostInput),
+  },
+};
+
+// Anthropic Messages
+const anthropicTool = {
+  name: 'twitter_post',
+  description: 'Post a tweet',
+  input_schema: z.toJSONSchema(twitterPostInput),
+};
+
+// MCP `tools/list`
+const mcpTool = {
+  name: 'twitter_post',
+  description: 'Post a tweet',
+  inputSchema: z.toJSONSchema(twitterPostInput),
+};
+
+// Then dispatch a tool call to the bound client:
+async function dispatch(name: string, input: unknown) {
+  switch (name) {
+    case 'twitter_post': {
+      const args = twitterPostInput.parse(input);
+      return client.twitter!.post({
+        text: args.text,
+        perPlatform: { twitter: { replyTo: args.replyToTweetId } },
+      });
+    }
+    // ... other tools
+  }
+}
+```
+
+That's 5 lines per tool. The package gives you:
+- **Methods** — `client.twitter!.post(...)`, `client.telegram!.send(...)` etc.
+- **Schemas** — pre-built zod v4 schemas in `@classytic/social/schemas`
+- **Capabilities** — `allCapabilities`, `providersWithCapability('messaging')` for filtering
+
+You compose them into whatever tool shape your LLM stack expects — and you control the input shape (e.g., flatten `perPlatform.twitter.replyTo` into a top-level `replyToTweetId`) without inheriting the package's opinions.
+
+---
+
+## OAuth flows
+
+Each sub-client exposes the standard OAuth lifecycle:
+
+```ts
+// 1. Build the consent URL
+const url = await client.twitter!.authUrl('csrf-state-token');
+// → redirect user
+
+// 2. Exchange callback code (PKCE handled internally)
+const tokens = await client.twitter!.exchangeCode(code, 'csrf-state-token');
+// tokens are stored on `client.twitter.config.tokens`
+
+// 3. Refresh later
+const fresh = await client.twitter!.refresh();
+```
+
+Telegram and WhatsApp use static tokens — no OAuth required.
+
+---
+
+## Subpath exports
+
+Tree-shakeable entrypoints — import only what you need.
+
+| Subpath | Purpose |
+|---|---|
+| `@classytic/social` | `SocialClient`, `fromEnv`, all provider classes, errors |
+| `@classytic/social/client` | Just the unified client + sub-clients |
+| `@classytic/social/schemas` | Zod v4 schemas + capability map (for arc, OpenAPI, MCP) |
+| `@classytic/social/common` | `httpRequest`, `oauth2*`, `paginate`, `pollUntilComplete`, `assertPublicHttpUrl` |
+| `@classytic/social/<provider>` | Direct access to a single provider class |
+
+---
+
+## Schemas — design APIs from the SDK
+
+Every credential, request input, and capability is a zod v4 schema. Generate JSON Schema, build forms, or validate at request boundaries:
+
+```ts
+import { z } from 'zod';
+import {
+  YouTubeUploadParamsSchema,
+  TelegramSendMessageSchema,
+  allCapabilities,
+  providersWithCapability,
+} from '@classytic/social/schemas';
+
+// Validate input
+const params = YouTubeUploadParamsSchema.parse(body);
+
+// Generate OpenAPI / MCP tool spec
+const jsonSchema = z.toJSONSchema(YouTubeUploadParamsSchema);
+
+// Filter providers by feature
+providersWithCapability('scheduling'); // → ['youtube', 'tiktok', 'facebook']
+providersWithCapability('messaging');  // → ['telegram', 'whatsapp']
+```
+
+---
+
+## Capabilities matrix
+
+| Provider | Auth | Posting | Upload | Messaging | Schedule | Delete | Analytics |
+|---|---|---|---|---|---|---|---|
+| YouTube | OAuth2 | — | ✓ | — | ✓ | ✓ | — |
+| TikTok | OAuth2 + PKCE | ✓ | ✓ | — | ✓ | — | — |
+| Instagram | OAuth2 (Meta) | ✓ | ✓ | — | — | — | ✓ |
+| Facebook | OAuth2 (Meta) | ✓ | ✓ | — | ✓ | ✓ | ✓ |
+| LinkedIn | OAuth2 | ✓ | ✓ | — | — | ✓ | ✓ |
+| Twitter/X | OAuth2 + PKCE | ✓ | ✓ | ✓ (DM) | — | ✓ | — |
+| Reddit | OAuth2 | ✓ | — | — | — | ✓ | — |
+| Telegram | Bot Token | — | ✓ | ✓ | — | ✓ | — |
+| WhatsApp | API Token | — | — | ✓ | — | — | — |
+
+---
+
+## Error handling
+
+All providers throw `SocialError` with a uniform shape:
+
+```ts
+import { SocialError } from '@classytic/social';
+
+try {
+  await client.twitter!.post({ text: 'Hi' });
+} catch (e) {
+  if (e instanceof SocialError) {
+    console.log(e.provider);    // 'twitter'
+    console.log(e.statusCode);  // 401, 429, 502, …
+    console.log(e.errorCode);   // platform-specific code
+    console.log(e.retryable);   // boolean | null
+    console.log(e.retryAfter);  // seconds (for 429)
+    console.log(e.hint);        // human-readable mitigation hint
+  }
+}
+```
+
+The unified `client.post()` / `client.upload()` never throw on per-platform failures — each result has `ok: boolean` and `error?` populated independently.
+
+---
+
+## Custom HTTP / OAuth — build your own provider
+
+```ts
+import { httpRequest, oauth2ExchangeCode, paginate } from '@classytic/social/common';
+
+// Same retry / timeout / 429 handling used internally
+const { data } = await httpRequest('mastodon', {
+  method: 'POST',
+  url: 'https://mastodon.social/api/v1/statuses',
+  bearer: accessToken,
+  json: { status: 'Hello' },
+  timeout: 30_000,
+  retry: { attempts: 2 },
+});
+```
+
+---
+
+## Environment variables (`fromEnv()`)
+
+Set any subset — only matching platforms are enabled.
+
+```bash
+# YouTube
+YOUTUBE_CLIENT_ID=...        YOUTUBE_CLIENT_SECRET=...
+YOUTUBE_ACCESS_TOKEN=...     YOUTUBE_REFRESH_TOKEN=...
+
+# Twitter
+TWITTER_CLIENT_ID=...        TWITTER_CLIENT_SECRET=...
+TWITTER_ACCESS_TOKEN=...     TWITTER_REFRESH_TOKEN=...
+
+# Facebook (Pages)
+FACEBOOK_APP_ID=...          FACEBOOK_APP_SECRET=...
+FACEBOOK_ACCESS_TOKEN=...    FACEBOOK_PAGE_ID=...
+FACEBOOK_PAGE_ACCESS_TOKEN=...
+
+# Instagram
+INSTAGRAM_APP_ID=...         INSTAGRAM_APP_SECRET=...
+INSTAGRAM_ACCESS_TOKEN=...   INSTAGRAM_USER_ID=...
+
+# LinkedIn
+LINKEDIN_CLIENT_ID=...       LINKEDIN_CLIENT_SECRET=...
+LINKEDIN_ACCESS_TOKEN=...    LINKEDIN_AUTHOR_URN=urn:li:person:...
+
+# Reddit
+REDDIT_CLIENT_ID=...         REDDIT_CLIENT_SECRET=...
+REDDIT_USER_AGENT="web:my-app:v1.0 (by /u/yourname)"
+REDDIT_ACCESS_TOKEN=...      REDDIT_REFRESH_TOKEN=...
+
+# TikTok
+TIKTOK_CLIENT_KEY=...        TIKTOK_CLIENT_SECRET=...
+TIKTOK_ACCESS_TOKEN=...      TIKTOK_REFRESH_TOKEN=...
+
+# Telegram (bot)
+TELEGRAM_BOT_TOKEN=123:abc   TELEGRAM_CHAT_ID=@my-channel
+
+# WhatsApp Business
+WHATSAPP_ACCESS_TOKEN=...    WHATSAPP_BUSINESS_ACCOUNT_ID=...
+WHATSAPP_PHONE_NUMBER_ID=...
+```
+
+---
+
+## Development
+
+```bash
+npm run build       # tsdown → dist/
+npm run typecheck   # tsc --noEmit
+npm test            # vitest (325 tests)
+npm run test:watch  # vitest watch mode
+```
+
+---
+
+## License
+
+MIT

package/dist/base-Bw7e52V8.mjs

@@ -0,0 +1,246 @@
+//#region src/base.ts
+var PlatformProvider = class {
+	name;
+	displayName;
+	config;
+	authType;
+	constructor(config = {}) {
+		this.name = "";
+		this.displayName = "";
+		this.config = config;
+		this.authType = "oauth2";
+	}
+	/**
+	* Get OAuth authorization URL
+	* @param state - State parameter for CSRF protection
+	* @param credData - Decrypted credential data (client ID, redirect URI, etc.)
+	* @returns Authorization URL
+	*/
+	getAuthUrl(state, credData, options) {
+		throw new Error(`${this.name}: getAuthUrl() not implemented`);
+	}
+	/**
+	* Exchange authorization code for access token
+	* @param code - Authorization code from OAuth callback
+	* @param credData - Decrypted credential data
+	* @returns Token data { access_token, refresh_token, expires_in, ... }
+	*/
+	async exchangeCode(code, credData, state) {
+		throw new Error(`${this.name}: exchangeCode() not implemented`);
+	}
+	/**
+	* Refresh access token using refresh token
+	* @param refreshToken - Refresh token
+	* @param credData - Decrypted credential data
+	* @returns New token data
+	*/
+	async refreshToken(refreshToken, credData) {
+		throw new Error(`${this.name}: refreshToken() not implemented`);
+	}
+	/**
+	* Get account information using access token
+	* @param accessToken - Access token
+	* @param credData - Decrypted credential data
+	* @returns Account info { id, name, email, profileImage, ... }
+	*/
+	async getAccountInfo(accessToken, credData) {
+		throw new Error(`${this.name}: getAccountInfo() not implemented`);
+	}
+	/**
+	* Revoke an OAuth access token. Forces the provider to show a fresh consent
+	* screen on next authorization (ensures newly enabled scopes are granted).
+	* Default: no-op. Override in providers that support token revocation.
+	*/
+	async revokeToken(accessToken, credData) {}
+	/**
+	* Test credential validity
+	* @param credentialData - Decrypted credential data
+	* @returns Test result { status: 'OK' | 'Error', message, ... }
+	*/
+	async testCredential(credentialData) {
+		throw new Error(`${this.name}: testCredential() not implemented`);
+	}
+	/**
+	* Upload video to platform.
+	* Each provider defines its own parameter type — the base accepts any shape.
+	* @param params - Platform-specific upload parameters
+	* @returns Upload result
+	*/
+	async uploadVideo(params) {
+		throw new Error(`${this.name}: uploadVideo() not implemented`);
+	}
+	/**
+	* Upload photo(s) to platform.
+	* Each provider defines its own parameter type.
+	* @param params - Platform-specific upload parameters
+	* @returns Upload result
+	*/
+	async uploadPhoto(params) {
+		throw new Error(`${this.name}: uploadPhoto() not implemented`);
+	}
+	/**
+	* Upload carousel (multi-media) post.
+	* Each provider defines its own parameter type.
+	* @param params - Platform-specific carousel parameters
+	* @returns Upload result
+	*/
+	async uploadCarousel(params) {
+		throw new Error(`${this.name}: uploadCarousel() not implemented`);
+	}
+	/**
+	* Send a message via the platform (Telegram, WhatsApp)
+	* @param args - Platform-specific arguments
+	*/
+	async sendMessage(...args) {
+		throw new Error(`${this.name}: sendMessage() not implemented`);
+	}
+	/**
+	* Delete/unpublish a post from the platform
+	* @param args - Platform-specific arguments (token, postId, etc.)
+	*/
+	async deletePost(...args) {
+		throw new Error(`${this.name}: deletePost() not implemented`);
+	}
+	/**
+	* Delete a message (Telegram-specific)
+	* @param botToken - Bot token
+	* @param chatId - Chat ID
+	* @param messageId - Message ID
+	*/
+	async deleteMessage(botToken, chatId, messageId) {
+		throw new Error(`${this.name}: deleteMessage() not implemented`);
+	}
+	/**
+	* Get credential schema for UI form rendering.
+	*
+	* Default implementation derives fields from the zod schema returned by
+	* `getCredentialZodSchema()`. Providers may override either method —
+	* overriding `getCredentialZodSchema()` is preferred so consumers also get
+	* runtime validation, JSON Schema generation, and TypeScript inference.
+	*/
+	getCredentialSchema() {
+		const zodSchema = this.getCredentialZodSchema();
+		if (!zodSchema) return [];
+		return deriveCredentialFields(zodSchema);
+	}
+	/**
+	* Return the zod schema for this provider's credentials. Providers should
+	* override this to enable runtime validation and form schema derivation.
+	*
+	* @returns A zod object schema, or `null` if the provider doesn't expose
+	*   credentials via this interface yet.
+	*/
+	getCredentialZodSchema() {
+		return null;
+	}
+	/**
+	* Get provider metadata for frontend display and dynamic form rendering.
+	* Subclasses should override to provide platform-specific details.
+	*
+	* @returns Provider metadata
+	*/
+	getMetadata() {
+		return {
+			name: this.name,
+			displayName: this.displayName,
+			authType: this.authType,
+			icon: this.name,
+			brandColor: null,
+			description: "",
+			scopes: [],
+			scopeDescriptions: {},
+			setupGuide: [],
+			supportsScheduling: false,
+			supportsEnvironment: false,
+			redirectUriPattern: `/api/oauth/${this.name}/callback`,
+			credentialSchema: this.getCredentialSchema()
+		};
+	}
+	/**
+	* Validate credential data using the provider's zod schema if available,
+	* falling back to a presence check on the UI schema.
+	*/
+	validateCredentials(data) {
+		const zodSchema = this.getCredentialZodSchema();
+		if (zodSchema) {
+			const result = zodSchema.safeParse(data);
+			if (result.success) return {
+				valid: true,
+				errors: []
+			};
+			return {
+				valid: false,
+				errors: result.error.issues.map((issue) => {
+					return `${issue.path.length ? issue.path.join(".") + ": " : ""}${issue.message}`;
+				})
+			};
+		}
+		const schema = this.getCredentialSchema();
+		const errors = [];
+		for (const field of schema) if (field.required && !data[field.name]) errors.push(`${field.displayName || field.name} is required`);
+		return {
+			valid: errors.length === 0,
+			errors
+		};
+	}
+};
+const SECRET_NAME = /token|secret|password|key|credential/i;
+/**
+* Derive UI form fields from a zod object schema. Heuristics:
+* - secret-named fields → `password`
+* - z.url() → `url`
+* - z.enum([...]) → `select`
+* - everything else → `text`
+*/
+function deriveCredentialFields(schema) {
+	const def = schema.def;
+	if (!def || def.type !== "object" || !def.shape) return [];
+	const out = [];
+	for (const [name, fieldSchema] of Object.entries(def.shape)) {
+		const innerDef = unwrap(fieldSchema).def;
+		let type = "text";
+		let options;
+		if (SECRET_NAME.test(name)) type = "password";
+		else if (innerDef?.type === "url" || innerDef?.format === "url") type = "url";
+		else if (innerDef?.type === "enum" && innerDef.entries) {
+			type = "select";
+			options = Object.values(innerDef.entries).map((v) => ({
+				label: String(v),
+				value: String(v)
+			}));
+		}
+		out.push({
+			name,
+			displayName: humanize(name),
+			type,
+			required: !isOptional(fieldSchema),
+			description: fieldSchema.description,
+			options
+		});
+	}
+	return out;
+}
+function unwrap(t) {
+	let cur = t;
+	for (let i = 0; i < 8; i++) {
+		const def = cur.def;
+		if (!def?.innerType) return cur;
+		if (def.type === "optional" || def.type === "nullable" || def.type === "default") {
+			cur = def.innerType;
+			continue;
+		}
+		return cur;
+	}
+	return cur;
+}
+function isOptional(t) {
+	const def = t.def;
+	return def?.type === "optional" || def?.type === "default" || def?.type === "nullable";
+}
+function humanize(name) {
+	return name.replace(/([A-Z])/g, " $1").replace(/^./, (c) => c.toUpperCase()).replace(/\bId\b/g, "ID").replace(/\bUrl\b/g, "URL").trim();
+}
+
+//#endregion
+export { deriveCredentialFields as n, PlatformProvider as t };
+//# sourceMappingURL=base-Bw7e52V8.mjs.map