@smarthome.exchange/integrations 1.0.0 → 3.0.0

package/dist_ts/integrations/pioneer/pioneer.classes.configflow.d.ts

@@ -1,5 +1,12 @@
-import { SimpleLocalConfigFlow } from '../../core/index.js';
+import type { IConfigFlow, INativeConfigFlowContext, IConfigFlowStep, IDiscoveryCandidate } from '../../core/types.js';
+import { NativeIntegrationScope, type INativeIntegrationOwnerOptions } from '../../core/classes.nativeintegrationowner.js';
 import type { IPioneerConfig } from './pioneer.types.js';
-export declare class PioneerConfigFlow extends SimpleLocalConfigFlow<IPioneerConfig> {
-    constructor();
+export declare class PioneerConfigFlow implements IConfigFlow<IPioneerConfig> {
+    private readonly owner?;
+    private readonly scope;
+    constructor(options?: INativeIntegrationOwnerOptions | NativeIntegrationScope);
+    start(input: IDiscoveryCandidate, context: INativeConfigFlowContext): Promise<IConfigFlowStep<IPioneerConfig>>;
+    destroy(): Promise<void>;
+    retryCleanup(): Promise<void>;
+    private submit;
 }

package/dist_ts/integrations/pioneer/pioneer.classes.configflow.js

@@ -1,8 +1,68 @@
-import { SimpleLocalConfigFlow } from '../../core/index.js';
-import { pioneerProfile } from './pioneer.types.js';
-export class PioneerConfigFlow extends SimpleLocalConfigFlow {
-    constructor() {
-        super(pioneerProfile);
+import { NativeIntegrationOwner, NativeIntegrationScope } from '../../core/classes.nativeintegrationowner.js';
+import { PioneerClient } from './pioneer.classes.client.js';
+import { normalizePioneerConfig, pioneerConfigKeys, pioneerRecord } from './pioneer.validation.js';
+export class PioneerConfigFlow {
+    owner;
+    scope;
+    constructor(options = {}) {
+        if (options instanceof NativeIntegrationScope)
+            this.scope = options;
+        else {
+            this.owner = new NativeIntegrationOwner('pioneer', options);
+            this.scope = this.owner.createFlowScope();
+        }
+    }
+    async start(input, context) {
+        const candidate = pioneerRecord(input);
+        if (candidate.integrationDomain !== 'pioneer')
+            return { kind: 'error', error: 'Candidate does not belong to Pioneer.' };
+        const metadata = candidate.metadata === undefined ? {} : pioneerRecord(candidate.metadata);
+        const hints = Object.freeze({ host: candidate.host, expectedUdn: candidate.id, model: candidate.model, descriptionUrl: metadata.descriptionUrl });
+        const captured = this.scope.admit(context);
+        return {
+            kind: 'form', title: 'Connect selected Pioneer SC-95 receiver',
+            description: 'The host selects the owning home. Confirm the private IPv4, UPnP identity and raw owner volume ceiling. HTTP/TCP identity is unauthenticated LAN consistency. Network Standby must already be enabled when needed.',
+            fields: [
+                { name: 'host', label: 'Selected receiver IPv4', type: 'text', required: true },
+                { name: 'descriptionUrl', label: 'Selected UPnP description URL', type: 'text', required: true },
+                { name: 'expectedUdn', label: 'Expected UPnP UDN', type: 'text', required: true },
+                { name: 'model', label: 'Documented model', type: 'select', required: true, options: [{ label: 'SC-95', value: 'SC-95' }] },
+                { name: 'allowUnencryptedLan', label: 'Allow plaintext LAN control', type: 'boolean', required: true },
+                { name: 'maximumVolumeRaw', label: 'Owner maximum raw volume (0–185)', type: 'number', required: true },
+                { name: 'name', label: 'Display name', type: 'text' },
+            ],
+            submit: (values) => this.submit(hints, values, captured),
+        };
+    }
+    destroy() { return this.owner ? this.owner.close() : this.scope.close(); }
+    retryCleanup() { return this.owner ? this.owner.retryCleanup() : this.scope.retryCleanup(); }
+    async submit(hints, input, context) {
+        this.scope.admit(context);
+        try {
+            const values = pioneerRecord(input, pioneerConfigKeys);
+            if (values.homeId !== undefined && values.homeId !== context.homeId)
+                throw new Error('Pioneer form home conflicts with the host-selected home.');
+            const config = normalizePioneerConfig({ ...hints, ...values, homeId: context.homeId });
+            return await this.scope.run(context, config.homeId, async (lease) => {
+                const client = new PioneerClient(config, lease.context);
+                let cleanupStarted = false;
+                lease.own(() => {
+                    const retry = cleanupStarted;
+                    cleanupStarted = true;
+                    return retry ? client.retryCleanup() : client.destroy();
+                });
+                await client.start(lease.signal);
+                lease.assertOpen();
+                return { kind: 'done', title: 'Selected receiver admitted', config };
+            });
+        }
+        catch (error) {
+            // Cleanup failures remain actionable; the shared owner retains their handles for explicit retry.
+            if (error instanceof AggregateError)
+                throw error;
+            this.scope.admit(context);
+            return { kind: 'error', title: 'Pioneer admission failed', error: 'Confirm exact home scope, SC-95 model, private IPv4 and UPnP identity, readable receiver settings and explicit raw owner volume ceiling.' };
+        }
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGlvbmVlci5jbGFzc2VzLmNvbmZpZ2Zsb3cuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9pbnRlZ3JhdGlvbnMvcGlvbmVlci9waW9uZWVyLmNsYXNzZXMuY29uZmlnZmxvdy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUU1RCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFcEQsTUFBTSxPQUFPLGlCQUFrQixTQUFRLHFCQUFxQztJQUMxRTtRQUNFLEtBQUssQ0FBQyxjQUFjLENBQUMsQ0FBQztJQUN4QixDQUFDO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/integrations/pioneer/pioneer.classes.integration.d.ts

@@ -1,12 +1,20 @@
-import { SimpleLocalIntegration, type IIntegrationRuntime, type IIntegrationSetupContext } from '../../core/index.js';
+import { BaseIntegration } from '../../core/classes.baseintegration.js';
+import type { IIntegrationRuntime, INativeIntegrationSetupContext } from '../../core/types.js';
+import { type INativeIntegrationOwnerOptions } from '../../core/classes.nativeintegrationowner.js';
 import { PioneerConfigFlow } from './pioneer.classes.configflow.js';
 import type { IPioneerConfig } from './pioneer.types.js';
-export declare class PioneerIntegration extends SimpleLocalIntegration<IPioneerConfig> {
+export declare class PioneerIntegration extends BaseIntegration<IPioneerConfig> {
     readonly domain = "pioneer";
-    readonly discoveryDescriptor: import("../../core/classes.discoverydescriptor.js").DiscoveryDescriptor;
+    readonly displayName = "Pioneer selected SC-95 receiver";
+    readonly status: 'control-runtime';
+    readonly discoveryDescriptor: import("../../index.js").DiscoveryDescriptor;
     readonly configFlow: PioneerConfigFlow;
-    constructor();
-    setup(configArg: IPioneerConfig, contextArg: IIntegrationSetupContext): Promise<IIntegrationRuntime>;
+    readonly metadata: Record<string, unknown>;
+    private readonly owner;
+    constructor(options?: INativeIntegrationOwnerOptions);
+    setup(input: IPioneerConfig, context: INativeIntegrationSetupContext): Promise<IIntegrationRuntime>;
+    destroy(): Promise<void>;
+    retryCleanup(): Promise<void>;
 }
 export declare class HomeAssistantPioneerIntegration extends PioneerIntegration {
 }

package/dist_ts/integrations/pioneer/pioneer.classes.integration.js

@@ -1,20 +1,248 @@
-import { SimpleLocalIntegration, SimpleLocalRuntime } from '../../core/index.js';
+import * as plugins from '../../plugins.js';
+import { BaseIntegration } from '../../core/classes.baseintegration.js';
+import { NativeIntegrationOwner } from '../../core/classes.nativeintegrationowner.js';
 import { PioneerClient } from './pioneer.classes.client.js';
 import { PioneerConfigFlow } from './pioneer.classes.configflow.js';
 import { createPioneerDiscoveryDescriptor } from './pioneer.discovery.js';
-import { pioneerDomain, pioneerProfile } from './pioneer.types.js';
-export class PioneerIntegration extends SimpleLocalIntegration {
-    domain = pioneerDomain;
+import { PioneerMapper } from './pioneer.mapper.js';
+import { normalizePioneerConfig, pioneerRecord, validatePioneerControl } from './pioneer.validation.js';
+import { pioneerProfile } from './pioneer.types.js';
+export class PioneerIntegration extends BaseIntegration {
+    domain = 'pioneer';
+    displayName = 'Pioneer selected SC-95 receiver';
+    status = 'control-runtime';
     discoveryDescriptor = createPioneerDiscoveryDescriptor();
-    configFlow = new PioneerConfigFlow();
-    constructor() {
-        super(pioneerProfile);
+    configFlow;
+    metadata = pioneerProfile.metadata;
+    owner;
+    constructor(options = {}) {
+        super();
+        this.owner = new NativeIntegrationOwner('pioneer', options);
+        this.configFlow = new PioneerConfigFlow(this.owner.createFlowScope());
     }
-    async setup(configArg, contextArg) {
-        void contextArg;
-        return new SimpleLocalRuntime(pioneerProfile, new PioneerClient(configArg));
+    setup(input, context) {
+        try {
+            const config = normalizePioneerConfig(input);
+            return this.owner.runSetup(context, config.homeId, async (lease) => {
+                const client = new PioneerClient(config, lease.context);
+                let runtime;
+                let cleanupStarted = false;
+                lease.own(() => {
+                    const retry = cleanupStarted;
+                    cleanupStarted = true;
+                    return runtime ? runtime.cleanupResources(retry) : retry ? client.retryCleanup() : client.destroy();
+                });
+                const initial = await client.start(lease.signal);
+                lease.assertOpen();
+                runtime = new PioneerRuntime(client, initial, lease);
+                lease.promoteToRuntime();
+                return runtime;
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
     }
+    destroy() { return this.owner.close(); }
+    retryCleanup() { return this.owner.retryCleanup(); }
 }
 export class HomeAssistantPioneerIntegration extends PioneerIntegration {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGlvbmVlci5jbGFzc2VzLmludGVncmF0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvaW50ZWdyYXRpb25zL3Bpb25lZXIvcGlvbmVlci5jbGFzc2VzLmludGVncmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxrQkFBa0IsRUFBMkQsTUFBTSxxQkFBcUIsQ0FBQztBQUMxSSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDNUQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDcEUsT0FBTyxFQUFFLGdDQUFnQyxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFMUUsT0FBTyxFQUFFLGFBQWEsRUFBRSxjQUFjLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUVuRSxNQUFNLE9BQU8sa0JBQW1CLFNBQVEsc0JBQXNDO0lBQzVELE1BQU0sR0FBRyxhQUFhLENBQUM7SUFDdkIsbUJBQW1CLEdBQUcsZ0NBQWdDLEVBQUUsQ0FBQztJQUN6RCxVQUFVLEdBQUcsSUFBSSxpQkFBaUIsRUFBRSxDQUFDO0lBRXJEO1FBQ0UsS0FBSyxDQUFDLGNBQWMsQ0FBQyxDQUFDO0lBQ3hCLENBQUM7SUFFZSxLQUFLLENBQUMsS0FBSyxDQUFDLFNBQXlCLEVBQUUsVUFBb0M7UUFDekYsS0FBSyxVQUFVLENBQUM7UUFDaEIsT0FBTyxJQUFJLGtCQUFrQixDQUFDLGNBQWMsRUFBRSxJQUFJLGFBQWEsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDO0lBQzlFLENBQUM7Q0FDRjtBQUVELE1BQU0sT0FBTywrQkFBZ0MsU0FBUSxrQkFBa0I7Q0FBRyJ9
+class PioneerRuntime {
+    client;
+    snapshot;
+    lease;
+    domain = 'pioneer';
+    subscriptions = new Set();
+    parentAbort;
+    closePromise;
+    cleanupPromise;
+    closed = false;
+    constructor(client, snapshot, lease) {
+        this.client = client;
+        this.snapshot = snapshot;
+        this.lease = lease;
+        // The lease retains the client and callbacks until cleanup succeeds, including explicit retries.
+        this.parentAbort = () => { void this.destroy().catch(() => { }); };
+        lease.signal.addEventListener('abort', this.parentAbort, { once: true });
+        if (lease.signal.aborted)
+            this.parentAbort();
+    }
+    isHealthy() { return !this.closed && this.client.isHealthy(); }
+    async devices(signal) {
+        this.assertOpen();
+        const snapshot = await this.client.getSnapshot(signal);
+        this.publish(snapshot);
+        return PioneerMapper.toDevices(snapshot);
+    }
+    async entities() {
+        this.assertOpen();
+        const snapshot = await this.client.getSnapshot();
+        this.publish(snapshot);
+        return PioneerMapper.toEntities(snapshot);
+    }
+    async writeFeature(input, signal) {
+        this.assertOpen();
+        const request = pioneerRecord(input, ['device', 'feature', 'value']);
+        const device = pioneerRecord(request.device);
+        const feature = pioneerRecord(request.feature);
+        const canonical = PioneerMapper.toDevices(this.snapshot)[0];
+        if (device.id !== canonical.id || device.integrationDomain !== this.domain)
+            throw new Error('Pioneer feature target is outside the selected home and receiver.');
+        const admitted = canonical.features.find((entry) => entry.id === feature.id);
+        if (!admitted?.writable || feature.capability !== admitted.capability)
+            throw new Error('Pioneer feature is not writable for the selected receiver.');
+        return this.control(validatePioneerControl({ feature: admitted.id, value: request.value }), signal);
+    }
+    async callService(input) {
+        this.assertOpen();
+        const request = pioneerRecord(input, ['domain', 'service', 'target', 'data']);
+        const target = pioneerRecord(request.target, ['deviceId', 'entityId']);
+        const deviceId = PioneerMapper.deviceId(this.snapshot.homeId, this.snapshot.identity.udn);
+        const entityId = PioneerMapper.entityId(this.snapshot.homeId, this.snapshot.identity.udn);
+        if ((!target.deviceId && !target.entityId) || (target.deviceId !== undefined && target.deviceId !== deviceId)
+            || (target.entityId !== undefined && target.entityId !== entityId))
+            throw new Error('Pioneer service target is outside the selected home and receiver.');
+        if (request.domain !== 'media_player')
+            throw new Error('Pioneer services use media_player.');
+        let control;
+        if (request.service === 'turn_on' || request.service === 'turn_off') {
+            pioneerRecord(request.data ?? {}, []);
+            control = { feature: 'power', value: request.service === 'turn_on' };
+        }
+        else if (request.service === 'set_volume_raw') {
+            const data = pioneerRecord(request.data, ['volume_raw']);
+            control = validatePioneerControl({ feature: 'volume_raw', value: data.volume_raw });
+        }
+        else if (request.service === 'volume_mute') {
+            const data = pioneerRecord(request.data, ['is_volume_muted']);
+            control = validatePioneerControl({ feature: 'muted', value: data.is_volume_muted });
+        }
+        else if (request.service === 'select_source') {
+            const data = pioneerRecord(request.data, ['source']);
+            control = validatePioneerControl({ feature: 'input', value: data.source });
+        }
+        else
+            throw new Error('Pioneer supports explicit power, mute, raw integer volume and observed physical input controls only.');
+        return this.control(control);
+    }
+    /** Emits completed observations only, with no background polling or unsolicited-event claim. */
+    async subscribe(handler, signal) {
+        this.assertOpen();
+        if (typeof handler !== 'function' || (signal !== undefined && !(signal instanceof AbortSignal)))
+            throw new TypeError('Pioneer subscription requires a callback and optional AbortSignal.');
+        signal?.throwIfAborted();
+        if (this.subscriptions.size >= 32)
+            throw new Error('Pioneer subscription capacity reached.');
+        const subscription = {
+            handler, callbacks: new Set(), active: true, failed: false,
+            detach: () => { subscription.active = false; signal?.removeEventListener('abort', aborted); },
+            stop: async () => {
+                subscription.detach();
+                await Promise.all([...subscription.callbacks]);
+                this.subscriptions.delete(subscription);
+                if (subscription.failed)
+                    throw subscription.failure;
+            },
+        };
+        const aborted = () => {
+            subscription.detach();
+            // Allow the current invocation and its tracked callback to settle before automatic removal.
+            void Promise.resolve().then(async () => {
+                await Promise.all([...subscription.callbacks]);
+                if (!subscription.failed)
+                    this.subscriptions.delete(subscription);
+            });
+        };
+        signal?.addEventListener('abort', aborted, { once: true });
+        this.subscriptions.add(subscription);
+        if (signal?.aborted)
+            aborted();
+        return subscription.stop;
+    }
+    destroy() {
+        if (!this.closePromise) {
+            this.closed = true;
+            this.closePromise = Promise.resolve().then(() => this.lease.close());
+        }
+        return this.closePromise;
+    }
+    cleanupResources(retry = false) {
+        if (retry)
+            this.cleanupPromise = undefined;
+        if (!this.cleanupPromise) {
+            this.closed = true;
+            this.cleanupPromise = Promise.resolve().then(async () => {
+                const results = await Promise.allSettled([retry ? this.client.retryCleanup() : this.client.destroy(),
+                    ...[...this.subscriptions].map((subscription) => subscription.stop())]);
+                const failures = results.filter((result) => result.status === 'rejected');
+                if (failures.length)
+                    throw new AggregateError(failures.map((result) => result.reason), 'Pioneer runtime cleanup failed.');
+            });
+            this.lease.signal.removeEventListener('abort', this.parentAbort);
+            for (const subscription of this.subscriptions)
+                subscription.detach();
+        }
+        return this.cleanupPromise;
+    }
+    async control(control, signal) {
+        try {
+            const result = await this.client.setControl(control, signal);
+            try {
+                this.publish(result.snapshot);
+            }
+            catch {
+                return { success: false, error: 'Pioneer was closed after dispatch; its effect is indeterminate.',
+                    data: { dispatch: result.dispatch, effectOutcome: 'indeterminate', commandAcknowledged: false, causalityConfirmed: false } };
+            }
+            return { success: result.outcome === 'observed-target', data: { dispatch: result.dispatch, effectOutcome: result.outcome,
+                    commandAcknowledged: result.commandAcknowledged, causalityConfirmed: result.causalityConfirmed } };
+        }
+        catch (error) {
+            return { success: false, error: 'Pioneer control was refused or its observation could not be reconciled.',
+                data: { effectOutcome: error instanceof plugins.ecobridgeDeviceManager.PioneerProtocolError ? error.effectOutcome : 'not-sent',
+                    commandAcknowledged: false, causalityConfirmed: false } };
+        }
+    }
+    publish(snapshot) {
+        this.assertOpen();
+        this.snapshot = snapshot;
+        for (const subscription of this.subscriptions) {
+            if (!subscription.active)
+                continue;
+            if (subscription.callbacks.size >= this.client.config.maxPendingOperations) {
+                subscription.failed = true;
+                subscription.failure = new Error('Pioneer observation callback capacity reached.');
+                subscription.detach();
+                continue;
+            }
+            let complete = () => { };
+            let fail = () => { };
+            const invoked = new Promise((resolve, reject) => { complete = resolve; fail = reject; });
+            const callback = invoked.catch((error) => {
+                subscription.failed = true;
+                subscription.failure = error;
+                subscription.detach();
+            }).finally(() => subscription.callbacks.delete(callback));
+            // Register before user code can synchronously abort or destroy its owner.
+            subscription.callbacks.add(callback);
+            try {
+                const returned = subscription.handler({ type: 'state_changed', integrationDomain: this.domain,
+                    deviceId: PioneerMapper.deviceId(snapshot.homeId, snapshot.identity.udn),
+                    entityId: PioneerMapper.entityId(snapshot.homeId, snapshot.identity.udn),
+                    data: { snapshot: structuredClone(snapshot), source: 'completed-receiver-observation' }, timestamp: Date.now() });
+                void Promise.resolve(returned).then(complete, fail);
+            }
+            catch (error) {
+                fail(error);
+            }
+        }
+        this.assertOpen();
+    }
+    assertOpen() {
+        if (this.closed)
+            throw new Error('Pioneer runtime is closed.');
+        this.lease.assertOpen();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pioneer.classes.integration.js","sourceRoot":"","sources":["../../../ts/integrations/pioneer/pioneer.classes.integration.ts"],"names":[],"mappings":"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"}

package/dist_ts/integrations/pioneer/pioneer.discovery.d.ts

@@ -1 +1,14 @@
-export declare const createPioneerDiscoveryDescriptor: () => import("../../core/classes.discoverydescriptor.js").DiscoveryDescriptor;
+import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
+import type { IDiscoveryCandidate, IDiscoveryMatch, IDiscoveryMatcher, IDiscoveryValidator } from '../../core/types.js';
+import type { IPioneerManualEntry } from './pioneer.types.js';
+export declare class PioneerManualMatcher implements IDiscoveryMatcher<IPioneerManualEntry> {
+    readonly id = "pioneer-manual-match";
+    readonly source: 'manual';
+    readonly description = "Selected SC-95 descriptor setup hints; native admission reads fresh identity.";
+    matches(input: IPioneerManualEntry): Promise<IDiscoveryMatch>;
+}
+export declare class PioneerCandidateValidator implements IDiscoveryValidator {
+    readonly id = "pioneer-candidate-validator";
+    validate(input: IDiscoveryCandidate): Promise<IDiscoveryMatch>;
+}
+export declare const createPioneerDiscoveryDescriptor: () => DiscoveryDescriptor;

package/dist_ts/integrations/pioneer/pioneer.discovery.js

@@ -1,4 +1,51 @@
-import { createSimpleLocalDiscoveryDescriptor } from '../../core/index.js';
-import { pioneerProfile } from './pioneer.types.js';
-export const createPioneerDiscoveryDescriptor = () => createSimpleLocalDiscoveryDescriptor(pioneerProfile);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGlvbmVlci5kaXNjb3ZlcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9pbnRlZ3JhdGlvbnMvcGlvbmVlci9waW9uZWVyLmRpc2NvdmVyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsb0NBQW9DLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUMzRSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFcEQsTUFBTSxDQUFDLE1BQU0sZ0NBQWdDLEdBQUcsR0FBRyxFQUFFLENBQUMsb0NBQW9DLENBQUMsY0FBYyxDQUFDLENBQUMifQ==
+import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
+import { pioneerDescription, pioneerHost, pioneerRecord, pioneerText, pioneerUdn } from './pioneer.validation.js';
+const miss = (reason) => ({ matched: false, confidence: 'low', reason });
+export class PioneerManualMatcher {
+    id = 'pioneer-manual-match';
+    source = 'manual';
+    description = 'Selected SC-95 descriptor setup hints; native admission reads fresh identity.';
+    async matches(input) {
+        try {
+            const record = pioneerRecord(input, ['source', 'integrationDomain', 'host', 'descriptionUrl', 'expectedUdn', 'id', 'name', 'manufacturer', 'model', 'metadata']);
+            if (record.source !== undefined && record.source !== 'manual')
+                return miss('Only selected manual endpoint hints are supported.');
+            if (record.integrationDomain !== undefined && record.integrationDomain !== 'pioneer')
+                return miss('Foreign integration hint.');
+            const metadata = record.metadata === undefined ? {} : pioneerRecord(record.metadata, ['descriptionUrl', 'identityEvidence']);
+            const host = pioneerHost(record.host);
+            const descriptionUrl = pioneerDescription(record.descriptionUrl ?? metadata.descriptionUrl, host);
+            const id = pioneerUdn(record.expectedUdn ?? record.id);
+            if (record.expectedUdn !== undefined && record.id !== undefined && pioneerUdn(record.expectedUdn) !== pioneerUdn(record.id))
+                return miss('Manual receiver identities conflict.');
+            if (record.model !== 'SC-95')
+                return miss('Model has no selected vendor profile.');
+            if (record.manufacturer !== undefined && record.manufacturer !== 'Pioneer')
+                return miss('Manufacturer does not match the selected profile.');
+            const name = record.name === undefined ? undefined : pioneerText(record.name, 'name', 128);
+            return { matched: true, confidence: 'medium', reason: 'Selected SC-95 setup hint; fresh UPnP and receiver state are required for native admission.',
+                normalizedDeviceId: id, candidate: { source: 'manual', integrationDomain: 'pioneer', id, host, name, manufacturer: 'Pioneer', model: 'SC-95',
+                    metadata: { descriptionUrl, identityEvidence: 'unauthenticated-discovery-hint' } } };
+        }
+        catch {
+            return miss('Manual setup requires the selected SC-95 model, private endpoint, descriptor URL and exact UDN.');
+        }
+    }
+}
+export class PioneerCandidateValidator {
+    id = 'pioneer-candidate-validator';
+    async validate(input) {
+        try {
+            const record = pioneerRecord(input);
+            if (record.integrationDomain !== 'pioneer' || record.source !== 'manual')
+                return miss('Candidate does not belong to selected Pioneer discovery.');
+            return new PioneerManualMatcher().matches(input);
+        }
+        catch {
+            return miss('Candidate must be a plain selected Pioneer record.');
+        }
+    }
+}
+export const createPioneerDiscoveryDescriptor = () => new DiscoveryDescriptor({ integrationDomain: 'pioneer', displayName: 'Pioneer selected SC-95 receiver' })
+    .addMatcher(new PioneerManualMatcher()).addValidator(new PioneerCandidateValidator());
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/integrations/pioneer/pioneer.mapper.d.ts

@@ -1,10 +1,16 @@
-import type * as shxInterfaces from '@smarthome.exchange/interfaces';
-import { type IIntegrationEntity, type ISimpleLocalSnapshot, type ISimpleLocalSnapshotOptions, type TSimpleLocalRawData } from '../../core/index.js';
-import type { IPioneerConfig } from './pioneer.types.js';
+import type * as plugins from '../../plugins.js';
+import type { IIntegrationEntity } from '../../core/types.js';
+import type { IPioneerOfflineConfig, IPioneerOfflineSnapshot, IPioneerSnapshot, TPioneerRawData } from './pioneer.types.js';
 export declare class PioneerMapper {
-    static toSnapshot(optionsArg: Omit<ISimpleLocalSnapshotOptions<IPioneerConfig>, 'profile'>): ISimpleLocalSnapshot;
-    static toSnapshotFromRaw(configArg: IPioneerConfig, rawDataArg: TSimpleLocalRawData): ISimpleLocalSnapshot;
-    static toDevices(snapshotArg: ISimpleLocalSnapshot): shxInterfaces.data.IDeviceDefinition[];
-    static toEntities(snapshotArg: ISimpleLocalSnapshot): IIntegrationEntity[];
-    static slug(valueArg: unknown): string;
+    static deviceId(homeId: string, udn: string): string;
+    static entityId(homeId: string, udn: string): string;
+    static toDevices(snapshot: IPioneerSnapshot): plugins.shxInterfaces.data.IDeviceDefinition[];
+    static toEntities(snapshot: IPioneerSnapshot): IIntegrationEntity[];
+}
+/** Explicitly offline transformation; this helper never creates or admits a native runtime. */
+export declare class PioneerOfflineMapper {
+    static toSnapshotFromRaw(config: IPioneerOfflineConfig, rawData: TPioneerRawData): IPioneerOfflineSnapshot;
+    static toDevices(snapshot: IPioneerOfflineSnapshot): plugins.shxInterfaces.data.IDeviceDefinition[];
+    static toEntities(snapshot: IPioneerOfflineSnapshot): IIntegrationEntity[];
+    private static offline;
 }

package/dist_ts/integrations/pioneer/pioneer.mapper.js

@@ -1,20 +1,62 @@
-import { SimpleLocalMapper } from '../../core/index.js';
+import { SimpleLocalMapper } from '../../core/classes.simplelocalintegration.js';
 import { pioneerProfile } from './pioneer.types.js';
 export class PioneerMapper {
-    static toSnapshot(optionsArg) {
-        return SimpleLocalMapper.toSnapshot({ ...optionsArg, profile: pioneerProfile });
+    static deviceId(homeId, udn) {
+        return `pioneer.receiver.${encodeURIComponent(homeId)}.${encodeURIComponent(udn)}`;
     }
-    static toSnapshotFromRaw(configArg, rawDataArg) {
-        return SimpleLocalMapper.toSnapshot({ profile: pioneerProfile, config: configArg, rawData: rawDataArg, online: true, source: 'manual' });
+    static entityId(homeId, udn) {
+        return `media_player.pioneer.${encodeURIComponent(homeId)}.${encodeURIComponent(udn)}`;
     }
-    static toDevices(snapshotArg) {
-        return SimpleLocalMapper.toDevices(pioneerProfile, snapshotArg);
+    static toDevices(snapshot) {
+        return [{
+                id: this.deviceId(snapshot.homeId, snapshot.identity.udn), integrationDomain: 'pioneer', name: snapshot.name,
+                protocol: 'tcp', manufacturer: snapshot.identity.manufacturer, model: snapshot.identity.model, online: true,
+                features: [
+                    { id: 'power', capability: 'media', name: 'Main-zone power', readable: true, writable: true },
+                    { id: 'muted', capability: 'media', name: 'Main-zone mute', readable: true, writable: true },
+                    { id: 'volume_raw', capability: 'media', name: 'Main-zone raw volume', unit: 'raw', readable: true, writable: true },
+                    { id: 'input', capability: 'media', name: 'Main-zone physical input', readable: true, writable: snapshot.observedInputs.length > 0 },
+                ],
+                state: [
+                    { featureId: 'power', value: snapshot.power, updatedAt: snapshot.observedAt },
+                    { featureId: 'muted', value: snapshot.muted, updatedAt: snapshot.observedAt },
+                    { featureId: 'volume_raw', value: snapshot.volumeRaw, updatedAt: snapshot.observedAt },
+                    { featureId: 'input', value: snapshot.inputId, updatedAt: snapshot.observedAt },
+                ],
+                metadata: { homeId: snapshot.homeId, udn: snapshot.identity.udn, host: snapshot.host, port: snapshot.port,
+                    serialNumber: snapshot.identity.serialNumber, zone: 'main', observedInputs: [...snapshot.observedInputs],
+                    maximumVolumeRaw: snapshot.maximumVolumeRaw, minimumVolumeRaw: 0, maximumReceiverVolumeRaw: 185,
+                    identitySource: snapshot.identity.source, identityTrust: snapshot.identity.trust,
+                    stateSource: 'receiver-observation', commandAcknowledged: false, causalityConfirmed: false },
+            }];
     }
-    static toEntities(snapshotArg) {
-        return SimpleLocalMapper.toEntities(pioneerProfile, snapshotArg);
+    static toEntities(snapshot) {
+        return [{
+                id: this.entityId(snapshot.homeId, snapshot.identity.udn), uniqueId: this.deviceId(snapshot.homeId, snapshot.identity.udn),
+                integrationDomain: 'pioneer', deviceId: this.deviceId(snapshot.homeId, snapshot.identity.udn), platform: 'media_player',
+                name: snapshot.name, state: snapshot.power ? 'on' : 'off', available: true,
+                attributes: { homeId: snapshot.homeId, udn: snapshot.identity.udn, zone: 'main', power: snapshot.power,
+                    volumeRaw: snapshot.volumeRaw, muted: snapshot.muted, source: snapshot.inputId,
+                    observedInputs: [...snapshot.observedInputs], maximumVolumeRaw: snapshot.maximumVolumeRaw,
+                    observedAt: snapshot.observedAt, stateSource: 'receiver-observation', identityTrust: snapshot.identity.trust,
+                    commandAcknowledged: false, causalityConfirmed: false },
+            }];
     }
-    static slug(valueArg) {
-        return SimpleLocalMapper.slug(valueArg);
+}
+/** Explicitly offline transformation; this helper never creates or admits a native runtime. */
+export class PioneerOfflineMapper {
+    static toSnapshotFromRaw(config, rawData) {
+        return this.offline(SimpleLocalMapper.toSnapshot({ profile: pioneerProfile, config: { ...config }, rawData, online: false, source: 'manual' }));
+    }
+    static toDevices(snapshot) {
+        return SimpleLocalMapper.toDevices(pioneerProfile, this.offline(snapshot));
+    }
+    static toEntities(snapshot) {
+        return SimpleLocalMapper.toEntities(pioneerProfile, this.offline(snapshot));
+    }
+    static offline(snapshot) {
+        return { ...snapshot, online: false, capabilities: { localRead: true, localControl: false, liveControlRequiresExecutor: false },
+            entities: snapshot.entities.map((entity) => ({ ...entity, available: false, writable: false })) };
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGlvbmVlci5tYXBwZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9pbnRlZ3JhdGlvbnMvcGlvbmVlci9waW9uZWVyLm1hcHBlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsaUJBQWlCLEVBQWtILE1BQU0scUJBQXFCLENBQUM7QUFFeEssT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXBELE1BQU0sT0FBTyxhQUFhO0lBQ2pCLE1BQU0sQ0FBQyxVQUFVLENBQUMsVUFBd0U7UUFDL0YsT0FBTyxpQkFBaUIsQ0FBQyxVQUFVLENBQUMsRUFBRSxHQUFHLFVBQVUsRUFBRSxPQUFPLEVBQUUsY0FBYyxFQUFFLENBQUMsQ0FBQztJQUNsRixDQUFDO0lBRU0sTUFBTSxDQUFDLGlCQUFpQixDQUFDLFNBQXlCLEVBQUUsVUFBK0I7UUFDeEYsT0FBTyxpQkFBaUIsQ0FBQyxVQUFVLENBQUMsRUFBRSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sRUFBRSxTQUFTLEVBQUUsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsQ0FBQyxDQUFDO0lBQzNJLENBQUM7SUFFTSxNQUFNLENBQUMsU0FBUyxDQUFDLFdBQWlDO1FBQ3ZELE9BQU8saUJBQWlCLENBQUMsU0FBUyxDQUFDLGNBQWMsRUFBRSxXQUFXLENBQUMsQ0FBQztJQUNsRSxDQUFDO0lBRU0sTUFBTSxDQUFDLFVBQVUsQ0FBQyxXQUFpQztRQUN4RCxPQUFPLGlCQUFpQixDQUFDLFVBQVUsQ0FBQyxjQUFjLEVBQUUsV0FBVyxDQUFDLENBQUM7SUFDbkUsQ0FBQztJQUVNLE1BQU0sQ0FBQyxJQUFJLENBQUMsUUFBaUI7UUFDbEMsT0FBTyxpQkFBaUIsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDMUMsQ0FBQztDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,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