@jini-ai/admin 0.3.10 → 0.4.1

package/dist/source-control/adapters/memory.js

@@ -0,0 +1,35 @@
+import { sourceControlProviders, sourceControlReady, sourceControlSummary, blankSourceControlDraft } from '../rules.js';
+export function createMemorySourceControlApi({ providers = [], credentials = [] }, { now = () => new Date().toISOString() } = {}) {
+    const catalog = Object.freeze(providers.map(p => Object.freeze({ ...p, ...(p.credential ? { credential: Object.freeze({ ...p.credential, fields: Object.freeze(p.credential.fields.map(f => Object.freeze({ ...f }))) }) } : {}) })));
+    const rows = new Map(credentials.map(row => [row.id, sourceControlSummary({ row })]));
+    let sequence = 0;
+    function fail(code) { throw Object.assign(new Error(code), { code }); }
+    function checkLabel(providerId, label, id) { if (!label.trim())
+        fail('VALIDATION'); if ([...rows.values()].some(r => r.providerId === providerId && r.label === label.trim() && r.id !== id))
+        fail('DUPLICATE_LABEL'); }
+    function validate(input) { const info = sourceControlProviders({ providers: catalog, credentials: [] }).find(p => p.id === input.providerId); if (!info || !sourceControlReady({ info, draft: { ...blankSourceControlDraft({}), token: input.token, values: input } }))
+        fail('VALIDATION'); }
+    function setDefault(row) { if (row.isDefault)
+        for (const old of rows.values())
+            if (old.providerId === row.providerId && old.id !== row.id && old.isDefault)
+                rows.set(old.id, sourceControlSummary({ row: { ...old, isDefault: false } })); rows.set(row.id, sourceControlSummary({ row })); return rows.get(row.id); }
+    return {
+        async providers(_r, o = {}) { o.signal?.throwIfAborted(); return catalog; },
+        async list(_r, o = {}) { o.signal?.throwIfAborted(); return Object.freeze([...rows.values()]); },
+        async create(input, o = {}) { o.signal?.throwIfAborted(); validate(input.connection); const providerId = input.connection.providerId, label = input.label.trim(); checkLabel(providerId, label); let id; do {
+            id = `memory-source-${++sequence}`;
+        } while (rows.has(id)); const timestamp = now(); return setDefault({ id, providerId, label, configured: true, isDefault: input.isDefault ?? ![...rows.values()].some(r => r.providerId === providerId), createdAt: timestamp, updatedAt: timestamp }); },
+        async update({ id, patch }, o = {}) { o.signal?.throwIfAborted(); const old = rows.get(id); if (!old)
+            fail('NOT_FOUND'); if (patch.connection) {
+            validate(patch.connection);
+            if (patch.connection.providerId !== old.providerId)
+                fail('VALIDATION');
+        } const label = (patch.label ?? old.label).trim(); checkLabel(old.providerId, label, id); return setDefault({ ...old, label, isDefault: patch.isDefault ?? old.isDefault, updatedAt: now() }); },
+        async remove({ id }, o = {}) { o.signal?.throwIfAborted(); const old = rows.get(id); rows.delete(id); if (old?.isDefault) {
+            const next = [...rows.values()].find(r => r.providerId === old.providerId);
+            if (next)
+                setDefault({ ...next, isDefault: true });
+        } },
+    };
+}
+//# sourceMappingURL=memory.js.map

package/dist/source-control/conformance/source-control-api.conformance.d.ts

@@ -0,0 +1,10 @@
+import type { SourceControlApiPort } from '../ports.js';
+/** Creates/deletes named test credentials: run only on a disposable authorized backend.
+ * Supply connectionFields for providers with required fields beyond the canonical token. */
+export declare function runSourceControlApiConformance({ api, providerId }: {
+    api: SourceControlApiPort;
+    providerId: string;
+}, { connectionFields }?: {
+    connectionFields?: Readonly<Record<string, string>>;
+}): Promise<readonly string[]>;
+//# sourceMappingURL=source-control-api.conformance.d.ts.map

package/dist/source-control/conformance/source-control-api.conformance.js

@@ -0,0 +1,48 @@
+/** Creates/deletes named test credentials: run only on a disposable authorized backend.
+ * Supply connectionFields for providers with required fields beyond the canonical token. */
+export async function runSourceControlApiConformance({ api, providerId }, { connectionFields = {} } = {}) {
+    const checks = [], ids = [];
+    const assert = (ok, name) => { if (!ok)
+        throw new Error(`Source control conformance: ${name}`); checks.push(name); };
+    async function rejects(run, name) { let rejected = false; try {
+        await run();
+    }
+    catch {
+        rejected = true;
+    } assert(rejected, name); }
+    const connection = { ...connectionFields, providerId, token: 'conformance-only-token' };
+    try {
+        assert((await api.providers({})).some(p => p.id === providerId), 'provider is listed');
+        const first = await api.create({ label: 'conformance-first', connection });
+        ids.push(first.id);
+        assert(first.configured && !!first.id, 'create returns configured summary');
+        assert(!('token' in first) && !('connection' in first), 'saved secrets never read back');
+        assert((await api.list({})).some(r => r.id === first.id), 'list contains created row');
+        await rejects(() => api.create({ label: 'conformance-first', connection }), 'duplicate label rejects');
+        const second = await api.create({ label: 'conformance-second', connection, isDefault: true });
+        ids.push(second.id);
+        const list = await api.list({});
+        assert(list.filter(r => r.providerId === providerId && r.isDefault).length === 1 && list.find(r => r.id === second.id)?.isDefault === true, 'server owns unique default slot');
+        const renamed = await api.update({ id: first.id, patch: { label: 'conformance-renamed' } });
+        assert(renamed.label === 'conformance-renamed' && renamed.configured, 'metadata-only update preserves configured credential');
+        assert(first.label === 'conformance-first', 'prior snapshots remain immutable');
+        const replaced = await api.update({ id: first.id, patch: { connection } });
+        assert(replaced.id === first.id && replaced.label === renamed.label, 'replacement retains identity and label');
+        await rejects(() => api.update({ id: first.id, patch: { connection: { providerId, token: '' } } }), 'blank replacement rejects');
+        const abort = new AbortController();
+        abort.abort();
+        await rejects(() => api.list({}, { signal: abort.signal }), 'aborted list rejects');
+        await rejects(() => api.update({ id: first.id, patch: { label: 'bad' } }, { signal: abort.signal }), 'aborted write rejects');
+        assert((await api.list({})).find(r => r.id === first.id)?.label === renamed.label, 'aborted write has no effects');
+        await api.remove({ id: first.id });
+        await api.remove({ id: first.id });
+        assert(!(await api.list({})).some(r => r.id === first.id), 'remove is idempotent');
+        await rejects(() => api.update({ id: first.id, patch: {} }), 'missing update rejects');
+        return Object.freeze(checks);
+    }
+    finally {
+        for (const id of ids)
+            await api.remove({ id });
+    }
+}
+//# sourceMappingURL=source-control-api.conformance.js.map

package/dist/source-control/controllers/source-control.controller.d.ts

@@ -0,0 +1,26 @@
+import type { SourceControlApiPort } from '../ports.js';
+import type { SourceControlState } from '../models.js';
+export declare function createSourceControlController({ api, permissions }: {
+    api: SourceControlApiPort;
+    permissions?: readonly string[];
+}, _optional?: {}): {
+    getSnapshot: () => Readonly<SourceControlState>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    load: (_required: Record<string, never>, _optional?: {}) => Promise<void>;
+    save: ({ providerId }: {
+        providerId: string;
+    }, _optional?: {}) => Promise<boolean>;
+    setToken({ providerId, value }: {
+        providerId: string;
+        value: string;
+    }, _optional?: {}): void;
+    setField({ providerId, name, value }: {
+        providerId: string;
+        name: string;
+        value: string;
+    }, _optional?: {}): void;
+    dispose(_required?: Record<string, never>, _optional?: {}): void;
+};
+//# sourceMappingURL=source-control.controller.d.ts.map

package/dist/source-control/controllers/source-control.controller.js

@@ -0,0 +1,70 @@
+import { createControllerStore } from '../../core/module/controller-store.js';
+import { blankSourceControlDraft, sourceControlProviders, defaultSourceControlCredential, sourceControlReady, buildSourceControlConnection, sourceControlSummary, sourceControlErrorMessage } from '../rules.js';
+export function createSourceControlController({ api, permissions = [] }, _optional = {}) {
+    const grants = new Set(permissions), store = createControllerStore({ initial: { providers: [], credentials: [], drafts: {}, loading: false, loaded: false, error: null, catalogError: null } });
+    let generation = 0, credentialRevision = 0;
+    const canRead = () => !store.signal.aborted && grants.has('source-control.read');
+    const canWrite = () => canRead() && grants.has('source-control.credentials.write');
+    function patchDraft(id, patch) { const state = store.getSnapshot(); store.set({ patch: { drafts: { ...state.drafts, [id]: { ...(state.drafts[id] ?? blankSourceControlDraft({})), ...patch } } } }); }
+    async function load(_required, _optional = {}) {
+        if (!canRead())
+            return;
+        const ticket = ++generation, revision = credentialRevision;
+        store.set({ patch: { loading: true } });
+        // Catalog failure must not hide saved connections; retain each successful store independently.
+        await Promise.all([
+            (async () => { try {
+                const credentials = await api.list({}, { signal: store.signal });
+                if (ticket === generation && revision === credentialRevision)
+                    store.set({ patch: { credentials: credentials.map(row => sourceControlSummary({ row })), loaded: true, error: null } });
+            }
+            catch {
+                if (ticket === generation)
+                    store.set({ patch: { error: 'Connections unavailable' } });
+            } })(),
+            (async () => { try {
+                const providers = await api.providers({}, { signal: store.signal });
+                if (ticket === generation)
+                    store.set({ patch: { providers, catalogError: null } });
+            }
+            catch {
+                if (ticket === generation)
+                    store.set({ patch: { catalogError: 'Provider catalog unavailable' } });
+            } })(),
+        ]);
+        if (ticket === generation)
+            store.set({ patch: { loading: false } });
+    }
+    async function save({ providerId }, _optional = {}) {
+        const state = store.getSnapshot(), draft = state.drafts[providerId] ?? blankSourceControlDraft({});
+        const info = sourceControlProviders({ providers: state.providers, credentials: state.credentials }).find(p => p.id === providerId);
+        if (!canWrite() || !state.loaded || draft.saving || !info || !sourceControlReady({ info, draft }))
+            return false;
+        const current = defaultSourceControlCredential({ credentials: state.credentials, providerId }), connection = buildSourceControlConnection({ info, draft });
+        patchDraft(providerId, { saving: true, error: null });
+        try {
+            const row = current ? await api.update({ id: current.id, patch: { connection } }, { signal: store.signal }) : await api.create({ label: 'default', connection }, { signal: store.signal });
+            if (store.signal.aborted)
+                return false;
+            credentialRevision++;
+            // One round trip per write: splice the summary, then erase accepted secret drafts immediately.
+            const credentials = store.getSnapshot().credentials, summary = sourceControlSummary({ row });
+            // Preserve server order: the first row is the defensive default when no row is marked default.
+            store.set({ patch: { credentials: Object.freeze(credentials.some(c => c.id === row.id) ? credentials.map(c => c.id === row.id ? summary : c) : [...credentials, summary]) } });
+            patchDraft(providerId, blankSourceControlDraft({}));
+            return true;
+        }
+        catch (error) {
+            patchDraft(providerId, { saving: false, error: sourceControlErrorMessage({ error }) });
+            return false;
+        }
+    }
+    return { getSnapshot: store.getSnapshot, subscribe: store.subscribe, load, save,
+        setToken({ providerId, value }, _optional = {}) { if (canWrite() && !store.getSnapshot().drafts[providerId]?.saving)
+            patchDraft(providerId, { token: value }); },
+        setField({ providerId, name, value }, _optional = {}) { const draft = store.getSnapshot().drafts[providerId] ?? blankSourceControlDraft({}); if (canWrite() && !draft.saving)
+            patchDraft(providerId, { values: { ...draft.values, [name]: value } }); },
+        dispose(_required = {}, _optional = {}) { generation++; store.set({ patch: { drafts: {} } }); store.dispose(); },
+    };
+}
+//# sourceMappingURL=source-control.controller.js.map

package/dist/source-control/index.d.ts

@@ -0,0 +1,8 @@
+export { sourceControlModule } from './source-control.module.js';
+export { createSourceControlController } from './controllers/source-control.controller.js';
+export { sourceControlApiToken } from './ports.js';
+export type { SourceControlApiPort, SourceControlTransportPort } from './ports.js';
+export type * from './models.js';
+export { sourceControlProviders, defaultSourceControlCredential, sourceControlReady, buildSourceControlConnection } from './rules.js';
+export { sourceControlMessagesEn } from './messages.en.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/source-control/index.js

@@ -0,0 +1,6 @@
+export { sourceControlModule } from './source-control.module.js';
+export { createSourceControlController } from './controllers/source-control.controller.js';
+export { sourceControlApiToken } from './ports.js';
+export { sourceControlProviders, defaultSourceControlCredential, sourceControlReady, buildSourceControlConnection } from './rules.js';
+export { sourceControlMessagesEn } from './messages.en.js';
+//# sourceMappingURL=index.js.map

package/dist/source-control/messages.en.d.ts

@@ -0,0 +1,11 @@
+export declare const sourceControlMessagesEn: Readonly<{
+    title: "Source Control";
+    providers: "Providers";
+    description: "Connect an account to read repositories and push to them later. Content versioning is a separate feature.";
+    denied: "Permission denied";
+    saved: "Token saved";
+    replace: "Replace token";
+    manage: "Create access token";
+    loading: "Loading connections…";
+}>;
+//# sourceMappingURL=messages.en.d.ts.map

package/dist/source-control/messages.en.js

@@ -0,0 +1,2 @@
+export const sourceControlMessagesEn = Object.freeze({ title: 'Source Control', providers: 'Providers', description: 'Connect an account to read repositories and push to them later. Content versioning is a separate feature.', denied: 'Permission denied', saved: 'Token saved', replace: 'Replace token', manage: 'Create access token', loading: 'Loading connections…' });
+//# sourceMappingURL=messages.en.js.map

package/dist/source-control/models.d.ts

@@ -0,0 +1,70 @@
+export interface SourceControlField {
+    readonly name: string;
+    readonly label: string;
+    readonly secret?: boolean;
+    readonly required?: boolean;
+    readonly hint?: string;
+    readonly userHelp?: string;
+    readonly help?: string;
+}
+export interface SourceControlProvider {
+    readonly id: string;
+    readonly label: string;
+    readonly credential?: {
+        readonly tokenField: string;
+        readonly fields: readonly SourceControlField[];
+        readonly tokenPageUrl?: string;
+        readonly help?: string;
+    };
+}
+export interface SourceControlCredential {
+    readonly id: string;
+    readonly providerId: string;
+    readonly label: string;
+    readonly configured: true;
+    readonly isDefault: boolean;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export type SourceControlConnection = {
+    providerId: string;
+    token: string;
+} & Readonly<Record<string, string>>;
+export interface SourceControlCredentialInput {
+    readonly label: string;
+    readonly connection: SourceControlConnection;
+    readonly isDefault?: boolean;
+}
+export interface SourceControlCredentialPatch {
+    readonly label?: string;
+    readonly connection?: SourceControlConnection;
+    readonly isDefault?: boolean;
+}
+export interface SourceControlDraft {
+    readonly token: string;
+    readonly values: Readonly<Record<string, string>>;
+    readonly saving: boolean;
+    readonly error: string | null;
+}
+export interface SourceControlProviderInfo {
+    readonly id: string;
+    readonly label: string;
+    readonly listed: boolean;
+    readonly tokenLabel: string;
+    readonly fields: readonly SourceControlField[];
+    readonly tokenPageUrl: string;
+    readonly help: string;
+}
+export interface SourceControlState {
+    readonly providers: readonly SourceControlProvider[];
+    readonly credentials: readonly SourceControlCredential[];
+    readonly drafts: Readonly<Record<string, SourceControlDraft>>;
+    readonly loading: boolean;
+    readonly loaded: boolean;
+    readonly error: string | null;
+    readonly catalogError: string | null;
+}
+export interface SourceControlRequestOptions {
+    readonly signal?: AbortSignal;
+}
+//# sourceMappingURL=models.d.ts.map

package/dist/source-control/models.js

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

package/dist/source-control/ports.d.ts

@@ -0,0 +1,23 @@
+import type { SourceControlProvider, SourceControlCredential, SourceControlCredentialInput, SourceControlCredentialPatch, SourceControlRequestOptions } from './models.js';
+export interface SourceControlApiPort {
+    providers(required: Record<string, never>, optional?: SourceControlRequestOptions): Promise<readonly SourceControlProvider[]>;
+    list(required: Record<string, never>, optional?: SourceControlRequestOptions): Promise<readonly SourceControlCredential[]>;
+    create(required: SourceControlCredentialInput, optional?: SourceControlRequestOptions): Promise<SourceControlCredential>;
+    update(required: {
+        id: string;
+        patch: SourceControlCredentialPatch;
+    }, optional?: SourceControlRequestOptions): Promise<SourceControlCredential>;
+    /** Idempotent; intentionally not offered by the connection page UI. */
+    remove(required: {
+        id: string;
+    }, optional?: SourceControlRequestOptions): Promise<void>;
+}
+export interface SourceControlTransportPort {
+    request<T>(required: {
+        path: string;
+        method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+        body?: unknown;
+    }, optional?: SourceControlRequestOptions): Promise<T>;
+}
+export declare const sourceControlApiToken: import("../core/module/token.js").AdminPortToken<SourceControlApiPort, "admin.source-control.api">;
+//# sourceMappingURL=ports.d.ts.map

package/dist/source-control/ports.js

@@ -0,0 +1,3 @@
+import { adminPort } from '../core/module/token.js';
+export const sourceControlApiToken = adminPort({ id: 'admin.source-control.api' });
+//# sourceMappingURL=ports.js.map

package/dist/source-control/react/components/SourceControlCredentialFields.d.ts

@@ -0,0 +1,5 @@
+import type { SourceControlRowView } from '../hooks/ProvidersTab.hooks.js';
+export declare function SourceControlCredentialFields({ row }: {
+    row: SourceControlRowView;
+}, _optional?: {}): import("react").JSX.Element;
+//# sourceMappingURL=SourceControlCredentialFields.d.ts.map

package/dist/source-control/react/components/SourceControlCredentialFields.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Button, Notice, TextField } from '@jini-ai/ui-kit/react';
+import { useSourceControlCredentialFields } from '../hooks/SourceControlCredentialFields.hooks.js';
+export function SourceControlCredentialFields({ row }, _optional = {}) {
+    const vm = useSourceControlCredentialFields({ row });
+    return _jsxs(_Fragment, { children: [_jsx(TextField, { label: vm.tokenLabel, type: "password", value: vm.token, onValueChange: vm.onToken, disabled: vm.saving, ref: vm.tokenRef }), _jsx("p", { children: vm.hint }), vm.hasGuidance && _jsxs("details", { children: [_jsx("summary", { children: "Which token do I need?" }), _jsxs("p", { children: [vm.help, " ", vm.tokenPageUrl && _jsx("a", { href: vm.tokenPageUrl, target: "_blank", rel: "noreferrer", children: "Create a token" })] })] }), vm.fields.map(field => _jsxs("div", { children: [_jsx(TextField, { label: field.label, type: field.secret ? 'password' : 'text', value: field.value, onValueChange: field.onValueChange, disabled: vm.saving, required: field.required, ref: field.ref }), field.hint && _jsx("p", { children: field.hint })] }, field.name)), _jsxs(Button, { onPress: vm.save, disabled: vm.disabled, pending: vm.saving, children: ["Save ", vm.label, " token"] }), vm.error && _jsx(Notice, { tone: "danger", children: vm.error })] });
+}
+//# sourceMappingURL=SourceControlCredentialFields.js.map

package/dist/source-control/react/components/SourceControlProviderRow.d.ts

@@ -0,0 +1,5 @@
+import type { SourceControlRowView } from '../hooks/ProvidersTab.hooks.js';
+export declare function SourceControlProviderRow({ row }: {
+    row: SourceControlRowView;
+}, _optional?: {}): import("react").JSX.Element;
+//# sourceMappingURL=SourceControlProviderRow.d.ts.map

package/dist/source-control/react/components/SourceControlProviderRow.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Notice } from '@jini-ai/ui-kit/react';
+import { SourceControlCredentialFields } from './SourceControlCredentialFields.js';
+export function SourceControlProviderRow({ row }, _optional = {}) {
+    return _jsxs("details", { name: "jini-source-control-provider", open: row.defaultOpen, "data-jini-part": "source-control.provider", children: [_jsxs("summary", { children: [_jsx("h2", { children: row.heading }), row.saved && _jsxs(_Fragment, { children: [_jsx("span", { children: "Token saved" }), _jsxs("span", { children: ["Saved ", row.saved.updatedAt] }), _jsx("span", { children: "Replace token \u25BE" })] }), !row.saved && _jsx("span", { children: "Expand \u25BE" })] }), row.unlisted ? _jsx(Notice, { children: "Its plugin is off or missing. Manage this token on the Access tokens page." }) : row.canEdit ? _jsx(SourceControlCredentialFields, { row: row }) : _jsx(Notice, { children: "Read-only connection" })] });
+}
+//# sourceMappingURL=SourceControlProviderRow.js.map

package/dist/source-control/react/hooks/ProvidersTab.hooks.d.ts

@@ -0,0 +1,45 @@
+import type { TabViewProps } from '../../../react/bind-react.js';
+export declare function useProvidersTab({ permissions }: TabViewProps, _optional?: {}): {
+    denied: boolean;
+    loading: boolean;
+    rows: {
+        id: string;
+        label: string;
+        heading: string;
+        saved: import("../../models.js").SourceControlCredential | undefined;
+        defaultOpen: boolean;
+        canEdit: boolean;
+        unlisted: boolean;
+        connected: boolean;
+        token: string;
+        tokenLabel: string;
+        hint: string;
+        saving: boolean;
+        error: string | null;
+        disabled: boolean;
+        help: string;
+        tokenPageUrl: string | undefined;
+        hasGuidance: boolean;
+        fields: {
+            name: string;
+            label: string;
+            value: string;
+            secret: boolean;
+            required: boolean;
+            hint: string | undefined;
+            onValueChange({ value }: {
+                value: string;
+            }): void;
+        }[];
+        onToken({ value }: {
+            value: string;
+        }): void;
+        save(): void;
+    }[];
+    errors: string[];
+    reload(): void;
+    canManage: boolean;
+    manage(): void;
+};
+export type SourceControlRowView = ReturnType<typeof useProvidersTab>['rows'][number];
+//# sourceMappingURL=ProvidersTab.hooks.d.ts.map

package/dist/source-control/react/hooks/ProvidersTab.hooks.js

@@ -0,0 +1,20 @@
+import { useController } from '../../../react/use-controller.js';
+import { createSourceControlController } from '../../controllers/source-control.controller.js';
+import { blankSourceControlDraft, sourceControlProviders, defaultSourceControlCredential, sourceControlReady, safeSourceControlUrl } from '../../rules.js';
+import { useSourceControlPorts } from './SourceControlPorts.hooks.js';
+export function useProvidersTab({ permissions = [] }, _optional = {}) {
+    const ports = useSourceControlPorts({}), key = permissions.join('\0'), canRead = permissions.includes('source-control.read'), canWrite = canRead && permissions.includes('source-control.credentials.write');
+    const { controller, snapshot: state } = useController({ create: () => createSourceControlController({ api: ports.sourceControlApi, permissions }), dependencies: [ports.sourceControlApi, key] }, { start: ({ controller }) => { void controller.load({}); } });
+    const infos = sourceControlProviders({ providers: state?.providers ?? [], credentials: state?.credentials ?? [] });
+    const first = infos.find(p => p.listed && !defaultSourceControlCredential({ credentials: state?.credentials ?? [], providerId: p.id }))?.id;
+    const rows = infos.map(info => {
+        const saved = defaultSourceControlCredential({ credentials: state?.credentials ?? [], providerId: info.id }), draft = state?.drafts[info.id] ?? blankSourceControlDraft({});
+        return { id: info.id, label: info.label, heading: saved ? info.label : `Connect ${info.label}`, saved, defaultOpen: info.id === first, canEdit: canWrite && info.listed, unlisted: !info.listed, connected: !!saved,
+            token: draft.token, tokenLabel: `${info.label} ${info.tokenLabel}`, hint: saved ? 'Leave blank to keep the current token.' : 'Once saved, the token is never displayed again.', saving: draft.saving, error: draft.error,
+            disabled: !canWrite || !sourceControlReady({ info, draft }), help: info.help, tokenPageUrl: safeSourceControlUrl({ url: info.tokenPageUrl }), hasGuidance: !!info.help || !!safeSourceControlUrl({ url: info.tokenPageUrl }),
+            fields: info.fields.map(field => ({ name: field.name, label: `${info.label} ${field.label}`, value: draft.values[field.name] ?? '', secret: !!field.secret, required: !!field.required, hint: field.userHelp ?? field.hint ?? field.help, onValueChange({ value }) { controller?.setField({ providerId: info.id, name: field.name, value }); } })),
+            onToken({ value }) { controller?.setToken({ providerId: info.id, value }); }, save() { void controller?.save({ providerId: info.id }); }, };
+    });
+    return { denied: !canRead, loading: !state || state.loading, rows, errors: [state?.error, state?.catalogError].filter((s) => !!s), reload() { void controller?.load({}); }, canManage: !!ports.sourceControlNavigation, manage() { ports.sourceControlNavigation?.open({ kind: 'source-control' }); } };
+}
+//# sourceMappingURL=ProvidersTab.hooks.js.map

package/dist/source-control/react/hooks/SourceControlCredentialFields.hooks.d.ts

@@ -0,0 +1,43 @@
+import type { SourceControlRowView } from './ProvidersTab.hooks.js';
+/** ui-kit's opaque attrs carry semantic metadata, not arbitrary input attributes.
+ * Use its forwarded input ref for credential autofill policy. Chrome ignores off for
+ * credential-shaped fields, so secret fields explicitly opt into new-password. */
+export declare function useSourceControlCredentialFields({ row }: {
+    row: SourceControlRowView;
+}, _optional?: {}): {
+    tokenRef: (node: HTMLInputElement | null) => void;
+    fields: {
+        ref(node: HTMLInputElement | null): void;
+        name: string;
+        label: string;
+        value: string;
+        secret: boolean;
+        required: boolean;
+        hint: string | undefined;
+        onValueChange({ value }: {
+            value: string;
+        }): void;
+    }[];
+    id: string;
+    label: string;
+    heading: string;
+    saved: import("../../models.js").SourceControlCredential | undefined;
+    defaultOpen: boolean;
+    canEdit: boolean;
+    unlisted: boolean;
+    connected: boolean;
+    token: string;
+    tokenLabel: string;
+    hint: string;
+    saving: boolean;
+    error: string | null;
+    disabled: boolean;
+    help: string;
+    tokenPageUrl: string | undefined;
+    hasGuidance: boolean;
+    onToken({ value }: {
+        value: string;
+    }): void;
+    save(): void;
+};
+//# sourceMappingURL=SourceControlCredentialFields.hooks.d.ts.map

package/dist/source-control/react/hooks/SourceControlCredentialFields.hooks.js

@@ -0,0 +1,9 @@
+import { useCallback } from 'react';
+/** ui-kit's opaque attrs carry semantic metadata, not arbitrary input attributes.
+ * Use its forwarded input ref for credential autofill policy. Chrome ignores off for
+ * credential-shaped fields, so secret fields explicitly opt into new-password. */
+export function useSourceControlCredentialFields({ row }, _optional = {}) {
+    const tokenRef = useCallback((node) => { node?.setAttribute('autocomplete', 'new-password'); }, []);
+    return { ...row, tokenRef, fields: row.fields.map(field => ({ ...field, ref(node) { node?.setAttribute('autocomplete', field.secret ? 'new-password' : 'off'); } })) };
+}
+//# sourceMappingURL=SourceControlCredentialFields.hooks.js.map

package/dist/source-control/react/hooks/SourceControlPage.hooks.d.ts

@@ -0,0 +1,17 @@
+import type { ModulePageProps } from '../../../react/bind-react.js';
+export declare function useSourceControlPage(props: ModulePageProps, _optional?: {}): {
+    denied: boolean;
+    ActiveTab: import("react").LazyExoticComponent<import("react").ComponentType<import("../../../react/bind-react.js").TabViewProps>> | undefined;
+    params: Readonly<Record<string, unknown>>;
+    permissions: readonly string[];
+    active: string;
+    items: {
+        id: string;
+        label: string;
+        content: null;
+    }[];
+    onValueChange({ value }: {
+        value: string;
+    }): void;
+};
+//# sourceMappingURL=SourceControlPage.hooks.d.ts.map

package/dist/source-control/react/hooks/SourceControlPage.hooks.js

@@ -0,0 +1,5 @@
+export function useSourceControlPage(props, _optional = {}) {
+    const active = props.description.tabs.find(t => t.visible && t.id.endsWith(`.${props.requestedTab ?? 'providers'}`)) ?? props.description.tabs.find(t => t.visible);
+    return { denied: !props.description.visible, ActiveTab: active ? props.tabs.providers : undefined, params: active?.params ?? {}, permissions: props.description.grants, active: 'providers', items: [{ id: 'providers', label: 'Providers', content: null }], onValueChange({ value }) { props.onTabChange?.({ tab: value }); } };
+}
+//# sourceMappingURL=SourceControlPage.hooks.js.map

package/dist/source-control/react/hooks/SourceControlPorts.hooks.d.ts

@@ -0,0 +1,9 @@
+import type { SourceControlApiPort } from '../../ports.js';
+import type { CredentialManagementPort } from '../../../contracts/credential-management.js';
+export interface SourceControlPorts {
+    readonly sourceControlApi: SourceControlApiPort;
+    readonly sourceControlNavigation?: CredentialManagementPort;
+}
+export declare const SourceControlPortsContext: import("react").Context<SourceControlPorts | null>;
+export declare function useSourceControlPorts(_required?: Record<string, never>, _optional?: {}): SourceControlPorts;
+//# sourceMappingURL=SourceControlPorts.hooks.d.ts.map

package/dist/source-control/react/hooks/SourceControlPorts.hooks.js

@@ -0,0 +1,6 @@
+import { createContext, useContext } from 'react';
+import { AdminConfigError } from '../../../core/module/index.js';
+export const SourceControlPortsContext = createContext(null);
+export function useSourceControlPorts(_required = {}, _optional = {}) { const ports = useContext(SourceControlPortsContext); if (!ports)
+    throw new AdminConfigError({ issues: ['React scope unavailable: source-control'] }); return ports; }
+//# sourceMappingURL=SourceControlPorts.hooks.js.map