@quipuscore/watson-core-capacitor 0.1.0

package/Package.swift

@@ -0,0 +1,24 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "QuipuscoreWatsonCore",
+    platforms: [.iOS(.v14)],
+    products: [
+        .library(
+            name: "QuipuscoreWatsonCore",
+            targets: ["WatsonCorePlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "7.0.0")
+    ],
+    targets: [
+        .target(
+            name: "WatsonCorePlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm")
+            ],
+            path: "ios/Sources/WatsonCore")
+    ]
+)

package/QuipuscoreWatsonCore.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'QuipuscoreWatsonCore'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = 'https://github.com/quipucorp/watson-capacitor'
+  s.author = package['author']
+  s.source = { :git => 'https://github.com/quipucorp/watson-capacitor.git', :tag => s.version.to_s }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target = '14.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/android/build.gradle

@@ -0,0 +1,46 @@
+ext {
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.0'
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    watsonCoreVersion = project.hasProperty('watsonCoreVersion') ? rootProject.ext.watsonCoreVersion : '0.1.0'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.7.2'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace "com.quipuscore.watson.core"
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 35
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 23
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 35
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+    lint {
+        abortOnError false
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    // The Watson core owns all policy: permissions, ledger, compression, aggregation.
+    implementation "com.quipuscore:watson-core:$watsonCoreVersion"
+    testImplementation "junit:junit:$junitVersion"
+}

package/android/settings.gradle

@@ -0,0 +1,5 @@
+// Only used for the standalone plugin build (`cd android && ./gradlew ...`). When the plugin is
+// consumed by an app, Capacitor's generated settings include capacitor-android instead.
+// node_modules is hoisted to the monorepo root by npm workspaces.
+include ':capacitor-android'
+project(':capacitor-android').projectDir = new File('../../../node_modules/@capacitor/android/capacitor')

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <!--
+      The core declares no dangerous permissions. Each collector artifact (com.quipuscore:watson-sms,
+      etc.) declares its own permission in its manifest, which merges into the app only when that
+      collector package is installed. This keeps permission isolation intact.
+    -->
+</manifest>

package/android/src/main/java/com/quipuscore/watson/core/CapacitorPermissionRequester.java

@@ -0,0 +1,63 @@
+package com.quipuscore.watson.core;
+
+import android.Manifest;
+
+import com.getcapacitor.PluginCall;
+
+import com.quipuscore.watson.core.PermissionRequester;
+import com.quipuscore.watson.core.PermissionResultCallback;
+
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * The wrapper's only permission code, and it decides nothing. The core hands it the exact list of
+ * permissions to prompt for; this adapter maps each to its Capacitor alias, fires the framework's
+ * permission flow, and signals completion once the user has responded. The core re-reads the live
+ * grant state of each collector when the run resumes, so no results are carried back.
+ *
+ * <p>Because the core owns the ledger and gating, the native default request code ({@code 8801}) and
+ * {@code handlePermissionResult} are not used with this requester — which avoids the fragility of
+ * reserved request codes across Capacitor versions.
+ */
+final class CapacitorPermissionRequester implements PermissionRequester {
+
+    private final WatsonCorePlugin plugin;
+    private final PluginCall call;
+
+    CapacitorPermissionRequester(WatsonCorePlugin plugin, PluginCall call) {
+        this.plugin = plugin;
+        this.call = call;
+    }
+
+    @Override
+    public void requestPermissions(List<String> permissions, PermissionResultCallback onComplete) {
+        String[] aliases = aliasesFor(permissions);
+        if (aliases.length == 0) {
+            // Nothing this wrapper knows how to prompt for; let the core proceed and gate per collector.
+            onComplete.onPermissionsResolved();
+            return;
+        }
+        plugin.promptForAliases(aliases, call, onComplete);
+    }
+
+    /**
+     * Maps runtime permission strings to the aliases declared in {@link WatsonCorePlugin}. Unknown
+     * permissions are dropped (a new collector permission needs a new alias in the plugin).
+     */
+    private static String[] aliasesFor(List<String> permissions) {
+        Set<String> aliases = new LinkedHashSet<>();
+        for (String permission : permissions) {
+            if (Manifest.permission.READ_SMS.equals(permission)) {
+                aliases.add("sms");
+            } else if (Manifest.permission.READ_CALENDAR.equals(permission)) {
+                aliases.add("calendar");
+            } else if (Manifest.permission.READ_CONTACTS.equals(permission)) {
+                aliases.add("contacts");
+            }
+        }
+        return new ArrayList<>(aliases).toArray(new String[0]);
+    }
+}

package/android/src/main/java/com/quipuscore/watson/core/WatsonCorePlugin.java

@@ -0,0 +1,156 @@
+package com.quipuscore.watson.core;
+
+import android.Manifest;
+
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import com.getcapacitor.annotation.Permission;
+import com.getcapacitor.annotation.PermissionCallback;
+
+import com.quipuscore.watson.core.CollectionCallback;
+import com.quipuscore.watson.core.CollectionResult;
+import com.quipuscore.watson.core.CollectorOutcome;
+import com.quipuscore.watson.core.PermissionResultCallback;
+import com.quipuscore.watson.core.WatsonService;
+
+import org.json.JSONException;
+
+import java.util.List;
+
+/**
+ * Capacitor bridge for the Watson core. Thin by design: it builds a native {@link WatsonService}
+ * from the collector ids sent across the bridge, delegates permission delivery to
+ * {@link CapacitorPermissionRequester}, and serializes the {@link CollectionResult} back to JS. It
+ * reimplements no policy — the native core decides which permissions to request, keeps the ledger,
+ * compresses and aggregates.
+ *
+ * <p>The permission aliases below are declared even though this module does not depend on the
+ * collector modules at compile time: the strings are Android constants, and the dangerous permission
+ * reaches the merged manifest through the collector artifact the developer installed. A new collector
+ * with a new permission means adding its alias here.
+ */
+@CapacitorPlugin(
+    name = "WatsonCore",
+    permissions = {
+        @Permission(strings = { Manifest.permission.READ_SMS }, alias = "sms"),
+        @Permission(strings = { Manifest.permission.READ_CALENDAR }, alias = "calendar"),
+        @Permission(strings = { Manifest.permission.READ_CONTACTS }, alias = "contacts"),
+    }
+)
+public class WatsonCorePlugin extends Plugin {
+
+    /** Held across the async Capacitor permission prompt so the core collection can resume. */
+    private PermissionResultCallback pendingPermissionCallback;
+
+    @PluginMethod
+    public void collect(PluginCall call) {
+        final WatsonService service;
+        try {
+            service = buildService(call);
+        } catch (JSONException e) {
+            call.reject("Invalid 'collectors' argument", e);
+            return;
+        }
+
+        service.collect(new CollectionCallback() {
+            @Override
+            public void onSuccess(CollectionResult result) {
+                call.resolve(toJs(result));
+            }
+
+            @Override
+            public void onError(Exception error) {
+                call.reject(error.getMessage(), error);
+            }
+        });
+    }
+
+    @PluginMethod
+    public void getUngrantedPermissions(PluginCall call) {
+        final WatsonService service;
+        try {
+            service = buildService(call);
+        } catch (JSONException e) {
+            call.reject("Invalid 'collectors' argument", e);
+            return;
+        }
+
+        JSArray permissions = new JSArray();
+        for (String permission : service.getUngrantedPermissions()) {
+            permissions.put(permission);
+        }
+        JSObject ret = new JSObject();
+        ret.put("permissions", permissions);
+        call.resolve(ret);
+    }
+
+    /**
+     * Builds the native service from the ids sent across the bridge. Built here (not in
+     * {@link #load()}) so every collector plugin has already registered its factory in the core's
+     * registry by the time collection runs.
+     */
+    private WatsonService buildService(PluginCall call) throws JSONException {
+        WatsonService.Builder builder = new WatsonService.Builder(getContext());
+        JSArray ids = call.getArray("collectors", new JSArray());
+        List<String> idList = ids.toList();
+        for (String id : idList) {
+            // Resolves via the core's WatsonRegistry; throws if the matching module is not installed.
+            builder.addCollector(id);
+        }
+        WatsonService service = builder
+            .permissionRequester(new CapacitorPermissionRequester(this, call))
+            .build();
+        // The ledger still uses the Activity to tell a temporary denial from a permanent one.
+        service.setActivity(getActivity());
+        return service;
+    }
+
+    /**
+     * Fires the Capacitor permission prompt for {@code aliases} and remembers {@code onComplete} so
+     * {@link #handleWatsonPermissions(PluginCall)} can resume the parked collection. Called only by
+     * {@link CapacitorPermissionRequester}.
+     */
+    void promptForAliases(String[] aliases, PluginCall call, PermissionResultCallback onComplete) {
+        this.pendingPermissionCallback = onComplete;
+        requestPermissionForAliases(aliases, call, "handleWatsonPermissions");
+    }
+
+    @PermissionCallback
+    private void handleWatsonPermissions(PluginCall call) {
+        PermissionResultCallback callback = this.pendingPermissionCallback;
+        this.pendingPermissionCallback = null;
+        if (callback != null) {
+            // The core re-reads live grant state per collector; no results are carried back here.
+            callback.onPermissionsResolved();
+        }
+    }
+
+    private JSObject toJs(CollectionResult result) {
+        JSObject res = new JSObject();
+        res.put("data", result.getData());
+        res.put("submissionId", result.getSubmissionId());
+        res.put("isComplete", result.isComplete());
+
+        JSArray outcomes = new JSArray();
+        for (CollectorOutcome outcome : result.getOutcomes()) {
+            JSObject o = new JSObject();
+            o.put("collectorId", outcome.getCollectorId());
+            o.put("status", outcome.getStatus().name());
+            if (outcome.getErrorMessage() != null) {
+                o.put("errorMessage", outcome.getErrorMessage());
+            }
+            JSArray missing = new JSArray();
+            for (String permission : outcome.getMissingPermissions()) {
+                missing.put(permission);
+            }
+            o.put("missingPermissions", missing);
+            outcomes.put(o);
+        }
+        res.put("outcomes", outcomes);
+        return res;
+    }
+}

package/dist/esm/collector.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Base type for a collector descriptor.
+ *
+ * Collector packages (for example `@quipuscore/watson-sms-capacitor`) extend this with the stable `id` their
+ * native module registered with the Watson core. A descriptor carries no logic: it only tells the
+ * core, across the bridge, which registered collector to run. This mirrors the explicit-registration
+ * model of the native SDK — a collector you never add is never collected.
+ */
+export declare abstract class WatsonCollector {
+    abstract readonly id: string;
+}
+//# sourceMappingURL=collector.d.ts.map

package/dist/esm/collector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collector.d.ts","sourceRoot":"","sources":["../../src/collector.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,8BAAsB,eAAe;IACnC,QAAQ,CAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CAC9B"}

package/dist/esm/collector.js

@@ -0,0 +1,11 @@
+/**
+ * Base type for a collector descriptor.
+ *
+ * Collector packages (for example `@quipuscore/watson-sms-capacitor`) extend this with the stable `id` their
+ * native module registered with the Watson core. A descriptor carries no logic: it only tells the
+ * core, across the bridge, which registered collector to run. This mirrors the explicit-registration
+ * model of the native SDK — a collector you never add is never collected.
+ */
+export class WatsonCollector {
+}
+//# sourceMappingURL=collector.js.map

package/dist/esm/collector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collector.js","sourceRoot":"","sources":["../../src/collector.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,OAAgB,eAAe;CAEpC"}

package/dist/esm/definitions.d.ts

@@ -0,0 +1,44 @@
+export type CollectorStatus = 'SUCCESS' | 'PERMISSION_DENIED' | 'PERMISSION_PERMANENTLY_DENIED' | 'ERROR';
+/** Per-collector result of a collection run. Mirrors the native `CollectorOutcome`. */
+export interface CollectorOutcome {
+    collectorId: string;
+    status: CollectorStatus;
+    /** Failure detail when `status === 'ERROR'`; otherwise absent. */
+    errorMessage?: string;
+    /**
+     * The ungranted runtime permissions that gated this collector. Non-empty only for the two
+     * `PERMISSION_*` statuses; empty otherwise.
+     */
+    missingPermissions: string[];
+}
+/** Result of a collection run. Mirrors the native `CollectionResult`. */
+export interface CollectionResult {
+    /**
+     * The aggregated payload, `base64(gzip(json))`. Send it verbatim to your backend; never
+     * decompress it on the device — that is the backend's job.
+     */
+    data: string;
+    /** Stable, idempotent id `<deviceId>-<collectedAt>`; also embedded inside the payload. */
+    submissionId: string;
+    /** True only if every collector ran successfully; false on any skipped or failed collector. */
+    isComplete: boolean;
+    /** Per-collector outcomes, including the ones that were skipped or failed. */
+    outcomes: CollectorOutcome[];
+}
+/**
+ * Low-level bridge contract for the native `WatsonCore` plugin. Application code should use the
+ * {@link WatsonService} class instead of calling this plugin directly.
+ */
+export interface WatsonCorePlugin {
+    /** Runs the given collector ids natively and returns the compressed payload plus outcomes. */
+    collect(options: {
+        collectors: string[];
+    }): Promise<CollectionResult>;
+    /** The runtime permissions required by the given collector ids that are not granted yet. */
+    getUngrantedPermissions(options: {
+        collectors: string[];
+    }): Promise<{
+        permissions: string[];
+    }>;
+}
+//# sourceMappingURL=definitions.d.ts.map

package/dist/esm/definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GACvB,SAAS,GACT,mBAAmB,GACnB,+BAA+B,GAC/B,OAAO,CAAC;AAEZ,uFAAuF;AACvF,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,eAAe,CAAC;IACxB,kEAAkE;IAClE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED,yEAAyE;AACzE,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,0FAA0F;IAC1F,YAAY,EAAE,MAAM,CAAC;IACrB,+FAA+F;IAC/F,UAAU,EAAE,OAAO,CAAC;IACpB,8EAA8E;IAC9E,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC9B;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,8FAA8F;IAC9F,OAAO,CAAC,OAAO,EAAE;QAAE,UAAU,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACtE,4FAA4F;IAC5F,uBAAuB,CAAC,OAAO,EAAE;QAAE,UAAU,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;CAChG"}

package/dist/esm/definitions.js

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

package/dist/esm/definitions.js.map

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

package/dist/esm/index.d.ts

@@ -0,0 +1,5 @@
+export * from './definitions';
+export { WatsonCollector } from './collector';
+export { WatsonService } from './service';
+export { WatsonCore } from './plugin';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC"}

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+export * from './definitions';
+export { WatsonCollector } from './collector';
+export { WatsonService } from './service';
+export { WatsonCore } from './plugin';
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC"}

package/dist/esm/plugin.d.ts

@@ -0,0 +1,7 @@
+import type { WatsonCorePlugin } from './definitions';
+/**
+ * The registered native `WatsonCore` plugin proxy. Exposed for advanced use; prefer the
+ * {@link WatsonService} class, which mirrors the native API surface.
+ */
+export declare const WatsonCore: WatsonCorePlugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/esm/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD;;;GAGG;AACH,eAAO,MAAM,UAAU,kBAErB,CAAC"}

package/dist/esm/plugin.js

@@ -0,0 +1,9 @@
+import { registerPlugin } from '@capacitor/core';
+/**
+ * The registered native `WatsonCore` plugin proxy. Exposed for advanced use; prefer the
+ * {@link WatsonService} class, which mirrors the native API surface.
+ */
+export const WatsonCore = registerPlugin('WatsonCore', {
+    web: () => import('./web').then(m => new m.WatsonCoreWeb()),
+});
+//# sourceMappingURL=plugin.js.map

package/dist/esm/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAIjD;;;GAGG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,cAAc,CAAmB,YAAY,EAAE;IACvE,GAAG,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,aAAa,EAAE,CAAC;CAC5D,CAAC,CAAC"}

package/dist/esm/service.d.ts

@@ -0,0 +1,26 @@
+import type { WatsonCollector } from './collector';
+import type { CollectionResult } from './definitions';
+/**
+ * JS-side orchestrator, mirroring the native `WatsonService`. It accumulates the ids of the
+ * collectors you add and hands that list to the native `WatsonCore` plugin on {@link collect}.
+ *
+ * The always-on `device` baseline is added by the native core itself; you never add it here. The
+ * single structural asymmetry with the native API is that `new WatsonService()` takes no `context`
+ * — the native plugin injects it.
+ */
+export declare class WatsonService {
+    private readonly collectorIds;
+    /**
+     * Registers a collector to run. Explicit by design: a collector you don't add is not collected
+     * and does not pull its runtime permission. Adding the same id twice is a no-op.
+     */
+    addCollector(collector: WatsonCollector): void;
+    /**
+     * Runs every added collector natively and resolves with the compressed payload and the
+     * per-collector outcomes. A denied or failing collector never aborts the others.
+     */
+    collect(): Promise<CollectionResult>;
+    /** The runtime permissions required by the added collectors that are not granted yet. */
+    getUngrantedPermissions(): Promise<string[]>;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/esm/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAGtD;;;;;;;GAOG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAgB;IAE7C;;;OAGG;IACH,YAAY,CAAC,SAAS,EAAE,eAAe,GAAG,IAAI;IAS9C;;;OAGG;IACH,OAAO,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAIpC,yFAAyF;IACnF,uBAAuB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAMnD"}

package/dist/esm/service.js

@@ -0,0 +1,41 @@
+import { WatsonCore } from './plugin';
+/**
+ * JS-side orchestrator, mirroring the native `WatsonService`. It accumulates the ids of the
+ * collectors you add and hands that list to the native `WatsonCore` plugin on {@link collect}.
+ *
+ * The always-on `device` baseline is added by the native core itself; you never add it here. The
+ * single structural asymmetry with the native API is that `new WatsonService()` takes no `context`
+ * — the native plugin injects it.
+ */
+export class WatsonService {
+    constructor() {
+        this.collectorIds = [];
+    }
+    /**
+     * Registers a collector to run. Explicit by design: a collector you don't add is not collected
+     * and does not pull its runtime permission. Adding the same id twice is a no-op.
+     */
+    addCollector(collector) {
+        if (!collector || !collector.id) {
+            throw new Error('addCollector requires a collector with a non-empty id');
+        }
+        if (this.collectorIds.indexOf(collector.id) === -1) {
+            this.collectorIds.push(collector.id);
+        }
+    }
+    /**
+     * Runs every added collector natively and resolves with the compressed payload and the
+     * per-collector outcomes. A denied or failing collector never aborts the others.
+     */
+    collect() {
+        return WatsonCore.collect({ collectors: this.collectorIds });
+    }
+    /** The runtime permissions required by the added collectors that are not granted yet. */
+    async getUngrantedPermissions() {
+        const { permissions } = await WatsonCore.getUngrantedPermissions({
+            collectors: this.collectorIds,
+        });
+        return permissions;
+    }
+}
+//# sourceMappingURL=service.js.map

package/dist/esm/service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.js","sourceRoot":"","sources":["../../src/service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtC;;;;;;;GAOG;AACH,MAAM,OAAO,aAAa;IAA1B;QACmB,iBAAY,GAAa,EAAE,CAAC;IA8B/C,CAAC;IA5BC;;;OAGG;IACH,YAAY,CAAC,SAA0B;QACrC,IAAI,CAAC,SAAS,IAAI,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC;YAChC,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;QAC3E,CAAC;QACD,IAAI,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;YACnD,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QACvC,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,OAAO;QACL,OAAO,UAAU,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC;IAC/D,CAAC;IAED,yFAAyF;IACzF,KAAK,CAAC,uBAAuB;QAC3B,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,UAAU,CAAC,uBAAuB,CAAC;YAC/D,UAAU,EAAE,IAAI,CAAC,YAAY;SAC9B,CAAC,CAAC;QACH,OAAO,WAAW,CAAC;IACrB,CAAC;CACF"}

package/dist/esm/web.d.ts

@@ -0,0 +1,9 @@
+import { WebPlugin } from '@capacitor/core';
+import type { CollectionResult, WatsonCorePlugin } from './definitions';
+export declare class WatsonCoreWeb extends WebPlugin implements WatsonCorePlugin {
+    collect(): Promise<CollectionResult>;
+    getUngrantedPermissions(): Promise<{
+        permissions: string[];
+    }>;
+}
+//# sourceMappingURL=web.d.ts.map

package/dist/esm/web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../../src/web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAIxE,qBAAa,aAAc,SAAQ,SAAU,YAAW,gBAAgB;IAChE,OAAO,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAIpC,uBAAuB,IAAI,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CAGpE"}

package/dist/esm/web.js

@@ -0,0 +1,11 @@
+import { WebPlugin } from '@capacitor/core';
+const MESSAGE = 'Watson is only available on Android and iOS.';
+export class WatsonCoreWeb extends WebPlugin {
+    async collect() {
+        throw this.unimplemented(MESSAGE);
+    }
+    async getUngrantedPermissions() {
+        throw this.unimplemented(MESSAGE);
+    }
+}
+//# sourceMappingURL=web.js.map

package/dist/esm/web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"web.js","sourceRoot":"","sources":["../../src/web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAI5C,MAAM,OAAO,GAAG,8CAA8C,CAAC;AAE/D,MAAM,OAAO,aAAc,SAAQ,SAAS;IAC1C,KAAK,CAAC,OAAO;QACX,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IACpC,CAAC;IAED,KAAK,CAAC,uBAAuB;QAC3B,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IACpC,CAAC;CACF"}

package/dist/plugin.cjs.js

@@ -0,0 +1,82 @@
+'use strict';
+
+var core = require('@capacitor/core');
+
+/**
+ * Base type for a collector descriptor.
+ *
+ * Collector packages (for example `@quipuscore/watson-sms-capacitor`) extend this with the stable `id` their
+ * native module registered with the Watson core. A descriptor carries no logic: it only tells the
+ * core, across the bridge, which registered collector to run. This mirrors the explicit-registration
+ * model of the native SDK — a collector you never add is never collected.
+ */
+class WatsonCollector {
+}
+
+/**
+ * The registered native `WatsonCore` plugin proxy. Exposed for advanced use; prefer the
+ * {@link WatsonService} class, which mirrors the native API surface.
+ */
+const WatsonCore = core.registerPlugin('WatsonCore', {
+    web: () => Promise.resolve().then(function () { return web; }).then(m => new m.WatsonCoreWeb()),
+});
+
+/**
+ * JS-side orchestrator, mirroring the native `WatsonService`. It accumulates the ids of the
+ * collectors you add and hands that list to the native `WatsonCore` plugin on {@link collect}.
+ *
+ * The always-on `device` baseline is added by the native core itself; you never add it here. The
+ * single structural asymmetry with the native API is that `new WatsonService()` takes no `context`
+ * — the native plugin injects it.
+ */
+class WatsonService {
+    constructor() {
+        this.collectorIds = [];
+    }
+    /**
+     * Registers a collector to run. Explicit by design: a collector you don't add is not collected
+     * and does not pull its runtime permission. Adding the same id twice is a no-op.
+     */
+    addCollector(collector) {
+        if (!collector || !collector.id) {
+            throw new Error('addCollector requires a collector with a non-empty id');
+        }
+        if (this.collectorIds.indexOf(collector.id) === -1) {
+            this.collectorIds.push(collector.id);
+        }
+    }
+    /**
+     * Runs every added collector natively and resolves with the compressed payload and the
+     * per-collector outcomes. A denied or failing collector never aborts the others.
+     */
+    collect() {
+        return WatsonCore.collect({ collectors: this.collectorIds });
+    }
+    /** The runtime permissions required by the added collectors that are not granted yet. */
+    async getUngrantedPermissions() {
+        const { permissions } = await WatsonCore.getUngrantedPermissions({
+            collectors: this.collectorIds,
+        });
+        return permissions;
+    }
+}
+
+const MESSAGE = 'Watson is only available on Android and iOS.';
+class WatsonCoreWeb extends core.WebPlugin {
+    async collect() {
+        throw this.unimplemented(MESSAGE);
+    }
+    async getUngrantedPermissions() {
+        throw this.unimplemented(MESSAGE);
+    }
+}
+
+var web = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    WatsonCoreWeb: WatsonCoreWeb
+});
+
+exports.WatsonCollector = WatsonCollector;
+exports.WatsonCore = WatsonCore;
+exports.WatsonService = WatsonService;
+//# sourceMappingURL=plugin.cjs.js.map

package/dist/plugin.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.cjs.js","sources":["esm/collector.js","esm/plugin.js","esm/service.js","esm/web.js"],"sourcesContent":["/**\n * Base type for a collector descriptor.\n *\n * Collector packages (for example `@quipuscore/watson-sms-capacitor`) extend this with the stable `id` their\n * native module registered with the Watson core. A descriptor carries no logic: it only tells the\n * core, across the bridge, which registered collector to run. This mirrors the explicit-registration\n * model of the native SDK — a collector you never add is never collected.\n */\nexport class WatsonCollector {\n}\n//# sourceMappingURL=collector.js.map","import { registerPlugin } from '@capacitor/core';\n/**\n * The registered native `WatsonCore` plugin proxy. Exposed for advanced use; prefer the\n * {@link WatsonService} class, which mirrors the native API surface.\n */\nexport const WatsonCore = registerPlugin('WatsonCore', {\n    web: () => import('./web').then(m => new m.WatsonCoreWeb()),\n});\n//# sourceMappingURL=plugin.js.map","import { WatsonCore } from './plugin';\n/**\n * JS-side orchestrator, mirroring the native `WatsonService`. It accumulates the ids of the\n * collectors you add and hands that list to the native `WatsonCore` plugin on {@link collect}.\n *\n * The always-on `device` baseline is added by the native core itself; you never add it here. The\n * single structural asymmetry with the native API is that `new WatsonService()` takes no `context`\n * — the native plugin injects it.\n */\nexport class WatsonService {\n    constructor() {\n        this.collectorIds = [];\n    }\n    /**\n     * Registers a collector to run. Explicit by design: a collector you don't add is not collected\n     * and does not pull its runtime permission. Adding the same id twice is a no-op.\n     */\n    addCollector(collector) {\n        if (!collector || !collector.id) {\n            throw new Error('addCollector requires a collector with a non-empty id');\n        }\n        if (this.collectorIds.indexOf(collector.id) === -1) {\n            this.collectorIds.push(collector.id);\n        }\n    }\n    /**\n     * Runs every added collector natively and resolves with the compressed payload and the\n     * per-collector outcomes. A denied or failing collector never aborts the others.\n     */\n    collect() {\n        return WatsonCore.collect({ collectors: this.collectorIds });\n    }\n    /** The runtime permissions required by the added collectors that are not granted yet. */\n    async getUngrantedPermissions() {\n        const { permissions } = await WatsonCore.getUngrantedPermissions({\n            collectors: this.collectorIds,\n        });\n        return permissions;\n    }\n}\n//# sourceMappingURL=service.js.map","import { WebPlugin } from '@capacitor/core';\nconst MESSAGE = 'Watson is only available on Android and iOS.';\nexport class WatsonCoreWeb extends WebPlugin {\n    async collect() {\n        throw this.unimplemented(MESSAGE);\n    }\n    async getUngrantedPermissions() {\n        throw this.unimplemented(MESSAGE);\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["registerPlugin","WebPlugin"],"mappings":";;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAM,eAAe,CAAC;AAC7B;;ACRA;AACA;AACA;AACA;AACY,MAAC,UAAU,GAAGA,mBAAc,CAAC,YAAY,EAAE;AACvD,IAAI,GAAG,EAAE,MAAM,mDAAe,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,aAAa,EAAE,CAAC;AAC/D,CAAC;;ACND;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAM,aAAa,CAAC;AAC3B,IAAI,WAAW,GAAG;AAClB,QAAQ,IAAI,CAAC,YAAY,GAAG,EAAE;AAC9B,IAAI;AACJ;AACA;AACA;AACA;AACA,IAAI,YAAY,CAAC,SAAS,EAAE;AAC5B,QAAQ,IAAI,CAAC,SAAS,IAAI,CAAC,SAAS,CAAC,EAAE,EAAE;AACzC,YAAY,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC;AACpF,QAAQ;AACR,QAAQ,IAAI,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE;AAC5D,YAAY,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;AAChD,QAAQ;AACR,IAAI;AACJ;AACA;AACA;AACA;AACA,IAAI,OAAO,GAAG;AACd,QAAQ,OAAO,UAAU,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,IAAI,CAAC,YAAY,EAAE,CAAC;AACpE,IAAI;AACJ;AACA,IAAI,MAAM,uBAAuB,GAAG;AACpC,QAAQ,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,UAAU,CAAC,uBAAuB,CAAC;AACzE,YAAY,UAAU,EAAE,IAAI,CAAC,YAAY;AACzC,SAAS,CAAC;AACV,QAAQ,OAAO,WAAW;AAC1B,IAAI;AACJ;;ACtCA,MAAM,OAAO,GAAG,8CAA8C;AACvD,MAAM,aAAa,SAASC,cAAS,CAAC;AAC7C,IAAI,MAAM,OAAO,GAAG;AACpB,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC;AACzC,IAAI;AACJ,IAAI,MAAM,uBAAuB,GAAG;AACpC,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC;AACzC,IAAI;AACJ;;;;;;;;;;;"}

package/dist/plugin.js

@@ -0,0 +1,85 @@
+var capacitorWatsonCore = (function (exports, core) {
+    'use strict';
+
+    /**
+     * Base type for a collector descriptor.
+     *
+     * Collector packages (for example `@quipuscore/watson-sms-capacitor`) extend this with the stable `id` their
+     * native module registered with the Watson core. A descriptor carries no logic: it only tells the
+     * core, across the bridge, which registered collector to run. This mirrors the explicit-registration
+     * model of the native SDK — a collector you never add is never collected.
+     */
+    class WatsonCollector {
+    }
+
+    /**
+     * The registered native `WatsonCore` plugin proxy. Exposed for advanced use; prefer the
+     * {@link WatsonService} class, which mirrors the native API surface.
+     */
+    const WatsonCore = core.registerPlugin('WatsonCore', {
+        web: () => Promise.resolve().then(function () { return web; }).then(m => new m.WatsonCoreWeb()),
+    });
+
+    /**
+     * JS-side orchestrator, mirroring the native `WatsonService`. It accumulates the ids of the
+     * collectors you add and hands that list to the native `WatsonCore` plugin on {@link collect}.
+     *
+     * The always-on `device` baseline is added by the native core itself; you never add it here. The
+     * single structural asymmetry with the native API is that `new WatsonService()` takes no `context`
+     * — the native plugin injects it.
+     */
+    class WatsonService {
+        constructor() {
+            this.collectorIds = [];
+        }
+        /**
+         * Registers a collector to run. Explicit by design: a collector you don't add is not collected
+         * and does not pull its runtime permission. Adding the same id twice is a no-op.
+         */
+        addCollector(collector) {
+            if (!collector || !collector.id) {
+                throw new Error('addCollector requires a collector with a non-empty id');
+            }
+            if (this.collectorIds.indexOf(collector.id) === -1) {
+                this.collectorIds.push(collector.id);
+            }
+        }
+        /**
+         * Runs every added collector natively and resolves with the compressed payload and the
+         * per-collector outcomes. A denied or failing collector never aborts the others.
+         */
+        collect() {
+            return WatsonCore.collect({ collectors: this.collectorIds });
+        }
+        /** The runtime permissions required by the added collectors that are not granted yet. */
+        async getUngrantedPermissions() {
+            const { permissions } = await WatsonCore.getUngrantedPermissions({
+                collectors: this.collectorIds,
+            });
+            return permissions;
+        }
+    }
+
+    const MESSAGE = 'Watson is only available on Android and iOS.';
+    class WatsonCoreWeb extends core.WebPlugin {
+        async collect() {
+            throw this.unimplemented(MESSAGE);
+        }
+        async getUngrantedPermissions() {
+            throw this.unimplemented(MESSAGE);
+        }
+    }
+
+    var web = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        WatsonCoreWeb: WatsonCoreWeb
+    });
+
+    exports.WatsonCollector = WatsonCollector;
+    exports.WatsonCore = WatsonCore;
+    exports.WatsonService = WatsonService;
+
+    return exports;
+
+})({}, capacitorExports);
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sources":["esm/collector.js","esm/plugin.js","esm/service.js","esm/web.js"],"sourcesContent":["/**\n * Base type for a collector descriptor.\n *\n * Collector packages (for example `@quipuscore/watson-sms-capacitor`) extend this with the stable `id` their\n * native module registered with the Watson core. A descriptor carries no logic: it only tells the\n * core, across the bridge, which registered collector to run. This mirrors the explicit-registration\n * model of the native SDK — a collector you never add is never collected.\n */\nexport class WatsonCollector {\n}\n//# sourceMappingURL=collector.js.map","import { registerPlugin } from '@capacitor/core';\n/**\n * The registered native `WatsonCore` plugin proxy. Exposed for advanced use; prefer the\n * {@link WatsonService} class, which mirrors the native API surface.\n */\nexport const WatsonCore = registerPlugin('WatsonCore', {\n    web: () => import('./web').then(m => new m.WatsonCoreWeb()),\n});\n//# sourceMappingURL=plugin.js.map","import { WatsonCore } from './plugin';\n/**\n * JS-side orchestrator, mirroring the native `WatsonService`. It accumulates the ids of the\n * collectors you add and hands that list to the native `WatsonCore` plugin on {@link collect}.\n *\n * The always-on `device` baseline is added by the native core itself; you never add it here. The\n * single structural asymmetry with the native API is that `new WatsonService()` takes no `context`\n * — the native plugin injects it.\n */\nexport class WatsonService {\n    constructor() {\n        this.collectorIds = [];\n    }\n    /**\n     * Registers a collector to run. Explicit by design: a collector you don't add is not collected\n     * and does not pull its runtime permission. Adding the same id twice is a no-op.\n     */\n    addCollector(collector) {\n        if (!collector || !collector.id) {\n            throw new Error('addCollector requires a collector with a non-empty id');\n        }\n        if (this.collectorIds.indexOf(collector.id) === -1) {\n            this.collectorIds.push(collector.id);\n        }\n    }\n    /**\n     * Runs every added collector natively and resolves with the compressed payload and the\n     * per-collector outcomes. A denied or failing collector never aborts the others.\n     */\n    collect() {\n        return WatsonCore.collect({ collectors: this.collectorIds });\n    }\n    /** The runtime permissions required by the added collectors that are not granted yet. */\n    async getUngrantedPermissions() {\n        const { permissions } = await WatsonCore.getUngrantedPermissions({\n            collectors: this.collectorIds,\n        });\n        return permissions;\n    }\n}\n//# sourceMappingURL=service.js.map","import { WebPlugin } from '@capacitor/core';\nconst MESSAGE = 'Watson is only available on Android and iOS.';\nexport class WatsonCoreWeb extends WebPlugin {\n    async collect() {\n        throw this.unimplemented(MESSAGE);\n    }\n    async getUngrantedPermissions() {\n        throw this.unimplemented(MESSAGE);\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["registerPlugin","WebPlugin"],"mappings":";;;IAAA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACO,MAAM,eAAe,CAAC;IAC7B;;ICRA;IACA;IACA;IACA;AACY,UAAC,UAAU,GAAGA,mBAAc,CAAC,YAAY,EAAE;IACvD,IAAI,GAAG,EAAE,MAAM,mDAAe,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,aAAa,EAAE,CAAC;IAC/D,CAAC;;ICND;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACO,MAAM,aAAa,CAAC;IAC3B,IAAI,WAAW,GAAG;IAClB,QAAQ,IAAI,CAAC,YAAY,GAAG,EAAE;IAC9B,IAAI;IACJ;IACA;IACA;IACA;IACA,IAAI,YAAY,CAAC,SAAS,EAAE;IAC5B,QAAQ,IAAI,CAAC,SAAS,IAAI,CAAC,SAAS,CAAC,EAAE,EAAE;IACzC,YAAY,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC;IACpF,QAAQ;IACR,QAAQ,IAAI,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE;IAC5D,YAAY,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;IAChD,QAAQ;IACR,IAAI;IACJ;IACA;IACA;IACA;IACA,IAAI,OAAO,GAAG;IACd,QAAQ,OAAO,UAAU,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,IAAI,CAAC,YAAY,EAAE,CAAC;IACpE,IAAI;IACJ;IACA,IAAI,MAAM,uBAAuB,GAAG;IACpC,QAAQ,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,UAAU,CAAC,uBAAuB,CAAC;IACzE,YAAY,UAAU,EAAE,IAAI,CAAC,YAAY;IACzC,SAAS,CAAC;IACV,QAAQ,OAAO,WAAW;IAC1B,IAAI;IACJ;;ICtCA,MAAM,OAAO,GAAG,8CAA8C;IACvD,MAAM,aAAa,SAASC,cAAS,CAAC;IAC7C,IAAI,MAAM,OAAO,GAAG;IACpB,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC;IACzC,IAAI;IACJ,IAAI,MAAM,uBAAuB,GAAG;IACpC,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC;IACzC,IAAI;IACJ;;;;;;;;;;;;;;;;;"}

package/ios/Sources/WatsonCore/WatsonCorePlugin.swift

@@ -0,0 +1,22 @@
+import Capacitor
+
+/// iOS stub. The Watson iOS base (`watson_ios`) does not exist yet, so this plugin is present only
+/// to keep the package structure iOS-ready. When `watson_ios` lands, implement these methods against
+/// it while preserving the TypeScript contract in `src/` unchanged.
+@objc(WatsonCorePlugin)
+public class WatsonCorePlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "WatsonCorePlugin"
+    public let jsName = "WatsonCore"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "collect", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getUngrantedPermissions", returnType: CAPPluginReturnPromise),
+    ]
+
+    @objc func collect(_ call: CAPPluginCall) {
+        call.unimplemented("The Watson iOS base is not available yet.")
+    }
+
+    @objc func getUngrantedPermissions(_ call: CAPPluginCall) {
+        call.unimplemented("The Watson iOS base is not available yet.")
+    }
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@quipuscore/watson-core-capacitor",
+  "version": "0.1.0",
+  "description": "Capacitor wrapper for the Watson core SDK: orchestrator + always-on device baseline.",
+  "license": "UNLICENSED",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "android/settings.gradle",
+    "dist/",
+    "ios/Sources/",
+    "Package.swift",
+    "QuipuscoreWatsonCore.podspec"
+  ],
+  "author": "Quipu",
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native",
+    "watson"
+  ],
+  "scripts": {
+    "build": "npm run clean && tsc && rollup -c rollup.config.js",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "verify:web": "npm run build",
+    "verify:android": "cd android && ./gradlew clean build test",
+    "capacitor": "cap"
+  },
+  "capacitor": {
+    "android": {
+      "src": "android"
+    }
+  },
+  "devDependencies": {
+    "@capacitor/android": "^7.0.0",
+    "@capacitor/core": "^7.0.0",
+    "rimraf": "^5.0.5",
+    "rollup": "^4.9.0",
+    "typescript": "^5.4.0"
+  },
+  "peerDependencies": {
+    "@capacitor/core": "^7.0.0"
+  }
+}