@webref/idl 3.61.5 → 3.62.0

package/fedcm.idl

@@ -84,8 +84,10 @@ dictionary IdentityProviderAPIConfig {
 
 dictionary IdentityProviderAccount {
   required USVString id;
-  required USVString name;
-  required USVString email;
+  USVString name;
+  USVString email;
+  USVString tel;
+  USVString username;
   USVString given_name;
   USVString picture;
   sequence<USVString> approved_clients;

package/image-capture.idl

@@ -3,7 +3,7 @@
 // (https://github.com/w3c/webref)
 // Source: MediaStream Image Capture (https://w3c.github.io/mediacapture-image/)
 
-[Exposed=Window]
+[Exposed=Window, SecureContext]
 interface ImageCapture {
    constructor(MediaStreamTrack videoTrack);
    Promise<Blob>              takePhoto(optional PhotoSettings photoSettings = {});

package/mediastream-recording.idl

@@ -56,7 +56,7 @@ interface BlobEvent : Event {
   readonly attribute DOMHighResTimeStamp timecode;
 };
 
-dictionary BlobEventInit {
+dictionary BlobEventInit : EventInit {
   required Blob data;
   DOMHighResTimeStamp timecode;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@webref/idl",
   "description": "Web IDL definitions of the web platform",
-  "version": "3.61.5",
+  "version": "3.62.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/w3c/webref.git"

package/turtledove.idl

@@ -206,6 +206,7 @@ partial interface Navigator {
 [Exposed=InterestGroupScriptRunnerGlobalScope]
 interface InterestGroupScriptRunnerGlobalScope {
   readonly attribute PrivateAggregation? privateAggregation;
+  readonly attribute ProtectedAudienceUtilities protectedAudience;
 };
 
 dictionary PASignalValue {
@@ -220,6 +221,12 @@ dictionary PAExtendedHistogramContribution {
   bigint filteringId = 0;
 };
 
+[Exposed=InterestGroupScriptRunnerGlobalScope]
+interface ProtectedAudienceUtilities {
+  Uint8Array encodeUtf8(USVString input);
+  USVString decodeUtf8(Uint8Array bytes);
+};
+
 [Exposed=InterestGroupBiddingAndScoringScriptRunnerGlobalScope]
 interface ForDebuggingOnly {
   undefined reportAdAuctionWin(USVString url);

package/webcodecs.idl

@@ -141,7 +141,7 @@ dictionary AudioDecoderConfig {
   required DOMString codec;
   [EnforceRange] required unsigned long sampleRate;
   [EnforceRange] required unsigned long numberOfChannels;
-  BufferSource description;
+  AllowSharedBufferSource description;
 };
 
 dictionary VideoDecoderConfig {

package/webgpu.idl

@@ -109,6 +109,7 @@ dictionary GPUDeviceDescriptor
 };
 
 enum GPUFeatureName {
+    "core-features-and-limits",
     "depth-clip-control",
     "depth32float-stencil8",
     "texture-compression-bc",

package/webnn.idl

@@ -36,6 +36,8 @@ interface MLContext {
   undefined dispatch(MLGraph graph, MLNamedTensors inputs, MLNamedTensors outputs);
 
   Promise<MLTensor> createTensor(MLTensorDescriptor descriptor);
+  Promise<MLTensor> createConstantTensor(
+    MLOperandDescriptor descriptor, AllowSharedBufferSource inputData);
 
   Promise<ArrayBuffer> readTensor(MLTensor tensor);
   Promise<undefined> readTensor(MLTensor tensor, AllowSharedBufferSource outputData);
@@ -133,6 +135,7 @@ interface MLTensor {
   readonly attribute FrozenArray<unsigned long> shape;
   readonly attribute boolean readable;
   readonly attribute boolean writable;
+  readonly attribute boolean constant;
 
   undefined destroy();
 };
@@ -154,6 +157,9 @@ interface MLGraphBuilder {
   // Create a scalar operand from the specified number of the specified type.
   MLOperand constant(MLOperandDataType type, MLNumber value);
 
+  // Create an operand from a specified constant tensor.
+  MLOperand constant(MLTensor tensor);
+
   // Compile the graph up to the specified output operands asynchronously.
   Promise<MLGraph> build(MLNamedOperands outputs);
 };

package/webxr-depth-sensing.idl

@@ -34,6 +34,10 @@ partial interface XRSession {
   readonly attribute XRDepthUsage depthUsage;
   readonly attribute XRDepthDataFormat depthDataFormat;
   readonly attribute XRDepthType? depthType;
+  readonly attribute boolean? depthActive;
+
+  undefined pauseDepthSensing();
+  undefined resumeDepthSensing();
 };
 
 [SecureContext, Exposed=Window]
@@ -43,9 +47,10 @@ interface XRDepthInformation {
 
   [SameObject] readonly attribute XRRigidTransform normDepthBufferFromNormView;
   readonly attribute float rawValueToMeters;
-  readonly attribute XRView? view;
 };
 
+XRDepthInformation includes XRViewGeometry;
+
 [Exposed=Window]
 interface XRCPUDepthInformation : XRDepthInformation {
   [SameObject] readonly attribute ArrayBuffer data;

package/webxr.idl

@@ -118,6 +118,11 @@ interface XRBoundedReferenceSpace : XRReferenceSpace {
   readonly attribute FrozenArray<DOMPointReadOnly> boundsGeometry;
 };
 
+[SecureContext, Exposed=Window] interface mixin XRViewGeometry {
+  readonly attribute Float32Array projectionMatrix;
+  [SameObject] readonly attribute XRRigidTransform transform;
+};
+
 enum XREye {
   "none",
   "left",
@@ -126,13 +131,13 @@ enum XREye {
 
 [SecureContext, Exposed=Window] interface XRView {
   readonly attribute XREye eye;
-  readonly attribute Float32Array projectionMatrix;
-  [SameObject] readonly attribute XRRigidTransform transform;
   readonly attribute double? recommendedViewportScale;
 
   undefined requestViewportScale(double? scale);
 };
 
+XRView includes XRViewGeometry;
+
 [SecureContext, Exposed=Window] interface XRViewport {
   readonly attribute long x;
   readonly attribute long y;

package/writing-assistance-apis.idl

@@ -0,0 +1,193 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Writing Assistance APIs (https://webmachinelearning.github.io/writing-assistance-apis/)
+
+[Exposed=Window, SecureContext]
+interface Summarizer {
+  static Promise<Summarizer> create(optional SummarizerCreateOptions options = {});
+  static Promise<Availability> availability(optional SummarizerCreateCoreOptions options = {});
+
+  Promise<DOMString> summarize(
+    DOMString input,
+    optional SummarizerSummarizeOptions options = {}
+  );
+  ReadableStream summarizeStreaming(
+    DOMString input,
+    optional SummarizerSummarizeOptions options = {}
+  );
+
+  readonly attribute DOMString sharedContext;
+  readonly attribute SummarizerType type;
+  readonly attribute SummarizerFormat format;
+  readonly attribute SummarizerLength length;
+
+  readonly attribute FrozenArray<DOMString>? expectedInputLanguages;
+  readonly attribute FrozenArray<DOMString>? expectedContextLanguages;
+  readonly attribute DOMString? outputLanguage;
+
+  Promise<double> measureInputUsage(
+    DOMString input,
+    optional SummarizerSummarizeOptions options = {}
+  );
+  readonly attribute unrestricted double inputQuota;
+};
+Summarizer includes DestroyableModel;
+
+dictionary SummarizerCreateCoreOptions {
+  SummarizerType type = "key-points";
+  SummarizerFormat format = "markdown";
+  SummarizerLength length = "short";
+
+  sequence<DOMString> expectedInputLanguages;
+  sequence<DOMString> expectedContextLanguages;
+  DOMString outputLanguage;
+};
+
+dictionary SummarizerCreateOptions : SummarizerCreateCoreOptions {
+  AbortSignal signal;
+  CreateMonitorCallback monitor;
+
+  DOMString sharedContext;
+};
+
+dictionary SummarizerSummarizeOptions {
+  AbortSignal signal;
+  DOMString context;
+};
+
+enum SummarizerType { "tl;dr", "teaser", "key-points", "headline" };
+enum SummarizerFormat { "plain-text", "markdown" };
+enum SummarizerLength { "short", "medium", "long" };
+
+[Exposed=Window, SecureContext]
+interface Writer {
+  static Promise<Writer> create(optional WriterCreateOptions options = {});
+  static Promise<Availability> availability(optional WriterCreateCoreOptions options = {});
+
+  Promise<DOMString> write(
+    DOMString input,
+    optional WriterWriteOptions options = {}
+  );
+  ReadableStream writeStreaming(
+    DOMString input,
+    optional WriterWriteOptions options = {}
+  );
+
+  readonly attribute DOMString sharedContext;
+  readonly attribute WriterTone tone;
+  readonly attribute WriterFormat format;
+  readonly attribute WriterLength length;
+
+  readonly attribute FrozenArray<DOMString>? expectedInputLanguages;
+  readonly attribute FrozenArray<DOMString>? expectedContextLanguages;
+  readonly attribute DOMString? outputLanguage;
+
+  Promise<double> measureInputUsage(
+    DOMString input,
+    optional WriterWriteOptions options = {}
+  );
+  readonly attribute unrestricted double inputQuota;
+};
+Writer includes DestroyableModel;
+
+dictionary WriterCreateCoreOptions {
+  WriterTone tone = "neutral";
+  WriterFormat format = "markdown";
+  WriterLength length = "short";
+
+  sequence<DOMString> expectedInputLanguages;
+  sequence<DOMString> expectedContextLanguages;
+  DOMString outputLanguage;
+};
+
+dictionary WriterCreateOptions : WriterCreateCoreOptions {
+  AbortSignal signal;
+  CreateMonitorCallback monitor;
+
+  DOMString sharedContext;
+};
+
+dictionary WriterWriteOptions {
+  DOMString context;
+  AbortSignal signal;
+};
+
+enum WriterTone { "formal", "neutral", "casual" };
+enum WriterFormat { "plain-text", "markdown" };
+enum WriterLength { "short", "medium", "long" };
+
+[Exposed=Window, SecureContext]
+interface Rewriter {
+  static Promise<Rewriter> create(optional RewriterCreateOptions options = {});
+  static Promise<Availability> availability(optional RewriterCreateCoreOptions options = {});
+
+  Promise<DOMString> rewrite(
+    DOMString input,
+    optional RewriterRewriteOptions options = {}
+  );
+  ReadableStream rewriteStreaming(
+    DOMString input,
+    optional RewriterRewriteOptions options = {}
+  );
+
+  readonly attribute DOMString sharedContext;
+  readonly attribute RewriterTone tone;
+  readonly attribute RewriterFormat format;
+  readonly attribute RewriterLength length;
+
+  readonly attribute FrozenArray<DOMString>? expectedInputLanguages;
+  readonly attribute FrozenArray<DOMString>? expectedContextLanguages;
+  readonly attribute DOMString? outputLanguage;
+
+  Promise<double> measureInputUsage(
+    DOMString input,
+    optional RewriterRewriteOptions options = {}
+  );
+  readonly attribute unrestricted double inputQuota;
+};
+Rewriter includes DestroyableModel;
+
+dictionary RewriterCreateCoreOptions {
+  RewriterTone tone = "as-is";
+  RewriterFormat format = "as-is";
+  RewriterLength length = "as-is";
+
+  sequence<DOMString> expectedInputLanguages;
+  sequence<DOMString> expectedContextLanguages;
+  DOMString outputLanguage;
+};
+
+dictionary RewriterCreateOptions : RewriterCreateCoreOptions {
+  AbortSignal signal;
+  CreateMonitorCallback monitor;
+
+  DOMString sharedContext;
+};
+
+dictionary RewriterRewriteOptions {
+  DOMString context;
+  AbortSignal signal;
+};
+
+enum RewriterTone { "as-is", "more-formal", "more-casual" };
+enum RewriterFormat { "as-is", "plain-text", "markdown" };
+enum RewriterLength { "as-is", "shorter", "longer" };
+
+[Exposed=Window, SecureContext]
+interface CreateMonitor : EventTarget {
+  attribute EventHandler ondownloadprogress;
+};
+
+callback CreateMonitorCallback = undefined (CreateMonitor monitor);
+
+enum Availability {
+  "unavailable",
+  "downloadable",
+  "downloading",
+  "available"
+};
+
+interface mixin DestroyableModel {
+  undefined destroy();
+};