@kehto/paja 0.33.1 → 0.35.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +15 -4
- package/dist/browser-host.js +1157 -900
- package/dist/browser-host.js.map +1 -1
- package/dist/{chunk-IWFPIHAE.js → chunk-CI2WKD4Y.js} +4 -4
- package/dist/chunk-CI2WKD4Y.js.map +1 -0
- package/dist/cli.js +1 -1
- package/dist/index.js +1 -1
- package/package.json +12 -11
- package/dist/chunk-IWFPIHAE.js.map +0 -1
package/dist/browser-host.js
CHANGED
|
@@ -3540,137 +3540,6 @@ function resolveCapabilitiesNap(msg) {
|
|
|
3540
3540
|
}
|
|
3541
3541
|
|
|
3542
3542
|
// ../firewall/dist/index.js
|
|
3543
|
-
function toKey2(napplet, opClass) {
|
|
3544
|
-
return `${napplet}:${opClass}`;
|
|
3545
|
-
}
|
|
3546
|
-
function actionToDecision(action) {
|
|
3547
|
-
if (action === "block") return "reject";
|
|
3548
|
-
return "pass";
|
|
3549
|
-
}
|
|
3550
|
-
function evaluate(config, state, observation) {
|
|
3551
|
-
const { napplet, opClass, now: now2 } = observation;
|
|
3552
|
-
const nappletRules = config.napplets[napplet];
|
|
3553
|
-
const policy = nappletRules?.policy;
|
|
3554
|
-
if (policy === "allow") {
|
|
3555
|
-
return {
|
|
3556
|
-
decision: "pass",
|
|
3557
|
-
action: "ignore",
|
|
3558
|
-
ruleId: "policy:allow",
|
|
3559
|
-
reason: `napplet ${napplet} has allow policy \u2014 bypassing all checks`,
|
|
3560
|
-
newState: state
|
|
3561
|
-
};
|
|
3562
|
-
}
|
|
3563
|
-
if (policy === "deny") {
|
|
3564
|
-
return {
|
|
3565
|
-
decision: "reject",
|
|
3566
|
-
action: "block",
|
|
3567
|
-
ruleId: "policy:deny",
|
|
3568
|
-
reason: `napplet ${napplet} has deny policy \u2014 always rejected`,
|
|
3569
|
-
newState: state
|
|
3570
|
-
};
|
|
3571
|
-
}
|
|
3572
|
-
if (policy === "ask") {
|
|
3573
|
-
return {
|
|
3574
|
-
decision: "prompt",
|
|
3575
|
-
action: "block",
|
|
3576
|
-
ruleId: "policy:ask",
|
|
3577
|
-
reason: `napplet ${napplet} has ask policy \u2014 prompting for consent`,
|
|
3578
|
-
newState: state
|
|
3579
|
-
};
|
|
3580
|
-
}
|
|
3581
|
-
const { initElapsedMs } = observation;
|
|
3582
|
-
if (initElapsedMs !== void 0 && initElapsedMs < config.burstGuard.windowMs) {
|
|
3583
|
-
const burstKey = observation.initKey ?? napplet;
|
|
3584
|
-
const existingBurst = state.bursts[burstKey];
|
|
3585
|
-
const activeBurst = existingBurst !== void 0 && now2 - existingBurst.windowStart < config.burstGuard.windowMs ? existingBurst : void 0;
|
|
3586
|
-
const newBurst = {
|
|
3587
|
-
count: (activeBurst?.count ?? 0) + 1,
|
|
3588
|
-
windowStart: activeBurst?.windowStart ?? now2
|
|
3589
|
-
};
|
|
3590
|
-
const newBursts = { ...state.bursts, [burstKey]: newBurst };
|
|
3591
|
-
if (newBurst.count > config.burstGuard.maxOps) {
|
|
3592
|
-
const burstAction = config.burstGuard.action;
|
|
3593
|
-
return {
|
|
3594
|
-
decision: actionToDecision(burstAction),
|
|
3595
|
-
action: burstAction,
|
|
3596
|
-
ruleId: "burst",
|
|
3597
|
-
reason: `napplet ${napplet} exceeded init-burst limit (${newBurst.count} > ${config.burstGuard.maxOps} ops within ${config.burstGuard.windowMs}ms)`,
|
|
3598
|
-
newState: { ...state, bursts: newBursts }
|
|
3599
|
-
};
|
|
3600
|
-
}
|
|
3601
|
-
state = { ...state, bursts: newBursts };
|
|
3602
|
-
}
|
|
3603
|
-
for (const matcher of config.matchers) {
|
|
3604
|
-
if (matcher.opClass !== void 0 && matcher.opClass !== opClass) continue;
|
|
3605
|
-
if (matcher.kinds !== void 0) {
|
|
3606
|
-
if (observation.kind === void 0) continue;
|
|
3607
|
-
if (!matcher.kinds.includes(observation.kind)) continue;
|
|
3608
|
-
}
|
|
3609
|
-
if (matcher.minSize !== void 0) {
|
|
3610
|
-
if (observation.size === void 0) continue;
|
|
3611
|
-
if (observation.size < matcher.minSize) continue;
|
|
3612
|
-
}
|
|
3613
|
-
if (matcher.focused !== void 0 && matcher.focused !== observation.focused) continue;
|
|
3614
|
-
if (matcher.maxMsSinceFocusGain !== void 0) {
|
|
3615
|
-
if (observation.msSinceFocusGain === void 0) continue;
|
|
3616
|
-
if (observation.msSinceFocusGain > matcher.maxMsSinceFocusGain) continue;
|
|
3617
|
-
}
|
|
3618
|
-
const matcherAction = matcher.action;
|
|
3619
|
-
return {
|
|
3620
|
-
decision: actionToDecision(matcherAction),
|
|
3621
|
-
action: matcherAction,
|
|
3622
|
-
ruleId: `matcher:${matcher.id}`,
|
|
3623
|
-
reason: `content matcher '${matcher.id}' fired`,
|
|
3624
|
-
newState: state
|
|
3625
|
-
};
|
|
3626
|
-
}
|
|
3627
|
-
let rateLimit = config.defaultRate;
|
|
3628
|
-
let rateLimitRuleId = "rate:default";
|
|
3629
|
-
if (nappletRules) {
|
|
3630
|
-
const opClassLimit = nappletRules.rateLimits[opClass];
|
|
3631
|
-
if (opClassLimit) {
|
|
3632
|
-
rateLimit = opClassLimit;
|
|
3633
|
-
rateLimitRuleId = "rate:opclass";
|
|
3634
|
-
} else if (nappletRules.globalRate) {
|
|
3635
|
-
rateLimit = nappletRules.globalRate;
|
|
3636
|
-
rateLimitRuleId = "rate:global";
|
|
3637
|
-
}
|
|
3638
|
-
}
|
|
3639
|
-
const effectiveCapacity = observation.focused ? rateLimit.capacity : rateLimit.capacity * config.unfocusedMultiplier;
|
|
3640
|
-
const refillRatePerMs = effectiveCapacity / rateLimit.windowMs;
|
|
3641
|
-
const bucketKey = toKey2(napplet, opClass);
|
|
3642
|
-
const existingBucket = state.buckets[bucketKey];
|
|
3643
|
-
const lastRefill = existingBucket?.lastRefill ?? now2;
|
|
3644
|
-
const initialTokens = existingBucket?.tokens ?? effectiveCapacity;
|
|
3645
|
-
const elapsed = Math.max(0, now2 - lastRefill);
|
|
3646
|
-
const tokens = Math.min(effectiveCapacity, initialTokens + elapsed * refillRatePerMs);
|
|
3647
|
-
if (tokens >= 1) {
|
|
3648
|
-
const nextBucket = { tokens: tokens - 1, lastRefill: now2 };
|
|
3649
|
-
return {
|
|
3650
|
-
decision: "pass",
|
|
3651
|
-
action: "ignore",
|
|
3652
|
-
ruleId: rateLimitRuleId,
|
|
3653
|
-
reason: `within budget (${rateLimitRuleId})`,
|
|
3654
|
-
newState: {
|
|
3655
|
-
...state,
|
|
3656
|
-
buckets: { ...state.buckets, [bucketKey]: nextBucket }
|
|
3657
|
-
}
|
|
3658
|
-
};
|
|
3659
|
-
} else {
|
|
3660
|
-
const nextBucket = { tokens, lastRefill: now2 };
|
|
3661
|
-
const exceedAction = rateLimit.action;
|
|
3662
|
-
return {
|
|
3663
|
-
decision: actionToDecision(exceedAction),
|
|
3664
|
-
action: exceedAction,
|
|
3665
|
-
ruleId: rateLimitRuleId,
|
|
3666
|
-
reason: `rate limit exceeded (${rateLimitRuleId}): ${tokens.toFixed(4)} tokens available, need 1`,
|
|
3667
|
-
newState: {
|
|
3668
|
-
...state,
|
|
3669
|
-
buckets: { ...state.buckets, [bucketKey]: nextBucket }
|
|
3670
|
-
}
|
|
3671
|
-
};
|
|
3672
|
-
}
|
|
3673
|
-
}
|
|
3674
3543
|
var DOMAIN2 = /^[a-z][a-z0-9-]*$/;
|
|
3675
3544
|
function permissionText(value, max = 4096) {
|
|
3676
3545
|
return typeof value === "string" && value.length > 0 && value.length <= max && !/[\u0000-\u001f\u007f]/.test(value);
|
|
@@ -3861,186 +3730,108 @@ function deserializePermissions(raw, options = {}) {
|
|
|
3861
3730
|
return { ok: false, reason: "invalid-state" };
|
|
3862
3731
|
}
|
|
3863
3732
|
}
|
|
3864
|
-
var
|
|
3865
|
-
var
|
|
3866
|
-
var
|
|
3867
|
-
var
|
|
3868
|
-
var
|
|
3869
|
-
var
|
|
3870
|
-
|
|
3871
|
-
|
|
3872
|
-
|
|
3873
|
-
|
|
3874
|
-
|
|
3875
|
-
|
|
3876
|
-
|
|
3877
|
-
|
|
3878
|
-
|
|
3879
|
-
|
|
3880
|
-
|
|
3881
|
-
|
|
3882
|
-
windowMs: DEFAULT_RATE_WINDOW_MS,
|
|
3883
|
-
action: DEFAULT_EXCEED_ACTION
|
|
3884
|
-
},
|
|
3885
|
-
unfocusedMultiplier: DEFAULT_UNFOCUSED_MULTIPLIER
|
|
3886
|
-
};
|
|
3887
|
-
}
|
|
3888
|
-
function createState2() {
|
|
3889
|
-
return { buckets: {}, bursts: {} };
|
|
3890
|
-
}
|
|
3891
|
-
function getNapplet(config, napplet) {
|
|
3892
|
-
const existing = config.napplets[napplet];
|
|
3893
|
-
if (existing) return existing;
|
|
3894
|
-
return { rateLimits: {} };
|
|
3895
|
-
}
|
|
3896
|
-
function setPolicy(config, napplet, policy) {
|
|
3897
|
-
const entry = getNapplet(config, napplet);
|
|
3898
|
-
return {
|
|
3899
|
-
...config,
|
|
3900
|
-
napplets: {
|
|
3901
|
-
...config.napplets,
|
|
3902
|
-
[napplet]: { ...entry, policy }
|
|
3903
|
-
}
|
|
3904
|
-
};
|
|
3905
|
-
}
|
|
3906
|
-
function setRateLimit(config, napplet, opClass, limit) {
|
|
3907
|
-
const entry = getNapplet(config, napplet);
|
|
3908
|
-
return {
|
|
3909
|
-
...config,
|
|
3910
|
-
napplets: {
|
|
3911
|
-
...config.napplets,
|
|
3912
|
-
[napplet]: {
|
|
3913
|
-
...entry,
|
|
3914
|
-
rateLimits: { ...entry.rateLimits, [opClass]: limit }
|
|
3915
|
-
}
|
|
3916
|
-
}
|
|
3917
|
-
};
|
|
3918
|
-
}
|
|
3919
|
-
function setGlobalRate(config, napplet, limit) {
|
|
3920
|
-
const entry = getNapplet(config, napplet);
|
|
3921
|
-
return {
|
|
3922
|
-
...config,
|
|
3923
|
-
napplets: {
|
|
3924
|
-
...config.napplets,
|
|
3925
|
-
[napplet]: { ...entry, globalRate: limit }
|
|
3926
|
-
}
|
|
3927
|
-
};
|
|
3928
|
-
}
|
|
3929
|
-
function setUnfocusedMultiplier(config, multiplier) {
|
|
3930
|
-
if (!Number.isFinite(multiplier) || multiplier <= 0) {
|
|
3931
|
-
throw new RangeError("unfocusedMultiplier must be a finite number above zero");
|
|
3932
|
-
}
|
|
3933
|
-
return { ...config, unfocusedMultiplier: multiplier };
|
|
3934
|
-
}
|
|
3935
|
-
function setBurstGuard(config, guard) {
|
|
3936
|
-
const { windowMs, maxOps, action } = guard;
|
|
3937
|
-
if (!Number.isFinite(windowMs) || windowMs < 0) {
|
|
3938
|
-
throw new RangeError("burstGuard.windowMs must be a finite number of zero or more");
|
|
3939
|
-
}
|
|
3940
|
-
if (!Number.isSafeInteger(maxOps) || maxOps < 0) {
|
|
3941
|
-
throw new RangeError("burstGuard.maxOps must be a non-negative safe integer");
|
|
3942
|
-
}
|
|
3943
|
-
if (!isValidAction(action)) {
|
|
3944
|
-
throw new RangeError("burstGuard.action must be 'flag', 'block' or 'ignore'");
|
|
3733
|
+
var DOMAIN22 = /^[a-z][a-z0-9-]*$/;
|
|
3734
|
+
var OPERATION = /^[a-z][a-z0-9-]*\.[A-Za-z0-9][A-Za-z0-9._-]*$/;
|
|
3735
|
+
var MAX_RULES = 512;
|
|
3736
|
+
var MAX_NAPPLETS = 256;
|
|
3737
|
+
var MAX_SUBJECT_LENGTH = 4096;
|
|
3738
|
+
var MAX_DOCUMENT_LENGTH = 512 * 1024;
|
|
3739
|
+
function isAction(value) {
|
|
3740
|
+
return value === "allow" || value === "ask" || value === "deny";
|
|
3741
|
+
}
|
|
3742
|
+
function actionMap(value, key) {
|
|
3743
|
+
if (value === void 0) return Object.freeze({});
|
|
3744
|
+
if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Invalid permission rule map");
|
|
3745
|
+
const entries = Object.entries(value);
|
|
3746
|
+
if (entries.length > MAX_RULES) throw new RangeError("Permission rule limit exceeded");
|
|
3747
|
+
const result2 = {};
|
|
3748
|
+
for (const [name, action] of entries) {
|
|
3749
|
+
if (!key.test(name) || name.length > 256 || !isAction(action)) throw new TypeError("Invalid permission rule");
|
|
3750
|
+
result2[name] = action;
|
|
3945
3751
|
}
|
|
3946
|
-
return
|
|
3947
|
-
}
|
|
3948
|
-
function addMatcher(config, matcher) {
|
|
3949
|
-
return { ...config, matchers: [...config.matchers, matcher] };
|
|
3752
|
+
return Object.freeze(result2);
|
|
3950
3753
|
}
|
|
3951
|
-
function
|
|
3952
|
-
|
|
3953
|
-
|
|
3954
|
-
|
|
3955
|
-
|
|
3956
|
-
|
|
3957
|
-
|
|
3958
|
-
|
|
3959
|
-
|
|
3960
|
-
const r = v;
|
|
3961
|
-
return typeof r["capacity"] === "number" && isFinite(r["capacity"]) && typeof r["windowMs"] === "number" && isFinite(r["windowMs"]) && isValidAction(r["action"]);
|
|
3962
|
-
}
|
|
3963
|
-
function isValidBurstGuard(v) {
|
|
3964
|
-
if (typeof v !== "object" || v === null) return false;
|
|
3965
|
-
const b = v;
|
|
3966
|
-
return typeof b["windowMs"] === "number" && isFinite(b["windowMs"]) && typeof b["maxOps"] === "number" && isFinite(b["maxOps"]) && isValidAction(b["action"]);
|
|
3754
|
+
function scopeSnapshot(value) {
|
|
3755
|
+
if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Invalid napplet permission rules");
|
|
3756
|
+
const scope = value;
|
|
3757
|
+
if (scope.default !== void 0 && !isAction(scope.default)) throw new TypeError("Invalid permission rule");
|
|
3758
|
+
return Object.freeze({
|
|
3759
|
+
...scope.default !== void 0 ? { default: scope.default } : {},
|
|
3760
|
+
domains: actionMap(scope.domains, DOMAIN22),
|
|
3761
|
+
operations: actionMap(scope.operations, OPERATION)
|
|
3762
|
+
});
|
|
3967
3763
|
}
|
|
3968
|
-
function
|
|
3969
|
-
|
|
3970
|
-
const m = v;
|
|
3971
|
-
if (typeof m["id"] !== "string") return false;
|
|
3972
|
-
if (!isValidAction(m["action"])) return false;
|
|
3973
|
-
if ("opClass" in m && typeof m["opClass"] !== "string") return false;
|
|
3974
|
-
if ("minSize" in m && typeof m["minSize"] !== "number") return false;
|
|
3975
|
-
if ("focused" in m && typeof m["focused"] !== "boolean") return false;
|
|
3976
|
-
if ("maxMsSinceFocusGain" in m && typeof m["maxMsSinceFocusGain"] !== "number") return false;
|
|
3977
|
-
if ("kinds" in m) {
|
|
3978
|
-
if (!Array.isArray(m["kinds"])) return false;
|
|
3979
|
-
if (!m["kinds"].every((k) => typeof k === "number")) return false;
|
|
3980
|
-
}
|
|
3981
|
-
return true;
|
|
3764
|
+
function subjectText(value) {
|
|
3765
|
+
return value.length > 0 && value.length <= MAX_SUBJECT_LENGTH && !/[\u0000-\u001f\u007f]/.test(value);
|
|
3982
3766
|
}
|
|
3983
|
-
function
|
|
3984
|
-
if (
|
|
3985
|
-
const
|
|
3986
|
-
|
|
3987
|
-
|
|
3988
|
-
|
|
3767
|
+
function createPermissionRules(init = {}) {
|
|
3768
|
+
if (init.default !== void 0 && !isAction(init.default)) throw new TypeError("Invalid permission rule");
|
|
3769
|
+
const napplets = {};
|
|
3770
|
+
const entries = Object.entries(init.napplets ?? {});
|
|
3771
|
+
if (entries.length > MAX_NAPPLETS) throw new RangeError("Permission rule limit exceeded");
|
|
3772
|
+
for (const [subject, scope] of entries) {
|
|
3773
|
+
if (!subjectText(subject)) throw new TypeError("Invalid permission rule subject");
|
|
3774
|
+
const snapshot22 = scopeSnapshot(scope);
|
|
3775
|
+
const empty = snapshot22.default === void 0 && !Object.keys(snapshot22.domains).length && !Object.keys(snapshot22.operations).length;
|
|
3776
|
+
if (!empty) napplets[subject] = snapshot22;
|
|
3989
3777
|
}
|
|
3990
|
-
|
|
3991
|
-
|
|
3992
|
-
|
|
3993
|
-
|
|
3994
|
-
|
|
3995
|
-
|
|
3778
|
+
return Object.freeze({
|
|
3779
|
+
version: 1,
|
|
3780
|
+
default: init.default ?? "ask",
|
|
3781
|
+
domains: actionMap(init.domains, DOMAIN22),
|
|
3782
|
+
operations: actionMap(init.operations, OPERATION),
|
|
3783
|
+
napplets: Object.freeze(napplets)
|
|
3784
|
+
});
|
|
3996
3785
|
}
|
|
3997
|
-
function
|
|
3786
|
+
function permissionRuleSubject(principal) {
|
|
3787
|
+
return principal.kind === "verified" ? principal.manifestKey : `development:${principal.target}`;
|
|
3788
|
+
}
|
|
3789
|
+
function resolvePermissionRule(rules, principal, requirement) {
|
|
3790
|
+
const operation = requirement.category === "interface" ? void 0 : requirement.operation;
|
|
3791
|
+
const napplet = rules.napplets[permissionRuleSubject(principal)];
|
|
3792
|
+
const pick = (scope) => {
|
|
3793
|
+
if (!scope) return void 0;
|
|
3794
|
+
const byOperation = operation !== void 0 && Object.hasOwn(scope.operations, operation) ? scope.operations[operation] : void 0;
|
|
3795
|
+
const byDomain = Object.hasOwn(scope.domains, requirement.domain) ? scope.domains[requirement.domain] : void 0;
|
|
3796
|
+
return byOperation ?? byDomain ?? scope.default;
|
|
3797
|
+
};
|
|
3798
|
+
return pick(napplet) ?? pick(rules) ?? rules.default;
|
|
3799
|
+
}
|
|
3800
|
+
function withEntry(map, key, action) {
|
|
3801
|
+
const next = { ...map };
|
|
3802
|
+
if (action === void 0) delete next[key];
|
|
3803
|
+
else next[key] = action;
|
|
3804
|
+
return next;
|
|
3805
|
+
}
|
|
3806
|
+
function setPermissionRule(rules, target, action) {
|
|
3807
|
+
if (target.domain !== void 0 && target.operation !== void 0) throw new TypeError("A rule targets a domain or an operation, not both");
|
|
3808
|
+
const apply = (scope) => {
|
|
3809
|
+
if (target.operation !== void 0) return { ...scope, operations: withEntry(scope.operations, target.operation, action) };
|
|
3810
|
+
if (target.domain !== void 0) return { ...scope, domains: withEntry(scope.domains, target.domain, action) };
|
|
3811
|
+
const { default: _removed, ...rest } = scope;
|
|
3812
|
+
return action === void 0 ? rest : { ...rest, default: action };
|
|
3813
|
+
};
|
|
3814
|
+
if (target.napplet === void 0) return createPermissionRules(apply(rules));
|
|
3815
|
+
const current = rules.napplets[target.napplet] ?? { domains: {}, operations: {} };
|
|
3816
|
+
return createPermissionRules({ ...rules, napplets: { ...rules.napplets, [target.napplet]: apply(current) } });
|
|
3817
|
+
}
|
|
3818
|
+
function serializePermissionRules(rules) {
|
|
3819
|
+
return JSON.stringify(createPermissionRules(rules));
|
|
3820
|
+
}
|
|
3821
|
+
function deserializePermissionRules(raw) {
|
|
3998
3822
|
try {
|
|
3999
|
-
|
|
4000
|
-
|
|
4001
|
-
|
|
4002
|
-
}
|
|
4003
|
-
|
|
4004
|
-
|
|
4005
|
-
if (!isValidNappletRules(value)) return defaultConfig();
|
|
4006
|
-
const raw = value;
|
|
4007
|
-
const rateLimits = {};
|
|
4008
|
-
for (const [opClass, limit] of Object.entries(raw.rateLimits)) {
|
|
4009
|
-
rateLimits[opClass] = limit;
|
|
4010
|
-
}
|
|
4011
|
-
const entry = { rateLimits };
|
|
4012
|
-
const withPolicy = raw.policy !== void 0 ? { ...entry, policy: raw.policy } : entry;
|
|
4013
|
-
const withGlobalRate = raw.globalRate !== void 0 ? { ...withPolicy, globalRate: raw.globalRate } : withPolicy;
|
|
4014
|
-
napplets[key] = withGlobalRate;
|
|
4015
|
-
}
|
|
4016
|
-
const matchers = [];
|
|
4017
|
-
for (const item of parsed.matchers) {
|
|
4018
|
-
if (!isValidContentMatcher(item)) return defaultConfig();
|
|
4019
|
-
matchers.push(item);
|
|
4020
|
-
}
|
|
4021
|
-
const bg = parsed.burstGuard;
|
|
4022
|
-
const dr = parsed.defaultRate;
|
|
4023
|
-
return {
|
|
4024
|
-
napplets,
|
|
4025
|
-
matchers,
|
|
4026
|
-
burstGuard: {
|
|
4027
|
-
windowMs: bg["windowMs"],
|
|
4028
|
-
maxOps: bg["maxOps"],
|
|
4029
|
-
action: bg["action"]
|
|
4030
|
-
},
|
|
4031
|
-
defaultRate: {
|
|
4032
|
-
capacity: dr["capacity"],
|
|
4033
|
-
windowMs: dr["windowMs"],
|
|
4034
|
-
action: dr["action"]
|
|
4035
|
-
},
|
|
4036
|
-
unfocusedMultiplier: parsed.unfocusedMultiplier
|
|
4037
|
-
};
|
|
3823
|
+
if (raw.length > MAX_DOCUMENT_LENGTH) return { ok: false, reason: "invalid-rules" };
|
|
3824
|
+
const parsed = JSON.parse(raw);
|
|
3825
|
+
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return { ok: false, reason: "invalid-rules" };
|
|
3826
|
+
if (parsed.version !== 1) return { ok: false, reason: "unsupported-version" };
|
|
3827
|
+
if (!isAction(parsed.default)) return { ok: false, reason: "invalid-rules" };
|
|
3828
|
+
return { ok: true, rules: createPermissionRules(parsed) };
|
|
4038
3829
|
} catch {
|
|
3830
|
+
return { ok: false, reason: "invalid-rules" };
|
|
4039
3831
|
}
|
|
4040
|
-
return defaultConfig();
|
|
4041
3832
|
}
|
|
4042
3833
|
|
|
4043
|
-
// ../../node_modules/.pnpm/@napplet+core@0.
|
|
3834
|
+
// ../../node_modules/.pnpm/@napplet+core@0.41.0/node_modules/@napplet/core/dist/index.js
|
|
4044
3835
|
var NAP_IMPLEMENTATIONS = {
|
|
4045
3836
|
shell: {
|
|
4046
3837
|
proposal: { url: "https://github.com/napplet/naps/pull/101", status: "merged", checkedAt: "2026-10-31" },
|
|
@@ -4552,142 +4343,168 @@ function createAclState(persistence, defaultPolicy = "permissive", onMutation, p
|
|
|
4552
4343
|
}
|
|
4553
4344
|
};
|
|
4554
4345
|
}
|
|
4555
|
-
|
|
4556
|
-
|
|
4557
|
-
|
|
4558
|
-
const
|
|
4559
|
-
|
|
4560
|
-
|
|
4561
|
-
}
|
|
4562
|
-
|
|
4563
|
-
|
|
4564
|
-
|
|
4565
|
-
|
|
4566
|
-
|
|
4567
|
-
|
|
4568
|
-
|
|
4569
|
-
|
|
4570
|
-
|
|
4571
|
-
|
|
4572
|
-
|
|
4573
|
-
|
|
4574
|
-
|
|
4575
|
-
|
|
4576
|
-
|
|
4577
|
-
|
|
4578
|
-
|
|
4579
|
-
}
|
|
4580
|
-
|
|
4581
|
-
|
|
4582
|
-
}
|
|
4583
|
-
|
|
4584
|
-
|
|
4585
|
-
}
|
|
4586
|
-
|
|
4587
|
-
|
|
4588
|
-
|
|
4589
|
-
|
|
4590
|
-
|
|
4591
|
-
|
|
4592
|
-
|
|
4593
|
-
|
|
4594
|
-
|
|
4595
|
-
|
|
4346
|
+
var DEFAULT_RULE_GRANT_PREFIX = "rule:";
|
|
4347
|
+
function createApprovalCoordinator(options) {
|
|
4348
|
+
const maxPending = options.maxPending ?? 64;
|
|
4349
|
+
const timeoutMs = options.timeoutMs ?? 6e4;
|
|
4350
|
+
if (!Number.isSafeInteger(maxPending) || maxPending < 1 || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2147483647) {
|
|
4351
|
+
throw new RangeError("Invalid approval queue limits");
|
|
4352
|
+
}
|
|
4353
|
+
const pending = /* @__PURE__ */ new Set();
|
|
4354
|
+
const groups = /* @__PURE__ */ new Map();
|
|
4355
|
+
let reserved = 0;
|
|
4356
|
+
let disposed = false;
|
|
4357
|
+
function cancel(sessionId) {
|
|
4358
|
+
for (const entry of pending) {
|
|
4359
|
+
if (sessionId === void 0 || entry.sessionId === sessionId) entry.controller.abort();
|
|
4360
|
+
}
|
|
4361
|
+
}
|
|
4362
|
+
function snapshot4(principal, sessionId, requirements3) {
|
|
4363
|
+
const request = {
|
|
4364
|
+
principal: Object.freeze({ ...principal }),
|
|
4365
|
+
sessionId,
|
|
4366
|
+
requestId: options.createId(),
|
|
4367
|
+
requirements: requirements3
|
|
4368
|
+
};
|
|
4369
|
+
const normalized = evaluatePermissions(createPermissionState(), request, options).missing;
|
|
4370
|
+
return Object.freeze({ ...request, requirements: normalized });
|
|
4371
|
+
}
|
|
4372
|
+
async function approve(request, entry, current, allowLifetimes) {
|
|
4373
|
+
if (!current()) return { status: "cancelled" };
|
|
4374
|
+
const state = options.getState();
|
|
4375
|
+
const decision = evaluatePermissions(state, request, options);
|
|
4376
|
+
if (decision.decision === "deny") return { status: "denied" };
|
|
4377
|
+
if (decision.decision === "allow") return void 0;
|
|
4378
|
+
let preset = "ask";
|
|
4379
|
+
try {
|
|
4380
|
+
preset = options.defaultDecision?.(request, decision.missing) ?? "ask";
|
|
4381
|
+
} catch {
|
|
4382
|
+
preset = "ask";
|
|
4383
|
+
}
|
|
4384
|
+
if (preset === "deny") return { status: "denied" };
|
|
4385
|
+
const byRule = preset === "allow" && allowLifetimes.includes("session");
|
|
4386
|
+
let answer;
|
|
4387
|
+
if (byRule) {
|
|
4388
|
+
answer = { effect: "allow", lifetime: "session" };
|
|
4389
|
+
} else {
|
|
4390
|
+
if (!options.prompt) return { status: "unavailable" };
|
|
4596
4391
|
try {
|
|
4597
|
-
|
|
4392
|
+
if (options.beforePrompt && !options.beforePrompt(request)) return { status: "busy" };
|
|
4598
4393
|
} catch {
|
|
4394
|
+
return { status: "unavailable" };
|
|
4599
4395
|
}
|
|
4600
|
-
},
|
|
4601
|
-
load() {
|
|
4602
4396
|
try {
|
|
4603
|
-
|
|
4604
|
-
if (!raw) return;
|
|
4605
|
-
config = deserialize2(raw);
|
|
4397
|
+
answer = await options.prompt(Object.freeze({ request, missing: decision.missing, signal: entry.controller.signal, allowLifetimes }));
|
|
4606
4398
|
} catch {
|
|
4607
|
-
|
|
4399
|
+
return { status: current() ? "unavailable" : "cancelled" };
|
|
4608
4400
|
}
|
|
4609
|
-
}
|
|
4610
|
-
|
|
4611
|
-
|
|
4612
|
-
|
|
4401
|
+
}
|
|
4402
|
+
if (!current()) return { status: "cancelled" };
|
|
4403
|
+
if (answer?.effect === "cancel") return { status: "cancelled" };
|
|
4404
|
+
const latest = options.getState();
|
|
4405
|
+
const rechecked = evaluatePermissions(latest, request, options);
|
|
4406
|
+
if (rechecked.decision === "deny") return { status: "denied" };
|
|
4407
|
+
const shown = new Set(decision.missing.map((requirement) => JSON.stringify(requirement)));
|
|
4408
|
+
if (rechecked.missing.some((requirement) => !shown.has(JSON.stringify(requirement)))) return { status: "cancelled" };
|
|
4409
|
+
if (!answer || answer.effect !== "allow" && answer.effect !== "deny" || !["once", "session", "persistent"].includes(answer.lifetime)) return { status: "unavailable" };
|
|
4410
|
+
if (answer.effect === "allow" && !allowLifetimes.includes(answer.lifetime)) return { status: "unavailable" };
|
|
4411
|
+
if (answer.effect === "deny" && answer.lifetime === "once") return { status: "denied" };
|
|
4412
|
+
try {
|
|
4413
|
+
let next = latest;
|
|
4414
|
+
for (const [index, permission] of decision.missing.entries()) {
|
|
4415
|
+
next = putPermissionGrant(next, {
|
|
4416
|
+
id: `${byRule ? DEFAULT_RULE_GRANT_PREFIX : ""}${request.requestId}-${index}`,
|
|
4417
|
+
principal: request.principal,
|
|
4418
|
+
permission,
|
|
4419
|
+
effect: answer.effect,
|
|
4420
|
+
lifetime: answer.lifetime,
|
|
4421
|
+
...answer.lifetime !== "persistent" ? { sessionId: request.sessionId } : {},
|
|
4422
|
+
...answer.lifetime === "once" ? { requestId: request.requestId } : {}
|
|
4423
|
+
}, options);
|
|
4424
|
+
}
|
|
4425
|
+
options.commit(next);
|
|
4426
|
+
} catch {
|
|
4427
|
+
return { status: "unavailable" };
|
|
4428
|
+
}
|
|
4429
|
+
return answer.effect === "deny" ? { status: "denied" } : void 0;
|
|
4430
|
+
}
|
|
4431
|
+
function run(principal, sessionId, requirements3, isCurrent, execute, lifetimes = ["once", "session", "persistent"], signal) {
|
|
4432
|
+
if (disposed || signal?.aborted) return Promise.resolve({ status: "cancelled" });
|
|
4433
|
+
if (reserved >= maxPending) return Promise.resolve({ status: "busy" });
|
|
4434
|
+
let request;
|
|
4435
|
+
try {
|
|
4436
|
+
request = snapshot4(principal, sessionId, requirements3);
|
|
4437
|
+
} catch {
|
|
4438
|
+
return Promise.resolve({ status: "denied" });
|
|
4439
|
+
}
|
|
4440
|
+
const allowLifetimes = Object.freeze(lifetimes.filter((lifetime) => principal.kind === "verified" || lifetime !== "persistent"));
|
|
4441
|
+
const controller = options.createCancellation();
|
|
4442
|
+
const entry = { sessionId, controller };
|
|
4443
|
+
pending.add(entry);
|
|
4444
|
+
reserved++;
|
|
4445
|
+
const current = () => !controller.signal.aborted && !disposed && isCurrent();
|
|
4446
|
+
const key = JSON.stringify([
|
|
4447
|
+
permissionPrincipalKey(request.principal),
|
|
4448
|
+
sessionId,
|
|
4449
|
+
request.requirements.map((item) => JSON.stringify(item)).sort()
|
|
4450
|
+
]);
|
|
4451
|
+
const previous = groups.get(key) ?? Promise.resolve();
|
|
4452
|
+
let clearDeadline;
|
|
4453
|
+
let onAbort;
|
|
4454
|
+
const cancelled3 = new Promise((resolve) => {
|
|
4455
|
+
onAbort = () => resolve({ status: "cancelled" });
|
|
4456
|
+
controller.signal.addEventListener("abort", onAbort, { once: true });
|
|
4457
|
+
clearDeadline = options.schedule(() => controller.abort(), timeoutMs);
|
|
4458
|
+
});
|
|
4459
|
+
const abortRequest = () => controller.abort();
|
|
4460
|
+
signal?.addEventListener("abort", abortRequest, { once: true });
|
|
4461
|
+
if (signal?.aborted) abortRequest();
|
|
4462
|
+
const operation = previous.then(async () => {
|
|
4463
|
+
const failure4 = await approve(request, entry, current, allowLifetimes);
|
|
4464
|
+
if (failure4) return failure4;
|
|
4465
|
+
if (!current()) return { status: "cancelled" };
|
|
4466
|
+
const state = options.getState();
|
|
4467
|
+
const consumed = consumePermissionGrants(state, request, options);
|
|
4468
|
+
if (consumed.decision.decision !== "allow") return { status: "denied" };
|
|
4613
4469
|
try {
|
|
4614
|
-
|
|
4470
|
+
if (consumed.state.grants.length !== state.grants.length) options.commit(consumed.state);
|
|
4615
4471
|
} catch {
|
|
4472
|
+
return { status: "unavailable" };
|
|
4616
4473
|
}
|
|
4617
|
-
|
|
4618
|
-
|
|
4619
|
-
|
|
4620
|
-
|
|
4621
|
-
|
|
4622
|
-
|
|
4623
|
-
|
|
4624
|
-
|
|
4625
|
-
|
|
4626
|
-
|
|
4627
|
-
|
|
4628
|
-
|
|
4629
|
-
|
|
4474
|
+
if (!current()) return { status: "cancelled" };
|
|
4475
|
+
const spent = state.grants.filter((grant2) => grant2.lifetime === "once" && consumed.decision.grantIds.includes(grant2.id));
|
|
4476
|
+
const value = await execute(controller.signal);
|
|
4477
|
+
if (!current()) return { status: "cancelled" };
|
|
4478
|
+
const latest = options.getState();
|
|
4479
|
+
const continuation = evaluatePermissions({ version: 1, grants: [...latest.grants, ...spent] }, request, options);
|
|
4480
|
+
return continuation.decision === "allow" ? { status: "executed", value } : { status: "cancelled" };
|
|
4481
|
+
});
|
|
4482
|
+
const settled = Promise.race([operation, cancelled3]).finally(() => {
|
|
4483
|
+
clearDeadline();
|
|
4484
|
+
controller.signal.removeEventListener("abort", onAbort);
|
|
4485
|
+
signal?.removeEventListener("abort", abortRequest);
|
|
4486
|
+
pending.delete(entry);
|
|
4487
|
+
});
|
|
4488
|
+
const completed2 = settled.then(() => void 0, () => void 0);
|
|
4489
|
+
const tail = previous.then(() => completed2).finally(() => {
|
|
4490
|
+
reserved--;
|
|
4491
|
+
if (groups.get(key) === tail) groups.delete(key);
|
|
4492
|
+
});
|
|
4493
|
+
groups.set(key, tail);
|
|
4494
|
+
return settled;
|
|
4495
|
+
}
|
|
4630
4496
|
return {
|
|
4631
|
-
|
|
4632
|
-
|
|
4633
|
-
|
|
4634
|
-
|
|
4635
|
-
|
|
4497
|
+
run,
|
|
4498
|
+
cancel,
|
|
4499
|
+
dispose() {
|
|
4500
|
+
disposed = true;
|
|
4501
|
+
cancel();
|
|
4502
|
+
},
|
|
4503
|
+
get pendingCount() {
|
|
4504
|
+
return pending.size;
|
|
4505
|
+
}
|
|
4636
4506
|
};
|
|
4637
4507
|
}
|
|
4638
|
-
function createRateLimitState() {
|
|
4639
|
-
return { buckets: {}, bursts: {} };
|
|
4640
|
-
}
|
|
4641
|
-
function positive(value) {
|
|
4642
|
-
return Number.isFinite(value) && value > 0;
|
|
4643
|
-
}
|
|
4644
|
-
function validAction(value) {
|
|
4645
|
-
return value === "flag" || value === "block" || value === "ignore";
|
|
4646
|
-
}
|
|
4647
|
-
function assertRateLimitConfig(config) {
|
|
4648
|
-
const { burst } = config;
|
|
4649
|
-
if (!positive(config.capacity) || !positive(config.windowMs) || !positive(config.unfocusedMultiplier) || !Number.isFinite(burst.windowMs) || burst.windowMs < 0 || !Number.isSafeInteger(burst.maxOperations) || burst.maxOperations < 0 || !validAction(config.action) || !validAction(burst.action)) {
|
|
4650
|
-
throw new RangeError("Rate limits require finite budgets in range and valid actions");
|
|
4651
|
-
}
|
|
4652
|
-
}
|
|
4653
|
-
function validate(config, observation) {
|
|
4654
|
-
assertRateLimitConfig(config);
|
|
4655
|
-
if (!observation.subject || !observation.operation || !observation.lifecycle || !Number.isFinite(observation.now) || !Number.isFinite(observation.elapsedSinceStartMs) || observation.elapsedSinceStartMs < 0 || typeof observation.focused !== "boolean") {
|
|
4656
|
-
throw new RangeError("Rate observations require a subject, operation, lifecycle and finite clock");
|
|
4657
|
-
}
|
|
4658
|
-
}
|
|
4659
|
-
function verdict(state, reason, action) {
|
|
4660
|
-
return { allowed: action !== "block", action, reason, state };
|
|
4661
|
-
}
|
|
4662
|
-
function evaluateRateLimit(config, state, observation) {
|
|
4663
|
-
validate(config, observation);
|
|
4664
|
-
const { subject, operation, lifecycle, now: now2 } = observation;
|
|
4665
|
-
if (observation.elapsedSinceStartMs < config.burst.windowMs) {
|
|
4666
|
-
const key2 = JSON.stringify([subject, lifecycle]);
|
|
4667
|
-
const previous2 = state.bursts[key2];
|
|
4668
|
-
const active = previous2 && now2 - previous2.startedAt < config.burst.windowMs ? previous2 : void 0;
|
|
4669
|
-
const burst = { count: (active?.count ?? 0) + 1, startedAt: active?.startedAt ?? now2 };
|
|
4670
|
-
state = { ...state, bursts: { ...state.bursts, [key2]: burst } };
|
|
4671
|
-
if (burst.count > config.burst.maxOperations) return verdict(state, "burst-exceeded", config.burst.action);
|
|
4672
|
-
}
|
|
4673
|
-
const key = JSON.stringify([subject, operation]);
|
|
4674
|
-
const capacity = config.capacity * (observation.focused ? 1 : config.unfocusedMultiplier);
|
|
4675
|
-
const previous = state.buckets[key];
|
|
4676
|
-
const updatedAt = Math.max(now2, previous?.updatedAt ?? now2);
|
|
4677
|
-
const elapsed = updatedAt - (previous?.updatedAt ?? updatedAt);
|
|
4678
|
-
const tokens = Math.min(capacity, (previous?.tokens ?? capacity) + elapsed * (capacity / config.windowMs));
|
|
4679
|
-
const exceeded = tokens < 1;
|
|
4680
|
-
const bucket = { tokens: exceeded ? tokens : tokens - 1, updatedAt };
|
|
4681
|
-
state = { ...state, buckets: { ...state.buckets, [key]: bucket } };
|
|
4682
|
-
return verdict(state, exceeded ? "rate-exceeded" : "within-budget", exceeded ? config.action : "ignore");
|
|
4683
|
-
}
|
|
4684
|
-
function retireRateLimitLifecycle(state, subject, lifecycle) {
|
|
4685
|
-
const key = JSON.stringify([subject, lifecycle]);
|
|
4686
|
-
if (!Object.hasOwn(state.bursts, key)) return state;
|
|
4687
|
-
const bursts = { ...state.bursts };
|
|
4688
|
-
delete bursts[key];
|
|
4689
|
-
return { ...state, bursts };
|
|
4690
|
-
}
|
|
4691
4508
|
function createManifestCache(persistence) {
|
|
4692
4509
|
const cache2 = /* @__PURE__ */ new Map();
|
|
4693
4510
|
const verificationCache = /* @__PURE__ */ new Map();
|
|
@@ -5191,13 +5008,14 @@ function createLegacyIgnoredWarning() {
|
|
|
5191
5008
|
return () => {
|
|
5192
5009
|
if (warned2) return;
|
|
5193
5010
|
warned2 = true;
|
|
5194
|
-
console.warn("FW-RUNTIME-LEGACY-IGNORED-001: onFirewallEvent
|
|
5011
|
+
console.warn("FW-RUNTIME-LEGACY-IGNORED-001: onFirewallEvent and legacyFirewall have no effect when RuntimeAdapter.permissions is configured; use permissions.onRateLimit, permissions.persistence and an explicit permissions.rateLimiter instead (warns once per runtime instance).");
|
|
5195
5012
|
};
|
|
5196
5013
|
}
|
|
5197
5014
|
function createFirewallGate(config) {
|
|
5198
5015
|
const { firewallState, sessionRegistry: sessionRegistry2, hooks, fireConsent } = config;
|
|
5199
5016
|
let warned2 = false;
|
|
5200
5017
|
return function firewallGate(windowId, envelope, senderCap, respond = true) {
|
|
5018
|
+
if (!firewallState) return "dispatch";
|
|
5201
5019
|
if (!warned2) {
|
|
5202
5020
|
warned2 = true;
|
|
5203
5021
|
console.warn("FW-RUNTIME-LEGACY-GATE-001: the legacy temporal Firewall gate is active; configure RuntimeAdapter.permissions for scoped Firewall approvals and independent rate limits (warns once per runtime instance; retained through the next minor release).");
|
|
@@ -5266,155 +5084,6 @@ function createDenialResponse(envelope, error) {
|
|
|
5266
5084
|
const type = denialResponseType(envelope);
|
|
5267
5085
|
return type ? { type, id, error } : null;
|
|
5268
5086
|
}
|
|
5269
|
-
function createApprovalCoordinator(options) {
|
|
5270
|
-
const maxPending = options.maxPending ?? 64;
|
|
5271
|
-
const timeoutMs = options.timeoutMs ?? 6e4;
|
|
5272
|
-
if (!Number.isSafeInteger(maxPending) || maxPending < 1 || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2147483647) {
|
|
5273
|
-
throw new RangeError("Invalid approval queue limits");
|
|
5274
|
-
}
|
|
5275
|
-
const pending = /* @__PURE__ */ new Set();
|
|
5276
|
-
const groups = /* @__PURE__ */ new Map();
|
|
5277
|
-
let reserved = 0;
|
|
5278
|
-
let disposed = false;
|
|
5279
|
-
function cancel(sessionId) {
|
|
5280
|
-
for (const entry of pending) {
|
|
5281
|
-
if (sessionId === void 0 || entry.sessionId === sessionId) entry.controller.abort();
|
|
5282
|
-
}
|
|
5283
|
-
}
|
|
5284
|
-
function snapshot3(principal, sessionId, requirements3) {
|
|
5285
|
-
const request = {
|
|
5286
|
-
principal: Object.freeze({ ...principal }),
|
|
5287
|
-
sessionId,
|
|
5288
|
-
requestId: options.createId(),
|
|
5289
|
-
requirements: requirements3
|
|
5290
|
-
};
|
|
5291
|
-
const normalized = evaluatePermissions(createPermissionState(), request, options).missing;
|
|
5292
|
-
return Object.freeze({ ...request, requirements: normalized });
|
|
5293
|
-
}
|
|
5294
|
-
async function approve(request, entry, current, allowLifetimes) {
|
|
5295
|
-
if (!current()) return { status: "cancelled" };
|
|
5296
|
-
const state = options.getState();
|
|
5297
|
-
const decision = evaluatePermissions(state, request, options);
|
|
5298
|
-
if (decision.decision === "deny") return { status: "denied" };
|
|
5299
|
-
if (decision.decision === "allow") return void 0;
|
|
5300
|
-
if (!options.prompt) return { status: "unavailable" };
|
|
5301
|
-
try {
|
|
5302
|
-
if (options.beforePrompt && !options.beforePrompt(request)) return { status: "busy" };
|
|
5303
|
-
} catch {
|
|
5304
|
-
return { status: "unavailable" };
|
|
5305
|
-
}
|
|
5306
|
-
let answer;
|
|
5307
|
-
try {
|
|
5308
|
-
answer = await options.prompt(Object.freeze({ request, missing: decision.missing, signal: entry.controller.signal, allowLifetimes }));
|
|
5309
|
-
} catch {
|
|
5310
|
-
return { status: current() ? "unavailable" : "cancelled" };
|
|
5311
|
-
}
|
|
5312
|
-
if (!current()) return { status: "cancelled" };
|
|
5313
|
-
if (answer?.effect === "cancel") return { status: "cancelled" };
|
|
5314
|
-
const latest = options.getState();
|
|
5315
|
-
const rechecked = evaluatePermissions(latest, request, options);
|
|
5316
|
-
if (rechecked.decision === "deny") return { status: "denied" };
|
|
5317
|
-
const shown = new Set(decision.missing.map((requirement) => JSON.stringify(requirement)));
|
|
5318
|
-
if (rechecked.missing.some((requirement) => !shown.has(JSON.stringify(requirement)))) return { status: "cancelled" };
|
|
5319
|
-
if (!answer || answer.effect !== "allow" && answer.effect !== "deny" || !["once", "session", "persistent"].includes(answer.lifetime)) return { status: "unavailable" };
|
|
5320
|
-
if (answer.effect === "allow" && !allowLifetimes.includes(answer.lifetime)) return { status: "unavailable" };
|
|
5321
|
-
if (answer.effect === "deny" && answer.lifetime === "once") return { status: "denied" };
|
|
5322
|
-
try {
|
|
5323
|
-
let next = latest;
|
|
5324
|
-
for (const [index, permission] of decision.missing.entries()) {
|
|
5325
|
-
next = putPermissionGrant(next, {
|
|
5326
|
-
id: `${request.requestId}-${index}`,
|
|
5327
|
-
principal: request.principal,
|
|
5328
|
-
permission,
|
|
5329
|
-
effect: answer.effect,
|
|
5330
|
-
lifetime: answer.lifetime,
|
|
5331
|
-
...answer.lifetime !== "persistent" ? { sessionId: request.sessionId } : {},
|
|
5332
|
-
...answer.lifetime === "once" ? { requestId: request.requestId } : {}
|
|
5333
|
-
}, options);
|
|
5334
|
-
}
|
|
5335
|
-
options.commit(next);
|
|
5336
|
-
} catch {
|
|
5337
|
-
return { status: "unavailable" };
|
|
5338
|
-
}
|
|
5339
|
-
return answer.effect === "deny" ? { status: "denied" } : void 0;
|
|
5340
|
-
}
|
|
5341
|
-
function run(principal, sessionId, requirements3, isCurrent, execute, lifetimes = ["once", "session", "persistent"], signal) {
|
|
5342
|
-
if (disposed || signal?.aborted) return Promise.resolve({ status: "cancelled" });
|
|
5343
|
-
if (reserved >= maxPending) return Promise.resolve({ status: "busy" });
|
|
5344
|
-
let request;
|
|
5345
|
-
try {
|
|
5346
|
-
request = snapshot3(principal, sessionId, requirements3);
|
|
5347
|
-
} catch {
|
|
5348
|
-
return Promise.resolve({ status: "denied" });
|
|
5349
|
-
}
|
|
5350
|
-
const allowLifetimes = Object.freeze(lifetimes.filter((lifetime) => principal.kind === "verified" || lifetime !== "persistent"));
|
|
5351
|
-
const controller = options.createCancellation();
|
|
5352
|
-
const entry = { sessionId, controller };
|
|
5353
|
-
pending.add(entry);
|
|
5354
|
-
reserved++;
|
|
5355
|
-
const current = () => !controller.signal.aborted && !disposed && isCurrent();
|
|
5356
|
-
const key = JSON.stringify([
|
|
5357
|
-
permissionPrincipalKey(request.principal),
|
|
5358
|
-
sessionId,
|
|
5359
|
-
request.requirements.map((item) => JSON.stringify(item)).sort()
|
|
5360
|
-
]);
|
|
5361
|
-
const previous = groups.get(key) ?? Promise.resolve();
|
|
5362
|
-
let clearDeadline;
|
|
5363
|
-
let onAbort;
|
|
5364
|
-
const cancelled3 = new Promise((resolve) => {
|
|
5365
|
-
onAbort = () => resolve({ status: "cancelled" });
|
|
5366
|
-
controller.signal.addEventListener("abort", onAbort, { once: true });
|
|
5367
|
-
clearDeadline = options.schedule(() => controller.abort(), timeoutMs);
|
|
5368
|
-
});
|
|
5369
|
-
const abortRequest = () => controller.abort();
|
|
5370
|
-
signal?.addEventListener("abort", abortRequest, { once: true });
|
|
5371
|
-
if (signal?.aborted) abortRequest();
|
|
5372
|
-
const operation = previous.then(async () => {
|
|
5373
|
-
const failure4 = await approve(request, entry, current, allowLifetimes);
|
|
5374
|
-
if (failure4) return failure4;
|
|
5375
|
-
if (!current()) return { status: "cancelled" };
|
|
5376
|
-
const state = options.getState();
|
|
5377
|
-
const consumed = consumePermissionGrants(state, request, options);
|
|
5378
|
-
if (consumed.decision.decision !== "allow") return { status: "denied" };
|
|
5379
|
-
try {
|
|
5380
|
-
if (consumed.state.grants.length !== state.grants.length) options.commit(consumed.state);
|
|
5381
|
-
} catch {
|
|
5382
|
-
return { status: "unavailable" };
|
|
5383
|
-
}
|
|
5384
|
-
if (!current()) return { status: "cancelled" };
|
|
5385
|
-
const spent = state.grants.filter((grant2) => grant2.lifetime === "once" && consumed.decision.grantIds.includes(grant2.id));
|
|
5386
|
-
const value = await execute(controller.signal);
|
|
5387
|
-
if (!current()) return { status: "cancelled" };
|
|
5388
|
-
const latest = options.getState();
|
|
5389
|
-
const continuation = evaluatePermissions({ version: 1, grants: [...latest.grants, ...spent] }, request, options);
|
|
5390
|
-
return continuation.decision === "allow" ? { status: "executed", value } : { status: "cancelled" };
|
|
5391
|
-
});
|
|
5392
|
-
const settled = Promise.race([operation, cancelled3]).finally(() => {
|
|
5393
|
-
clearDeadline();
|
|
5394
|
-
controller.signal.removeEventListener("abort", onAbort);
|
|
5395
|
-
signal?.removeEventListener("abort", abortRequest);
|
|
5396
|
-
pending.delete(entry);
|
|
5397
|
-
});
|
|
5398
|
-
const completed2 = settled.then(() => void 0, () => void 0);
|
|
5399
|
-
const tail = previous.then(() => completed2).finally(() => {
|
|
5400
|
-
reserved--;
|
|
5401
|
-
if (groups.get(key) === tail) groups.delete(key);
|
|
5402
|
-
});
|
|
5403
|
-
groups.set(key, tail);
|
|
5404
|
-
return settled;
|
|
5405
|
-
}
|
|
5406
|
-
return {
|
|
5407
|
-
run,
|
|
5408
|
-
cancel,
|
|
5409
|
-
dispose() {
|
|
5410
|
-
disposed = true;
|
|
5411
|
-
cancel();
|
|
5412
|
-
},
|
|
5413
|
-
get pendingCount() {
|
|
5414
|
-
return pending.size;
|
|
5415
|
-
}
|
|
5416
|
-
};
|
|
5417
|
-
}
|
|
5418
5087
|
function createPermissionStore(options) {
|
|
5419
5088
|
let state = createPermissionState();
|
|
5420
5089
|
let healthy = true;
|
|
@@ -5579,10 +5248,6 @@ function createPermissionRuntime(context) {
|
|
|
5579
5248
|
const { adapter } = context;
|
|
5580
5249
|
const lifetimes = /* @__PURE__ */ new Map();
|
|
5581
5250
|
const retiredSources = /* @__PURE__ */ new WeakSet();
|
|
5582
|
-
let rates = createRateLimitState();
|
|
5583
|
-
let promptRates = createRateLimitState();
|
|
5584
|
-
let rateLimitOverride;
|
|
5585
|
-
const currentRateLimit = () => rateLimitOverride ?? adapter.rateLimit ?? defaultRateLimitConfig();
|
|
5586
5251
|
let disposed = false;
|
|
5587
5252
|
let globalAdmissionRevision = 0;
|
|
5588
5253
|
const sourceAdmissionRevisions = /* @__PURE__ */ new WeakMap();
|
|
@@ -5627,8 +5292,9 @@ function createPermissionRuntime(context) {
|
|
|
5627
5292
|
const source = [...lifetimes].find(([, lifetime2]) => lifetime2.id === request.sessionId);
|
|
5628
5293
|
if (!source) return false;
|
|
5629
5294
|
const [windowId, lifetime] = source;
|
|
5295
|
+
if (!adapter.promptRateLimiter) return true;
|
|
5630
5296
|
const now2 = adapter.now();
|
|
5631
|
-
const rate =
|
|
5297
|
+
const rate = adapter.promptRateLimiter.evaluate({
|
|
5632
5298
|
subject: lifetime.subject,
|
|
5633
5299
|
operation: "permission.prompt",
|
|
5634
5300
|
lifecycle: lifetime.id,
|
|
@@ -5636,7 +5302,6 @@ function createPermissionRuntime(context) {
|
|
|
5636
5302
|
focused: context.focused(windowId),
|
|
5637
5303
|
now: now2
|
|
5638
5304
|
});
|
|
5639
|
-
promptRates = rate.state;
|
|
5640
5305
|
if (rate.reason !== "within-budget") {
|
|
5641
5306
|
try {
|
|
5642
5307
|
adapter.onRateLimit?.({ windowId, operation: "permission.prompt", action: rate.action, reason: rate.reason });
|
|
@@ -5649,22 +5314,16 @@ function createPermissionRuntime(context) {
|
|
|
5649
5314
|
const lifetime = lifetimes.get(windowId);
|
|
5650
5315
|
if (disposed || !store2.available || !lifetime || retiredSources.has(lifetime.entry) || context.getSession(windowId) !== lifetime.entry) return "unavailable";
|
|
5651
5316
|
try {
|
|
5317
|
+
if (!adapter.rateLimiter) return void 0;
|
|
5652
5318
|
const now2 = adapter.now();
|
|
5653
|
-
const
|
|
5654
|
-
const config = mode === "observe" ? {
|
|
5655
|
-
...configured,
|
|
5656
|
-
action: configured.action === "block" ? "flag" : configured.action,
|
|
5657
|
-
burst: { ...configured.burst, action: configured.burst.action === "block" ? "flag" : configured.burst.action }
|
|
5658
|
-
} : configured;
|
|
5659
|
-
const rate = evaluateRateLimit(config, rates, {
|
|
5319
|
+
const rate = adapter.rateLimiter.evaluate({
|
|
5660
5320
|
subject: lifetime.subject,
|
|
5661
5321
|
operation,
|
|
5662
5322
|
lifecycle: lifetime.id,
|
|
5663
5323
|
elapsedSinceStartMs: Math.max(0, now2 - lifetime.started),
|
|
5664
5324
|
focused: context.focused(windowId),
|
|
5665
5325
|
now: now2
|
|
5666
|
-
});
|
|
5667
|
-
rates = rate.state;
|
|
5326
|
+
}, mode);
|
|
5668
5327
|
if (rate.reason !== "within-budget") {
|
|
5669
5328
|
try {
|
|
5670
5329
|
adapter.onRateLimit?.({ windowId, operation, action: rate.action, reason: rate.reason });
|
|
@@ -5682,8 +5341,12 @@ function createPermissionRuntime(context) {
|
|
|
5682
5341
|
retiredSources.add(lifetime.entry);
|
|
5683
5342
|
lifetimes.delete(windowId);
|
|
5684
5343
|
store2.retire(lifetime.id);
|
|
5685
|
-
|
|
5686
|
-
|
|
5344
|
+
for (const limiter of [adapter.rateLimiter, adapter.promptRateLimiter]) {
|
|
5345
|
+
try {
|
|
5346
|
+
limiter?.retire(lifetime.subject, lifetime.id);
|
|
5347
|
+
} catch {
|
|
5348
|
+
}
|
|
5349
|
+
}
|
|
5687
5350
|
}
|
|
5688
5351
|
function run(windowId, operation, requirements3, isCurrent, execute, phase = "operation", signal) {
|
|
5689
5352
|
if (disposed || signal?.aborted) return Promise.resolve({ status: "cancelled" });
|
|
@@ -5759,13 +5422,6 @@ function createPermissionRuntime(context) {
|
|
|
5759
5422
|
return () => {
|
|
5760
5423
|
invalidationListeners.delete(listener);
|
|
5761
5424
|
};
|
|
5762
|
-
},
|
|
5763
|
-
get rateLimit() {
|
|
5764
|
-
return currentRateLimit();
|
|
5765
|
-
},
|
|
5766
|
-
setRateLimit(config) {
|
|
5767
|
-
assertRateLimitConfig(config);
|
|
5768
|
-
rateLimitOverride = Object.freeze({ ...config, burst: Object.freeze({ ...config.burst }) });
|
|
5769
5425
|
}
|
|
5770
5426
|
};
|
|
5771
5427
|
return {
|
|
@@ -7310,7 +6966,7 @@ function createRuntimeInstance(context) {
|
|
|
7310
6966
|
for (const name of attachedServices.keys()) detachService(name);
|
|
7311
6967
|
manifestCache2.persist();
|
|
7312
6968
|
aclState.persist();
|
|
7313
|
-
firewallState
|
|
6969
|
+
firewallState?.persist();
|
|
7314
6970
|
replayDetector.clear();
|
|
7315
6971
|
subscriptions.clear();
|
|
7316
6972
|
incRuntime.clear();
|
|
@@ -7356,7 +7012,7 @@ function createRuntimeInstance(context) {
|
|
|
7356
7012
|
get aclState() {
|
|
7357
7013
|
return aclState;
|
|
7358
7014
|
},
|
|
7359
|
-
get
|
|
7015
|
+
get legacyFirewall() {
|
|
7360
7016
|
return firewallState;
|
|
7361
7017
|
},
|
|
7362
7018
|
get permissions() {
|
|
@@ -7399,12 +7055,12 @@ function createRuntime(hooks) {
|
|
|
7399
7055
|
const serviceRegistry = { ...hooks.services };
|
|
7400
7056
|
const registeredServices = createRegisteredServices(serviceRegistry);
|
|
7401
7057
|
const warnLegacyIgnored = hooks.permissions ? createLegacyIgnoredWarning() : void 0;
|
|
7402
|
-
if (hooks.onFirewallEvent || hooks.
|
|
7403
|
-
const firewallState =
|
|
7058
|
+
if (hooks.onFirewallEvent || hooks.legacyFirewall) warnLegacyIgnored?.();
|
|
7059
|
+
const firewallState = hooks.permissions ? void 0 : hooks.legacyFirewall;
|
|
7404
7060
|
let extensions;
|
|
7405
7061
|
let permissions;
|
|
7406
7062
|
const sessionRegistry2 = createSessionRegistry(hooks.onPendingUpdate, (windowId) => {
|
|
7407
|
-
firewallState
|
|
7063
|
+
firewallState?.resetInitBudget(windowId);
|
|
7408
7064
|
extensions?.destroyWindow(windowId);
|
|
7409
7065
|
permissions?.retire(windowId);
|
|
7410
7066
|
if (hooks.permissions) notifyServiceWindowDestroyed(windowId, serviceRegistry);
|
|
@@ -7441,8 +7097,8 @@ function createRuntime(hooks) {
|
|
|
7441
7097
|
napplet,
|
|
7442
7098
|
pubkey: "",
|
|
7443
7099
|
resolve: (allowed2) => {
|
|
7444
|
-
firewallState
|
|
7445
|
-
firewallState
|
|
7100
|
+
firewallState?.setPolicy(napplet, allowed2 ? "allow" : "deny");
|
|
7101
|
+
firewallState?.persist();
|
|
7446
7102
|
}
|
|
7447
7103
|
});
|
|
7448
7104
|
};
|
|
@@ -7487,7 +7143,7 @@ function createRuntime(hooks) {
|
|
|
7487
7143
|
hooks.getConfigOverrides ? () => hooks.getConfigOverrides().ringBufferSize ?? RING_BUFFER_SIZE : void 0
|
|
7488
7144
|
);
|
|
7489
7145
|
aclState.load();
|
|
7490
|
-
firewallState
|
|
7146
|
+
firewallState?.load();
|
|
7491
7147
|
manifestCache2.load();
|
|
7492
7148
|
const domainHandlers = createRuntimeDomainHandlers({ hooks, serviceRegistry, sessionRegistry: sessionRegistry2, aclState });
|
|
7493
7149
|
const napHandlers = {
|
|
@@ -16172,7 +15828,7 @@ function delay(signal) {
|
|
|
16172
15828
|
if (signal.aborted) done();
|
|
16173
15829
|
});
|
|
16174
15830
|
}
|
|
16175
|
-
async function pumpAudio(source,
|
|
15831
|
+
async function pumpAudio(source, element3, reader, mime, signal) {
|
|
16176
15832
|
await waitEvent(source, "sourceopen", signal);
|
|
16177
15833
|
const buffer = source.addSourceBuffer(mime);
|
|
16178
15834
|
while (!signal.aborted) {
|
|
@@ -16183,10 +15839,10 @@ async function pumpAudio(source, element4, reader, mime, signal) {
|
|
|
16183
15839
|
}
|
|
16184
15840
|
if (item.value.byteLength > 1024 * 1024) throw new Error("live audio chunk too large");
|
|
16185
15841
|
for (let offset = 0; offset < item.value.byteLength; offset += 64 * 1024) {
|
|
16186
|
-
while (!signal.aborted && buffer.buffered.length && buffer.buffered.end(buffer.buffered.length - 1) -
|
|
15842
|
+
while (!signal.aborted && buffer.buffered.length && buffer.buffered.end(buffer.buffered.length - 1) - element3.currentTime > 30) {
|
|
16187
15843
|
await delay(signal);
|
|
16188
15844
|
}
|
|
16189
|
-
const cutoff =
|
|
15845
|
+
const cutoff = element3.currentTime - 15;
|
|
16190
15846
|
if (buffer.buffered.length && cutoff > buffer.buffered.start(0) + 5) {
|
|
16191
15847
|
await waitEvent(buffer, "updateend", signal, () => buffer.remove(0, cutoff));
|
|
16192
15848
|
}
|
|
@@ -16195,7 +15851,7 @@ async function pumpAudio(source, element4, reader, mime, signal) {
|
|
|
16195
15851
|
}
|
|
16196
15852
|
}
|
|
16197
15853
|
}
|
|
16198
|
-
function createMediaStream(response,
|
|
15854
|
+
function createMediaStream(response, element3, controller, urls) {
|
|
16199
15855
|
const mime = response.headers.get("content-type") ?? "";
|
|
16200
15856
|
if (!response.body || typeof MediaSource === "undefined" || !MediaSource.isTypeSupported(mime)) {
|
|
16201
15857
|
void response.body?.cancel().catch(() => {
|
|
@@ -16211,11 +15867,11 @@ function createMediaStream(response, element4, controller, urls) {
|
|
|
16211
15867
|
});
|
|
16212
15868
|
};
|
|
16213
15869
|
controller.signal.addEventListener("abort", cancel, { once: true });
|
|
16214
|
-
void pumpAudio(source,
|
|
15870
|
+
void pumpAudio(source, element3, reader, mime, controller.signal).catch(() => {
|
|
16215
15871
|
if (!controller.signal.aborted) {
|
|
16216
15872
|
controller.abort();
|
|
16217
|
-
|
|
16218
|
-
|
|
15873
|
+
element3.pause();
|
|
15874
|
+
element3.dispatchEvent(new Event("error"));
|
|
16219
15875
|
}
|
|
16220
15876
|
}).finally(() => {
|
|
16221
15877
|
controller.signal.removeEventListener("abort", cancel);
|
|
@@ -16277,12 +15933,12 @@ function sourceUrl(options) {
|
|
|
16277
15933
|
if (typeof source?.blossomHash === "string" && /^[a-f0-9]{64}$/i.test(source.blossomHash)) return `blossom:${source.blossomHash}`;
|
|
16278
15934
|
throw new Error("unsupported source");
|
|
16279
15935
|
}
|
|
16280
|
-
function loadMedia(
|
|
15936
|
+
function loadMedia(element3, url, signal) {
|
|
16281
15937
|
return new Promise((resolve, reject2) => {
|
|
16282
15938
|
const cleanup = () => {
|
|
16283
15939
|
clearTimeout(timer);
|
|
16284
|
-
|
|
16285
|
-
|
|
15940
|
+
element3.removeEventListener("loadedmetadata", loaded);
|
|
15941
|
+
element3.removeEventListener("error", failed2);
|
|
16286
15942
|
signal.removeEventListener("abort", failed2);
|
|
16287
15943
|
};
|
|
16288
15944
|
const loaded = () => {
|
|
@@ -16294,36 +15950,36 @@ function loadMedia(element4, url, signal) {
|
|
|
16294
15950
|
reject2(new Error("media decoding failed or cancelled"));
|
|
16295
15951
|
};
|
|
16296
15952
|
const timer = setTimeout(failed2, 5e3);
|
|
16297
|
-
|
|
16298
|
-
|
|
15953
|
+
element3.addEventListener("loadedmetadata", loaded, { once: true });
|
|
15954
|
+
element3.addEventListener("error", failed2, { once: true });
|
|
16299
15955
|
signal.addEventListener("abort", failed2, { once: true });
|
|
16300
15956
|
if (signal.aborted) return failed2();
|
|
16301
15957
|
try {
|
|
16302
|
-
|
|
16303
|
-
|
|
15958
|
+
element3.src = url;
|
|
15959
|
+
element3.load();
|
|
16304
15960
|
} catch {
|
|
16305
15961
|
failed2();
|
|
16306
15962
|
}
|
|
16307
15963
|
});
|
|
16308
15964
|
}
|
|
16309
|
-
function attachPlayback(
|
|
15965
|
+
function attachPlayback(element3, live, release, changed) {
|
|
16310
15966
|
let retired = false;
|
|
16311
15967
|
let generation2 = 0;
|
|
16312
|
-
let state = { status: "paused", position: 0, volume:
|
|
15968
|
+
let state = { status: "paused", position: 0, volume: element3.volume };
|
|
16313
15969
|
const actions = () => [
|
|
16314
15970
|
"play",
|
|
16315
15971
|
"pause",
|
|
16316
15972
|
"stop",
|
|
16317
15973
|
"volume",
|
|
16318
|
-
...!live && Number.isFinite(
|
|
15974
|
+
...!live && Number.isFinite(element3.duration) && element3.duration > 0 ? ["seek"] : []
|
|
16319
15975
|
];
|
|
16320
15976
|
const publish = (status = state.status, reason) => {
|
|
16321
15977
|
if (retired) return;
|
|
16322
15978
|
state = {
|
|
16323
15979
|
status,
|
|
16324
|
-
position:
|
|
16325
|
-
volume:
|
|
16326
|
-
...Number.isFinite(
|
|
15980
|
+
position: element3.currentTime,
|
|
15981
|
+
volume: element3.volume,
|
|
15982
|
+
...Number.isFinite(element3.duration) ? { duration: element3.duration } : {},
|
|
16327
15983
|
...reason ? { reason } : {}
|
|
16328
15984
|
};
|
|
16329
15985
|
changed({ ...state }, actions());
|
|
@@ -16348,9 +16004,9 @@ function attachPlayback(element4, live, release, changed) {
|
|
|
16348
16004
|
volumechange: () => publish(),
|
|
16349
16005
|
seeked: () => publish()
|
|
16350
16006
|
};
|
|
16351
|
-
for (const [event, handler] of Object.entries(handlers))
|
|
16007
|
+
for (const [event, handler] of Object.entries(handlers)) element3.addEventListener(event, handler);
|
|
16352
16008
|
return {
|
|
16353
|
-
element:
|
|
16009
|
+
element: element3,
|
|
16354
16010
|
get state() {
|
|
16355
16011
|
return { ...state };
|
|
16356
16012
|
},
|
|
@@ -16362,28 +16018,28 @@ function attachPlayback(element4, live, release, changed) {
|
|
|
16362
16018
|
const token = ++generation2;
|
|
16363
16019
|
switch (command.action) {
|
|
16364
16020
|
case "play":
|
|
16365
|
-
if (live &&
|
|
16366
|
-
void
|
|
16021
|
+
if (live && element3.buffered.length && (element3.ended || element3.currentTime < element3.buffered.start(0))) element3.currentTime = element3.buffered.start(0);
|
|
16022
|
+
void element3.play().then(() => {
|
|
16367
16023
|
if (!retired && token === generation2) publish("playing", command.reason);
|
|
16368
16024
|
}).catch(() => {
|
|
16369
16025
|
if (!retired && token === generation2) publish("paused", "error");
|
|
16370
16026
|
});
|
|
16371
16027
|
break;
|
|
16372
16028
|
case "pause":
|
|
16373
|
-
|
|
16029
|
+
element3.pause();
|
|
16374
16030
|
publish("paused", command.reason);
|
|
16375
16031
|
break;
|
|
16376
16032
|
case "stop":
|
|
16377
|
-
|
|
16378
|
-
if (!live)
|
|
16033
|
+
element3.pause();
|
|
16034
|
+
if (!live) element3.currentTime = 0;
|
|
16379
16035
|
publish("stopped", command.reason);
|
|
16380
16036
|
break;
|
|
16381
16037
|
case "seek":
|
|
16382
|
-
|
|
16038
|
+
element3.currentTime = Math.min(command.value, element3.duration);
|
|
16383
16039
|
publish();
|
|
16384
16040
|
break;
|
|
16385
16041
|
case "volume":
|
|
16386
|
-
|
|
16042
|
+
element3.volume = command.value;
|
|
16387
16043
|
publish();
|
|
16388
16044
|
break;
|
|
16389
16045
|
}
|
|
@@ -16392,11 +16048,11 @@ function attachPlayback(element4, live, release, changed) {
|
|
|
16392
16048
|
if (retired) return;
|
|
16393
16049
|
retired = true;
|
|
16394
16050
|
generation2++;
|
|
16395
|
-
for (const [event, handler] of Object.entries(handlers))
|
|
16396
|
-
|
|
16397
|
-
|
|
16398
|
-
|
|
16399
|
-
|
|
16051
|
+
for (const [event, handler] of Object.entries(handlers)) element3.removeEventListener(event, handler);
|
|
16052
|
+
element3.pause();
|
|
16053
|
+
element3.removeAttribute("src");
|
|
16054
|
+
element3.load();
|
|
16055
|
+
element3.remove();
|
|
16400
16056
|
release();
|
|
16401
16057
|
}
|
|
16402
16058
|
};
|
|
@@ -16410,17 +16066,17 @@ function createBrowserMediaPlayback(options) {
|
|
|
16410
16066
|
const blob = await readSource(options.resource, windowId, sourceUrl(request), signal);
|
|
16411
16067
|
if (signal.aborted) throw new Error("media source cancelled");
|
|
16412
16068
|
if (!/^(audio|video)\//.test(blob.type)) throw new Error("unsupported media type");
|
|
16413
|
-
const
|
|
16414
|
-
if (!
|
|
16415
|
-
|
|
16416
|
-
if (
|
|
16069
|
+
const element3 = doc.createElement(blob.type.startsWith("video/") ? "video" : "audio");
|
|
16070
|
+
if (!element3.canPlayType(blob.type)) throw new Error("unsupported media type");
|
|
16071
|
+
element3.preload = "metadata";
|
|
16072
|
+
if (element3.tagName === "VIDEO") element3.playsInline = true;
|
|
16417
16073
|
const url = urls.createObjectURL(blob);
|
|
16418
|
-
const playback = attachPlayback(
|
|
16074
|
+
const playback = attachPlayback(element3, request.live === true, () => urls.revokeObjectURL(url), changed);
|
|
16419
16075
|
const abort = () => playback.destroy();
|
|
16420
16076
|
signal.addEventListener("abort", abort, { once: true });
|
|
16421
16077
|
try {
|
|
16422
|
-
await loadMedia(
|
|
16423
|
-
if (request.autoplay) await
|
|
16078
|
+
await loadMedia(element3, url, signal);
|
|
16079
|
+
if (request.autoplay) await element3.play();
|
|
16424
16080
|
if (signal.aborted) throw new Error("media source cancelled");
|
|
16425
16081
|
return playback;
|
|
16426
16082
|
} catch (error) {
|
|
@@ -16445,12 +16101,12 @@ async function openLive(windowId, request, signal, changed, options, doc, urls)
|
|
|
16445
16101
|
await response.body?.cancel();
|
|
16446
16102
|
throw new Error("media source cancelled");
|
|
16447
16103
|
}
|
|
16448
|
-
const
|
|
16449
|
-
|
|
16450
|
-
const stream = createMediaStream(response,
|
|
16451
|
-
playback = attachPlayback(
|
|
16452
|
-
await loadMedia(
|
|
16453
|
-
if (request.autoplay) await
|
|
16104
|
+
const element3 = doc.createElement("audio");
|
|
16105
|
+
element3.preload = "auto";
|
|
16106
|
+
const stream = createMediaStream(response, element3, controller, urls);
|
|
16107
|
+
playback = attachPlayback(element3, true, stream.destroy, changed);
|
|
16108
|
+
await loadMedia(element3, stream.url, controller.signal);
|
|
16109
|
+
if (request.autoplay) await element3.play();
|
|
16454
16110
|
if (controller.signal.aborted) throw new Error("media source cancelled");
|
|
16455
16111
|
return playback;
|
|
16456
16112
|
} catch (error) {
|
|
@@ -16611,8 +16267,8 @@ function updateRow(row, session, service) {
|
|
|
16611
16267
|
row.volume.disabled = !session.actions.includes("volume");
|
|
16612
16268
|
if (row.seek.getRootNode() instanceof ShadowRoot && row.seek.getRootNode().activeElement !== row.seek) row.seek.value = String(state?.position ?? 0);
|
|
16613
16269
|
if (row.volume.getRootNode() instanceof ShadowRoot && row.volume.getRootNode().activeElement !== row.volume) row.volume.value = String(state?.volume ?? 1);
|
|
16614
|
-
const
|
|
16615
|
-
if (
|
|
16270
|
+
const element3 = service.getElement(session.sessionId);
|
|
16271
|
+
if (element3 && element3.parentElement !== row.media) row.media.append(element3);
|
|
16616
16272
|
}
|
|
16617
16273
|
function mountMediaPlayer(service, container = document.body) {
|
|
16618
16274
|
const doc = container.ownerDocument;
|
|
@@ -18812,6 +18468,110 @@ function installPajaResourceSettings() {
|
|
|
18812
18468
|
return { getServers: settings.getServers, dispose: () => form?.removeEventListener("submit", submit) };
|
|
18813
18469
|
}
|
|
18814
18470
|
|
|
18471
|
+
// ../rate-limit/dist/chunk-ACC3QLIN.js
|
|
18472
|
+
function defaultRateLimitConfig() {
|
|
18473
|
+
return {
|
|
18474
|
+
capacity: 60,
|
|
18475
|
+
windowMs: 6e4,
|
|
18476
|
+
action: "flag",
|
|
18477
|
+
unfocusedMultiplier: 0.25,
|
|
18478
|
+
burst: { windowMs: 3e3, maxOperations: 20, action: "block" }
|
|
18479
|
+
};
|
|
18480
|
+
}
|
|
18481
|
+
function defaultPromptRateLimitConfig() {
|
|
18482
|
+
return {
|
|
18483
|
+
capacity: 12,
|
|
18484
|
+
windowMs: 6e4,
|
|
18485
|
+
action: "block",
|
|
18486
|
+
unfocusedMultiplier: 1,
|
|
18487
|
+
burst: { windowMs: 3e3, maxOperations: 8, action: "block" }
|
|
18488
|
+
};
|
|
18489
|
+
}
|
|
18490
|
+
function createRateLimitState() {
|
|
18491
|
+
return { buckets: {}, bursts: {} };
|
|
18492
|
+
}
|
|
18493
|
+
function positive(value) {
|
|
18494
|
+
return Number.isFinite(value) && value > 0;
|
|
18495
|
+
}
|
|
18496
|
+
function validAction(value) {
|
|
18497
|
+
return value === "flag" || value === "block" || value === "ignore";
|
|
18498
|
+
}
|
|
18499
|
+
function assertRateLimitConfig(config) {
|
|
18500
|
+
const { burst } = config;
|
|
18501
|
+
if (!Number.isFinite(config.capacity) || config.capacity < 0 || !positive(config.windowMs) || !positive(config.unfocusedMultiplier) || !Number.isFinite(burst.windowMs) || burst.windowMs < 0 || !Number.isSafeInteger(burst.maxOperations) || burst.maxOperations < 0 || !validAction(config.action) || !validAction(burst.action)) {
|
|
18502
|
+
throw new RangeError("Rate limits require finite budgets in range and valid actions");
|
|
18503
|
+
}
|
|
18504
|
+
}
|
|
18505
|
+
function validate(config, observation) {
|
|
18506
|
+
assertRateLimitConfig(config);
|
|
18507
|
+
if (!observation.subject || !observation.operation || !observation.lifecycle || !Number.isFinite(observation.now) || !Number.isFinite(observation.elapsedSinceStartMs) || observation.elapsedSinceStartMs < 0 || typeof observation.focused !== "boolean") {
|
|
18508
|
+
throw new RangeError("Rate observations require a subject, operation, lifecycle and finite clock");
|
|
18509
|
+
}
|
|
18510
|
+
}
|
|
18511
|
+
function verdict(state, reason, action) {
|
|
18512
|
+
return { allowed: action !== "block", action, reason, state };
|
|
18513
|
+
}
|
|
18514
|
+
function evaluateRateLimit(config, state, observation) {
|
|
18515
|
+
validate(config, observation);
|
|
18516
|
+
const { subject, operation, lifecycle, now: now2 } = observation;
|
|
18517
|
+
if (observation.elapsedSinceStartMs < config.burst.windowMs) {
|
|
18518
|
+
const key2 = JSON.stringify([subject, lifecycle]);
|
|
18519
|
+
const previous2 = state.bursts[key2];
|
|
18520
|
+
const active = previous2 && now2 - previous2.startedAt < config.burst.windowMs ? previous2 : void 0;
|
|
18521
|
+
const burst = { count: (active?.count ?? 0) + 1, startedAt: active?.startedAt ?? now2 };
|
|
18522
|
+
state = { ...state, bursts: { ...state.bursts, [key2]: burst } };
|
|
18523
|
+
if (burst.count > config.burst.maxOperations) return verdict(state, "burst-exceeded", config.burst.action);
|
|
18524
|
+
}
|
|
18525
|
+
const key = JSON.stringify([subject, operation]);
|
|
18526
|
+
const capacity = config.capacity * (observation.focused ? 1 : config.unfocusedMultiplier);
|
|
18527
|
+
const previous = state.buckets[key];
|
|
18528
|
+
const updatedAt = Math.max(now2, previous?.updatedAt ?? now2);
|
|
18529
|
+
const elapsed = updatedAt - (previous?.updatedAt ?? updatedAt);
|
|
18530
|
+
const tokens = Math.min(capacity, (previous?.tokens ?? capacity) + elapsed * (capacity / config.windowMs));
|
|
18531
|
+
const exceeded = tokens < 1;
|
|
18532
|
+
const bucket = { tokens: exceeded ? tokens : tokens - 1, updatedAt };
|
|
18533
|
+
state = { ...state, buckets: { ...state.buckets, [key]: bucket } };
|
|
18534
|
+
return verdict(state, exceeded ? "rate-exceeded" : "within-budget", exceeded ? config.action : "ignore");
|
|
18535
|
+
}
|
|
18536
|
+
function retireRateLimitLifecycle(state, subject, lifecycle) {
|
|
18537
|
+
const key = JSON.stringify([subject, lifecycle]);
|
|
18538
|
+
if (!Object.hasOwn(state.bursts, key)) return state;
|
|
18539
|
+
const bursts = { ...state.bursts };
|
|
18540
|
+
delete bursts[key];
|
|
18541
|
+
return { ...state, bursts };
|
|
18542
|
+
}
|
|
18543
|
+
|
|
18544
|
+
// ../rate-limit/dist/index.js
|
|
18545
|
+
function snapshot3(config) {
|
|
18546
|
+
assertRateLimitConfig(config);
|
|
18547
|
+
return Object.freeze({ ...config, burst: Object.freeze({ ...config.burst }) });
|
|
18548
|
+
}
|
|
18549
|
+
function createRateLimiter(initial) {
|
|
18550
|
+
let config = snapshot3(initial);
|
|
18551
|
+
let state = createRateLimitState();
|
|
18552
|
+
return {
|
|
18553
|
+
get config() {
|
|
18554
|
+
return config;
|
|
18555
|
+
},
|
|
18556
|
+
setConfig(next) {
|
|
18557
|
+
config = snapshot3(next);
|
|
18558
|
+
},
|
|
18559
|
+
evaluate(observation, mode = "enforce") {
|
|
18560
|
+
const effective = mode === "observe" ? {
|
|
18561
|
+
...config,
|
|
18562
|
+
action: config.action === "block" ? "flag" : config.action,
|
|
18563
|
+
burst: { ...config.burst, action: config.burst.action === "block" ? "flag" : config.burst.action }
|
|
18564
|
+
} : config;
|
|
18565
|
+
const result2 = evaluateRateLimit(effective, state, observation);
|
|
18566
|
+
state = result2.state;
|
|
18567
|
+
return result2;
|
|
18568
|
+
},
|
|
18569
|
+
retire(subject, lifecycle) {
|
|
18570
|
+
state = retireRateLimitLifecycle(state, subject, lifecycle);
|
|
18571
|
+
}
|
|
18572
|
+
};
|
|
18573
|
+
}
|
|
18574
|
+
|
|
18815
18575
|
// ../shell/dist/index.js
|
|
18816
18576
|
function randomUUID() {
|
|
18817
18577
|
const provider = globalThis.crypto;
|
|
@@ -19144,7 +18904,7 @@ function adaptHooks(shellHooks, deps) {
|
|
|
19144
18904
|
shellSecretPersistence: createShellSecretPersistence(),
|
|
19145
18905
|
guidPersistence: createGuidPersistence(),
|
|
19146
18906
|
onAclCheck: shellHooks.onAclCheck,
|
|
19147
|
-
|
|
18907
|
+
legacyFirewall: shellHooks.legacyFirewall,
|
|
19148
18908
|
onFirewallEvent: shellHooks.onFirewallEvent,
|
|
19149
18909
|
getFocusContext: shellHooks.getFocusContext,
|
|
19150
18910
|
onHashMismatch: shellHooks.onHashMismatch,
|
|
@@ -20837,11 +20597,11 @@ function nappletNamespacePrelude(domains, normalizeIntentUri2, frameLock) {
|
|
|
20837
20597
|
post({ type: "shell.ready" });
|
|
20838
20598
|
return shell2;
|
|
20839
20599
|
}
|
|
20840
|
-
function domainEventHandle(eventType, callback,
|
|
20600
|
+
function domainEventHandle(eventType, callback, select22 = (message3) => message3.event) {
|
|
20841
20601
|
const off = listen((event) => {
|
|
20842
20602
|
if (!isShellMessage(event)) return;
|
|
20843
20603
|
const msg = event.data;
|
|
20844
|
-
if (typeof msg === "object" && msg !== null && msg.type === eventType) callback(
|
|
20604
|
+
if (typeof msg === "object" && msg !== null && msg.type === eventType) callback(select22(msg));
|
|
20845
20605
|
});
|
|
20846
20606
|
return subscriptionHandle(off);
|
|
20847
20607
|
}
|
|
@@ -21724,7 +21484,7 @@ function nappletNamespacePrelude(domains, normalizeIntentUri2, frameLock) {
|
|
|
21724
21484
|
const value = message3.delivery;
|
|
21725
21485
|
if (!value || typeof value !== "object" || Array.isArray(value)) return;
|
|
21726
21486
|
const delivery = value;
|
|
21727
|
-
if (typeof delivery.sender !== "string" || typeof delivery.archetype !== "string" || typeof delivery.action !== "string" || typeof delivery.convention !== "string") return;
|
|
21487
|
+
if (typeof delivery.sender !== "string" || delivery.sender === "" || typeof delivery.archetype !== "string" || typeof delivery.action !== "string" || typeof delivery.convention !== "string") return;
|
|
21728
21488
|
pending.push(Object.freeze({
|
|
21729
21489
|
sender: delivery.sender,
|
|
21730
21490
|
archetype: delivery.archetype,
|
|
@@ -21996,9 +21756,9 @@ function nappletNamespacePrelude(domains, normalizeIntentUri2, frameLock) {
|
|
|
21996
21756
|
const incoming = event.data;
|
|
21997
21757
|
if (!incoming || incoming.type !== "gamepad.state" || "id" in incoming || !valid(incoming)) return;
|
|
21998
21758
|
state = copy(incoming);
|
|
21999
|
-
const
|
|
21759
|
+
const snapshot4 = copy(state);
|
|
22000
21760
|
const recipients = Array.from(handlers);
|
|
22001
|
-
for (const entry of recipients) if (handlers.has(entry)) entry.handler(copy(
|
|
21761
|
+
for (const entry of recipients) if (handlers.has(entry)) entry.handler(copy(snapshot4));
|
|
22002
21762
|
});
|
|
22003
21763
|
const api = {
|
|
22004
21764
|
get available() {
|
|
@@ -22457,109 +22217,266 @@ async function admitBrowserDocument(request) {
|
|
|
22457
22217
|
return failed2("invalid");
|
|
22458
22218
|
}
|
|
22459
22219
|
}
|
|
22460
|
-
var
|
|
22461
|
-
|
|
22220
|
+
var LIFETIME_LABELS = Object.freeze({
|
|
22221
|
+
once: "Just this once",
|
|
22222
|
+
session: "Until it closes",
|
|
22223
|
+
persistent: "Always"
|
|
22224
|
+
});
|
|
22225
|
+
var RULE_ACTION_LABELS = Object.freeze({
|
|
22226
|
+
allow: "Allow",
|
|
22227
|
+
ask: "Ask",
|
|
22228
|
+
deny: "Block"
|
|
22229
|
+
});
|
|
22230
|
+
var OPERATION_LABELS = Object.freeze({
|
|
22231
|
+
"link.open": "Open link",
|
|
22232
|
+
"keys.registerAction": "Register shortcut",
|
|
22233
|
+
"resource.bytes": "Fetch",
|
|
22234
|
+
"upload.upload": "Upload to",
|
|
22235
|
+
"intent.invoke": "Invoke intent",
|
|
22236
|
+
"serial.open": "Open serial port",
|
|
22237
|
+
"serial.write": "Write to serial port",
|
|
22238
|
+
"webrtc.open": "Open peer connection"
|
|
22239
|
+
});
|
|
22240
|
+
var PROMPT_TITLES = Object.freeze({
|
|
22241
|
+
"link.open": "Open an external link?",
|
|
22242
|
+
"upload.upload": "Upload a file?",
|
|
22243
|
+
"intent.invoke": "Hand off to another napplet?"
|
|
22244
|
+
});
|
|
22245
|
+
function principalIdentity(principal) {
|
|
22246
|
+
return principal.kind === "verified" ? `Verified manifest ${principal.manifestKey}; artifact SHA-256 ${principal.artifactHash}` : `Development target ${principal.target}; artifact SHA-256 ${principal.artifactHash}`;
|
|
22247
|
+
}
|
|
22248
|
+
function shorten(value, head = 8, tail = 6) {
|
|
22249
|
+
return value.length > head + tail + 1 ? `${value.slice(0, head)}\u2026${value.slice(-tail)}` : value;
|
|
22250
|
+
}
|
|
22251
|
+
function principalSummary(principal) {
|
|
22252
|
+
const artifact = `artifact ${shorten(principal.artifactHash)}`;
|
|
22253
|
+
if (principal.kind === "development") return `${principal.target} \xB7 ${artifact}`;
|
|
22254
|
+
const parts = principal.manifestKey.split(":");
|
|
22255
|
+
const manifest = parts.length >= 3 ? `${parts[1]}:${shorten(parts[2])}${parts.length > 3 ? `:${parts.slice(3).join(":")}` : ""}` : principal.manifestKey;
|
|
22256
|
+
return `${manifest} \xB7 ${artifact}`;
|
|
22257
|
+
}
|
|
22258
|
+
function describeRequirement(requirement) {
|
|
22259
|
+
if (requirement.category === "interface") return { action: `Use the ${requirement.domain} interface` };
|
|
22260
|
+
const value = requirement.scope.value;
|
|
22261
|
+
if (requirement.category === "network" && requirement.operation.startsWith("network.")) {
|
|
22262
|
+
return { action: `Connect directly (${requirement.operation.slice("network.".length)})`, target: value };
|
|
22263
|
+
}
|
|
22264
|
+
const action = OPERATION_LABELS[requirement.operation] ?? requirement.operation;
|
|
22265
|
+
if (requirement.category === "network") return { action: `${action} \u2014 contact origin`, target: value };
|
|
22266
|
+
if (requirement.scope.kind === "directory") return { action: `${action} \u2014 folder`, target: value };
|
|
22267
|
+
const prefix = `${requirement.domain}:`;
|
|
22268
|
+
return { action, target: value.startsWith(prefix) ? value.slice(prefix.length).replace(":", " ") : value };
|
|
22269
|
+
}
|
|
22270
|
+
function distinct(values) {
|
|
22271
|
+
return [...new Set(values)];
|
|
22272
|
+
}
|
|
22273
|
+
var DIRECT = "network.";
|
|
22274
|
+
function describeRequirements(missing) {
|
|
22275
|
+
const rows = [];
|
|
22276
|
+
const direct = /* @__PURE__ */ new Map();
|
|
22277
|
+
for (const item of missing) {
|
|
22278
|
+
if (item.category !== "network" || !item.operation.startsWith(DIRECT)) {
|
|
22279
|
+
rows.push(describeRequirement(item));
|
|
22280
|
+
continue;
|
|
22281
|
+
}
|
|
22282
|
+
const directives = direct.get(item.scope.value);
|
|
22283
|
+
if (directives) directives.push(item.operation.slice(DIRECT.length));
|
|
22284
|
+
else direct.set(item.scope.value, [item.operation.slice(DIRECT.length)]);
|
|
22285
|
+
}
|
|
22286
|
+
return [...rows, ...[...direct].map(([target, directives]) => ({ action: `Connect directly (${distinct(directives).join(", ")})`, target }))];
|
|
22287
|
+
}
|
|
22288
|
+
function promptTitle(missing) {
|
|
22289
|
+
const operations = distinct(missing.filter((item) => item.category !== "interface").map((item) => item.operation));
|
|
22290
|
+
if (operations.length && operations.every((operation) => operation.startsWith(DIRECT))) return "Allow direct network access?";
|
|
22291
|
+
if (operations.length === 1) return PROMPT_TITLES[operations[0]] ?? `Allow ${operations[0]}?`;
|
|
22292
|
+
if (operations.length > 1) return `Allow ${operations.length} operations?`;
|
|
22293
|
+
const domains = distinct(missing.map((item) => item.domain));
|
|
22294
|
+
return domains.length === 1 ? `Allow access to ${domains[0]}?` : `Allow access to ${domains.length} interfaces?`;
|
|
22295
|
+
}
|
|
22296
|
+
function ruleTargetFor(missing) {
|
|
22297
|
+
const domains = distinct(missing.map((item) => item.domain));
|
|
22298
|
+
if (domains.length !== 1) return void 0;
|
|
22299
|
+
const operations = distinct(missing.filter((item) => item.category !== "interface").map((item) => item.operation));
|
|
22300
|
+
if (operations.length === 1 && missing.every((item) => item.category !== "interface")) return { operation: operations[0] };
|
|
22301
|
+
return { domain: domains[0] };
|
|
22302
|
+
}
|
|
22303
|
+
function isRuleGrant(grant2) {
|
|
22304
|
+
return grant2.id.startsWith(DEFAULT_RULE_GRANT_PREFIX);
|
|
22305
|
+
}
|
|
22306
|
+
function groupGrants(grants) {
|
|
22307
|
+
const groups = /* @__PURE__ */ new Map();
|
|
22308
|
+
for (const grant2 of grants) {
|
|
22309
|
+
const key = `${permissionRuleSubject(grant2.principal)}#${grant2.principal.artifactHash}`;
|
|
22310
|
+
let group = groups.get(key);
|
|
22311
|
+
if (!group) groups.set(key, group = { principal: grant2.principal, decided: /* @__PURE__ */ new Map(), byRule: [] });
|
|
22312
|
+
if (isRuleGrant(grant2)) {
|
|
22313
|
+
group.byRule.push(grant2);
|
|
22314
|
+
continue;
|
|
22315
|
+
}
|
|
22316
|
+
const domain = group.decided.get(grant2.permission.domain);
|
|
22317
|
+
if (domain) domain.push(grant2);
|
|
22318
|
+
else group.decided.set(grant2.permission.domain, [grant2]);
|
|
22319
|
+
}
|
|
22320
|
+
return [...groups].map(([key, group]) => ({
|
|
22321
|
+
key,
|
|
22322
|
+
principal: group.principal,
|
|
22323
|
+
byRule: group.byRule,
|
|
22324
|
+
decided: [...group.decided].map(([domain, list]) => ({ domain, grants: list }))
|
|
22325
|
+
}));
|
|
22326
|
+
}
|
|
22327
|
+
function parseCapability(text2) {
|
|
22328
|
+
const value = text2.trim();
|
|
22329
|
+
if (/^[a-z][a-z0-9-]*$/.test(value)) return { domain: value };
|
|
22330
|
+
if (/^[a-z][a-z0-9-]*\.[A-Za-z0-9][A-Za-z0-9._-]*$/.test(value)) return { operation: value };
|
|
22331
|
+
return void 0;
|
|
22332
|
+
}
|
|
22333
|
+
function element(document2, tag, text2, className) {
|
|
22462
22334
|
const node = document2.createElement(tag);
|
|
22463
22335
|
if (text2 !== void 0) node.textContent = text2;
|
|
22336
|
+
if (className) node.className = className;
|
|
22464
22337
|
return node;
|
|
22465
22338
|
}
|
|
22466
|
-
function
|
|
22467
|
-
|
|
22339
|
+
function select2(document2, label, options, value) {
|
|
22340
|
+
const node = element(document2, "select");
|
|
22341
|
+
node.setAttribute("aria-label", label);
|
|
22342
|
+
for (const [optionValue, text2] of options) {
|
|
22343
|
+
const option = element(document2, "option", text2);
|
|
22344
|
+
option.value = optionValue;
|
|
22345
|
+
node.append(option);
|
|
22346
|
+
}
|
|
22347
|
+
node.value = value;
|
|
22348
|
+
return node;
|
|
22468
22349
|
}
|
|
22469
|
-
|
|
22470
|
-
|
|
22350
|
+
var MAX_PENDING_PROMPTS = 64;
|
|
22351
|
+
var NETWORK_NOTE = "Direct browser traffic to these origins is outside parent mediation and rate limits. Browser rules may also allow HTTP to HTTPS upgrades and WebSocket origins to match HTTP(S); hosts and port restrictions still apply, but default ports may upgrade with the scheme.";
|
|
22352
|
+
var CANCELLED2 = Object.freeze({ answer: Object.freeze({ effect: "cancel" }), asRule: false, userGesture: false });
|
|
22353
|
+
function buildDialog(document2) {
|
|
22354
|
+
const dialog = element(document2, "dialog", void 0, "kehto-approval-dialog");
|
|
22471
22355
|
dialog.setAttribute("aria-labelledby", "kehto-approval-title");
|
|
22472
22356
|
dialog.setAttribute("aria-describedby", "kehto-approval-description");
|
|
22473
|
-
const
|
|
22357
|
+
const eyebrow = element(document2, "p", void 0, "kehto-approval-eyebrow");
|
|
22358
|
+
const title = element(document2, "h2");
|
|
22474
22359
|
title.id = "kehto-approval-title";
|
|
22475
|
-
const description = element(document2, "p");
|
|
22360
|
+
const description = element(document2, "p", void 0, "kehto-approval-who");
|
|
22476
22361
|
description.id = "kehto-approval-description";
|
|
22477
|
-
const
|
|
22478
|
-
const
|
|
22479
|
-
const
|
|
22480
|
-
const
|
|
22481
|
-
|
|
22482
|
-
|
|
22483
|
-
|
|
22362
|
+
const requirements3 = element(document2, "ul", void 0, "kehto-approval-scopes");
|
|
22363
|
+
const mediation = element(document2, "p", void 0, "kehto-approval-note");
|
|
22364
|
+
const identity = element(document2, "details", void 0, "kehto-approval-identity");
|
|
22365
|
+
const identityText = element(document2, "p");
|
|
22366
|
+
identity.append(element(document2, "summary", "Technical identity"), identityText);
|
|
22367
|
+
const remember = element(document2, "div", void 0, "kehto-approval-remember");
|
|
22368
|
+
remember.setAttribute("role", "group");
|
|
22369
|
+
remember.setAttribute("aria-label", "Remember this decision");
|
|
22370
|
+
const rule = element(document2, "label", void 0, "kehto-approval-rule");
|
|
22371
|
+
const ruleBox = element(document2, "input");
|
|
22372
|
+
ruleBox.type = "checkbox";
|
|
22373
|
+
const ruleText = element(document2, "span");
|
|
22374
|
+
rule.append(ruleBox, ruleText);
|
|
22375
|
+
const actions = element(document2, "div", void 0, "kehto-approval-actions");
|
|
22484
22376
|
const deny = element(document2, "button", "Deny");
|
|
22485
22377
|
deny.type = "button";
|
|
22486
|
-
const
|
|
22487
|
-
cancel.type = "button";
|
|
22488
|
-
const allow = element(document2, "button", "Allow");
|
|
22378
|
+
const allow = element(document2, "button", "Allow", "kehto-approval-primary");
|
|
22489
22379
|
allow.type = "button";
|
|
22490
|
-
actions.append(deny,
|
|
22491
|
-
dialog.append(title, description,
|
|
22380
|
+
actions.append(deny, allow);
|
|
22381
|
+
dialog.append(eyebrow, title, description, requirements3, mediation, identity, remember, rule, actions);
|
|
22382
|
+
return { dialog, eyebrow, title, description, requirements: requirements3, mediation, identityText, remember, rule, ruleBox, ruleText, deny, allow };
|
|
22383
|
+
}
|
|
22384
|
+
function createBrowserApprovalPrompt(document2, labelForPrincipal, offersRule = () => false) {
|
|
22385
|
+
const view = buildDialog(document2);
|
|
22386
|
+
const { dialog, deny, allow } = view;
|
|
22492
22387
|
const queue = [];
|
|
22493
22388
|
let finishActive;
|
|
22494
22389
|
let destroyed = false;
|
|
22390
|
+
function showQueue() {
|
|
22391
|
+
view.eyebrow.textContent = queue.length ? `Permission request \xB7 ${queue.length} more waiting` : "Permission request";
|
|
22392
|
+
}
|
|
22393
|
+
function fill(request) {
|
|
22394
|
+
const principal = request.request.principal;
|
|
22395
|
+
view.title.textContent = promptTitle(request.missing);
|
|
22396
|
+
view.description.replaceChildren(
|
|
22397
|
+
element(document2, "strong", labelForPrincipal(principal)),
|
|
22398
|
+
element(document2, "span", principal.kind === "verified" ? "verified" : "development", "kehto-approval-badge"),
|
|
22399
|
+
element(document2, "span", " is asking to:")
|
|
22400
|
+
);
|
|
22401
|
+
view.identityText.textContent = principalIdentity(principal);
|
|
22402
|
+
view.requirements.replaceChildren(...describeRequirements(request.missing).map((text2) => {
|
|
22403
|
+
const row = element(document2, "li");
|
|
22404
|
+
row.append(element(document2, "span", text2.action));
|
|
22405
|
+
if (text2.target !== void 0) row.append(element(document2, "code", text2.target));
|
|
22406
|
+
return row;
|
|
22407
|
+
}));
|
|
22408
|
+
view.mediation.textContent = request.missing.some((item) => item.category === "network" && item.operation.startsWith("network.")) ? NETWORK_NOTE : "The parent mediates and limits this operation.";
|
|
22409
|
+
const target = offersRule() ? ruleTargetFor(request.missing) : void 0;
|
|
22410
|
+
view.rule.hidden = !target;
|
|
22411
|
+
view.ruleBox.checked = false;
|
|
22412
|
+
view.ruleText.textContent = target ? `Do this for every future ${target.operation ?? `${target.domain} interface`} request from this napplet` : "";
|
|
22413
|
+
}
|
|
22495
22414
|
function present(request) {
|
|
22496
|
-
|
|
22497
|
-
|
|
22498
|
-
|
|
22499
|
-
|
|
22500
|
-
"
|
|
22501
|
-
|
|
22502
|
-
|
|
22503
|
-
|
|
22504
|
-
|
|
22505
|
-
|
|
22506
|
-
|
|
22507
|
-
|
|
22508
|
-
|
|
22509
|
-
|
|
22510
|
-
}
|
|
22511
|
-
|
|
22512
|
-
|
|
22415
|
+
fill(request);
|
|
22416
|
+
showQueue();
|
|
22417
|
+
let selected = request.allowLifetimes[0];
|
|
22418
|
+
const choices = request.allowLifetimes.map((lifetime) => {
|
|
22419
|
+
const choice = element(document2, "button", LIFETIME_LABELS[lifetime]);
|
|
22420
|
+
choice.type = "button";
|
|
22421
|
+
choice.value = lifetime;
|
|
22422
|
+
return choice;
|
|
22423
|
+
});
|
|
22424
|
+
const mark = () => {
|
|
22425
|
+
for (const choice of choices) {
|
|
22426
|
+
choice.setAttribute("aria-pressed", String(choice.value === selected));
|
|
22427
|
+
choice.disabled = view.ruleBox.checked;
|
|
22428
|
+
}
|
|
22429
|
+
};
|
|
22430
|
+
view.remember.replaceChildren(element(document2, "span", "Remember"), ...choices);
|
|
22431
|
+
view.remember.hidden = choices.length === 0;
|
|
22432
|
+
allow.disabled = selected === void 0;
|
|
22433
|
+
mark();
|
|
22513
22434
|
const priorFocus = document2.activeElement;
|
|
22514
22435
|
return new Promise((resolve) => {
|
|
22515
22436
|
let settled = false;
|
|
22516
|
-
const
|
|
22437
|
+
const listeners = [];
|
|
22438
|
+
const listen = (target, type, listener) => {
|
|
22439
|
+
target.addEventListener(type, listener);
|
|
22440
|
+
listeners.push(() => target.removeEventListener(type, listener));
|
|
22441
|
+
};
|
|
22442
|
+
const finish = (result2) => {
|
|
22517
22443
|
if (settled) return;
|
|
22518
22444
|
settled = true;
|
|
22519
22445
|
finishActive = void 0;
|
|
22520
|
-
|
|
22521
|
-
deny.removeEventListener("click", onDeny);
|
|
22522
|
-
cancel.removeEventListener("click", onCancel);
|
|
22523
|
-
allow.removeEventListener("click", onAllow);
|
|
22524
|
-
lifetime.removeEventListener("change", onLifetime);
|
|
22525
|
-
dialog.removeEventListener("cancel", onDialogCancel);
|
|
22526
|
-
dialog.removeEventListener("close", onDialogClose);
|
|
22446
|
+
for (const remove of listeners.splice(0)) remove();
|
|
22527
22447
|
if (dialog.open) dialog.close();
|
|
22528
22448
|
if (priorFocus && "focus" in priorFocus && priorFocus.isConnected) {
|
|
22529
22449
|
priorFocus.focus();
|
|
22530
22450
|
}
|
|
22531
|
-
resolve(
|
|
22532
|
-
};
|
|
22533
|
-
const onAbort = () => finish({ effect: "cancel" });
|
|
22534
|
-
const onDeny = () => finish({ effect: "deny", lifetime: "once" });
|
|
22535
|
-
const onCancel = () => finish({ effect: "cancel" });
|
|
22536
|
-
const onAllow = () => {
|
|
22537
|
-
const selected = request.allowLifetimes.find((item) => item === lifetime.value);
|
|
22538
|
-
if (selected) finish({ effect: "allow", lifetime: selected });
|
|
22539
|
-
};
|
|
22540
|
-
const onLifetime = () => {
|
|
22541
|
-
allow.disabled = !request.allowLifetimes.includes(lifetime.value);
|
|
22542
|
-
};
|
|
22543
|
-
const onDialogCancel = (event) => {
|
|
22544
|
-
event.preventDefault();
|
|
22545
|
-
finish({ effect: "cancel" });
|
|
22546
|
-
};
|
|
22547
|
-
const onDialogClose = () => {
|
|
22548
|
-
if (!dialog.open) finish({ effect: "cancel" });
|
|
22451
|
+
resolve(result2);
|
|
22549
22452
|
};
|
|
22550
22453
|
finishActive = finish;
|
|
22454
|
+
const onAbort = () => finish(CANCELLED2);
|
|
22551
22455
|
request.signal.addEventListener("abort", onAbort, { once: true });
|
|
22552
|
-
|
|
22553
|
-
|
|
22554
|
-
allow
|
|
22555
|
-
|
|
22556
|
-
|
|
22557
|
-
|
|
22456
|
+
listeners.push(() => request.signal.removeEventListener("abort", onAbort));
|
|
22457
|
+
listen(deny, "click", (event) => finish({ answer: { effect: "deny", lifetime: "once" }, asRule: view.ruleBox.checked, userGesture: event.isTrusted }));
|
|
22458
|
+
listen(allow, "click", (event) => {
|
|
22459
|
+
const asRule = view.ruleBox.checked;
|
|
22460
|
+
const lifetime = asRule && request.allowLifetimes.includes("session") ? "session" : selected;
|
|
22461
|
+
if (lifetime) finish({ answer: { effect: "allow", lifetime }, asRule, userGesture: event.isTrusted });
|
|
22462
|
+
});
|
|
22463
|
+
for (const choice of choices) listen(choice, "click", () => {
|
|
22464
|
+
selected = choice.value;
|
|
22465
|
+
mark();
|
|
22466
|
+
});
|
|
22467
|
+
listen(view.ruleBox, "change", mark);
|
|
22468
|
+
listen(dialog, "cancel", (event) => {
|
|
22469
|
+
event.preventDefault();
|
|
22470
|
+
finish(CANCELLED2);
|
|
22471
|
+
});
|
|
22472
|
+
listen(dialog, "close", () => {
|
|
22473
|
+
if (!dialog.open) finish(CANCELLED2);
|
|
22474
|
+
});
|
|
22558
22475
|
try {
|
|
22559
22476
|
dialog.showModal();
|
|
22560
22477
|
deny.focus();
|
|
22561
22478
|
} catch {
|
|
22562
|
-
finish(
|
|
22479
|
+
finish(CANCELLED2);
|
|
22563
22480
|
}
|
|
22564
22481
|
});
|
|
22565
22482
|
}
|
|
@@ -22569,99 +22486,346 @@ function createBrowserApprovalPrompt(document2, labelForPrincipal) {
|
|
|
22569
22486
|
if (!next) return;
|
|
22570
22487
|
next.request.signal.removeEventListener("abort", next.onAbort);
|
|
22571
22488
|
if (next.request.signal.aborted) {
|
|
22572
|
-
next.resolve(
|
|
22489
|
+
next.resolve(CANCELLED2);
|
|
22573
22490
|
pump();
|
|
22574
22491
|
return;
|
|
22575
22492
|
}
|
|
22576
|
-
void present(next.request).then((
|
|
22577
|
-
next.resolve(
|
|
22493
|
+
void present(next.request).then((result2) => {
|
|
22494
|
+
next.resolve(result2);
|
|
22578
22495
|
pump();
|
|
22579
22496
|
});
|
|
22580
22497
|
}
|
|
22581
22498
|
function prompt(request) {
|
|
22582
22499
|
if (destroyed || request.signal.aborted || queue.length + Number(!!finishActive) >= MAX_PENDING_PROMPTS) {
|
|
22583
|
-
return Promise.resolve(
|
|
22500
|
+
return Promise.resolve(CANCELLED2);
|
|
22584
22501
|
}
|
|
22585
22502
|
return new Promise((resolve) => {
|
|
22586
|
-
const
|
|
22587
|
-
|
|
22588
|
-
|
|
22589
|
-
|
|
22590
|
-
|
|
22503
|
+
const queued = {
|
|
22504
|
+
request,
|
|
22505
|
+
resolve,
|
|
22506
|
+
onAbort: () => {
|
|
22507
|
+
const index = queue.indexOf(queued);
|
|
22508
|
+
if (index < 0) return;
|
|
22509
|
+
queue.splice(index, 1);
|
|
22510
|
+
showQueue();
|
|
22511
|
+
resolve(CANCELLED2);
|
|
22512
|
+
}
|
|
22591
22513
|
};
|
|
22592
|
-
request.signal.addEventListener("abort", onAbort, { once: true });
|
|
22593
|
-
queue.push(
|
|
22514
|
+
request.signal.addEventListener("abort", queued.onAbort, { once: true });
|
|
22515
|
+
queue.push(queued);
|
|
22516
|
+
showQueue();
|
|
22594
22517
|
pump();
|
|
22595
22518
|
});
|
|
22596
22519
|
}
|
|
22597
22520
|
function destroy() {
|
|
22598
22521
|
destroyed = true;
|
|
22599
|
-
finishActive?.(
|
|
22600
|
-
for (const
|
|
22601
|
-
|
|
22602
|
-
|
|
22522
|
+
finishActive?.(CANCELLED2);
|
|
22523
|
+
for (const queued of queue.splice(0)) {
|
|
22524
|
+
queued.request.signal.removeEventListener("abort", queued.onAbort);
|
|
22525
|
+
queued.resolve(CANCELLED2);
|
|
22603
22526
|
}
|
|
22604
22527
|
}
|
|
22605
22528
|
return { dialog, prompt, destroy };
|
|
22606
22529
|
}
|
|
22607
|
-
|
|
22608
|
-
|
|
22609
|
-
|
|
22610
|
-
|
|
22530
|
+
var SHORT_LIFETIME = Object.freeze({
|
|
22531
|
+
once: "once",
|
|
22532
|
+
session: "session",
|
|
22533
|
+
persistent: "always"
|
|
22534
|
+
});
|
|
22535
|
+
function createGrantList(document2, options) {
|
|
22536
|
+
const root = element(document2, "div", void 0, "kehto-fw-grants");
|
|
22537
|
+
const closedNapplets = /* @__PURE__ */ new Set();
|
|
22538
|
+
const openRows = /* @__PURE__ */ new Set();
|
|
22539
|
+
function icon(glyph, label, grants) {
|
|
22540
|
+
const node = element(document2, "button", glyph, "kehto-fw-icon");
|
|
22541
|
+
node.type = "button";
|
|
22542
|
+
node.title = label;
|
|
22543
|
+
node.setAttribute("aria-label", label);
|
|
22544
|
+
node.addEventListener("click", (event) => {
|
|
22545
|
+
event.preventDefault();
|
|
22546
|
+
event.stopPropagation();
|
|
22547
|
+
options.revoke(grants);
|
|
22548
|
+
});
|
|
22549
|
+
return node;
|
|
22550
|
+
}
|
|
22551
|
+
function track(details, key, open, invert2) {
|
|
22552
|
+
details.open = open.has(key) !== invert2;
|
|
22553
|
+
details.addEventListener("toggle", () => {
|
|
22554
|
+
if (details.open !== invert2) open.add(key);
|
|
22555
|
+
else open.delete(key);
|
|
22556
|
+
});
|
|
22557
|
+
}
|
|
22558
|
+
function dot(effect) {
|
|
22559
|
+
const node = element(document2, "span", void 0, `kehto-fw-dot kehto-fw-${effect}`);
|
|
22560
|
+
node.setAttribute("aria-hidden", "true");
|
|
22561
|
+
return node;
|
|
22562
|
+
}
|
|
22563
|
+
function effectOf(grants) {
|
|
22564
|
+
const denied2 = grants.filter((grant2) => grant2.effect === "deny").length;
|
|
22565
|
+
return denied2 === 0 ? "allow" : denied2 === grants.length ? "deny" : "mixed";
|
|
22566
|
+
}
|
|
22567
|
+
function grantRow(group, grant2) {
|
|
22568
|
+
const text2 = describeRequirement(grant2.permission);
|
|
22569
|
+
const scope = grant2.permission.scope;
|
|
22570
|
+
const details = element(document2, "details", void 0, "kehto-fw-grant");
|
|
22571
|
+
track(details, `${group.key}#${grant2.id}`, openRows, false);
|
|
22572
|
+
const row = element(document2, "summary", void 0, "kehto-fw-row");
|
|
22573
|
+
row.append(dot(grant2.effect), element(document2, "span", text2.action, "kehto-fw-name"));
|
|
22574
|
+
if (text2.target !== void 0) row.append(element(document2, "code", text2.target));
|
|
22575
|
+
row.append(
|
|
22576
|
+
element(document2, "small", SHORT_LIFETIME[grant2.lifetime]),
|
|
22577
|
+
icon("\xD7", `Revoke ${grant2.permission.operation} ${scope.kind}:${scope.value}`, [grant2])
|
|
22578
|
+
);
|
|
22579
|
+
const more = element(document2, "p", void 0, "kehto-fw-more");
|
|
22580
|
+
more.append(
|
|
22581
|
+
element(document2, "span", `${grant2.effect === "allow" ? "Allowed" : "Blocked"} \xB7 ${LIFETIME_LABELS[grant2.lifetime]}`),
|
|
22582
|
+
element(document2, "code", `${grant2.permission.operation} ${scope.kind}:${scope.value}`)
|
|
22583
|
+
);
|
|
22584
|
+
details.append(row, more);
|
|
22585
|
+
return details;
|
|
22586
|
+
}
|
|
22587
|
+
function nappletGroup(group) {
|
|
22588
|
+
const label = options.labelForPrincipal(group.principal);
|
|
22589
|
+
const all = [...group.decided.flatMap((domain) => domain.grants), ...group.byRule];
|
|
22590
|
+
const details = element(document2, "details", void 0, "kehto-fw-napplet");
|
|
22591
|
+
track(details, group.key, closedNapplets, true);
|
|
22592
|
+
const summary = element(document2, "summary", void 0, "kehto-fw-row");
|
|
22593
|
+
summary.append(
|
|
22594
|
+
dot(effectOf(all)),
|
|
22595
|
+
element(document2, "strong", label, "kehto-fw-name"),
|
|
22596
|
+
element(document2, "span", group.principal.kind === "verified" ? "verified" : "dev", "kehto-approval-badge"),
|
|
22597
|
+
element(document2, "small", String(all.length)),
|
|
22598
|
+
icon("\xD7", `Revoke every grant for ${label}`, all)
|
|
22599
|
+
);
|
|
22600
|
+
const identity = element(document2, "p", principalSummary(group.principal), "kehto-fw-identity");
|
|
22601
|
+
identity.title = principalIdentity(group.principal);
|
|
22602
|
+
details.append(summary, identity);
|
|
22603
|
+
if (group.byRule.length) {
|
|
22604
|
+
const byRule = element(document2, "div", void 0, "kehto-fw-row kehto-fw-by-rule");
|
|
22605
|
+
byRule.append(
|
|
22606
|
+
dot("allow"),
|
|
22607
|
+
element(document2, "span", `${group.byRule.length} allowed by default rules`, "kehto-fw-name"),
|
|
22608
|
+
element(document2, "small", "session"),
|
|
22609
|
+
icon("\u21BA", `Reset default-rule grants for ${label}`, group.byRule)
|
|
22610
|
+
);
|
|
22611
|
+
details.append(byRule);
|
|
22612
|
+
}
|
|
22613
|
+
for (const domain of group.decided) {
|
|
22614
|
+
const section = element(document2, "details", void 0, "kehto-fw-domain");
|
|
22615
|
+
track(section, `${group.key}#${domain.domain}`, openRows, false);
|
|
22616
|
+
const heading = element(document2, "summary", void 0, "kehto-fw-row");
|
|
22617
|
+
heading.append(
|
|
22618
|
+
dot(effectOf(domain.grants)),
|
|
22619
|
+
element(document2, "code", domain.domain, "kehto-fw-name"),
|
|
22620
|
+
element(document2, "small", String(domain.grants.length)),
|
|
22621
|
+
icon("\xD7", `Revoke all ${domain.domain} decisions for ${label}`, domain.grants)
|
|
22622
|
+
);
|
|
22623
|
+
section.append(heading, ...domain.grants.map((grant2) => grantRow(group, grant2)));
|
|
22624
|
+
details.append(section);
|
|
22625
|
+
}
|
|
22626
|
+
return details;
|
|
22627
|
+
}
|
|
22628
|
+
function render(grants) {
|
|
22629
|
+
const groups = groupGrants(grants);
|
|
22630
|
+
root.replaceChildren(...groups.length ? groups.map(nappletGroup) : [element(document2, "p", "No grants yet.", "kehto-fw-hint")]);
|
|
22631
|
+
}
|
|
22632
|
+
return { root, render };
|
|
22633
|
+
}
|
|
22634
|
+
var ACTIONS = ["allow", "ask", "deny"].map((action) => [action, RULE_ACTION_LABELS[action]]);
|
|
22635
|
+
var EVERY_NAPPLET = "";
|
|
22636
|
+
function scopeRows(scope, napplet) {
|
|
22637
|
+
const base = napplet === void 0 ? {} : { napplet };
|
|
22638
|
+
return [
|
|
22639
|
+
...napplet !== void 0 && scope.default !== void 0 ? [{ target: base, action: scope.default }] : [],
|
|
22640
|
+
...Object.entries(scope.domains).map(([domain, action]) => ({ target: { ...base, domain }, action })),
|
|
22641
|
+
...Object.entries(scope.operations).map(([operation, action]) => ({ target: { ...base, operation }, action }))
|
|
22642
|
+
];
|
|
22643
|
+
}
|
|
22644
|
+
function capabilityText(target) {
|
|
22645
|
+
return target.operation ?? (target.domain !== void 0 ? `${target.domain}.*` : "Everything");
|
|
22646
|
+
}
|
|
22647
|
+
function createRulesEditor(document2, options) {
|
|
22648
|
+
const root = element(document2, "section", void 0, "kehto-fw-rules");
|
|
22649
|
+
root.setAttribute("aria-label", "Default rules");
|
|
22650
|
+
const head = element(document2, "div", void 0, "kehto-fw-head");
|
|
22651
|
+
const title = element(document2, "h3", "Default rules");
|
|
22652
|
+
title.title = "Used when no grant covers a request. The most specific rule wins. Tightening a rule stops napplets that relied on it.";
|
|
22653
|
+
const list = element(document2, "ul", void 0, "kehto-fw-rule-list");
|
|
22654
|
+
const form = element(document2, "form", void 0, "kehto-fw-rule-add");
|
|
22655
|
+
const scope = element(document2, "select");
|
|
22656
|
+
scope.setAttribute("aria-label", "Rule applies to");
|
|
22657
|
+
const capability = element(document2, "input");
|
|
22658
|
+
capability.type = "text";
|
|
22659
|
+
capability.setAttribute("aria-label", "Interface or operation");
|
|
22660
|
+
capability.setAttribute("placeholder", "link or link.open");
|
|
22661
|
+
capability.setAttribute("list", "kehto-fw-capabilities");
|
|
22662
|
+
capability.setAttribute("autocomplete", "off");
|
|
22663
|
+
capability.setAttribute("spellcheck", "false");
|
|
22664
|
+
const suggestions = element(document2, "datalist");
|
|
22665
|
+
suggestions.id = "kehto-fw-capabilities";
|
|
22666
|
+
const action = select2(document2, "Rule action", ACTIONS, "ask");
|
|
22667
|
+
const add = element(document2, "button", "+", "kehto-fw-icon");
|
|
22668
|
+
add.type = "submit";
|
|
22669
|
+
add.title = "Add rule";
|
|
22670
|
+
add.setAttribute("aria-label", "Add rule");
|
|
22671
|
+
form.append(capability, suggestions, scope, action, add);
|
|
22672
|
+
const error = element(document2, "p", void 0, "kehto-fw-error");
|
|
22673
|
+
error.setAttribute("role", "alert");
|
|
22674
|
+
const restore = element(document2, "button", "\u21BA", "kehto-fw-icon");
|
|
22675
|
+
restore.type = "button";
|
|
22676
|
+
restore.title = "Restore defaults";
|
|
22677
|
+
restore.setAttribute("aria-label", "Restore defaults");
|
|
22678
|
+
head.append(title, restore);
|
|
22679
|
+
root.append(head, list, form, error);
|
|
22680
|
+
function apply(next) {
|
|
22681
|
+
try {
|
|
22682
|
+
options.rules.set(next());
|
|
22683
|
+
error.textContent = "";
|
|
22684
|
+
} catch {
|
|
22685
|
+
error.textContent = "That rule could not be saved.";
|
|
22686
|
+
}
|
|
22687
|
+
options.onChange();
|
|
22688
|
+
}
|
|
22689
|
+
function row(label, capabilityLabel, entry, removable) {
|
|
22690
|
+
const item = element(document2, "li", void 0, "kehto-fw-row");
|
|
22691
|
+
const state = element(document2, "span", void 0, `kehto-fw-dot kehto-fw-${entry.action}`);
|
|
22692
|
+
state.setAttribute("aria-hidden", "true");
|
|
22693
|
+
const name = element(document2, "span", void 0, "kehto-fw-name");
|
|
22694
|
+
name.append(element(document2, "code", capabilityLabel), element(document2, "small", label));
|
|
22695
|
+
const choice = select2(document2, `Action for ${capabilityLabel}, ${label}`, ACTIONS, entry.action);
|
|
22696
|
+
choice.addEventListener("change", () => {
|
|
22697
|
+
apply(() => setPermissionRule(options.rules.get(), entry.target, choice.value));
|
|
22698
|
+
});
|
|
22699
|
+
item.append(state, name, choice);
|
|
22700
|
+
if (removable) {
|
|
22701
|
+
const remove = element(document2, "button", "\xD7", "kehto-fw-icon");
|
|
22702
|
+
remove.type = "button";
|
|
22703
|
+
remove.title = "Remove rule";
|
|
22704
|
+
remove.setAttribute("aria-label", `Remove rule for ${capabilityLabel}, ${label}`);
|
|
22705
|
+
remove.addEventListener("click", () => apply(() => setPermissionRule(options.rules.get(), entry.target, void 0)));
|
|
22706
|
+
item.append(remove);
|
|
22707
|
+
}
|
|
22708
|
+
return item;
|
|
22709
|
+
}
|
|
22710
|
+
function refresh() {
|
|
22711
|
+
const rules = options.rules.get();
|
|
22712
|
+
const subjects = options.subjects();
|
|
22713
|
+
const labelFor2 = (subject) => subjects.find((item) => item.subject === subject)?.label ?? subject;
|
|
22714
|
+
list.replaceChildren(
|
|
22715
|
+
row("all", "Everything else", { target: {}, action: rules.default }, false),
|
|
22716
|
+
...scopeRows(rules).map((entry) => row("all", capabilityText(entry.target), entry, true)),
|
|
22717
|
+
...Object.entries(rules.napplets).flatMap(([subject, napplet]) => scopeRows(napplet, subject).map((entry) => row(labelFor2(subject), capabilityText(entry.target), entry, true)))
|
|
22718
|
+
);
|
|
22719
|
+
const chosen = scope.value;
|
|
22720
|
+
const known = new Map([...subjects, ...Object.keys(rules.napplets).map((subject) => ({ subject, label: labelFor2(subject) }))].map((item) => [item.subject, item.label]));
|
|
22721
|
+
scope.replaceChildren(...[[EVERY_NAPPLET, "All napplets"], ...known].map(([value, text2]) => {
|
|
22722
|
+
const option = element(document2, "option", text2);
|
|
22723
|
+
option.value = value;
|
|
22724
|
+
return option;
|
|
22725
|
+
}));
|
|
22726
|
+
scope.value = known.has(chosen) ? chosen : EVERY_NAPPLET;
|
|
22727
|
+
suggestions.replaceChildren(...[...new Set(options.suggestions())].sort().map((value) => {
|
|
22728
|
+
const option = element(document2, "option");
|
|
22729
|
+
option.value = value;
|
|
22730
|
+
return option;
|
|
22731
|
+
}));
|
|
22732
|
+
restore.hidden = !options.rules.defaults;
|
|
22733
|
+
}
|
|
22734
|
+
form.addEventListener("submit", (event) => {
|
|
22735
|
+
event.preventDefault();
|
|
22736
|
+
const target = parseCapability(capability.value);
|
|
22737
|
+
if (!target) {
|
|
22738
|
+
error.textContent = "Enter an interface such as link, or an operation such as link.open.";
|
|
22739
|
+
return;
|
|
22740
|
+
}
|
|
22741
|
+
const napplet = scope.value === EVERY_NAPPLET ? {} : { napplet: scope.value };
|
|
22742
|
+
apply(() => setPermissionRule(options.rules.get(), { ...napplet, ...target }, action.value));
|
|
22743
|
+
if (!error.textContent) capability.value = "";
|
|
22744
|
+
});
|
|
22745
|
+
restore.addEventListener("click", () => {
|
|
22746
|
+
const defaults = options.rules.defaults;
|
|
22747
|
+
if (defaults) apply(() => defaults());
|
|
22748
|
+
});
|
|
22749
|
+
return { root, refresh };
|
|
22611
22750
|
}
|
|
22612
22751
|
function createBrowserApprovalUi(options) {
|
|
22613
22752
|
const document2 = options.mount.ownerDocument;
|
|
22614
|
-
const root =
|
|
22615
|
-
|
|
22616
|
-
const presenter = createBrowserApprovalPrompt(document2, options.labelForPrincipal);
|
|
22617
|
-
|
|
22753
|
+
const root = element(document2, "section", void 0, "kehto-approval-ui");
|
|
22754
|
+
const promptRoot = options.promptMount ? element(document2, "section", void 0, "kehto-approval-ui") : root;
|
|
22755
|
+
const presenter = createBrowserApprovalPrompt(document2, options.labelForPrincipal, () => !!options.rules);
|
|
22756
|
+
let destroyed = false;
|
|
22757
|
+
const management = element(document2, "section", void 0, "kehto-fw-management");
|
|
22618
22758
|
management.setAttribute("aria-label", "Firewall grants");
|
|
22619
|
-
const
|
|
22620
|
-
const status = element2(document2, "p");
|
|
22759
|
+
const status = element(document2, "p", void 0, "kehto-fw-error");
|
|
22621
22760
|
status.setAttribute("role", "alert");
|
|
22622
22761
|
status.setAttribute("aria-live", "assertive");
|
|
22623
|
-
const
|
|
22624
|
-
const clear = element2(document2, "button", "Clear all grants");
|
|
22762
|
+
const clear = element(document2, "button", "\xD7", "kehto-fw-icon");
|
|
22625
22763
|
clear.type = "button";
|
|
22626
|
-
|
|
22764
|
+
clear.title = "Clear all grants";
|
|
22765
|
+
clear.setAttribute("aria-label", "Clear all grants");
|
|
22766
|
+
const retry = element(document2, "button", "Retry permission storage");
|
|
22627
22767
|
retry.type = "button";
|
|
22628
|
-
|
|
22629
|
-
|
|
22768
|
+
const head = element(document2, "div", void 0, "kehto-fw-head");
|
|
22769
|
+
head.append(element(document2, "h3", "Firewall grants"), clear);
|
|
22770
|
+
function revoke2(grants) {
|
|
22771
|
+
const live = options.getPermissions();
|
|
22772
|
+
if (!live) return;
|
|
22773
|
+
const results = grants.map((grant2) => [grant2, live.revoke(grant2.id)]);
|
|
22774
|
+
for (const [grant2, durable] of results) options.onGrantRevoked?.(grant2, durable);
|
|
22775
|
+
if (results.some(([, durable]) => !durable)) reportStorageError("save-failed");
|
|
22776
|
+
refresh();
|
|
22777
|
+
}
|
|
22778
|
+
function subjects() {
|
|
22779
|
+
const seen = /* @__PURE__ */ new Map();
|
|
22780
|
+
for (const grant2 of options.getPermissions()?.grants ?? []) {
|
|
22781
|
+
const subject = permissionRuleSubject(grant2.principal);
|
|
22782
|
+
if (!seen.has(subject)) seen.set(subject, options.labelForPrincipal(grant2.principal));
|
|
22783
|
+
}
|
|
22784
|
+
return [...seen].map(([subject, label]) => ({ subject, label }));
|
|
22785
|
+
}
|
|
22786
|
+
function resetStaleRuleGrants() {
|
|
22787
|
+
const rules = options.rules?.get();
|
|
22788
|
+
const grants = options.getPermissions()?.grants ?? [];
|
|
22789
|
+
if (!rules) return;
|
|
22790
|
+
const stale = grants.filter((grant2) => isRuleGrant(grant2) && resolvePermissionRule(rules, grant2.principal, grant2.permission) !== "allow");
|
|
22791
|
+
if (stale.length) revoke2(stale);
|
|
22792
|
+
else refresh();
|
|
22793
|
+
}
|
|
22794
|
+
const grantList = createGrantList(document2, { labelForPrincipal: options.labelForPrincipal, revoke: revoke2 });
|
|
22795
|
+
const rulesEditor = options.rules ? createRulesEditor(document2, {
|
|
22796
|
+
rules: options.rules,
|
|
22797
|
+
subjects,
|
|
22798
|
+
onChange: resetStaleRuleGrants,
|
|
22799
|
+
suggestions: () => (options.getPermissions()?.grants ?? []).flatMap((grant2) => [
|
|
22800
|
+
grant2.permission.domain,
|
|
22801
|
+
...grant2.permission.category === "interface" ? [] : [grant2.permission.operation]
|
|
22802
|
+
])
|
|
22803
|
+
}) : void 0;
|
|
22804
|
+
management.append(head, status, retry, grantList.root);
|
|
22805
|
+
promptRoot.append(presenter.dialog);
|
|
22806
|
+
if (rulesEditor) root.append(rulesEditor.root);
|
|
22807
|
+
root.append(management);
|
|
22630
22808
|
options.mount.append(root);
|
|
22631
|
-
|
|
22809
|
+
options.promptMount?.append(promptRoot);
|
|
22632
22810
|
function refresh() {
|
|
22633
22811
|
if (destroyed) return;
|
|
22812
|
+
rulesEditor?.refresh();
|
|
22634
22813
|
const permissions = options.getPermissions();
|
|
22635
|
-
list.replaceChildren();
|
|
22636
22814
|
if (!permissions) {
|
|
22815
|
+
grantList.render([]);
|
|
22637
22816
|
status.textContent = "Firewall permission runtime is unavailable.";
|
|
22638
22817
|
clear.disabled = true;
|
|
22639
22818
|
retry.disabled = true;
|
|
22819
|
+
retry.hidden = true;
|
|
22640
22820
|
options.onStorageStateChanged?.(false);
|
|
22641
22821
|
return;
|
|
22642
22822
|
}
|
|
22643
22823
|
clear.disabled = permissions.grants.length === 0;
|
|
22644
22824
|
retry.disabled = permissions.available;
|
|
22825
|
+
retry.hidden = permissions.available;
|
|
22645
22826
|
if (permissions.available && !status.dataset.storageFailure) status.textContent = "";
|
|
22646
22827
|
if (!permissions.available) status.textContent ||= "Permission storage is unavailable; new grants are blocked. Retry storage.";
|
|
22647
|
-
|
|
22648
|
-
const row = element2(document2, "li");
|
|
22649
|
-
const scope = grant2.permission.scope;
|
|
22650
|
-
const detail = element2(document2, "span", `${options.labelForPrincipal(grant2.principal)} \u2014 ${principalIdentity(grant2.principal)} \u2014 ${grant2.effect} ${grant2.permission.operation} ${scope.kind}:${scope.value} (${grant2.lifetime})`);
|
|
22651
|
-
const revoke2 = element2(document2, "button", "Revoke");
|
|
22652
|
-
revoke2.type = "button";
|
|
22653
|
-
revoke2.setAttribute("aria-label", `Revoke ${grant2.permission.operation} ${scope.kind}:${scope.value}`);
|
|
22654
|
-
revoke2.addEventListener("click", () => {
|
|
22655
|
-
const live = options.getPermissions();
|
|
22656
|
-
if (!live) return;
|
|
22657
|
-
const durable = live.revoke(grant2.id);
|
|
22658
|
-
options.onGrantRevoked?.(grant2, durable);
|
|
22659
|
-
if (!durable) reportStorageError("save-failed");
|
|
22660
|
-
refresh();
|
|
22661
|
-
});
|
|
22662
|
-
row.append(detail, revoke2);
|
|
22663
|
-
list.append(row);
|
|
22664
|
-
}
|
|
22828
|
+
grantList.render(permissions.grants);
|
|
22665
22829
|
options.onStorageStateChanged?.(permissions.available);
|
|
22666
22830
|
}
|
|
22667
22831
|
function reportStorageError(failure4) {
|
|
@@ -22688,14 +22852,29 @@ function createBrowserApprovalUi(options) {
|
|
|
22688
22852
|
} else reportStorageError("save-failed");
|
|
22689
22853
|
refresh();
|
|
22690
22854
|
});
|
|
22855
|
+
function rememberAsRule(request, effect) {
|
|
22856
|
+
const target = ruleTargetFor(request.missing);
|
|
22857
|
+
if (!options.rules || !target) return;
|
|
22858
|
+
try {
|
|
22859
|
+
const napplet = permissionRuleSubject(request.request.principal);
|
|
22860
|
+
options.rules.set(setPermissionRule(options.rules.get(), { napplet, ...target }, effect));
|
|
22861
|
+
} catch {
|
|
22862
|
+
}
|
|
22863
|
+
}
|
|
22691
22864
|
async function prompt(request) {
|
|
22692
|
-
const answer = await presenter.prompt(request);
|
|
22865
|
+
const { answer, asRule, userGesture } = await presenter.prompt(request);
|
|
22866
|
+
try {
|
|
22867
|
+
options.onAnswer?.(answer, userGesture);
|
|
22868
|
+
} catch {
|
|
22869
|
+
}
|
|
22870
|
+
if (asRule && answer.effect !== "cancel") rememberAsRule(request, answer.effect);
|
|
22693
22871
|
queueMicrotask(() => queueMicrotask(refresh));
|
|
22694
22872
|
return answer;
|
|
22695
22873
|
}
|
|
22696
22874
|
function destroy() {
|
|
22697
22875
|
destroyed = true;
|
|
22698
22876
|
presenter.destroy();
|
|
22877
|
+
if (promptRoot !== root) promptRoot.remove();
|
|
22699
22878
|
root.remove();
|
|
22700
22879
|
}
|
|
22701
22880
|
refresh();
|
|
@@ -22712,14 +22891,14 @@ var FRAME_ELEMENTS = /* @__PURE__ */ new Set([
|
|
|
22712
22891
|
]);
|
|
22713
22892
|
var FRAME_TAG = /<\/?(?:iframe|frame|frameset|object|embed|portal|fencedframe)(?=[\s/>]|$)/i;
|
|
22714
22893
|
function subtreeHasFrame(root) {
|
|
22715
|
-
for (const
|
|
22716
|
-
const local = (
|
|
22717
|
-
if (
|
|
22894
|
+
for (const element22 of Array.from(root.querySelectorAll("*"))) {
|
|
22895
|
+
const local = (element22.localName || "").toLowerCase();
|
|
22896
|
+
if (element22.namespaceURI === "http://www.w3.org/1999/xhtml" && FRAME_ELEMENTS.has(local)) {
|
|
22718
22897
|
return true;
|
|
22719
22898
|
}
|
|
22720
|
-
const template =
|
|
22899
|
+
const template = element22;
|
|
22721
22900
|
if (local === "template" && template.content && subtreeHasFrame(template.content)) return true;
|
|
22722
|
-
if (
|
|
22901
|
+
if (element22.shadowRoot && subtreeHasFrame(element22.shadowRoot)) return true;
|
|
22723
22902
|
}
|
|
22724
22903
|
return false;
|
|
22725
22904
|
}
|
|
@@ -22742,6 +22921,72 @@ function assertNappletHasNoFrame(html) {
|
|
|
22742
22921
|
}
|
|
22743
22922
|
}
|
|
22744
22923
|
|
|
22924
|
+
// src/browser-link.ts
|
|
22925
|
+
var APPROVAL_CLICK_WINDOW_MS = 1e3;
|
|
22926
|
+
var approvalClickAt = Number.NEGATIVE_INFINITY;
|
|
22927
|
+
function notePajaApprovalClick(now2 = performance.now()) {
|
|
22928
|
+
approvalClickAt = now2;
|
|
22929
|
+
}
|
|
22930
|
+
function hasPajaApprovalClick(now2 = performance.now()) {
|
|
22931
|
+
if (now2 - approvalClickAt > APPROVAL_CLICK_WINDOW_MS) return false;
|
|
22932
|
+
return typeof navigator !== "undefined" && navigator.userActivation?.isActive === true;
|
|
22933
|
+
}
|
|
22934
|
+
async function confirmPajaExternalLink(context, confirm, getIdentity, open, userActivation, isActivated = hasPajaApprovalClick) {
|
|
22935
|
+
const { windowId, url, options, signal } = context;
|
|
22936
|
+
if (signal?.aborted) return { status: "denied" };
|
|
22937
|
+
const fallback = { dTag: "dev-target", aggregateHash: "paja" };
|
|
22938
|
+
const identity = getIdentity?.(windowId) ?? fallback;
|
|
22939
|
+
const isCurrent = () => {
|
|
22940
|
+
const current = getIdentity?.(windowId) ?? fallback;
|
|
22941
|
+
return !signal?.aborted && (identity.isCurrent?.() ?? true) && current.dTag === identity.dTag && current.aggregateHash === identity.aggregateHash;
|
|
22942
|
+
};
|
|
22943
|
+
const request = {
|
|
22944
|
+
action: "link",
|
|
22945
|
+
windowId,
|
|
22946
|
+
napplet: identity,
|
|
22947
|
+
url: url.href,
|
|
22948
|
+
...options?.label ? { label: options.label.slice(0, 256) } : {},
|
|
22949
|
+
isCurrent
|
|
22950
|
+
};
|
|
22951
|
+
const openCurrent = () => isCurrent() && open(url);
|
|
22952
|
+
if (signal && isActivated() && openCurrent()) return { status: "opened" };
|
|
22953
|
+
try {
|
|
22954
|
+
const opened = userActivation ? await userActivation.run(request, openCurrent) : await confirm(request) && openCurrent();
|
|
22955
|
+
return { status: opened ? "opened" : "denied" };
|
|
22956
|
+
} catch {
|
|
22957
|
+
return { status: "denied" };
|
|
22958
|
+
}
|
|
22959
|
+
}
|
|
22960
|
+
|
|
22961
|
+
// src/browser-permission-rules.ts
|
|
22962
|
+
var PAJA_PERMISSION_RULES_STORAGE_KEY = "kehto:paja:firewall-rules:v1";
|
|
22963
|
+
function pajaDefaultPermissionRules() {
|
|
22964
|
+
return createPermissionRules({ default: "allow", operations: { "link.open": "ask" } });
|
|
22965
|
+
}
|
|
22966
|
+
function createPajaPermissionRuleStore(storage) {
|
|
22967
|
+
let rules = pajaDefaultPermissionRules();
|
|
22968
|
+
try {
|
|
22969
|
+
const raw = storage?.getItem(PAJA_PERMISSION_RULES_STORAGE_KEY);
|
|
22970
|
+
const loaded = raw ? deserializePermissionRules(raw) : void 0;
|
|
22971
|
+
if (loaded?.ok) rules = loaded.rules;
|
|
22972
|
+
} catch {
|
|
22973
|
+
}
|
|
22974
|
+
return {
|
|
22975
|
+
get: () => rules,
|
|
22976
|
+
set(next) {
|
|
22977
|
+
const validated = createPermissionRules(next);
|
|
22978
|
+
storage?.setItem(PAJA_PERMISSION_RULES_STORAGE_KEY, serializePermissionRules(validated));
|
|
22979
|
+
rules = validated;
|
|
22980
|
+
},
|
|
22981
|
+
defaults: pajaDefaultPermissionRules,
|
|
22982
|
+
decide(request, missing) {
|
|
22983
|
+
const actions = missing.map((requirement) => resolvePermissionRule(rules, request.principal, requirement));
|
|
22984
|
+
if (actions.includes("deny")) return "deny";
|
|
22985
|
+
return actions.every((action) => action === "allow") ? "allow" : "ask";
|
|
22986
|
+
}
|
|
22987
|
+
};
|
|
22988
|
+
}
|
|
22989
|
+
|
|
22745
22990
|
// src/browser-permission-adapter.ts
|
|
22746
22991
|
var PAJA_PERMISSION_STORAGE_KEY = "kehto:paja:firewall-permissions:v1";
|
|
22747
22992
|
function readStorage() {
|
|
@@ -22753,20 +22998,44 @@ function readStorage() {
|
|
|
22753
22998
|
}
|
|
22754
22999
|
function createPajaPermissionAdapter(options) {
|
|
22755
23000
|
const storage = options.storage === void 0 ? readStorage() : options.storage;
|
|
23001
|
+
const rules = createPajaPermissionRuleStore(storage);
|
|
22756
23002
|
const ui = createBrowserApprovalUi({
|
|
22757
23003
|
mount: options.mount,
|
|
23004
|
+
// A modal inside collapsed details/display:none still blocks the page,
|
|
23005
|
+
// but cannot show the decision admission is waiting for.
|
|
23006
|
+
promptMount: options.mount.ownerDocument.body,
|
|
22758
23007
|
getPermissions: options.getPermissions,
|
|
22759
23008
|
labelForPrincipal: options.labelForPrincipal ?? ((principal) => principal.kind === "verified" ? "Verified napplet" : "Development target"),
|
|
22760
|
-
onGrantRevoked: options.onGrantRevoked
|
|
23009
|
+
onGrantRevoked: options.onGrantRevoked,
|
|
23010
|
+
rules,
|
|
23011
|
+
onAnswer(answer, userGesture) {
|
|
23012
|
+
if (answer.effect === "allow" && userGesture) notePajaApprovalClick();
|
|
23013
|
+
}
|
|
22761
23014
|
});
|
|
23015
|
+
let refreshPending = false;
|
|
23016
|
+
const scheduleRefresh = () => {
|
|
23017
|
+
if (refreshPending) return;
|
|
23018
|
+
refreshPending = true;
|
|
23019
|
+
window.setTimeout(() => {
|
|
23020
|
+
refreshPending = false;
|
|
23021
|
+
ui.refresh();
|
|
23022
|
+
}, 0);
|
|
23023
|
+
};
|
|
22762
23024
|
const adapter = {
|
|
22763
23025
|
now: Date.now,
|
|
23026
|
+
rateLimiter: createRateLimiter(defaultRateLimitConfig()),
|
|
23027
|
+
promptRateLimiter: createRateLimiter(defaultPromptRateLimitConfig()),
|
|
22764
23028
|
createCancellation: () => new AbortController(),
|
|
22765
23029
|
schedule(callback, delayMs) {
|
|
22766
23030
|
const timer = window.setTimeout(callback, delayMs);
|
|
22767
23031
|
return () => window.clearTimeout(timer);
|
|
22768
23032
|
},
|
|
22769
23033
|
prompt: ui.prompt,
|
|
23034
|
+
defaultDecision(request, missing) {
|
|
23035
|
+
const decision = rules.decide(request, missing);
|
|
23036
|
+
if (decision === "allow") scheduleRefresh();
|
|
23037
|
+
return decision;
|
|
23038
|
+
},
|
|
22770
23039
|
onStorageError: ui.reportStorageError,
|
|
22771
23040
|
...storage ? { persistence: {
|
|
22772
23041
|
load: () => storage.getItem(PAJA_PERMISSION_STORAGE_KEY),
|
|
@@ -22774,7 +23043,7 @@ function createPajaPermissionAdapter(options) {
|
|
|
22774
23043
|
} } : {}
|
|
22775
23044
|
};
|
|
22776
23045
|
if (!storage) ui.reportStorageError("storage-unavailable");
|
|
22777
|
-
return { adapter, ui, destroy: () => ui.destroy() };
|
|
23046
|
+
return { adapter, ui, rules, destroy: () => ui.destroy() };
|
|
22778
23047
|
}
|
|
22779
23048
|
|
|
22780
23049
|
// src/local-target.ts
|
|
@@ -22951,20 +23220,20 @@ function createPajaSecuritySettings(getStorage = () => localStorage) {
|
|
|
22951
23220
|
}
|
|
22952
23221
|
function installPajaSecuritySettings() {
|
|
22953
23222
|
const settings = createPajaSecuritySettings();
|
|
22954
|
-
const
|
|
23223
|
+
const select3 = document.getElementById("paja-nested-context-lock");
|
|
22955
23224
|
const status = document.getElementById("paja-nested-context-lock-status");
|
|
22956
|
-
if (!
|
|
23225
|
+
if (!select3 || !status) return { getSetting: settings.getSetting, dispose: () => {
|
|
22957
23226
|
} };
|
|
22958
|
-
|
|
23227
|
+
select3.value = settings.getSetting() ?? "";
|
|
22959
23228
|
status.textContent = settings.getStatus();
|
|
22960
23229
|
const onChange = () => {
|
|
22961
|
-
const result2 = settings.save(
|
|
22962
|
-
|
|
23230
|
+
const result2 = settings.save(select3.value);
|
|
23231
|
+
select3.setAttribute("aria-invalid", String(!result2.ok));
|
|
22963
23232
|
status.textContent = result2.message;
|
|
22964
|
-
if (!result2.ok)
|
|
23233
|
+
if (!result2.ok) select3.value = settings.getSetting() ?? "";
|
|
22965
23234
|
};
|
|
22966
|
-
|
|
22967
|
-
return { getSetting: settings.getSetting, dispose: () =>
|
|
23235
|
+
select3.addEventListener("change", onChange);
|
|
23236
|
+
return { getSetting: settings.getSetting, dispose: () => select3.removeEventListener("change", onChange) };
|
|
22968
23237
|
}
|
|
22969
23238
|
|
|
22970
23239
|
// src/browser-target-frame.ts
|
|
@@ -23209,6 +23478,15 @@ function revokedPajaTabIds(config, tabs, grant2) {
|
|
|
23209
23478
|
return principal && permissionPrincipalKey(principal) === revoked;
|
|
23210
23479
|
}).map((tab) => tab.id);
|
|
23211
23480
|
}
|
|
23481
|
+
function pajaPrincipalLabel(config, tabs, principal) {
|
|
23482
|
+
const key = permissionPrincipalKey(principal);
|
|
23483
|
+
const tab = tabs.find((candidate) => {
|
|
23484
|
+
const open = getTargetOriginIdentity(config, candidate.resolvedTarget).permissionPrincipal;
|
|
23485
|
+
return open && permissionPrincipalKey(open) === key;
|
|
23486
|
+
});
|
|
23487
|
+
if (tab?.title) return tab.title;
|
|
23488
|
+
return principal.kind === "verified" ? "Verified napplet" : principal.target;
|
|
23489
|
+
}
|
|
23212
23490
|
|
|
23213
23491
|
// src/browser-llm-models.ts
|
|
23214
23492
|
var PajaLlmModelsError = class extends Error {
|
|
@@ -23425,7 +23703,7 @@ function meets(record3, requirements3) {
|
|
|
23425
23703
|
if (requirements3.tools === true && record3.tools !== true) return false;
|
|
23426
23704
|
return !(requirements3.json === true && !record3.json);
|
|
23427
23705
|
}
|
|
23428
|
-
function
|
|
23706
|
+
function describeRequirements2(requirements3) {
|
|
23429
23707
|
const parts = [
|
|
23430
23708
|
requirements3.model ? `model ${requirements3.model}` : "any model",
|
|
23431
23709
|
requirements3.images ? "image input" : null,
|
|
@@ -23479,12 +23757,12 @@ function createPajaLlmHost(options) {
|
|
|
23479
23757
|
}
|
|
23480
23758
|
return credential;
|
|
23481
23759
|
}
|
|
23482
|
-
async function
|
|
23760
|
+
async function select3(context, requirements3, prompt) {
|
|
23483
23761
|
const signal = prompt?.signal;
|
|
23484
23762
|
const napplet = getIdentity(context.windowId);
|
|
23485
23763
|
const candidates = store2.list().filter((record3) => meets(record3, requirements3));
|
|
23486
23764
|
if (candidates.length === 0) {
|
|
23487
|
-
const configure = await confirm({ action: "llm-configure", windowId: context.windowId, napplet, requirements:
|
|
23765
|
+
const configure = await confirm({ action: "llm-configure", windowId: context.windowId, napplet, requirements: describeRequirements2(requirements3), configured: store2.list().length, ...signal ? { signal } : {} });
|
|
23488
23766
|
if (!configure) return null;
|
|
23489
23767
|
options.openPanel();
|
|
23490
23768
|
throw new LlmServiceError("unsupported", "No compatible language model connection is configured yet. Add one in Paja's Language models panel, then select again.");
|
|
@@ -23496,7 +23774,7 @@ function createPajaLlmHost(options) {
|
|
|
23496
23774
|
}
|
|
23497
23775
|
return {
|
|
23498
23776
|
isConfigured: () => store2.list().length > 0,
|
|
23499
|
-
select:
|
|
23777
|
+
select: select3,
|
|
23500
23778
|
describe(_context, connectionId) {
|
|
23501
23779
|
const record3 = store2.get(connectionId);
|
|
23502
23780
|
return record3 ? toConnection(record3) : null;
|
|
@@ -23696,8 +23974,8 @@ function createPajaLlmVault(options = {}) {
|
|
|
23696
23974
|
|
|
23697
23975
|
// src/browser-llm-panel.ts
|
|
23698
23976
|
function byId(id, ctor) {
|
|
23699
|
-
const
|
|
23700
|
-
return
|
|
23977
|
+
const element3 = document.getElementById(id);
|
|
23978
|
+
return element3 instanceof ctor ? element3 : null;
|
|
23701
23979
|
}
|
|
23702
23980
|
function presetById(id) {
|
|
23703
23981
|
return LLM_PROVIDER_PRESETS.find((preset) => preset.id === id);
|
|
@@ -23779,10 +24057,10 @@ function createPasswordDialog() {
|
|
|
23779
24057
|
function createChooserDialog() {
|
|
23780
24058
|
const dialog = byId("paja-llm-select-dialog", HTMLDialogElement);
|
|
23781
24059
|
const copy = byId("paja-llm-select-copy", HTMLElement);
|
|
23782
|
-
const
|
|
24060
|
+
const select3 = byId("paja-llm-select-options", HTMLSelectElement);
|
|
23783
24061
|
const use = byId("paja-llm-select-use", HTMLButtonElement);
|
|
23784
24062
|
const deny = byId("paja-llm-select-deny", HTMLButtonElement);
|
|
23785
|
-
if (!dialog || !copy || !
|
|
24063
|
+
if (!dialog || !copy || !select3 || !use || !deny) return { choose: async () => null, dispose: () => void 0 };
|
|
23786
24064
|
let settle4 = null;
|
|
23787
24065
|
const finish = (value) => {
|
|
23788
24066
|
const current = settle4;
|
|
@@ -23790,7 +24068,7 @@ function createChooserDialog() {
|
|
|
23790
24068
|
if (dialog.open) dialog.close();
|
|
23791
24069
|
current?.(value);
|
|
23792
24070
|
};
|
|
23793
|
-
const onUse = () => finish(
|
|
24071
|
+
const onUse = () => finish(select3.value || null);
|
|
23794
24072
|
const onDeny = (event) => {
|
|
23795
24073
|
event.preventDefault();
|
|
23796
24074
|
finish(null);
|
|
@@ -23804,13 +24082,13 @@ function createChooserDialog() {
|
|
|
23804
24082
|
if (context.signal?.aborted) return Promise.resolve(null);
|
|
23805
24083
|
const wanted = [context.requirements.model ? `model ${context.requirements.model}` : null, context.requirements.images ? "image input" : null, context.requirements.json ? "JSON output" : null, context.requirements.tools ? "tool calling" : null].filter(Boolean).join(", ");
|
|
23806
24084
|
copy.textContent = `${context.napplet.dTag} (${context.windowId}) asks to use a language model${wanted ? ` with ${wanted}` : ""}. Selecting does not send anything yet; each generation asks for consent.`;
|
|
23807
|
-
|
|
24085
|
+
select3.replaceChildren(...candidates.map((record3) => {
|
|
23808
24086
|
const option = document.createElement("option");
|
|
23809
24087
|
option.value = record3.id;
|
|
23810
24088
|
option.textContent = `${record3.name} \u2014 ${record3.model} (${new URL(record3.baseUrl).origin})`;
|
|
23811
24089
|
return option;
|
|
23812
24090
|
}));
|
|
23813
|
-
|
|
24091
|
+
select3.selectedIndex = candidates.length > 0 ? 0 : -1;
|
|
23814
24092
|
return new Promise((resolve) => {
|
|
23815
24093
|
const mine = (value) => {
|
|
23816
24094
|
detach();
|
|
@@ -23821,7 +24099,7 @@ function createChooserDialog() {
|
|
|
23821
24099
|
});
|
|
23822
24100
|
settle4 = mine;
|
|
23823
24101
|
dialog.showModal();
|
|
23824
|
-
|
|
24102
|
+
select3.focus();
|
|
23825
24103
|
});
|
|
23826
24104
|
},
|
|
23827
24105
|
dispose() {
|
|
@@ -27527,9 +27805,9 @@ function createPajaUploadRuntime(options) {
|
|
|
27527
27805
|
if (simulation.upload.mimeTypes && (!mimeType || !simulation.upload.mimeTypes.includes(mimeType))) {
|
|
27528
27806
|
throw new Error("unsupported media type");
|
|
27529
27807
|
}
|
|
27530
|
-
const
|
|
27531
|
-
if (!
|
|
27532
|
-
const selectedIdentity =
|
|
27808
|
+
const snapshot4 = identity;
|
|
27809
|
+
if (!snapshot4) throw new Error("no signer available");
|
|
27810
|
+
const selectedIdentity = snapshot4;
|
|
27533
27811
|
const server = effectiveServers(simulation, selectedIdentity.pubkey, discovered)[0];
|
|
27534
27812
|
if (!server) throw new Error("no server configured");
|
|
27535
27813
|
const selectedGeneration = generation2;
|
|
@@ -27567,12 +27845,12 @@ function createPajaUploadRuntime(options) {
|
|
|
27567
27845
|
};
|
|
27568
27846
|
function uploadInfo() {
|
|
27569
27847
|
const simulation = options.getSimulation();
|
|
27570
|
-
const
|
|
27571
|
-
const server =
|
|
27848
|
+
const snapshot4 = identity;
|
|
27849
|
+
const server = snapshot4 ? effectiveServers(simulation, snapshot4.pubkey, discovered)[0] : void 0;
|
|
27572
27850
|
return {
|
|
27573
27851
|
rails: [{
|
|
27574
27852
|
rail: "blossom",
|
|
27575
|
-
enabled: simulation.upload.mode === "blossom" && Boolean(
|
|
27853
|
+
enabled: simulation.upload.mode === "blossom" && Boolean(snapshot4 && server),
|
|
27576
27854
|
...server ? { returns: [new URL(server).protocol.slice(0, -1)] } : {}
|
|
27577
27855
|
}],
|
|
27578
27856
|
...simulation.upload.maxBytes !== void 0 ? { maxBytes: simulation.upload.maxBytes } : {},
|
|
@@ -28062,8 +28340,8 @@ function createPajaSocialCache(options) {
|
|
|
28062
28340
|
try {
|
|
28063
28341
|
const follows = await verifiedFollows(capturedPubkey, isStillCurrent, controller.signal);
|
|
28064
28342
|
if (!isStillCurrent()) return;
|
|
28065
|
-
const
|
|
28066
|
-
snapshots.set(capturedPubkey,
|
|
28343
|
+
const snapshot4 = { follows, profiles: /* @__PURE__ */ new Map() };
|
|
28344
|
+
snapshots.set(capturedPubkey, snapshot4);
|
|
28067
28345
|
for (let index = 0; index < follows.length; index += 1) {
|
|
28068
28346
|
if (!isStillCurrent()) return;
|
|
28069
28347
|
const author = follows[index];
|
|
@@ -28078,7 +28356,7 @@ function createPajaSocialCache(options) {
|
|
|
28078
28356
|
if (!isStillCurrent()) return;
|
|
28079
28357
|
if (warmed) {
|
|
28080
28358
|
const profile = profileResult(warmed, author);
|
|
28081
|
-
if (profile)
|
|
28359
|
+
if (profile) snapshot4.profiles.set(author, profile);
|
|
28082
28360
|
}
|
|
28083
28361
|
if ((index + 1) % PROFILE_WARM_YIELD_EVERY === 0 && index + 1 < follows.length) {
|
|
28084
28362
|
if (!isStillCurrent()) return;
|
|
@@ -28099,10 +28377,10 @@ function createPajaSocialCache(options) {
|
|
|
28099
28377
|
async function augmentQuery(filters, queryOptions, execute, signal) {
|
|
28100
28378
|
const canAugmentAtStart = canReadIdentity?.() ?? true;
|
|
28101
28379
|
const activePubkey = normalizePubkey2(options.getActivePubkey() ?? "");
|
|
28102
|
-
const
|
|
28380
|
+
const snapshot4 = canAugmentAtStart && activePubkey ? snapshots.get(activePubkey) : void 0;
|
|
28103
28381
|
const base = await execute();
|
|
28104
28382
|
if (signal?.aborted || !canAugmentAtStart || !(canReadIdentity?.() ?? true)) return base;
|
|
28105
|
-
return mergeResult(base, matchingCachedProfiles(
|
|
28383
|
+
return mergeResult(base, matchingCachedProfiles(snapshot4?.profiles, filters), filters, queryOptions);
|
|
28106
28384
|
}
|
|
28107
28385
|
return {
|
|
28108
28386
|
...router.getEvent ? { getEvent: router.getEvent.bind(router) } : {},
|
|
@@ -29195,33 +29473,6 @@ function waitForIceGathering(connection) {
|
|
|
29195
29473
|
});
|
|
29196
29474
|
}
|
|
29197
29475
|
|
|
29198
|
-
// src/browser-link.ts
|
|
29199
|
-
async function confirmPajaExternalLink(context, confirm, getIdentity, open, userActivation) {
|
|
29200
|
-
const { windowId, url, options, signal } = context;
|
|
29201
|
-
if (signal?.aborted) return { status: "denied" };
|
|
29202
|
-
const fallback = { dTag: "dev-target", aggregateHash: "paja" };
|
|
29203
|
-
const identity = getIdentity?.(windowId) ?? fallback;
|
|
29204
|
-
const isCurrent = () => {
|
|
29205
|
-
const current = getIdentity?.(windowId) ?? fallback;
|
|
29206
|
-
return !signal?.aborted && (identity.isCurrent?.() ?? true) && current.dTag === identity.dTag && current.aggregateHash === identity.aggregateHash;
|
|
29207
|
-
};
|
|
29208
|
-
const request = {
|
|
29209
|
-
action: "link",
|
|
29210
|
-
windowId,
|
|
29211
|
-
napplet: identity,
|
|
29212
|
-
url: url.href,
|
|
29213
|
-
...options?.label ? { label: options.label.slice(0, 256) } : {},
|
|
29214
|
-
isCurrent
|
|
29215
|
-
};
|
|
29216
|
-
const openCurrent = () => isCurrent() && open(url);
|
|
29217
|
-
try {
|
|
29218
|
-
const opened = userActivation ? await userActivation.run(request, openCurrent) : await confirm(request) && openCurrent();
|
|
29219
|
-
return { status: opened ? "opened" : "denied" };
|
|
29220
|
-
} catch {
|
|
29221
|
-
return { status: "denied" };
|
|
29222
|
-
}
|
|
29223
|
-
}
|
|
29224
|
-
|
|
29225
29476
|
// src/browser-fs-support.ts
|
|
29226
29477
|
var MAX_READ_BYTES = 1024 * 1024;
|
|
29227
29478
|
var MAX_WRITE_BYTES = 1024 * 1024;
|
|
@@ -29526,22 +29777,22 @@ async function createPajaBrowserFsBackend(options) {
|
|
|
29526
29777
|
}
|
|
29527
29778
|
}
|
|
29528
29779
|
async function snapshotEntry(entry, recursive) {
|
|
29529
|
-
const
|
|
29780
|
+
const snapshot4 = /* @__PURE__ */ new Map();
|
|
29530
29781
|
async function visit(path, handle, descend) {
|
|
29531
29782
|
if (handle.kind === "file") {
|
|
29532
29783
|
const file = await handle.getFile();
|
|
29533
|
-
|
|
29784
|
+
snapshot4.set(path, `file:${file.size}:${file.lastModified}`);
|
|
29534
29785
|
return;
|
|
29535
29786
|
}
|
|
29536
|
-
|
|
29787
|
+
snapshot4.set(path, "directory");
|
|
29537
29788
|
for await (const [name, childHandle] of handle.entries()) {
|
|
29538
29789
|
const childPath = `${path}/${name.normalize("NFC")}`;
|
|
29539
29790
|
if (childHandle.kind === "file" || descend) await visit(childPath, childHandle, descend);
|
|
29540
|
-
else
|
|
29791
|
+
else snapshot4.set(childPath, "directory");
|
|
29541
29792
|
}
|
|
29542
29793
|
}
|
|
29543
29794
|
await visit(entry.path, entry.handle, recursive);
|
|
29544
|
-
return
|
|
29795
|
+
return snapshot4;
|
|
29545
29796
|
}
|
|
29546
29797
|
function covered(watch, path) {
|
|
29547
29798
|
if (!watch.directory) return path === watch.path;
|
|
@@ -29814,7 +30065,7 @@ async function createPajaBrowserFsBackend(options) {
|
|
|
29814
30065
|
const entry = await resolveExisting(windowId, path);
|
|
29815
30066
|
assertPendingWatch(pending);
|
|
29816
30067
|
requirePermission(entry, "watch");
|
|
29817
|
-
const
|
|
30068
|
+
const snapshot4 = await snapshotEntry(entry, watchOptions?.recursive === true);
|
|
29818
30069
|
assertPendingWatch(pending);
|
|
29819
30070
|
const callback = onChange ?? (() => void 0);
|
|
29820
30071
|
const record3 = {
|
|
@@ -29823,7 +30074,7 @@ async function createPajaBrowserFsBackend(options) {
|
|
|
29823
30074
|
directory: entry.handle.kind === "directory",
|
|
29824
30075
|
recursive: watchOptions?.recursive === true,
|
|
29825
30076
|
onChange: callback,
|
|
29826
|
-
snapshot:
|
|
30077
|
+
snapshot: snapshot4,
|
|
29827
30078
|
closed: false
|
|
29828
30079
|
};
|
|
29829
30080
|
backendWatches.add(record3);
|
|
@@ -31459,8 +31710,8 @@ function createSignerConsentChoices(consentStore, reportSignerConsentChange, sha
|
|
|
31459
31710
|
["paja-signer-consent-napplet-verb", `Allow all ${request.action === "publish" ? "publishing" : "signing"} from`],
|
|
31460
31711
|
["paja-signer-consent-warning", `Paja will ${verb.toLowerCase()} any event this napplet version requests without asking again. A different version or signer needs new approval.`]
|
|
31461
31712
|
]) {
|
|
31462
|
-
const
|
|
31463
|
-
if (
|
|
31713
|
+
const element3 = document.getElementById(id);
|
|
31714
|
+
if (element3) element3.textContent = text2;
|
|
31464
31715
|
}
|
|
31465
31716
|
};
|
|
31466
31717
|
const rememberSignerChoice = (request) => {
|
|
@@ -33320,9 +33571,9 @@ function readPersistedRuntimeTabs(config) {
|
|
|
33320
33571
|
function persistRuntimeTabs(state) {
|
|
33321
33572
|
const storage = runtimeTabsStorage(state.config);
|
|
33322
33573
|
if (!storage) return;
|
|
33323
|
-
const
|
|
33574
|
+
const snapshot4 = snapshotRuntimeTabs(state);
|
|
33324
33575
|
try {
|
|
33325
|
-
if (
|
|
33576
|
+
if (snapshot4) storage.setItem(PAJA_RUNTIME_TABS_STORAGE_KEY, JSON.stringify(snapshot4));
|
|
33326
33577
|
else storage.removeItem(PAJA_RUNTIME_TABS_STORAGE_KEY);
|
|
33327
33578
|
} catch {
|
|
33328
33579
|
}
|
|
@@ -33643,26 +33894,26 @@ function createPajaIntentLinkController(document2 = window.document, options = {
|
|
|
33643
33894
|
}
|
|
33644
33895
|
|
|
33645
33896
|
// src/browser-intent-builder-controls.ts
|
|
33646
|
-
function
|
|
33897
|
+
function element2(name, className) {
|
|
33647
33898
|
const result2 = document.createElement(name);
|
|
33648
33899
|
if (className) result2.className = className;
|
|
33649
33900
|
return result2;
|
|
33650
33901
|
}
|
|
33651
33902
|
function createSelect(label, controlId) {
|
|
33652
|
-
const field =
|
|
33653
|
-
const labelText =
|
|
33903
|
+
const field = element2("label", "config-field");
|
|
33904
|
+
const labelText = element2("span", "config-field-label");
|
|
33654
33905
|
labelText.textContent = label;
|
|
33655
|
-
const control =
|
|
33906
|
+
const control = element2("select");
|
|
33656
33907
|
control.id = controlId;
|
|
33657
33908
|
field.htmlFor = control.id;
|
|
33658
33909
|
field.append(labelText, control);
|
|
33659
33910
|
return { field, control };
|
|
33660
33911
|
}
|
|
33661
33912
|
function createTextAreaField(label, controlId, readOnly = false) {
|
|
33662
|
-
const field =
|
|
33663
|
-
const labelText =
|
|
33913
|
+
const field = element2("label", "config-field");
|
|
33914
|
+
const labelText = element2("span", "config-field-label");
|
|
33664
33915
|
labelText.textContent = label;
|
|
33665
|
-
const control =
|
|
33916
|
+
const control = element2("textarea");
|
|
33666
33917
|
control.id = controlId;
|
|
33667
33918
|
control.rows = readOnly ? 3 : 5;
|
|
33668
33919
|
control.readOnly = readOnly;
|
|
@@ -33672,29 +33923,29 @@ function createTextAreaField(label, controlId, readOnly = false) {
|
|
|
33672
33923
|
return { field, control };
|
|
33673
33924
|
}
|
|
33674
33925
|
function createIntentLinkBuilderElements(id) {
|
|
33675
|
-
const dialog =
|
|
33926
|
+
const dialog = element2("dialog", "config-dialog");
|
|
33676
33927
|
dialog.id = `${id}-dialog`;
|
|
33677
33928
|
dialog.setAttribute("aria-labelledby", `${id}-title`);
|
|
33678
33929
|
dialog.setAttribute("aria-describedby", `${id}-status`);
|
|
33679
|
-
const form =
|
|
33680
|
-
const title =
|
|
33930
|
+
const form = element2("div", "dialog");
|
|
33931
|
+
const title = element2("div", "dialog-title");
|
|
33681
33932
|
title.id = `${id}-title`;
|
|
33682
33933
|
title.textContent = "Create intent link";
|
|
33683
|
-
const fields =
|
|
33684
|
-
const status =
|
|
33934
|
+
const fields = element2("div", "config-fields");
|
|
33935
|
+
const status = element2("div", "config-error");
|
|
33685
33936
|
status.id = `${id}-status`;
|
|
33686
33937
|
status.setAttribute("role", "status");
|
|
33687
33938
|
status.setAttribute("aria-live", "polite");
|
|
33688
|
-
const actions =
|
|
33689
|
-
const cancel =
|
|
33939
|
+
const actions = element2("div", "dialog-actions");
|
|
33940
|
+
const cancel = element2("button");
|
|
33690
33941
|
cancel.type = "button";
|
|
33691
33942
|
cancel.id = `${id}-cancel`;
|
|
33692
33943
|
cancel.textContent = "Cancel";
|
|
33693
|
-
const copy =
|
|
33944
|
+
const copy = element2("button");
|
|
33694
33945
|
copy.type = "button";
|
|
33695
33946
|
copy.id = `${id}-copy`;
|
|
33696
33947
|
copy.textContent = "Copy link";
|
|
33697
|
-
const test =
|
|
33948
|
+
const test = element2("button");
|
|
33698
33949
|
test.type = "button";
|
|
33699
33950
|
test.id = `${id}-test`;
|
|
33700
33951
|
test.textContent = "Test intent";
|
|
@@ -33705,21 +33956,21 @@ function createIntentLinkBuilderElements(id) {
|
|
|
33705
33956
|
const convention = createSelect("Convention", `${id}-convention`);
|
|
33706
33957
|
const routing = createSelect("Routing", `${id}-routing`);
|
|
33707
33958
|
const payloadMode = createSelect("Payload mode", `${id}-payload-mode`);
|
|
33708
|
-
const parameterGroup =
|
|
33709
|
-
const parameterLegend =
|
|
33959
|
+
const parameterGroup = element2("fieldset", "config-group");
|
|
33960
|
+
const parameterLegend = element2("legend");
|
|
33710
33961
|
parameterLegend.textContent = "Parameters";
|
|
33711
|
-
const parameterRows =
|
|
33962
|
+
const parameterRows = element2("div");
|
|
33712
33963
|
parameterRows.id = `${id}-parameters`;
|
|
33713
|
-
const addParameter =
|
|
33964
|
+
const addParameter = element2("button");
|
|
33714
33965
|
addParameter.type = "button";
|
|
33715
33966
|
addParameter.id = `${id}-add-parameter`;
|
|
33716
33967
|
addParameter.textContent = "Add parameter";
|
|
33717
33968
|
parameterGroup.append(parameterLegend, parameterRows, addParameter);
|
|
33718
33969
|
const { field: jsonField, control: json } = createTextAreaField("JSON payload", `${id}-json-payload`);
|
|
33719
|
-
const previewField =
|
|
33720
|
-
const previewLabel =
|
|
33970
|
+
const previewField = element2("label", "config-field");
|
|
33971
|
+
const previewLabel = element2("span", "config-field-label");
|
|
33721
33972
|
previewLabel.textContent = "Decoded preview";
|
|
33722
|
-
const preview =
|
|
33973
|
+
const preview = element2("output");
|
|
33723
33974
|
preview.id = `${id}-preview`;
|
|
33724
33975
|
previewField.append(previewLabel, preview);
|
|
33725
33976
|
const { field: linkField, control: link } = createTextAreaField("Copyable URL", `${id}-url`, true);
|
|
@@ -33751,12 +34002,12 @@ function createIntentLinkBuilderElements(id) {
|
|
|
33751
34002
|
link
|
|
33752
34003
|
};
|
|
33753
34004
|
}
|
|
33754
|
-
function appendIntentLinkBuilderOption(
|
|
33755
|
-
const option =
|
|
34005
|
+
function appendIntentLinkBuilderOption(select3, value, label, disabled = false) {
|
|
34006
|
+
const option = element2("option");
|
|
33756
34007
|
option.value = value;
|
|
33757
34008
|
option.textContent = label;
|
|
33758
34009
|
option.disabled = disabled;
|
|
33759
|
-
|
|
34010
|
+
select3.append(option);
|
|
33760
34011
|
}
|
|
33761
34012
|
|
|
33762
34013
|
// src/browser-intent-builder-rows.ts
|
|
@@ -34278,11 +34529,11 @@ function originLabel(getIdentity, windowId) {
|
|
|
34278
34529
|
return identity?.dTag ? `${identity.dTag} \xB7 ${windowId}` : windowId;
|
|
34279
34530
|
}
|
|
34280
34531
|
function button(document2, label, className) {
|
|
34281
|
-
const
|
|
34282
|
-
|
|
34283
|
-
|
|
34284
|
-
|
|
34285
|
-
return
|
|
34532
|
+
const element3 = document2.createElement("button");
|
|
34533
|
+
element3.type = "button";
|
|
34534
|
+
element3.className = className;
|
|
34535
|
+
element3.textContent = label;
|
|
34536
|
+
return element3;
|
|
34286
34537
|
}
|
|
34287
34538
|
function createPajaNotifyController(options) {
|
|
34288
34539
|
const document2 = options.document ?? globalThis.document;
|
|
@@ -34605,22 +34856,22 @@ function renderObjectFields(document2, parent, schema, values, path, bindings, s
|
|
|
34605
34856
|
}
|
|
34606
34857
|
function createFieldBinding(document2, path, schema, current, required) {
|
|
34607
34858
|
if (Array.isArray(schema.enum)) {
|
|
34608
|
-
const
|
|
34609
|
-
|
|
34859
|
+
const select3 = document2.createElement("select");
|
|
34860
|
+
select3.required = required;
|
|
34610
34861
|
if (!required) {
|
|
34611
34862
|
const empty = document2.createElement("option");
|
|
34612
34863
|
empty.value = "";
|
|
34613
34864
|
empty.textContent = "Not set";
|
|
34614
|
-
|
|
34865
|
+
select3.append(empty);
|
|
34615
34866
|
}
|
|
34616
34867
|
for (const [index, value] of schema.enum.entries()) {
|
|
34617
34868
|
const option = document2.createElement("option");
|
|
34618
34869
|
option.value = JSON.stringify(value);
|
|
34619
34870
|
option.textContent = Array.isArray(schema.enumDescriptions) && typeof schema.enumDescriptions[index] === "string" ? `${String(value)} \u2014 ${schema.enumDescriptions[index]}` : String(value);
|
|
34620
34871
|
option.selected = Object.is(value, current);
|
|
34621
|
-
|
|
34872
|
+
select3.append(option);
|
|
34622
34873
|
}
|
|
34623
|
-
return { element:
|
|
34874
|
+
return { element: select3, read: () => select3.value === "" ? void 0 : JSON.parse(select3.value) };
|
|
34624
34875
|
}
|
|
34625
34876
|
if (schema.type === "boolean") {
|
|
34626
34877
|
const input2 = document2.createElement("input");
|
|
@@ -34926,16 +35177,16 @@ async function loadRuntimePointer(state, context, value, options = {}) {
|
|
|
34926
35177
|
appendPajaMessageLog(state, "paja", { type: "paja.pointer.error", error: message3 });
|
|
34927
35178
|
}
|
|
34928
35179
|
}
|
|
34929
|
-
async function restorePersistedRuntimeTabs(state, context,
|
|
34930
|
-
for (const pointer of
|
|
35180
|
+
async function restorePersistedRuntimeTabs(state, context, snapshot4) {
|
|
35181
|
+
for (const pointer of snapshot4.pointers) {
|
|
34931
35182
|
await loadRuntimePointer(state, context, pointer, { skipDuplicatePrompt: true, persist: false });
|
|
34932
35183
|
}
|
|
34933
|
-
const activeTab = state.tabs[
|
|
35184
|
+
const activeTab = state.tabs[snapshot4.activeIndex] ?? state.tabs[0];
|
|
34934
35185
|
if (activeTab) activateRuntimeTab(state, context, activeTab.id);
|
|
34935
35186
|
persistRuntimeTabs2(state);
|
|
34936
35187
|
}
|
|
34937
|
-
async function hydratePersistedIntentCatalog(state, context,
|
|
34938
|
-
const pointers = /* @__PURE__ */ new Set([...readPajaIntentCatalogPointers(), ...
|
|
35188
|
+
async function hydratePersistedIntentCatalog(state, context, snapshot4) {
|
|
35189
|
+
const pointers = /* @__PURE__ */ new Set([...readPajaIntentCatalogPointers(), ...snapshot4?.pointers ?? []]);
|
|
34939
35190
|
await Promise.all([...pointers].map(async (pointer) => {
|
|
34940
35191
|
try {
|
|
34941
35192
|
const resolved = await resolvePajaPointer(pointer, pajaPointerResolverOptions(context));
|
|
@@ -35208,18 +35459,24 @@ async function installPajaHost() {
|
|
|
35208
35459
|
const permissionMount = document.getElementById("paja-permission-ui");
|
|
35209
35460
|
if (!permissionMount) throw new Error("Paja Firewall permission mount is missing");
|
|
35210
35461
|
let permissionBridge = null;
|
|
35462
|
+
const retiringPrincipals = /* @__PURE__ */ new Set();
|
|
35211
35463
|
const permissionController = createPajaPermissionAdapter({
|
|
35212
35464
|
mount: permissionMount,
|
|
35213
35465
|
getPermissions: () => permissionBridge?.runtime.permissions,
|
|
35466
|
+
labelForPrincipal: (principal) => pajaPrincipalLabel(config, stateRef?.tabs ?? [], principal),
|
|
35214
35467
|
onGrantRevoked(grant2) {
|
|
35215
35468
|
if (!stateRef) return;
|
|
35216
35469
|
const revoked = permissionPrincipalKey(grant2.principal);
|
|
35470
|
+
if (retiringPrincipals.has(revoked)) return;
|
|
35471
|
+
retiringPrincipals.add(revoked);
|
|
35472
|
+
queueMicrotask(() => retiringPrincipals.delete(revoked));
|
|
35217
35473
|
if (config.target.mode === "runtime-pointer") {
|
|
35218
35474
|
for (const tabId of revokedPajaTabIds(config, stateRef.tabs, grant2)) stateRef.closeTab(tabId);
|
|
35219
35475
|
} else {
|
|
35220
35476
|
const source = frame?.contentWindow;
|
|
35221
35477
|
const principal = source ? originRegistry.getIdentity(source)?.permissionPrincipal : void 0;
|
|
35222
|
-
|
|
35478
|
+
const retired = contextRef?.runtime.currentWindowId === null;
|
|
35479
|
+
if (retired || principal && permissionPrincipalKey(principal) === revoked) stateRef.reload();
|
|
35223
35480
|
}
|
|
35224
35481
|
}
|
|
35225
35482
|
});
|